I recently deployed a WPF app on a server that allowed the user to stop and start some application-related services. The purpose of the app was to allow users with administrative rights an easy way to manage the services that they needed to manage. Granted, they could manage the services through the services MMC, but the little WPF app was a requirement, and it’s our job as developers to make things easier for our clients – right?

All went well until a change of requirements meant that a user without administrative rights needed to use the program to stop and start the required services. When I tried to use the app, I got an exception – quite rightly, stopping and starting the services required admin rights. We needed the restricted user to be able to log on and use the app, but still needed to restrict their permissions.

So – step in programmatic impersonation in C# – a way to give restricted users the power that that’s required, all within the confines of your application.

The first thing to point out is that I got quite a bit of this code from a google search, but I had to do a bit of work to get things in a state that I found really useful.

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Runtime.InteropServices;
using System.Linq;
using System.Security.Principal;
using System.Text;

namespace ServiceControllerApp.Security
{
    public class Impersonator : IDisposable
    {
        private WindowsImpersonationContext _impersonatedUser = null;
        private IntPtr _userHandle;

        public Impersonator()
        {
            _userHandle = new IntPtr(0);

            string user = "servicecontroller";
            string userDomain = ConfigurationManager.AppSettings["MachineDomain"];
            string password = "yourpassword";

            bool returnValue = LogonUser(user, userDomain, password, LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, ref _userHandle);

            if (!returnValue)
                throw new ApplicationException("Could not impersonate user");

            WindowsIdentity newId = new WindowsIdentity(_userHandle);
            _impersonatedUser = newId.Impersonate();
        }

        #region IDisposable Members

        public void Dispose()
        {
            if (_impersonatedUser != null)
            {
                _impersonatedUser.Undo();
                CloseHandle(_userHandle);
            }
        }

        #endregion

        #region Interop imports/constants
        public const int LOGON32_LOGON_INTERACTIVE = 2;
        public const int LOGON32_LOGON_SERVICE = 3;
        public const int LOGON32_PROVIDER_DEFAULT = 0;

        [DllImport("advapi32.dll", CharSet = CharSet.Auto)]
        public static extern bool LogonUser(String lpszUserName, String lpszDomain, String lpszPassword, int dwLogonType, int dwLogonProvider, ref IntPtr phToken);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public extern static bool CloseHandle(IntPtr handle);
        #endregion
    }
}

Impersonator is a simple class that uses interop to call Win32 LogonUser and CloseHandle functions. We have to use interop because .NET doesn’t provide the equivalent methods.

The code shown above has a user, domain and password actually in the code – for some situations this is a security risk, so the credentials should be obtained in another manner, but for my needs, it was satisfactory, and their direct inclusion simplifies this example.

The class has a WindowsImpersonationContext to manage the impersonation, and the constructor sets up the required logon rights using the LogonUser interop.

Crucially, the impersonation must end, with an equivalent Log Off – and the class implements IDisposable to call the required log off code. Using the class is easy.

using (Impersonator impersonator = new Impersonator())
{
    // code in here
}

The good thing is that because the class implements IDisposable, you don’t have to pepper your code with the log off code equivalent. I hope it’s of use to somebody wishing to implement impersonation.

An updated version of this post, containing full source for the control and explanation is available here.

Original Post

The guys over at Gravatar.com have been hard at work updating their service, and I’ve updated the ASP.NET control I developed to reflect the changes.

The maximum size of Gravatars has now been increased from 80 to 512, so there’s a code change in the Render method:

// if the size property has been specified, and in the range
// 1..512:
try
{
    // if it's not in the allowed range, throw an exception:
    if (Size < 1 || Size > 512)
        throw new ArgumentOutOfRangeException();
}
catch
{
    Size = 80;
}

So, a default of 80 will still be used if the value specified is not within the 1 to 512 range, or it is not specified, but allows for a larger size.

The avatar.php URL serving the images now supports abbreviation, but the code in the control has not been changed.

