Puteti descarca de la adresele de mai jos prezentarea Moles si proiectul demo:

• Prezentarea – http://byteflux.me/wp-content/uploads/2010/07/Moles-Isolation-Framework.pptx
• Proiect demo: http://byteflux.me/wp-content/uploads/2010/07/MolesSample.zip

Cerinte minime pentru proiectul demo:

- Visual Studio 2010 Professional

- Moles plug-in (http://research.microsoft.com/en-us/projects/moles/)

Astept comentariile voastre si feedback.

Disclaimer: Nu lucrez pentru Microsoft si nici nu sunt implicat in vreun fel in dezvoltarea acestui proiect. Notele si proiectul demo reprezinta punctul meu personal de vedere.

[English]

You can download my Moles presentation and demo project from the links below. Unfortunately at this moment the presentation is only in Romanian but I will translate it and provide an English version the next few days.This is a translation of the original presentation in Romanian

• Slides – http://byteflux.me/wp-content/uploads/2010/07/Moles-Isolation-Framework-English.pptx
• Demo project: http://byteflux.me/wp-content/uploads/2010/07/MolesSample.zip

Minimum requirements for running the demo:

- Visual Studio 2010 Professional

- Moles plug-in (http://research.microsoft.com/en-us/projects/moles/)

I am waiting for your comments and feedback.

Disclaimer: I am not working for Microsoft, nor am I involved in this project. The slides and demo project are strictly my point of view and I am doing this to share something that I feel can be useful.

Prima jumatate a lunii iulie incepe cu doua evenimente apropiate pentru programatorii .NET sibieni:

Turneu RONUA.RO de lansare Visual Studio 2010

(de la organizatori:)
Începem pe 12 iulie la Brasov, apoi megem
in Sibiu, Cluj, Oradea, Timisoara, Bucuresti si Iasi.

Te îndemn să te înscrii ACUM
http://bit.ly/VS2010LI

Din cauza numărului de locuri limitate în săli,
numai cei inscrisi au acces GRATUIT.
http://bit.ly/VS2010LI

M-ar bucura sa folosesti LikedIn Status-ul tău
pentru a populariza acest eveniment în rândul
conexiunilor tale LinkedIn.

Dacă poți posta acest anunț și pe alte grupuri
relevante contextului VS2010, please do it!

And thanks.

http://bit.ly/VS2010LI

Pentru sibieni intalnirea va avea loc:

Marti 13 iulie 2010, ora 18:00-22:00
Str. Dorului,  Nr. 20 (cladirea in care se afla si Registrul Comertului), etaj 2, camera 7, ora 18:00.
Facultatea de Stiinte – Str. Ion Ratiu, camera A26, etajul 2

Intalnirea lunara a progamatorilor Sibieni

Subiectul de luna aceasta este Test Driven Development. Daca esti interesat de acest subiect sau vrei sa prezinti ceva legat de el, te asteptam cu placere.

Evenimentul va avea loc:

Joi, 15 iulie 2010, incepand cu ora 18
Terasa Club Liquid – Str. Dobrun nr.1

The series is divided into four parts:

Part I  – creating a Visual Studio Package

Part II  – creating and registering a code generator

Part III (this one) – generating code & debugging

Part IV – creating the setup project and deploying the package

Generating the code and debugging

So far we’ve created a Visual Studio integration package and a skeleton code generator. The next step will be to actually generate some code.

Before we do that, we must decide on the file format and the output.

For simplicity, let’s assume we will  have plain text files which define constants. The first line will have the full class name (including namespace):

MyNamespace.MyClass
Red=1
Blue=2
Pink=3

The output for the above example could be:

namespace MyNamespace
{
	public class MyClass
	{
		public const int Red = 1;
		public const int Blue = 2;
		public const int Pink = 3;
	}
}

First we need to modify the GetDefaultExtension() method and make it return a file extension. I like the idea of making it clear when the code is auto generated by a designer, so we’ll return “.designer.cs” as the extension.

Second we need to parse the input file. To make this blog post shorter, I will skip over the parsing details, but you can check the source zip for how we parse the file.

To generate the code we will use CodeDom which makes things easier. Right now the class should look like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio.TextTemplating.VSHost;
using Microsoft.VisualStudio.Shell;
using VSLangProj80;
using System.Diagnostics;
using System.IO;
using System.CodeDom.Compiler;
using System.CodeDom;

namespace MyCompany.MyCodeGenerator
{
    [ComVisible(true)]
    [Guid(GuidList.guidMyCodeGenerator)]
    [CodeGeneratorRegistration(typeof(MyCodeGenerator), ".myfile", vsContextGuids.vsContextGuidVCSProject, GeneratesDesignTimeSource = true, GeneratorRegKeyName = ".myfile")]
    public class MyCodeGenerator : BaseCodeGeneratorWithSite
    {
        protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
        {
            var provider = CodeDomProvider.CreateProvider("C#");

            try
            {
                var parser = new ConstantsDefinitionParser(inputFileContent);
                var definition = parser.Parse();

                var compileUnit = GenerateCode(definition);
                using (StringWriter writer = new StringWriter())
                {
                    CodeGeneratorOptions options = GetCodeOptions();

                    provider.GenerateCodeFromCompileUnit(compileUnit, writer, options);
                    //Generate the code
                    writer.Flush();

                    return GetContentBytes(writer);
                }
            }
            catch (Exception e)
            {
                HanldeException(e);

                //Returning null signifies that generation has failed
                return null;
            }
        }

        private CodeCompileUnit GenerateCode(ConstantsDefinition definition)
        {
            throw new NotSupportedException();
        }

        private static CodeGeneratorOptions GetCodeOptions()
        {
            CodeGeneratorOptions options = new CodeGeneratorOptions();
            options.BlankLinesBetweenMembers = true;
            options.BracingStyle = "C";
            return options;
        }

        private void HanldeException(Exception e)
        {
            StackTrace exceptionStackTrace = new StackTrace(e, true);
            StackFrame exceptionStackFrame = exceptionStackTrace.GetFrame(-2);
            int lineNumber = exceptionStackFrame.GetFileLineNumber();
            int column = exceptionStackFrame.GetFileColumnNumber();
            base.GeneratorErrorCallback(false, 4, e.ToString(), lineNumber, column);
        }

        public override string GetDefaultExtension()
        {
            return ".designer.cs";
        }

        private static byte[] GetContentBytes(StringWriter writer)
        {
            //Get the Encoding used by the writer. We're getting the WindowsCodePage encoding,
            //which may not work with all languages
            Encoding enc = Encoding.GetEncoding(writer.Encoding.WindowsCodePage);

            //Get the preamble (byte-order mark) for our encoding
            byte[] preamble = enc.GetPreamble();
            int preambleLength = preamble.Length;

            //Convert the writer contents to a byte array
            byte[] body = enc.GetBytes(writer.ToString());

            //Prepend the preamble to body (store result in resized preamble array)
            Array.Resize<byte>(ref preamble, preambleLength + body.Length);
            Array.Copy(body, 0, preamble, preambleLength, body.Length);

            //Return the combined byte array
            return preamble;
        }

    }
}

Most of the code is self-explanatory. The GetContentBytes method is used to convert the string to it’s binary equivalent and to prepend (if necessary) the byte order mark to it.

The whole code generation magic will happen in the GenerateCode(definition) method:

 private CodeCompileUnit GenerateCode(ConstantsDefinition definition)
{
	throw new NotSupportedException();
}

Although CodeDom makes it rather easy to generate code, there is a library called LinqToCodedom on CodePlex that provides a whole set of extension methods and classes that help creating dynamic code.

The GenerateCode method needs to create a namespace, add a class definition to it and then add definitions for each of the defined constants. As you can see below, the code is really easy to make and to understand, but a bit verbose if the classes are complex:

        private CodeCompileUnit GenerateCode(ConstantsDefinition definition)
        {
            var generator = new CodeDomGenerator();

            // create the namespace in which the class resides
            var codeNamespace = generator.AddNamespace(definition.Namespace);

            // create the class definition and set it's attributes
            var classDefinition = codeNamespace.AddClass(definition.ClassName);
            classDefinition.IsClass = true;
            classDefinition.TypeAttributes = System.Reflection.TypeAttributes.Public;

            AddConstantDefinitions(definition, classDefinition);

            return generator.GetCompileUnit(CodeDomGenerator.Language.CSharp);
        }

        private static void AddConstantDefinitions(ConstantsDefinition definition, CodeTypeDeclaration classDefinition)
        {
            for (var i = 0; i < definition.Constants.Count; i++)
            {
                var constantName = definition.Constants.GetKey(i);
                var constantValue = definition.Constants.GetValues(i)[0];

                var constant = new CodeMemberField(typeof(int), constantName);
                constant.Attributes = MemberAttributes.Public | MemberAttributes.Const;

                constant.InitExpression = new CodePrimitiveExpression(Convert.ToInt32(constantValue));

                classDefinition.Members.Add(constant);
            }
        }

Debugging the code

Fortunately debugging code generators is very easy due to a feature of Visual Studio called the “experimental hive”. Basically there is a copy of the related registry keys which can be used by VisualStudio when debugging instead of the main registry (to prevent hard to diagnose and fix problems). The Visual Studio SDK comes with a command line tool called ‘Reset the Microsoft Visual Studio 2008 Experimental hive’ which, as its name implies, resets this copy of the registry. So if something goes wrong, you can easily go back to the initial state of the experimental hive registry.

If you compile and run the code, a new Visual Studio window will appear. Create a new C# project (a ClassLibrary or Console project) and add a new text file to it. Name the file test.myfile and paste the definition into it. The moment you are saving the file, an automated file is created. If you’ve used the definition above, the generated file should look like this:

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:2.0.50727.4927
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace MyNamespace
{

    public class MyClass
    {

        public const int Red = 1;

        public const int Blue = 2;

        public const int Pink = 3;
    }
}

Stay tuned for part 4 of this series in which I go into creating a setup package and deploying the generator.

Downloads

The series is divided into four parts:

Part I  – creating a Visual Studio Package

Part II (this one) – creating and registering a code generator

Part III – generating code & debugging

Part IV – creating the setup project and deploying the package

So let’s jump directly to the problem at hand:

Part II – Creating and registering a code generator class

Since VS2008 add-ins are COM objects, our code generator needs to be prepared for COM interop first. To accomplish this, we need to make it com visible and to assign it a unique identifier.

First, open up the Guids.cs file. We will add there a new constant that keeps our generator’s GUID. You can use the GUID tool in Visual Studio (Tools->Create GUID). Make sure you are using the registry format and remove the brackets. I’m not a big fan of the default coding style found in the pre-generated classes, but for simplicity I’ve kept the same style in our demo project:

// Guids.cs
// MUST match guids.h
using System;

namespace MyCompany.MyCodeGenerator
{
    static class GuidList
    {
        public const string guidMyCodeGeneratorPkgString = "51b9761b-d943-454c-9397-29e2f2b68431";
        public const string guidMyCodeGeneratorCmdSetString = "a619ef76-b153-4f88-bbc5-fda566fe7b4a";
        public const string guidMyCodeGenerator = "1432CFC5-D0C4-44cd-A937-1D476F999219";
        public static readonly Guid guidMyCodeGeneratorCmdSet = new Guid(guidMyCodeGeneratorCmdSetString);
    };
}

The next step is to mark the actual code generator as COM visible and to set it’s GUID. This can be easily done by decorating the generator class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace MyCompany.MyCodeGenerator
{
    [ComVisible(true)]
    [Guid(GuidList.guidMyCodeGenerator)]
    public class MyCodeGenerator
    {
    }
}

The code generator has to be also registered as a code generator with Visual Studio and must implement the BaseCodeGeneratorWithSite abstract base class. When you register the code generator you have two options:

1. Register it with a human-readable name and then set it explicitly for a certain file. This method is especially useful if you have more generators that get the same input or if you don’t want to use the generator by default for a certain file. Another situation is where you don’t define a special extension but use already existing file types (XML for example).
2. Register it as a generator for a certain file extension. This is my favorite since I can create different file extensions for different scenarios. I will go with this option in my example, but you only have to change the name from “.extension” to whatever name you want.

In the attached zip file you will see that we have a CodeGeneratorRegistrationAttribute class. This can be found in the Visual Studio SDK or you can copy it from the zip. This file is responsible with creating the necessary registry keys for our generator. To register the generator we need to decorate it using this attribute:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio.TextTemplating.VSHost;
using Microsoft.VisualStudio.Shell;
using VSLangProj80;

namespace MyCompany.MyCodeGenerator
{
    [ComVisible(true)]
    [Guid(GuidList.guidMyCodeGenerator)]
    [CodeGeneratorRegistration(typeof(MyCodeGenerator), ".myfile", vsContextGuids.vsContextGuidVCSProject, GeneratesDesignTimeSource = true, GeneratorRegKeyName = ".myfile")]
    public class MyCodeGenerator : BaseCodeGeneratorWithSite
    {
        protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
        {
            throw new NotImplementedException();
        }

        public override string GetDefaultExtension()
        {
            throw new NotImplementedException();
        }
    }
}

The attribute tells Visual Studio that it should automatically use the generator for all *.myfile files. The vsContextGuids.vsContextGuidVCSProject tells Visual Studio that this generator should be used when editing a C# project. There are other options for different supported languages. The other parameters are self-explaining.

Downloads:

MyCodeGenerator-part2

Since there are almost no resources (and the existing ones are very blurry) I’ve decided to create a series of blogs that will be a guide to creating custom code generators, followed by some other posts with real examples and solutions to problems.

The series is divided into four parts:

Part I (this one) – creating a Visual Studio Package

Part II – creating and registering a code generator

Part III – generating code & debugging

Part IV – creating the setup project and deploying the package

*DISCLAIMER* – Even if everybody is in the new VS2010 hype, I still think there are a lot of developers that are and will be working in VS2008 for a while.

Before jumping to the gory details, you need to be aware that creating code generators is only possible using Visual Studio Professional or higher. Also, you need to install the Visual Studio SDK which can be found here.

Part I  – Creating a Visual Studio package

In order to create a custom code generator we need to create a Visual Studio package. I am not 100% sure that this is needed, but I wasn’t able to install the code generator in any other kind of project.

So open Visual Studio and create a new Visual Studio Integration Package project. I’ll call it MyCodeGenerator

A wizard will start guiding you through the package creation steps. You will want to select Visual C# as the language, and to create a new key to sign the assembly. Optionally, if you already have a key, use that one:

The next screen will ask you for package details. You can enter here a company name, a human-readable package name, the package version and the minimum required Visual Studio version required to use the package. Also, you can set an icon for the package. This information will be later used for signing the package.

The third screen will allow you to add extra functionality to the package (menu commands, tool windows or a custom editor). For our generator we don’t need any, so leave the fields unchecked.

To keep things simple, we won’t use integration or unit tests, so leave the next fields unchecked. If you are using TDD with the Visual Studio test framework, you can leave the checkboxes selected.

After clicking finish, you will get a new Visual Studio Integration Project.

Package and assembly registration

Add a new class, and name it MyGenerator.cs. Change the class visibility to public. Since Visual Studio code generators and packages are used as COM objects, we need to register the generator assembly and package. The Visual Studio SDK contains an attribute class that makes this an easy task. The class is called CodeGeneratorRegistrationAttribute and you can find it in the SimpleFileGenerator example project (mine is in c:\Program Files\Microsoft Visual Studio 2008 SDK\VisualStudioIntegration\Samples\Project\CSharp\Example.SingleFileGenerator\CodeGeneratorRegistrationAttribute.cs). Alternatively, you can use the one in the attached project.

Add the file to the project and add references to the following assemblies:

• Microsoft.VisualStudio.TextTemplating.VSHost
• VSLangProj
• VSLangProj2
• VSLangProj80
• VSLangProj90

The VSLangProj assemblies are duplicated in the GAC (they can be found in two locations). I have successfully used the ones in the C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies\ folder.

For the package assembly to be registered as a COM, you need to set it’s ComVisible attribute to true. Open Properties –> AssemblyInfo.cs and edit the line that says:

[assembly: ComVisible(false)]

to

[assembly: ComVisible(true)]

Also, you need to register the assembly from COM Interop. You can accomplish this by opening the project properties and checking the Register for COM interop checkbox.

That’s it for the first step.

Check out the second part of this tutorial on how the code generator is implemented and how we can debug it.

Downloads:

MyCodeGenerator-part1

The ISynchronized interface

The first thing to do is to make a contract for all classes that need to expose this functionality. The ISynchronized interface declares this contract. Basically it only exposes a single property which contains the synchronization context on which the code must be executed.

   1: using System.Threading;

   2:

   3: /// <summary>

   4: /// Contract for classes that must be able to execute methods in a certain synchronization context.

   5: /// </summary>

   6: public interface ISynchronized

   7: {

   8:     /// <summary>

   9:     /// Gets the synchronization context.

  10:     /// </summary>

  11:     /// <value>The synchronization context.</value>

  12:     SynchronizationContext SynchronizationContext

  13:     {

  14:         get;

  15:     }

  16: }

The extension method

In order to easily use this I have made an extension method that allows specifying an Action to be executed on the synchronization context.

   1: using System;

   2:

   3: /// <summary>

   4: /// This class contains the extension methods for the ISynchronized implementations.

   5: /// </summary>

   6: public static class SynchronizedExtensions

   7: {

   8:     /// <summary>

   9:     /// Executes the supplied action in the instance's SynchronizationContext.

  10:     /// </summary>

  11:     /// <param name="instance">The synchronized instance.</param>

  12:     /// <param name="synchronizedAction">The synchronized action.</param>

  13:     public static void Synchronized(this ISynchronized instance, Action synchronizedAction)

  14:     {

  15:         if (instance.SynchronizationContext != null)

  16:         {

  17:             instance.SynchronizationContext.Post(CallAction, synchronizedAction);

  18:         }

  19:         else

  20:         {

  21:             synchronizedAction();

  22:         }

  23:     }

  24:

  25:     /// <summary>

  26:     /// Calls the passed action.

  27:     /// </summary>

  28:     /// <param name="state">The state.</param>

  29:     private static void CallAction(object action)

  30:     {

  31:         var actionToExecute = action as Action;

  32:         actionToExecute();

  33:     }

  34: }

The Synchronized method checks if there is a synchronization context and if it is, it will post a call on the synchronization context. If it doesn’t exist, it will call the action directly.

Sample usage

Suppose we have a method SetText which sets the text in a control on the current Form/User control etc. This method must be called on the UI thread, otherwise an exception is raised by the framework. The following method will do this using the above extension method:

public void MethodThatGetsCalledOnAnArbitraryThread(string text)

{

this.Synchronized(() =>

{

this.SetText(text);

});

}

You can write any code inside the action or just use a delegate for this.

For all the issues above, there is a very simple solution which will make your life easier. You just need to right click an XAML file and choose Open With…. In the dialog select Source Code (Text) Editor and make it the default editor. You will get exactly the same features as in the XAML editor (Intellisense etc.), but without the crashes and performance issues.

Windows & multimedia utilities

Here is stuff that I use for normal Windows operations, multimedia etc.

• IZarc – I actually like this more than 7zip because of it’s GUI. It “knows” the same archive formats as 7zip and it is very fast.
• Total Commander – This is one of the most used and useful tools out there. For those that don’t know it (what planet do you live on?), TC is a Windows file manager similar to Norton Commander. It offers two-pane file system navigation, basic copy/move/rename operations (that can be moved in the background or queued), multiple file renaming, file comparison, viewer and editor integration and way more. If you don’t have it already, go try it, it has a very large list of features (and add-ins) that will cover all your file & folder manipulation needs. I have tried several alternatives, but none compare with Total Commander.
• cdrtools frontend – A free, open source front-end for all the Linux command line CD/DVD writing tools. It is simple to use and offers all functionality that commercial packages provide (Data CD/DVD & Audio CD writing, creating and writing CD images, Video CD writing etc.). I particularly like it because it’s very light and only does what it’s supposed to do. Most commercial packages (like Nero or Roxio) have become very bloated for me and I don’t use them anymore. If you feel the same, then cdrtools offers you a great alternative.
• AIMP – A free alternative to Winamp. Same as with Nero, Winamp has become a very big and bloated application. In the end I just need something to listen to music, and AIMP is great for this. Designed as a Winamp clone, it offers more features in some areas (like playlist management), it’s very easy to use and has a very low memory footprint.
• FastStone Image Viewer – One of the best image viewers out there. It supports a lot of image formats (couldn’t find an unsupported one yet), has basic image manipulation features (crop, resize, adjust colors etc.) and also has support for batch file processing. It also features an easy to use screen capture utility.
• GOM player – A very nice video player which automatically downloads necessary codecs. It has a lot of options for tweaking the videos you watch and a feature that I particularly like is that it automatically loads similar files from the same folder. This is very useful when watching a TV series and it loads all other episodes from the same folder.
• The GIMP – An alternative to Adobe Photoshop. It is not as advanced or easy to use as Photoshop, but you can get simple things done with it. It features multi-layer image editing, a lot of effects and brushes.
• Exact Audio Copy – This is a CD ripping tool that supports output to WAV, FLAC or MP3.
• CUE Splitter – A tool that splits a single audio file into tracks based on information in a CUE file.
• Audio Grabber – A free application for ripping and most important Line in sampling. I use it all the time for recording mixes or live performances.

Development tools

• Reflector – This is invaluable to any .NET programmer. It allows you to dig inside assemblies and view their source code. Sometimes this is the only way to accomplish things.
• CodeRush Express – This is also mentioned on Scott Hanselman’s list but I think it really deserves to be mentioned again. With every version it becomes better and better and it just fills all the missing spots in the Visual Studio IDE. The paid edition offers even more functionality, but even with the free one, you can boost your productivity many times.
• GhostDoc – This small Visual Studio Add-in is a gem. You can provide documentation for your code with two clicks. The documentation is generated by analyzing your method or property names, which means that most of the time you need to hand edit it. Still it is a huge timesaver and if you follow correct coding rules, you can minimize the hand editing effort.
• FXCop – Provided by Microsoft, it is a free add-in that checks your code at compile time for various issues that affect performance, security and other areas.
• StyleCop – The complement for FXCop, it checks your code at compile time for coding standards violations. This is very useful for actively imposing a coding standard to your team.
• NArrange – This is a helper tool which beautifies your source code. There are other alternatives (like Regionerate) out there, but the nice thing about NArrange is that the result is StyleCop compliant. This is very useful especially when introducing StyleCop on a very large project because you can quickly eliminate 80% of the violations. Both tools can be customized to impose your own coding standard.
• NUnit – one of the oldest unit testing tools for the .NET platform. It’s simple and easy to learn and I use it in my testing projects. There are alternatives out there (including the Visual Studio unit testing components), but I like that I can use NUnit without Visual Studio and it is free.
• Moq – A very nice mocking framework. At the beginning I was oscillating between Rhino Mocks and Moq, but I couldn’t use Rhino Mocks for mocking (or is it moqing ) methods that received Action or Function arguments. Moq provides a nice fluent interface and it is very very easy to use. I recommend also checking out Rhino Mocks, since that is also a very good mocking framework.
• StructureMap – IoC/DI is a very common buzzword. From all IoC/DI frameworks I’ve tried, I like  StructureMap the most. It provides a lot of ways for registering and resolving dependencies and one feature that I use a lot is the possibility of managing the object lifetime.
• VScommands – Free add-on for Visual Studio that allows you to group files together.
• Subversion, TortoiseSVN and Visual SVN Server – This is really indispensable in my day-to-day work. Subversion keeps track of your code files, allows you to share them with your team and to version them. TortoiseSVN is the front-end GUI for Subversion, while Visual SVN Server is a very easy way to setup your Subversion server on the Windows platform.

Browsers, addins and extensions

I mostly use FireFox for web browsing and sometimes Google Chrome or Internet Explorer. So this will cover mostly my addins for FireFox:

• ColorZilla – Color picker tool useful for web development
• Dafizilla Table2Clipboard – Firefox doesn’t copy HTML tables correctly for pasting in Word. This add-on fixes this issue.
• Delicious Bookmarks – This is one of my favorites add-ins. It allows you to save your bookmarks in Delicious. Now you can also tweet your bookmarks.
• DownThemAll – A very good download manager for FireFox. It allows you to choose different download destinations and replaces the default basic download manager that comes with Firefox.
• Firebug – Indispensable if you do web development. It allows you to view all details of the current page (network traffic, request/response headers, response content, cookie information, JavaScript information & debugger). Also you can use the YSlow extension to find performance issues in your website.
• IE Tab – Useful if you need to do cross-browser tests.
• LastPass – This is an add-on which saves your passwords in an online storage. The passwords are encrypted using 256 bits encryption.
• MeasureIt – Add-on for measuring elements on web pages.
• Web Developer toolbar – Adds various web development tools (such as disable JavaScript, disable cache, etc.)

While this list is not exhaustive I hope it is useful for somebody out there. Let me know if you know/use more cool tools.

The INotifyChangedProperty exposes only the PropertyChanged event which is used by observers to subscribe to the change notifications. The typical pattern is to have a base class which will fire the events like this:

   1: public abstract class PropertyChangedNotifier : INotifyPropertyChanged

   2:    {

   3:        protected virtual void OnPropertyChanged(string propertyName)

   4:        {

   5:            var eventHandler = PropertyChanged;

   6:            if (eventHandler != null)

   7:            {

   8:                eventHandler(this, new PropertyChangedEventArgs(propertyName));

   9:            }

  10:        }

  11: }

This can be used like this:

   1: public class MyClass

   2: {

   3:     private string myProperty;

   4:     public string MyProperty

   5:     {

   6:         get { return myProperty; }

   7:         set

   8:         {

   9:             if(myProperty != value)

  10:             {

  11:                 myProperty = value;

  12:                 OnPropertyChanged("MyProperty");

  13:             }

  14:         }

  15:     }

  16: }

For small projects, this implementation is ok, but on large scale projects, using such an implementation will lead to a maintenance nightmare, especially when performing property rename refactorings. After each refactoring, you need to manually change the name of the property inside the setter.

Type safe implementation using Expression Trees

.NET 3.5 comes with the ability of navigating through the object hierarchy using Expression trees. This is used for example in LINQ providers for dynamically building the SQL queries. The same Expression trees can be used in this case for building a type safe solution for the OnPropertyChanged method:

   1: public abstract class PropertyChangedNotifier : INotifyPropertyChanged

   2: {

   3:    protected virtual void OnPropertyChanged<T>(Expression<Func<T>> action)

   4:    {

   5:        var propertyName = GetPropertyName<T>(action);

   6:        OnPropertyChanged(propertyName);

   7:    }

   8:

   9:    protected static string GetPropertyName<T>(Expression<Func<T>> action)

  10:    {

  11:        var expression = (MemberExpression)action.Body;

  12:        var propertyName = expression.Member.Name;

  13:        return propertyName;

  14:    }

  15:

  16:    public event PropertyChangedEventHandler PropertyChanged;

  17: }

Coming back to the class example above, the new type safe implementation can be used as below:

   1: public class MyClass

   2: {

   3:     private string myProperty;

   4:     public string MyProperty

   5:     {

   6:         get { return myProperty; }

   7:         set

   8:         {

   9:             if(myProperty != value)

  10:             {

  11:                 myProperty = value;

  12:                 OnPropertyChanged(()=>this.MyProperty);

  13:             }

  14:         }

  15:     }

  16: }

Conclusion

In this blog article I have presented a way of implementing a type-safe notifier for the INotifyPropertyChanged interface. The implementation presented here uses expression trees for achieving this.

I haven’t tested the performance overhead of using expression trees, but I guess if this is an issue, you can easily cache the results for further usage.

• IDictionary<TKey, TValue>.GetValueOrDefault
• IEnumerable<T>.ToHashSet
• IEnumerable<T>.ToJoinedString

GetValueOrDefault

GetValueOrDefault is a simple extension method that wraps the IDictionary.TryGetValue method. Since the TryGetValue method cannot be used in lambda expressions, it makes it difficult to use dictionary lookups in LINQ, for example. The GetValueOrDefault method offers a wrapper which silently tries to get a value based on a key. If the value does not exist in the dictionary, it will return either the default value for the value type or a supplied default value.

ToHashSet

There are several extension methods in LINQ which allow conversion from an IEnumerable to another collection type (ToList, ToArray, ToDictionary etc.). Sometimes it is useful to convert an IEnumerable to a HashSet, in order to perform quick lookups for a certain value.

The nice thing about the HashSet is that it has an O(1) lookup and insertion complexity, so it is really fast.

The ToHashSet extension method converts a source IEnumerable to a strongly typed HashSet, and has the possibility of supplying an IEqualityComparer. This is nice if the comparison logic is more complex or if you want for example to build a case-insensitive HashSet<string>.

ToJoinedString

One of the methods that is very common when working with string arrays is string.Join. Unfortunately, this method can only use string arrays. Of course you can always convert a string collection to an array and then apply the ToString method, but this induces some overhead, especially when the collection is large.

The ToJoinedString extension method does the same thing as string.Join but works on any type of IEnumerable. Internally it uses a StringBuilder object to concatenate strings, so it offers a high performance, even when working with large string collections.

The Code

Here is the code for the extension methods. You can just copy & paste the following code in your project and use it as is:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public static class GenericCollectionExtensionMethods
{
    #region Methods

    /// <summary>
    /// Tries to get a value from a dictionary based on a supplied key. If the value does not exist in
    /// the dictionary it will return the default value for the value type.
    /// </summary>
    /// <typeparam name="TKey">The type of the key.</typeparam>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="dict">The dictionary.</param>
    /// <param name="key">The key.</param>
    /// <returns>
    /// The value that corresponds to the supplied key or the default value for the value type.
    /// </returns>
    public static TValue GetValueOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dict, TKey key)
    {
        TValue value;
        if (dict.TryGetValue(key, out value))
        {
            return value;
        }
        else
        {
            return default(TValue);
        }
    }

    /// <summary>
    /// Tries to get a value from a dictionary based on a supplied key. If the value does not exist in
    /// the dictionary it will return the supplied value.
    /// </summary>
    /// <typeparam name="TKey">The type of the key.</typeparam>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="dict">The dictionary.</param>
    /// <param name="key">The key.</param>
    /// <param name="defaultValue">The default value.</param>
    /// <returns>
    /// The value that corresponds to the supplied key or the value of the 
    /// <paramref name="defaultValue"/> parameter.
    /// </returns>
    public static TValue GetValueOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dict, TKey key, TValue defaultValue)
    {
        TValue value;
        if (dict.TryGetValue(key, out value))
        {
            return value;
        }
        else
        {
            return default(TValue);
        }
    }

    /// <summary>
    /// Converts the source to a hash set.
    /// </summary>
    /// <typeparam name="TSource">The type of the source.</typeparam>
    /// <param name="source">The source enumerable.</param>
    /// <returns>A typed hash set containing the items from the source enumerable.</returns>
    public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource> source)
    {
        return new HashSet<TSource>(source);
    }

    /// <summary>
    /// Converts the source to a hash set.
    /// </summary>
    /// <typeparam name="TSource">The type of the source.</typeparam>
    /// <param name="source">The source enumerable.</param>
    /// <param name="comparer">
    /// The comparer used by the hash set. This is useful for example when building a case insensitive
    /// hash set.
    /// </param>
    /// <returns>A typed hash set containing the items from the source enumerable.</returns>
    public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
    {
        return new HashSet<TSource>(source, comparer);
    }

    /// <summary>
    /// Joins the string representation of all items in an IEnumerable to a string, using a separator.
    /// </summary>
    /// <typeparam name="T">The type of the elements contained in source collection.</typeparam>
    /// <param name="source">The source collection</param>
    /// <param name="separator">The separator used to glue items together</param>
    /// <returns>
    /// A string obtained by glueing the collection items with the separator, similar to string.Join
    /// </returns>
    public static string ToJoinedString<T>(this IEnumerable<T> source, string separator)
    {
        var sb = new StringBuilder();
        bool first = true;
        foreach (var item in source)
        {
            if (first)
            {
                first = false;
            }
            else
            {
                sb.Append(separator);
            }

            sb.Append(item.ToString());
        }

        return sb.ToString();
    }

    #endregion Methods
}