.NET

In a new world, my new job and coming to terms with ExtJs

Scott Galloway — Mon, 24 Jan 2011 09:57:05 GMT

After over a year away from them, I’m busy at my new job in Glasgow with Dell (you know, they make the big black computers) as a Senior Dev Lead (I think, titles are still a bit mixed up). Loving being back working with a team; though I’ve spent most of my time sniping from the sidelines…the beginnings of my influencing the future direction our application takes. This is a bit of a departure for me, I’m used to developing very high scale and performance apps for internet use, but this one has a more limited audience (so far!) . The app I’m working on is the one used by the Dell factory and corporate customers for defining the ‘images’ written on to machines at the factory…and new machines in IT departments. So before you ask…no I don’t write the crapware, but our app is used to write it to the machines (sorry!).

Anyway, the app I’m working on is pretty interesting, very MS based, uses an SOA architecture and ExtJS as a front end. Kind of uses MVC 2 (just a very thin layer used to provide JSON through ExtJs.Direct.MVC).
ExtJs is an interesting beast…essentially and entirely client side UI framework which bumps all it’s templates and code down to the browser in one big file (we use script combining and compression). From then on, you app UI is instantiated entirely on the client…for an old jQuery / Server-side coder like me this is a bit shocking. I understand the theory behind it…in essence all you require from the server after the first load is the JSON which represents the data each ‘page’ requires (though really each ‘operation’).
My biggest issue with this approach is: Javascript is a sucky language to build UI with. There, I’ve said it! Now don’t get me wrong, I love Javascript, books like those I recommend below really have over the past year or two really rekindled my love of Javascript (along of course with the superlative jQuery).

Amazon.co.uk Widgets

My main issue with ExtJS is that is defines the templates it uses entirely in code…and any customization to those templates (size, contents etc…) is also performed using Client-Side code. Looking at the codebase of a reasonably large application like our, I can see well over 200 individual JS files which typically map to operations. Frankly, it’s a bit of a pain to read this stuff and update it. Validation logic, text strings containing content etc…are all encapsulated in these files along with operation –> operation flow information.

Anyway, unfortunately I’ve joined the team when we’re just about to do our first release…so it’s WAY too late to change (and frankly we have a huge investment in this). My preference is to write UI using server side code to generate HTML (with Razor pages of course!) and load initial data in to the UI using this server side code (whether through partial views and jQuery or just direct rendering to the browser). AJAX is awesome and when used properly can give a very responsive UI…for example, when saving data from a page back to the server, I would always use AJAX these days and give validation feedback direct to the page. Well anyway, enough of the rant. There’s lots of places where I *can* make improvements…and hey, it’s a good job right!

Sometimes, no matter how much you want to change stuff you just have to live with it!

Best Practices for .NET developers

Scott Galloway — Tue, 18 Jan 2011 13:46:44 GMT

This is something I'm doing for my team at work...thought you may like a look / comment etc...

Know the SOLID principles…

See http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod (the first 5). These are fundamental principles for good OO software design, know them…love them!

If you don’t need it…delete it!

As for Code Comments below, never check in an Excluded Class to the source control system. It adds noise and is a great way to have hard to trace exceptions if they’re accidentally re-included.

Code comments

I know it’s in the policy document but to be honest no-one uses generated docs when tests are a better alternative for learning code.

Code comments should only be used to clarify complex algorithms, apart from that they just add cruft to code and make it harder to read. Method / parameter names should be descriptive (I frankly don’t care how long they are, that’s what intellisense is for!). If you can’t work out what a method does from its name…rename it. Or if a method does more stuff than you can reasonably fit in a name, you need to refactor the method.

Keep classes compact

No hard and fast rule here but if you’re >200 lines in a single class think seriously whether you need to refactor. If you follow rule 1 of SOLID (Single Responsibility Principle) then this should rarely happen.

Keep names meaningful

There are, no prizes for being terse…the more readable your code, the easier it is for you and others to find bugs.