The image shows the Design time view of the control, with the width set at the default value of 80. I’ve checked the control at 512 pixels, but my Gravatar doesn’t look too good expanded out to that size, so I’ve decided to stick at size 80 for the screenshot!

An updated version of this post, containing full source for the control and explanation is available here.

Original Post

I just got myself a freshclickmedia.com Gravatar over at gravatar.com. A Gravatar is a little avatar associated with an email address, and quite a few blogs use them to decorate post comments. Signing up is easy – all you need to do is supply an email address, and image, and give your image a content rating.

The source of the gravatar image tag points to gravatar.com’s image generator and includes an MD5 hash of the email address to prevent email harvesting. A ‘max rating’ parameter prevents the display of unsavoury content.

There are a wide number of blogging gravatar plugins, so I decided to write an ASP.NET custom control to do the job. Here I present the control and its features.

Using the Control

To get up and running, the control requires an email address:

<fcm:Gravatar ID='Gravatar1' runat='server' Email='username@domain.com' />

For my email address, I get the following:

And if we look at the generated source:

<a id="Gravatar1" href="http://www.gravatar.com" title="Get your avatar"><img width="80" height="80" src="http://www.gravatar.com/avatar.php?gravatar_id=ccf3b8c638f15d005e5d070aeb1a3923&rating=G&size=80" alt="Gravatar" /></a>

The default produces a hyperlink off to the Gravatar site with a title “Get your avatar”. The image contains the MD5 email hash, a rating of “G” (suitable for all audience types), and a size of 80.

Customisation

The control supports a number of properties supporting the customisation of its output.

Size

The size property of the control can be in the range 1 to 80. If it is outside this range, a default of 80 will be used.

MaxAllowedRating

The ‘highest’ allowed rating of image.

• A G rated gravatar is suitable for display on all websites with any audience type.
• PG rated gravatars contain may contain rude gestures, provocatively dressed individuals, the lesser swear words, or mild violence.
• R rated gravatars may contain such things as harsh profanity, intense violence, nudity, or hard drug use.
• X rated gravatars may contain hardcore sexual imagery or extremely disturbing violence.

OutputGravatarSiteLink

True by default, determines whether a hyperlink linking to the gravatar website will be output around the image.

LinkTitle

“Get your avatar” by default, allows the customisation of the ‘title’ attribute of the link (obviously doesn’t apply if OutputGravatarSiteLink property is set to false.)

DefaultImage

URL encoded URL, protocol included, of a GIF, JPEG, or PNG image that should be returned if either the requested email address has no associated gravatar, or that gravatar has a rating higher than is allowed by the “MaxAllowedRating” property.

The code snippet below shows the associated properties.

<fcm:Gravatar ID="Gravatar1" runat="server"
    Email="username@domain.com"
    DefaultImage="http://www.site.com/default.jpg"
    OutputGravatarSiteLink="true" Size="40" />

Download and Get Started

You can download the Gravatar Custom Control here. Once you’ve extracted the assembly from the ZIP file, add to the Visual Studio toolbox by right clicking on the toolbox and selecting “Choose Items” from the context menu. Browse to the assembly (Freshclickmedia.Web.dll), and click “OK” to add.

