I’ve been more used to unit testing in a C# environment, particularly NUnit and MS Unit, so googletest was a fresh look at unit testing for C++. Note that the screenr title is incorrect, it should read ‘Getting started with googletest – the Google C++ Testing Framework :)

Cost

There once was a time when the standard IDE for developing ASP.NET apps, Visual Studio, was prohibitively expensive for the average Joe. In late 2007, Microsoft released its first versions of ‘Express’ software, aimed at students and hobbyists. Though Express incarnations have fewer features than their full version cousins, they do offer the possibility of exploring ASP.NET. The Microsoft website offers a download page for Visual Web Developer 2008 Express Edition. An express version of SQL Server is also available, and can be downloaded from the SQL Server 2008 download page.

MVC Support

The MVC pattern is an established and well-recognised way of building web applications, and is familiar to RoR, Java and PHP developers. For many years, MVC was not available as a standard approach to developing ASP.NET websites, but Microsoft has recognised the deficiency and have (at the time of writing) released version 1.0 Release Candidate of ASP.NET MVC. The release has had a mixed response from the ASP.NET community, many of whom are used to the traditional code-behind model. Despite the inevitable squabbles as to which way is best, many have welcomed the MVC approach for its separation of concerns and finer control over JavaScript and markup. To find out more about the release candidate, head over to Scott Guthrie’s blog post.

Learning Resources

A big advantage for anybody learning a new technology is the wealth of learning material that is available. Although you can rely on a large number of books, the ASP.NET learn website contains many videos on both traditional and MVC ASP.NET as well as data access.

Intrinsic jQuery Support

The lightweight open source JavaScript library that’s taken the web by storm is now fully supported by Microsoft. As well as full intellisense support in Visual Studio, Microsoft will be using the library as-is, without forking or changing the code from the main jQuery branch. What’s more, Microsoft will be using jQuery as a basis for future ASP.NET and ASP.NET AJAX features. I feel this counters the argument of Microsoft not supporting open-source software.

Career Prospects

Microsoft’s ubiquity means that learning ASP.NET and supporting technologies will do no harm to your career prospects. .NET skills are ranked as some of the most in-demand in the UK.

It’s been a busy old month, and with so much time working, I’m going to share some of the things that have interested me during October.

Windows 7 Desktop Improvements

With hardware compatability issues and a reluctance from users and computer manufacturers to adopt it, Vista hasn’t perhaps been the success that Microsoft had hoped. The next version of Windows gets a preview over at channel9. There’s quite a lot of verbal fluff at the beginning, but forward through and you’ll get an idea of some of the features that’ll be present in the next version.

ASP.NET MVC Beta

Many of the great frameworks, such as CodeIgniter and Ruby on Rails use a MVC architecture, and it’s a concept that many web developers are familiar with. Maybe not so developers who have exclusively used ASP.NET for their development. Since the introduction of Visual Web Developer Express, developing has become very attractive for hobby developers wishing to get to grips with ASP.NET. I think the development of ASP.NET MVC will encourage those familiar with the pattern to give it a go. Scott Guthrie describes the beta release on his blog.

Microsoft to ship jQuery with future versions of Visual Studio

I’ve been using jQuery alongside ASP.NET for several months now, and find it to be an excellent JavaScript library. I was quite shocked that Microsoft will be distributing it with future versions of Visual Studio (including express versions), providing support for it, and providing intellisense support for it. Good on ‘em!

Google releases Google Earth for iPhone/iPod Touch

I’d definitely recommend a download of free app Google Earth – well worth taking a look.

For more information, head over to the Google Earth on the iPhone page.

Google Android Phone

Following the launch of Chrome , Google is pressing ahead with Mobile Device Platform Android. Now the first handset, the T-Mobile G1 has hit the market. It’s certainly no looker, but Google is a company that has the expertise to change the mobile market, and I’ll be keeping an eye on things, that’s for sure. For now though, I’ll keep my iPhone.

No opera for iPhone

Well well, a version of Opera has been developed for the iPhone, but Apple has refused to add it to their App Store, stating that it is too similar to Safari. So, I won’t be holding my breath for a version of Firefox, either. John Gruber offers his opinion over at Daring Fireball.

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.

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.