Use ‘var’ instead of the type name where appropriate.

In general it’s both neater and increases code readability to replace an often lengthy type name with the ‘var’ keyword. The main counterpoint to this is when the return type of an operation is not obvious from the name of the method / context.

Instead of:

StringBuilder sb = new StringBuilder(256);
UTF8Encoding e = new UTF8Encoding();
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();

We’d end up with this

var sb = new StringBuilder(256);
var e = new UTF8Encoding();
var md5 = new MD5CryptoServiceProvider();

Use the ‘as’ operator when casting reference types

The ‘as’ operator avoids runtime exceptions (e.g., (string)foo[“bar”] could well throw an exception), in addition it is far more performant that doing an ‘is’ followed by an explcit cast.

Prefer enums over bools when they are used as return types from methods.

Enumerators make your code more readable (e.g. returning the value Car.Red from is CarColor rather returning true from the method IsCarRed) , they also make it far easier to extend code later on (true and false being rather limiting…)

Exceptions should only be used to indicate Technical Errors

Exceptions in .NET are valuable and when used well are a great feature. However, they should never be used as a tool in normal programmatic flow, only when an object does not perform an operation according to its specification / interface should an exception be returned.

Never catch an exception you can’t do something with

Unless you actually do something with an exception, let it bubble up to somewhere which can do something (even if just reporting it to the user)

Use nullable types sparingly

Nullable types encourage optional parameters…optional parameters encourage branching within methods and reduce testability. Avoid them.

Never call the GC manually

It’s smarter than you (oh, EXCEPT if you’re using unmanaged objects)

Always use generic collection types over their non-generic ancestors

The generic collections are faster, avoid boxing and are basically cooler

The same applies to the new Concurrent collections when multithreading in 4.

Use the TPL

In .NET 4 when using concurrency prefer the new TPL http://msdn.microsoft.com/en-us/library/dd460717.aspx functions over managing threads ‘by hand’

Prefer simplicity over more complex language features

Keeping your code simple to follow is critical to making changes easy and relatively low risk, one of the simplest ways to achieve this is to keep your code as transparent and simple to follow as you can.

Write, Test, Refactor, Test

Well factored code is easier to read, easier to change and easier to debug…A great test for well factored code is the ‘Single Responsibility Principal’, each method should really only perform a single operation on an object (for example, a single method should never both update and delete, or compress and save to disk).

· Avoid branching within methods
· Where you can avoid recursive methods

Avoid Regions

If you can’t navigate through a single class file without collapsing sections of the code then your class is almost certainly in need of refactoring.

Regions add noise and make it harder to read code.

Only place they can be valuable is with long test classes…

Avoid Singletons

They mostly avoid concurrency issues at the expense of performance...there's almost always a better way.

Use Conditional Statements and Conditional Directives

When used properly, Conditional Debug Statements and conditional directives such as those below can be extremely useful in adding extra information to help you debug apps:

#if DEBUG
…
#endif

and

[Conditional(“DEBUG”)]

The main advantage of this method of adding additional debug information is that they are not output when the code is compiled in release mode.

If you DO use nullable types NEVER cast directly to the non nullable form

Again, this is a potential source of runtime exceptions. Instead, always use the .GetValueOrDefault() method and test for the default value (if necessary) before trying to use the value.

Avoid using the ‘this.’ Keyword

If your naming scheme is correct, you should never have to use ‘this.’ to specify that an object is local to your class.

Handy indexes for versioning with RavenDB

Scott Galloway — Mon, 12 Jul 2010 13:59:40 GMT

Mainly for me to remember this but if you’re using the excellent Versioning bundle for RavenDB then you’ll find you quickly need to work out a way to get the latest version of a document if querying on any field other than ID (I *believe* ID actually only gets the latest one). The little index definitions below do just that (the secome one is just adding another field to the map so I can query by that…useful example)…