I’ll start the overview with the introduction of two classes, Person, and MyExtensions.

    public partial class Person
    {
        public Person()
        {
            LogCreation();
        }

        // automatic properties:
        public int Age { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public short NumberOfChildren { get; set; }

        // partial method:
        partial void LogCreation();
    }

    // this could (and probably would) be in a different file:
    public partial class Person
    {
        // partial method implementation:
        partial void LogCreation()
        {
            Console.WriteLine("Person created");
        }
    }

The Person class introduces two new language features.

Partial Methods

The LogCreation method in the Person class has been decorated with the ‘partial’ keyword, meaning that it is a ‘partial method’.

Partial methods add a lightweight event handling mechanism to C#. They’re basically methods where the declaration or prototype is specified in the declaration of a partial class, but the implementation can only be provided in another declaration for that partial class. In other words, a partial method will only compile if it is specified in one partial class definition and is the implementation is provided in another partial class definition, as shown above.

The ‘clever’ thing is that because no definition for the method is provided, no IL code is produced for that method, so the resulting assembly is no bigger or slower than if the partial method wasn’t there in the first place. This then begs the question – if an implementation isn’t provided, why have the prototype at all? Well, you could set up some ‘hooks’ into your code for specific methods, that may or may not be implemented by a developer.

The Person class invokes the partial method LogCreation, and because an implementation is provided, the code is executed. If the second partial class definition didn’t exist, or the method wasn’t implemented, the code would not be executed. In practice, they are used by some new LINQ (more on that shortly) SQL entity classes as a hook for property value change notification. A partial method is called before a property value changes, and a partial method is called after the property value has changed. If you wish to hook into these, you can implement the methods in your partial class and be notified. If not, the partial methods are ‘removed’ from the assembly’s output.

Syntactically, there are a few rules for partial methods:

1. Can only be defined and implemented in partial classes
2. Must specify the partial modifer
3. Must not specify an access modifier, but are private. If an access modifier (even if it’s private) is specified, you’ll get a compiler error
4. They must return void

A little less strict in some other areas:

1. They can have arguments
2. The don’t have to be implemented
3. They can be static

The second class, MyExtensions, is shown below:

    public static class MyExtensions
    {
        // extension method
        public static bool IsEven(this int number)
        {
            return number % 2 == 0;
        }
    }

The MyExtensions class shown above may look familiar at first glance, but the this keyword in the method arguments makes it stand out as an extension method.

Extension Methods

Basically, extension methods are a way of ‘extending’ a .NET type with a method so that it may be called on an instance of that method.

The example shown illustrates the rules that an extension method must be defined as static, in a static class, and contain the this keyword in the method arguments list. The type of argument is the .NET type that is being extended.

The nice thing is that when you have an extension method, you can do something like this:

Our example extends int, and the Visual Studio 2008 IDE indicates our extension method with a little icon and associated text. Perhaps I need to get out a little more, but I find extension methods quite exciting.

Collection and Object initialization

// collection initializer:
List people = new List< Person>
{
    // object initializer:
    new Person { Age = 6, FirstName = "Andy", LastName = "Andrews", NumberOfChildren = 0 },
    new Person { Age = 46, FirstName = "Bob", LastName = "Bobbins", NumberOfChildren = 3 },
    new Person { Age = 19, FirstName = "Charlie", LastName = "Charles", NumberOfChildren = 0 }
};

Collection initialization is a shorter way of creating a collection and initialising it. Whereas before, the list would have to be created, and each item added separately, the whole thing can be done in one swoop.

Object initialization is very similar, and makes it easier to create an object and set property values at the same time.

Lambda Expressions

For the three Person instances added to the list, you could specify an anonymous method in C# 2.0 to extract items (in our case items of type Person) from the list based on a set of ‘matching criteria’:

List< Person> children = people.FindAll( delegate( Person p) { return p.Age < 18; } );

This is all well and good, but the problem with anonymous methods is that they're a little bit, well, clunky.

With lambda expressions, we can rewrite the above 'query' as follows:

    IEnumerable<Person> children =
                people.Select(p => p).Where(p => p.Age < 18);

Basically, we're referring to an item in the list as 'p', selecting 'p', and filtering using the Where method where the Age of the item is less than 18. At first, I found them a little strange syntactically, but I've got used to them now, and don't typically use the old style anonymous methods.

LINQ, var and anonymous type projection

LINQ is part of C# 3.0 and it's going to revolutionise the way that .NET developers access and manipulate data. The previous example showed how the Select and Where methods seem familiar to a SQL way of dealing with data.

I attended a DDD event last year, and was introduced to the 'var' keyword during a presentation. I'm guessing that it was new to my fellow developers present because there were several loud gasps from the attendees.

Aaaggggh! It's like the old days of variants!

var myName = "Shane";

The thing to really shout about here is that it is not a variant! The compiler simply infers the type from the data on the right side of the assignment, in this case, a string. It is a string! It is not a variant!

The reason that this keyword is introduced is for anonymous types, and the following example, with some new LINQ syntax thrown in for good measure, will illustrate:

var adults =
    from p in people
    where p.Age >= 18
    select new { Name = p.FirstName + " " + p.LastName, Age = p.Age }; // anonymous type projection

The first thing to note is that from, where and select keywords are exactly as in a SQL query, but that the from occurs first. This is mandatory, and it's unusual position is because Visual Studio's intellisense can only offer member information based on the data that is being queried. Because this is first, Visual Studio can offer help for the where clause and the select clause (which appears last.) There are a number of other methods and keywords, but I'll keep things brief here.

You'll notice that we're referring to an item in the list as 'p', referencing 'p' in the where clause with the Age property of the Person class, and then doing a select.

This select is doing something more interesting than the earlier example (which was just selecting people from the list). It is using anonymous type projection, whereby an anonymous type is created as a result of a select on the data.

The type doesn't have a name (therefore it's anonymous), and its properties can be specified 'on the fly'. Here, we're creating a new type to merge the first name and last name as 'Name', and creating an 'Age' property for the Person 'Age' property.