documentStore.DatabaseCommands.PutIndex("CurrentVersion", new IndexDefinition { Map = @"from doc in docs where doc[""@metadata""][ ""Raven-Document-Revision-Status""] != null && doc[""@metadata""][ ""Raven-Document-Revision-Status""] == ""Current"" select new {doc};" },true); documentStore.DatabaseCommands.PutIndex("CurrentImageVersionBySlug", new IndexDefinition { Map = @"from doc in docs where doc[""@metadata""][""Raven-Entity-Name""] ==""Images"" && doc[""Slug""]!=null && doc[""@metadata""][ ""Raven-Document-Revision-Status""] != null && doc[""@metadata""][ ""Raven-Document-Revision-Status""] == ""Current"" select new {Slug=doc[""Slug""]};" , } , true);

John Lam’s Dev Kit

Scott Galloway — Mon, 08 Sep 2008 22:35:43 GMT

Kind of a ‘tools’ list but a great post on what John uses on his machine…a few new ones I hadn’t seen which is always nice!

Premature optimization and user perception...my pet project and CSS Sprites

Scott Galloway — Sat, 12 Jul 2008 02:54:36 GMT

One of the themes I'm looking at for vNext of ASP.NET is the optimization of sites by reducing the number of server requests required for a single page.
A new classic in the area of improving the perceived performance of your sites by reducing the number of server roundtrips is Steven Sounders book 'High Performance Websites'. Steven's book is very small, very readable and probably the best book on anything to do with the web that I've read in years.
This book was a huge revelation for me...I spent most of my coding career writing the slickest, highest performing code I could...and frankly thinking about the structure of the actualy pages the user sees would've been a better use of my time in a lot of cases. As an example,, this was one of the last sites which I worked on as a full time developer...the code is about the best I ever created, the DB is optimized up the wazoo and I very nearly killed myself trying to make it 'perfect'...but for the hundreds of hours I spent sweating blood over the code you could now spend a couple of thousand dollars on a faster server and improve the performance even more...(even ignoring the fact that it's HUGELY overengineered...even has it's own MVC system and templating feature...hey, I was bored!)
As servers get faster and programming frameworks get more efficient, the amount of time your web server actually spends processing a page, doing a DB request and whatever else it has to do to generate HTML gets smaller and smaller; with better use of caching, AJAX and other techniques it's likely that you page actually returns it's total content to the user in milliseconds.... You can really only make minimal gains to 'preceived performance' in your sites by optimizing the dynamic code in your web application these days...(and this will likely only reduce over time)

Welcome to Moore's law

The fact is that for 99% of web pages the issue is no longer really about optimizing the amount of time your page takes to return HTML content to the user...it's what happens afterwards which leads to poor download performance.

The Problem

Websites nowadays have more and more separate elements in a single webpage, images, css, js files, flash content, videos etc...often the number of requests sent from single page can take MANY (as in several orders of magnitude) times longer than the bit we developers commonly fret about. As an example a few seconds ago I requested the CNN homepage, the actual page of HTML content loaded in 222ms, but the OTHER 153 requests for the rest of the stuff the page needed took a total of 4.65s.
One way to avoid a large number of these other requests is to combine requests for multiple objects together. In ASP.NET 3.5 SP1 we'll be shipping a feature called 'ASP.NET AJAX Script Combining', as the name suggests this feature combines multiple HTTP requests (in this case for the ASP.NET AJAX scripts) into a single request, potentially greatly reducing the number of roundtrips to the server.

Where is this going?