Because this type is anonymous, we need to specify the var keyword, and let the compiler work things out by inferring the type.

// local variable type inference:
foreach (var currentAdult in adults)
{
    Console.WriteLine(currentAdult.Name + ".  Their age is " +
          (currentAdult.Age.IsEven() ? "" : "not ") + "even");
}

Once again, type inference comes into play, and we loop through the selected adults. Note that the previously demonstrated int extension method is used (IsEven).

Remember that the Person class had a LogCreation partial method that was implemented? Well, that is called every time a Person is constructed, so for our collection, object initialization and output, we get the following:

If the partial method implementation is taken out of the Person class, everything still compiles, but we get the following:

So, that concludes my brief overview of new language features. Without doubt, the var keyword is likely to cause some controversy, but it really isn't bad, and is in fact required for anonymous types (which I believe to be a very handy addition to the language.)

I'm certainly looking forward to using the new language features, and I hope you do too.

In particular, it pays attention to:

• Deriving from the WebControl class, and customising the control’s output using the HtmlTextWriter class;
• Customising the control using properties;
• Adding the control to the Visual Studio toolbox and adding to a page;
• Dealing with Postback data;
• Validating the control like a typical web control

The TimePicker control is a drop down list containing times separated by a user-definable time-period, such as 15 minutes. The WebControl class provides a good foundation for custom control development in that it provides a number of methods, properties and events common to web controls in ASP.NET.

To start, create a new class library in Visual Studio. In this case, I’ll mimick the Microsoft naming standards and call it Freshclickmedia.Web.

To further mimick the Microsoft namespace hiearchy, I have created UI and WebControls folders.

One this has been done, right click on the project and select ‘add new item’. Add a new item of type ‘Web Custom Control’ called .

Once the new control has been added, there will be a lot of default, but unwanted code. Remove the class data so that you end up with something like this:

[ToolboxData("<{0}:TimePicker runat=server>")]
public class TimePicker : WebControl{protected override void RenderContents(HtmlTextWriter output)
{

}

The first line is an attribute that defines what text will be added to a webform when the control is dragged from the toolbox. More on this later.

The class contains a single overridden WebControl method, RenderContents. The HtmlTextWriter class parameter allows control developers to customise the HTML markup that is rendered by the control at runtime, and it is this method that we’ll look at first.

By default, a class inheriting from WebControl will have a default ‘outer’ HTML element of type Span. We’re looking to write a Select, so we’ll add a constructor to specify this outer HTML element type:

///
/// Constructor defining outer HTML element type
///
public TimePicker() : base( HtmlTextWriterTag.Select)
{

}

Now when the control is used, the outer tag will be of type Select, which is what we want. However, to output our times, we’ll need to go back to the RenderContents method. In this simple example, we’ll write out a list of times. Before we do this, we need to specify some properties as follows:

• The default text, such as ‘Select time’;
• The minute increment for the control
• The selected value on a Page postback

Shown below is the code for those properties. Note that each one uses the ViewState to persist the information across postbacks, and have default values of “Select Time”, 15, and string.Empty respectively.

///
/// Gets or sets the default selection text.
///
public string DefaultSelectionText
{
  get { return ViewState["DefaultSelectionText"] == null ? "Select time" : (string)ViewState["DefaultSelectionText"]; }
  set { ViewState["DefaultSelectionText"] = value; }
}

///
/// Gets or sets the minute increment.
///
public int MinuteIncrement
{
  get { return ViewState["MinuteIncrement"] == null ? 15 : (int)ViewState["MinuteIncrement"]; }
  set { ViewState["MinuteIncrement"] = value; }
}

///
/// Gets or sets the selected value.
///
public string SelectedValue
{
  get { return ViewState["SelectedValue"] == null ? string.Empty : (string)ViewState["SelectedValue"]; }
  set { ViewState["SelectedValue"] = value; }
}

To keep things simple, the RenderContents method will simply loop from 00:00 to the last available time, based on the MinuteIncrement property value. The code is shown below:

protected override void RenderContents(HtmlTextWriter writer)
{
  // write out the options:
  writer.Write("<option value=\"\"{0}>{1}</option>", string.IsNullOrEmpty(SelectedValue) ? " selected=\"selected\"" : "", DefaultSelectionText);

  int minuteIncrement = Convert.ToInt32(MinuteIncrement);

  // 24 hours in a day, 60 minutes in an hour, 24 * 60 = 1440
  for (int minuteLoop = 0; minuteLoop < 1440; minuteLoop += minuteIncrement)
  {
    // convert the minuteLoop value to a meaningful time:
    int hours = minuteLoop / 60;
    int leftOverMinutes = minuteLoop % 60;

    string time = string.Format("{0:00}:{1:00}", hours, leftOverMinutes);

    writer.Write( "<option{0} value=\"{1}\">{2}</option>", time == SelectedValue ? " selected=\"selected\"" : "", time, time);
  }

  base.RenderContents(writer);
}

The key points from the code are that a series of <option> tags are written to the browser. Some logic is included to determine whether the current option is the selected value, in which case a ’selected’ attribute is written out for that option value.

Before using the control, let’s spend a moment on adding it to the toolbox, and also customising the default toolbox image for the control. To use a custom toolbox image, add a 16×16 image of type .bmp to the same directory as the control class. After the image has been added to the project, select properties and select the ‘Build Action’ to be ‘Embedded Resource’.

Once the control has been built, do the following to add the control to the toolbox.

1. [Optional] Right click on the toolbox and select ‘Add tab’. Enter a name for the tab and press enter.
2. Right click on a tab and select ‘Choose items…’
3. Browse for the control assembly
4. Click OK to add the control to the toolbox.

So, once the control has been added, using it is as simple as dragging it from the toolbox onto a web form.

<form id="form1" runat="server">
	<cc1:timepicker id="TimePicker1" runat="server"></cc1:timepicker>
	<asp:button id="Button1" runat="server" text="Submit"></asp:button>
</form>

The markup shown above shows a very simple ASPX page with a time picker control and a button that will initiate a postback.

When we view it in the browser, we get the following:

This all looks great – exactly what we wanted, but there is one huge remaining issue. If we click the submit button, the selected time is lost, so the control may look right, but functionally it’s rather useless if we can’t access the selected time, and the selected time doesn’t persist visually on the page across page postbacks.

To sort out the postback issue, we must implement 3 things:

• Derive our control from IPostBackDataHandler, and implement the 2 interface methods, LoadPostData and RaisePostDataChangedEvent.
• Output an HTML ‘name’ attribute to the rendering output so that the form can pick up the control’s submitted data.
• Call RegisterRequiresPostback to indicate that the control requires page postback data handling.

Implementing the IPostBackDataHandler interface results in the following class definition change:

public class TimePicker : WebControl, IPostBackDataHandler

The 2 interface methods, LoadPostData and RaisePostDataChangedEvent are coded as follows:

public virtual bool LoadPostData(string postDataKey, NameValueCollection values)
{
  SelectedValue = Convert.ToString(values[this.UniqueID]);
  return false;
}

public void RaisePostDataChangedEvent()
{
  // Part of the IPostBackDataHandler contract.  Invoked if we ever returned true from the
  // LoadPostData method (indicates that we want a change notification raised).  Since we
  // always return false, this method is just a no-op.
}

The LoadPostData retrieves information from the posted form data and assigns it to the SelectedValue property of the control.

The RaisePostDataChangedEvent method is an essential method here, since we’re inheriting from IPostBackDataHandler. However, it is only invoked if the LoadPostData method returns true, and in our case it returns false. Returning true can be used to raise event based on changed data, but that is beyond the scope of this tutorial.

We also need to output an HTML ‘name’ attribute to the control’s output, since this is what will be used to identify the control’s data when the form is posted to the server. To do this, override the base class’ AddAttributesToRender method:

protected override void AddAttributesToRender(HtmlTextWriter writer)
{
  writer.AddAttribute(HtmlTextWriterAttribute.Name, this.UniqueID);
  base.AddAttributesToRender(writer);
}

The last thing is to override the base class’ OnPreRender method, to allow us to notify the page on which the control is hosted that the control requires post back handling:

protected override void OnPreRender(EventArgs e)
{
  base.OnPreRender(e);    

  if (Page != null)
  {
    Page.RegisterRequiresPostBack(this);
  }
}

Rebuilding will now fix the posting back issue, and the control will retain it’s selected value property.

Another issue with the control that’s very easy to implement is validation. Placing a RequiredFieldAttribute on the page and associating it to the TimePicker control will result in the following error:

To resolve this issue, simply add a ValidationProperty attribute to the control class:

[ValidationProperty("SelectedValue")]
public class TimePicker : WebControl, IPostBackDataHandler

Adding this simple line will give us nice co-operation with the ASP.NET validator controls.

So, that’s it for a simple custom control. In future, I’ll be doing something slightly more interesting, as I look at integrating JavaScript within a control.

Much like T-SQL’s ISNULL function, the operator replaces null values with the specified replacement value.

So, in T-SQL