Well, a feature I've been playing with (and which I'm considering for ASP.NET vNext) is an ASP.NET CSS Sprite Control. Zack Owens has already posted about a technique for doing this in ASP.NET, but I wanted to increase the usability of generating these sprites; think using an ASP.NET image control and them magically being combined and output as part of a Sprite...
For those who don't know, CSS Sprites are essentially a technique which involves combining multiple images into one and using CSS to specify which one to show when they download. With this technique you both reduce the number of server requests as well as 'pre-loading' images on the fly (when's the last time you had an image rollover which seemed to stutter as it loaded the next image?).
Anyway, that's the idea; below is a some ASP.NET markup I'm playing with...this would resuly in a single PNG image being generated, along with a CSS definition for the sprite and for each 'image' to be displayed in the page.
This is still very much a work in progress and there's a ton of challenges around persisting the generated image in a scalable way etc...But well, I've been quiet of late so I thought I'd let you know what I'm playing with these days...

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<cs:SpriteManager runat="server" GroupName="DEFAULTGROUP" ImageFormat="png"></cs:SpriteManager>
</head>
<body>
<form id="form1" runat="server">
<cs:Sprite ID="Sprite" ReferenceId="Clock" runat="server" ImageUrl="~/icons/Clock.ico"/>
<cs:Sprite ID="Sprite1" ReferenceId="Contacts" runat="server" ImageUrl="~/icons/contacts 1.ico"/>
<cs:Sprite ID="Sprite2" ReferenceId="Alerts" runat="server" ImageUrl="~/icons/alerts.ico" />
<cs:Sprite ID="Sprite3" ReferenceId="Download" runat="server" ImageUrl="~/icons/download.ico"/>
<cs:Sprite ID="Sprite4" ReferenceId="Desktop" runat="server" ImageUrl="~/icons/desktop.ico" />
</form>
</body>
</html>

My secret project....NET 3.5 SP1 Beta (well, the release bit)

Scott Galloway — Mon, 12 May 2008 16:53:33 GMT

I should have made this a better post but anyway. Brad Abrams just posted about the .NET 3.5 SP1 Beta release .
We've also posted a bunch of new Screencasts covering the new features for ASP.NET in this release, as well as a readme which has some getting started and upgrade information for migrating from the previous release...

Grrr...poor use of singletons and a very cool Generic Singleton pattern!

Scott Galloway — Thu, 01 May 2008 05:42:20 GMT

I posted earlier that I'm switching to blogengine.net, as part of this I've been fiddling around with the code (as is my way..I'll contribute back to the source when I've finished). One of my major pet hates is poor use of the singleton pattern, especially as there's a definitive article on the pattern in .NET and how to do it well. It's actually likely that this pattern is overkill in this case and a ReaderWriterLockSlim could be better (though it has it's own problems) . Anyway, on the assumption that a Singleton is the best choice here, let's look at the current code:

public static BlogSettings Instance

        {

            get

            {

                if (blogSettingsSingleton == null)

                {

                    blogSettingsSingleton = new BlogSettings();

                }

                return blogSettingsSingleton;

            }

        }

If you look at the article I mentioned above you'll see that this is the version which is specifically called out as follows:

"the above is not thread-safe. Two different threads could both have evaluated the test if (instance==null) and found it to be true, then both create instances, which violates the singleton pattern. Note that in fact the instance may already have been created before the expression is evaluated, but the memory model doesn't guarantee that the new value of instance will be seen by other threads unless suitable memory barriers have been passed.'

The common 'best' singleton pattern (well, it's debatable...but generally the best...) is a lot more wordy (see version 5 in that article) so I was please to find this post on a Generic Singleton (actually this was posted a while ago on Codeproject)...really nice. In the Utils class I added this:

    /// <summary>

        /// Provides a Singleton implementation using Generics.

        /// </summary>

        /// <typeparam name="T">Type of singleton instance</typeparam>

        public sealed class Singleton<T> where T : new()

        {

            Singleton() { }

            public static T Instance

            {

                get

                {

                    return Nested.instance;

                }

            }

            class Nested

            {

                // Explicit static constructor to tell C# compiler

                // not to mark type as beforefieldinit

                static Nested() { }

                internal static readonly T instance = new T();

            }

        }

The code for returning the instance then becomes:

        public static BlogSettings Instance

        {

            get

            {

                return Utils.Singleton<BlogSettings>.Instance;

            }

        }

You have to also change the constructor for BlogSettings to public to allow this this to work which does let devs shoot themselves in the foot (by ignoring the singleton) and you of course have to balance the benefit agains that risk...

Why do single chances make me nervous...life should come with an undo function...

Scott Galloway — Wed, 16 Apr 2008 05:01:34 GMT

Spent most of the day not doing what I should've been doing. I have a number of balls in the air at the moment and it feels like I've just added a spinning plate act at the same time...noisy disaster may ensue. Right now I'm working on another Codeplex release, working on a private build of some beta bits for the Insiders, getting our bugs migrated to the right place so we can get cracking on ASP.NET v.Next, getting the notes together for the last meeting (before the next one happens!) as well as getting the Hands-On-Labs ready for this thing...All of which are pretty much due right now...oh and I just got out of a multi-month relationship with my now ex-girlfriend...so let's say my time is now exactly my own right now. (Ideally I'd be sitting in a little boat in the Caribbean for a couple of weeks but alas...). Anyway in the heart of this perfect storm I managed to do a bit of fiddling with code...Essentially I'm putting a method together to help us make quicker, less onerous Codeplex releases (we want to get as much stuff there as often as possible). I've been writing (and I've written about it before) a little directory comparer tool which I'm about to expand into adding changed items into TFS (for Codeplex pushes)...for various reasons the current way TFS makes us do this is a bit problematic for us...which meant we were using a python based tool which was 1. a bit flaky (poor errors) and 2. unmaintainable since of all the languages used in my team, Python ain't one...

Well, here's some code for the most recent incarnation (solution for follow)...it's getting a few add-ons like the ability to ignore certain directories / file extensions, multi-part configuration system and just a few general performance fixes.

Oh, and next week I plan to take a deep dive into the ASP.NET Page framework, giving an overly detailed guided tour of how it does it's stuff...

using System;

using System.Collections.Generic;

using System.Collections;

using System.Collections.Specialized;

using System.Text;

using System.IO;

namespace MergeDirs

{

    class Program

    {

        #region Sample Config

        /* Sample code for default config creation

        * {           ConfigurationGroup cg = new ConfigurationGroup();

            cg.ConfigurationItems.Add( new Config() { SourceDirectory = "source1", DestinationDirectory = "dest1", ClearDestination = true, ExtensionsToExclude = new List<string>(new string[] { "vssscc", "dll", "pdb", "vspscc" }), DirectoriesToExclude = new List<string>(new string[] { "bin" }) });

            cg.ConfigurationItems.Add(new Config() { SourceDirectory = "source2", DestinationDirectory = "dest2", ClearDestination = true, ExtensionsToExclude = new List<string>(new string[] { "vssscc", "dll", "pdb", "vspscc" }), DirectoriesToExclude = new List<string>(new string[] { "bin" }) });

            cg.Serialize(@"C:\TestConfig\ConfigGroup.xml");

            return;*/

        #endregion

        private ConfigurationGroup Cfg { get; set; }

        private static string ConfigFile = string.Empty;

        static void Main(string[] args)

        {

            Program pgm = new Program();

            pgm.Run(args);

        }

        public void Run(string[] args)

        {

            Cfg = new ConfigurationGroup();

            if (args.Length > 0)

            {

                foreach (string argument in args)

                {

                    string tokenName = argument.Substring(1, 1);

                    switch (tokenName)

                    {

                        case ("f"):

                            ConfigFile = args[0].Substring(3).Trim();

                            break;

                    }

                }

            }

            Cfg.Deserialize(ConfigFile);

            if (Cfg == null)

            {

                Console.WriteLine("No config file at " + ConfigFile + " and no arguments...I can't guess!");

                Console.ReadLine();

                return;

            }

            foreach (Config cfg in Cfg.ConfigurationItems)

            {

                if (!string.IsNullOrEmpty(cfg.SourceDirectory) && !string.IsNullOrEmpty(cfg.DestinationDirectory))

                {

                    if (Directory.Exists(cfg.SourceDirectory))

                    {

                        if (!Directory.Exists(cfg.DestinationDirectory))

                            Directory.CreateDirectory(cfg.DestinationDirectory);

                        if (!Directory.Exists(cfg.DestinationDirectory))

                            throw new IOException("Failed to create directory:" + cfg.DestinationDirectory);

                        CompareDirs(cfg.SourceDirectory, cfg.DestinationDirectory, cfg.ClearDestination, cfg.ExtensionsToExclude, cfg.DirectoriesToExclude, cfg.ExtensionsToLeave);

                    }

                    else

                    {

                        Console.WriteLine("Both source and destination directories must already exist!!");

                    }

                }

                else

                {

                    Console.WriteLine("You must specify both source and destination directories!");

                }

            }

            Console.WriteLine("Finished!");

#if DEBUG

            Console.ReadLine();

#endif

        }

        private bool CompareDirs(string sourceDir, string destDir, bool clearRight, List<string> extensionsToExclude, List<string> directoriesToExclude, List<string> extensionsToLeave)

        {

            List<string> srcFileNames = new List<string>(GetFSItems(new DirectoryInfo(sourceDir).GetFiles()));

            List<string> dstFileNames = new List<string>(GetFSItems(new DirectoryInfo(destDir).GetFiles()));

            foreach (string fileName in srcFileNames)

            {

                //Console.WriteLine(string.Format("Comparing:{0} and {1}", Path.Combine(sourceDir, fileName), Path.Combine(destDir, fileName)));

                bool excludeFile = false;

                foreach (string excludeExt in extensionsToExclude)

                {

                    if (fileName.EndsWith("." + excludeExt))

                    {

                        excludeFile = true;

                        break;

                    }

                }

                if (excludeFile)

                    continue;

                if (!dstFileNames.Contains(fileName))

                {

                    File.Copy(Path.Combine(sourceDir, fileName), Path.Combine(destDir, fileName));

                    Console.WriteLine("Adding:" + Path.Combine(destDir, fileName));

                }

                else

                {

                    DateTime srcInf = new FileInfo(Path.Combine(sourceDir, fileName)).LastWriteTime;

                    DateTime dstInf = new FileInfo(Path.Combine(destDir, fileName)).LastWriteTime;

                    if (dstInf != srcInf)

                    {

                        File.Copy(Path.Combine(sourceDir, fileName), Path.Combine(destDir, fileName), true);

                        Console.WriteLine("Overwriting:" + Path.Combine(destDir, fileName));

                    }

                }

            }

            foreach (string fileName in dstFileNames)

            {

                string extension = fileName.Substring(fileName.LastIndexOf('.') + 1);

                if (!srcFileNames.Contains(fileName) || extensionsToExclude.Contains(extension))

                {

                    if (extensionsToLeave.Contains(extension))

                    {

                        Console.WriteLine("Leaving:" + fileName);

                        continue;

                    }

                    else

                    {

                        File.Delete(Path.Combine(destDir, fileName));

                        Console.WriteLine("Deleteing:" + fileName);

                    }

                }

            }

            List<string> sourceNames = new List<string>(GetFSItems(new DirectoryInfo(sourceDir).GetDirectories()));

            List<string> destNames = new List<string>(GetFSItems(new DirectoryInfo(destDir).GetDirectories()));

            foreach (string dirName in sourceNames)

            {

                if (directoriesToExclude.Contains(dirName))

                {

                    Console.WriteLine("Skipping: " + dirName);

                    continue;

                }

                //Console.WriteLine(string.Format("Comparing:{0} and {1}", Path.Combine(sourceDir, dirName), Path.Combine(destDir, dirName)));

                if (!destNames.Contains(dirName))

                {

                    string newDestDir = Path.Combine(destDir, dirName);

                    Directory.CreateDirectory(newDestDir);

                    Console.WriteLine("Adding:" + Path.Combine(destDir, dirName));

                    CompareDirs(Path.Combine(sourceDir, dirName), newDestDir, clearRight, extensionsToExclude, directoriesToExclude, extensionsToLeave);

                }

                else

                {

                    CompareDirs(Path.Combine(sourceDir, dirName), Path.Combine(destDir, dirName), clearRight, extensionsToExclude, directoriesToExclude, extensionsToLeave);

                }

            }

            foreach (string dirName in destNames)

            {

                if (!sourceNames.Contains(dirName) || directoriesToExclude.Contains(dirName))

                {

                    Directory.Delete(Path.Combine(destDir, dirName), true);

                    Console.WriteLine("Deleteing:" + Path.Combine(destDir, dirName));

                }

            }

            return false;

        }

        private IEnumerable<string> GetFSItems(FileSystemInfo[] dirInfos)

        {

            foreach (FileSystemInfo dinf in dirInfos)

            {

                yield return dinf.Name;

            }

        }

    }

}

Obsessive Coding, optimal string Reverse...

Scott Galloway — Mon, 04 Feb 2008 17:00:41 GMT
I love this type of thing, a whole post on optimal string reverse algorithms. I always love this sort of thing, learning huge amounts of detail about fundamental operations (sort of, umm when do you ever reverse strings?). Actually looking at Justin Rogers' blog he has lots of great performance posts...

Why do so many people mess up Singletons?

Scott Galloway — Mon, 28 Jan 2008 00:47:55 GMT

I've written about this a few times now (use the search thingy to find where) but I'm still surprised how many people mess up the Singleton pattern.

For instance take:

if (blogSettingsSingleton == null)
                {
                    blogSettingsSingleton = new BlogSettings();
                }
                return blogSettingsSingleton;

Looks ok, right? But this is a classic poor pattern when dealing with multi-threaded apps. Why? Look at the initial 'if' statement, and think what happens if multiple treads hit this at the same time...one thread could be in the process of creating this object whilst the others are evaluating the condition...

If you're using Singletons PLEASE read this article. The singleton pattern article from Wikipedia has the following excellent implementation of a singleton:

/// <summary> /// Class implements singleton pattern. /// </summary> public class Singleton { // Private constructor to avoid other instantiation // This must be present otherwise the compiler provide // a default public constructor private Singleton() { } /// <summary> /// Return an instance of <see cref="Singleton"/> /// </summary> public static Singleton Instance { get { /// An instance of Singleton wont be created until the very first /// call to the sealed class. This a CLR optimization that ensure that /// we have properly lazy-loading singleton. return SingletonCreator.CreatorInstance; } } /// <summary> /// Sealed class to avoid any heritage from this helper class /// </summary> private sealed class SingletonCreator { // Retrieve a single instance of a Singleton private static readonly Singleton _instance = new Singleton(); /// <summary> /// Return an instance of the class <see cref="Singleton"/> /// </summary> public static Singleton CreatorInstance { get { return _instance; } } } }

This is a lazy-initializing, thread safe singleton...does sacrifice *some* performance (see the earlier article for details of this) but it is FAR safer than the original I showed...

Oh, and one last thing...are you REALLY sure you need a Singleton? One horrible pattern I've seen is code is using Singletons to access database connections...this is VERY RARELY required and sacrifices a lot of the benefits which modern databases offer for concurrent access.

UPDATE: Umm...realized that I don't explain what a 'Singleton' is...essentially it's a pattern which limits the access of an object to a single caller at a time. Common uses for Singletons could be accessing files on a file-system where you really want to make sure that only one thread has access at one time. Oh, and to make things even more complicated you'd more commonly want to use a ReaderWriterLock in this scenario to allow many readers or a single writer...only of course you wouldn't...told you it was complicated! Oh, and to further complicate matters in VS2008 and above you'd probably want ReaderWriterLockSlim!