	SELECT
		ISNULL( Fieldname, '')
	FROM
		TableName

In C#, the ?? operator is the ISNULL equivalent. So, we have the following in C#

	string nullString = null;

	string anotherString = nullString ?? "It was null";

	// anotherString now contains "It was null"

	string myName = "Shane";

	anotherString = myName ?? "Name is null";

	// anotherString now contains "Shane"

Hardly revolutionary stuff, but I’ve never seen the operator before, so either it’s been discussed and regarded as useless, or other people are unaware of it, like I was until about 10 minutes ago.

A snippet that I use probably the most is the ‘prop’ snippet. To activate it, type ‘prop’ at class scope in a Visual C# project.

Selecting ‘prop’ from the list, or tabbing twice will then produce the following code:

The focus is initially over the private member’s data type ‘int’. This, and all the other text highlighted in green can be typed over. Each piece of text can be cycled through by pressing the tab key.

You’ll also notice that the property’s type is outlined with a dotted line. This means that once something has been typed in the active selection, tabbing out will change the dotted selection’s text to be the same. This makes sense, since a property and the member that it relates to must be the same type.

In this quick scenario, we’ll change the data type to be of type string, the member to be _name, and property to be Name. Note that tabbing through will cycle through the highlighted text. When you’re happy, press enter, and you have a property. Once the method for using snippets becomes familiar, their use becomes second nature and you’ll wonder how you ever worked without them.

The ‘prop’ example is just one of many that can be managed through the ‘Code Snippets Manager’, accessed from the Visual Studio Tools menu.

The real fun with snippets (real fun? perhaps I need to get out more) comes with developing your own. The rest of the tutorial will create a simple property snippet to write/read information to/from the ViewState on an ASP.NET page.

A snippet is just an XML file, and the default Visual Studio snippets can be found in C:\Program Files\Microsoft Visual Studio 8\VC#\Snippets\1033\Visual C# by default.

If we open the prop.snippet file, we get this:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>prop</Title>
      <Shortcut>prop</Shortcut>
      <Description>Code snippet for property and backing field</Description>
      <Author>Microsoft Corporation</Author>
      <SnippetTypes>
      <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
   </Header>
   <Snippet>
     <Declarations>
        <Literal>
          <ID>type</ID>
          <ToolTip>Property type</ToolTip>
          <Default>int</Default>
        </Literal>
        <Literal>
          <ID>property</ID>
          <ToolTip>Property name</ToolTip>
          <Default>MyProperty</Default>
        </Literal>
        <Literal>
          <ID>field</ID>
          <ToolTip>The variable backing this property</ToolTip>
          <Default>myVar</Default>
        </Literal>
      </Declarations>
      <Code Language="csharp"><![CDATA[private $type$ $field$;
	public $type$ $property$
	{
          get { return $field$;}
          set { $field$ = value;}
	}
	$end$]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

The two main areas are the Header and the Snippet elements, underneath the main CodeSnippet element. The Header contains the snippet title, shortcut (what you type in the editor to invoke the snippet), the description, author, and the snippet types. In our case, it’ll be an Expansion type, meaning it will expand to generate a piece of code.

The Snippet element contains a declarations section. This section contains 0 or more (in this case 3) items, 1 for each item that can be customised. Each of these items has a unique identifier, ID, a tooltip and a default value. The Snippet element also contains a Code section. Wrapped in a CDATA section (since it’s quite likely we’ll be using reserved xml characters in here), it contains the injected code. The variables declared in the Declarations are referenced in $s. The $end$ defines where the cursor will be when the user types enter.

When I develop my own snippets, I often find it useful to start with an example of the type of code that the snippet will produce, before developing the snippet and removing ‘configurable’ items.

public string SelectedValue
{
  get { return ViewState["SelectedValue"] == null ? 15 : (int)ViewState["SelectedValue"]; }
  set { ViewState["SelectedValue"] = value; }
}

So, thinking about a snippet, it would be good to define the type of the property (string), the property name (SelectedValue), which is also used as the ViewStateIdentifier, and the default value (15).

Translating that into the snippet code gives us:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>propvs</Title>
      <Shortcut>propvs</Shortcut>
      <Description>Code snippet for property and ViewState backing</Description>
      <Author>Shane Porter</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>type</ID>
          <ToolTip>Property type</ToolTip>
          <Default>string</Default>
        </Literal>
        <Literal>
          <ID>property</ID>
          <ToolTip>Property name</ToolTip>
          <Default>MyProperty</Default>
        </Literal>
        <Literal>
          <ID>default</ID>
          <ToolTip>The default value, if the ViewState value is null</ToolTip>
          <Default>string.Empty</Default>
        </Literal>
      </Declarations>
      <Code Language="csharp"><![CDATA[public $type$ $property$
        {
          get { return ViewState["$property$"] == null ? $default$ : (int)ViewState["$property$"]; }
          set { ViewState["$property$"] = value; }
        }
	$end$]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Things are pretty simple. I took the code that I wanted, thought about what I needed, created a variable (Literal element) for each thing, and replaced the hard-coded values in the pasted C# code to the $variable$ syntax. I called the snippet ‘propvs’, since it uses the View State, and doesn’t clash with the default ‘prop’ snippet. You can have multiple snippets with the same name, but it becomes a little harder to distinguish them at usage-time since the Visual Studio IDE simply presents the two in a menu.

To use the snippet, you’ll need to import it using the Visual Studio Tools -> Code Snippets Manager menu item. On the resulting dialog, click the ‘Import’ button and browse for the snippet. You will then see this dialog:

Once Finish is clicked, click OK on the previous dialog to return to the editor. Then, we can use our newly developed snippet by typing propvs and tabbing, or by selecting from the menu.

Once this has been selected, you will get the injected code:

Tabbing through, typing what we need, will give us a very quick and easy way to insert the viewstate property pattern into our code.