.NET

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!

C# null Coalescing operator

Scott Galloway — Sun, 04 Nov 2007 01:07:42 GMT

Just because I always forget this...the C# null Coalescing operator:

Sample below shamelessly stolen from here...

MyClass anObject;
...
// Variant 1: Using a full if/else clause
MyClass anotherObject;
if (anObject != null)
anotherObject = anObject;
else
anotherObject = new MyClass();

// Variant 2: Using the ?/: conditional operator
MyClass anotherObject = anObject != null ? anObject : new MyClass();

// Variant 3: Using the ?? operator
MyClass anotherObject = anObject ?? new MyClass();

MasterPages

Scott Galloway — Mon, 14 Jul 2003 17:04:00 GMT

As I've written about a hundred times now. I'm currently rebuilding this site - don't stop reading, I really am this time!
So, I'm in the process of defining an architecture - rebuilding the site is more about my playing with some new technologies rather than actually making a site thats' for anything. The architecture I choose will have many of the features I'd expect to see in ASP.NET 2.0 - with a view to converting once I get the bits.
The way it is currently going is to use a version of MasterPages , maybe taking a few pointers from Paul Wilsons articles on the subject. In addition I want to have some sort of MVC type implementation, where I can control the flow and navigational logic from a central location - there's an approach I've used before in Java where the Controller is responsible for filling the page Context with the information which the page needs to render, the page then just has to access Context to populate itself, might see if this is easy in ASP.NET.
Of course, I'm going to be heavily using the MS Application Blocks - I can't emphasise enough how fantastic these things are when building applications!
One thing I really dislike about the current BlogX - the blogging engine currently powering this site - is that it doesn't use SQL Server- this essentially means my information is stored on the server in plain XML - it's hard to index (no search!), if some other format comes along, it'll mean writing a hideous XSLT to do the transform and I can't load balance the site (OK, not a problem any time soon, but the Architect in me objects). Plan will be to replace BlogX with another engine (with a better architecture), this will be based on SQL Server, have built in support for encryption and compression -I hate the fact that right now, big old chunks of unencrypted XML contain the config settings for my site and regularly fly through the ether - this is NOT secure in the slightest. In addition, front-end caching (even more necessary with the shift to SQL Server) - I may even have a look at caching each blog entry as an entity and then just assembling them as the page renders...hmm...

Dynamically added controls...

Scott Galloway — Wed, 04 Jun 2003 13:35:00 GMT

One of the most frequent queries about dynamically added controls is how to get their values after postback... This is not as easy as it sounds if the value of these controls has a direct impact on the next set of controls bound to the page. There are various methods to do this - persisting the controls in Session state and reloading on init being one I've used in the past, there's also more code-intensive methods involving intercepting the postback event and reinding there. One of the most elegant methods I've encountered is Denis Bauers' Dynamic Controls placeholder » link , its' not perfect but it is a really good solution to this all too frequent problem.

My little compression helper...improved version

Scott Galloway — Tue, 06 Apr 2004 18:31:00 GMT

I posted my compression helper class before and realised almost instantly that it suffered from 'legacy lag' - so it'd been changed so much over the months that it was really bad!
Anyway, presented below is a modified version of that class (which I've also tried out my new formatting scheme on) as a reminder, it's just a simple wrapper around SharpZipLib.

using System;

using System.Text;

using System.IO;

using ICSharpCode.SharpZipLib;

namespace SerializableJob.Compression

{

public enum CompressionType

{

GZip,

BZip2,

Zip

}

public class Compression

{

public static CompressionType CompressionProvider = CompressionType.GZip;

private static Stream OutputStream(Stream inputStream)

{

switch(CompressionProvider)

{

case CompressionType.BZip2:

return new ICSharpCode.SharpZipLib.BZip2.BZip2OutputStream(inputStream);

case CompressionType.GZip:

return new ICSharpCode.SharpZipLib.GZip.GZipOutputStream(inputStream);

case CompressionType.Zip:

return new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(inputStream);

default:

return new ICSharpCode.SharpZipLib.GZip.GZipOutputStream(inputStream);

}

private static Stream InputStream(Stream inputStream)

{

switch(CompressionProvider)

{

case CompressionType.BZip2:

return new ICSharpCode.SharpZipLib.BZip2.BZip2InputStream(inputStream);

case CompressionType.GZip:

return new ICSharpCode.SharpZipLib.GZip.GZipInputStream(inputStream);

case CompressionType.Zip:

return new ICSharpCode.SharpZipLib.Zip.ZipInputStream(inputStream);

default:

return new ICSharpCode.SharpZipLib.GZip.GZipInputStream(inputStream);

}

public static byte[] Compress(byte[] bytesToCompress)

{

MemoryStream ms = new MemoryStream();

Stream s = OutputStream(ms);

s.Write(bytesToCompress,0, bytesToCompress.Length);

s.Close();

return ms.ToArray();

}

public static string Compress(string stringToCompress)

{

byte[] compressedData = CompressToByte(stringToCompress);

string strOut = Convert.ToBase64String(compressedData);

return strOut;

}

public static byte[] CompressToByte(string stringToCompress)

{

byte[] bytData = Encoding.Unicode.GetBytes(stringToCompress);

return Compress(bytData);;

}

public string DeCompress(string stringToDecompress)

{

string outString = string.Empty;

if (stringToDecompress == null)

{

throw new ArgumentNullException("stringToDecompress","You tried to use an empty string");

}

try

{

byte[] inArr = Convert.FromBase64String(stringToDecompress.Trim());

outString = System.Text.Encoding.Unicode.GetString(DeCompress(inArr));

}

catch (NullReferenceException nEx)

{

return nEx.Message;

}

return outString;

}

public static byte[] DeCompress(byte[] bytesToDecompress)

{

byte[] writeData = new byte[4096];

Stream s2 = InputStream(new MemoryStream(bytesToDecompress));

MemoryStream outStream = new MemoryStream();

while(true)

{

int size = s2.Read(writeData,0,writeData.Length);

if(size>0)

{

outStream.Write(writeData,0,size);

}

else

{

break;

}

s2.Close();

byte[] outArr = outStream.ToArray();

outStream.Close();

return outArr;

}

Crazy busy at work, back soon!

Scott Galloway — Wed, 17 Oct 2007 20:44:05 GMT

Things have been insane at work over the past few days...back to this soon! Plan to get a nice 'Amazon book suggestion' tool on the site; going to let readers suggest books on various topics by entering an ISBN and then provide the country appropriate URL to buy that book. Still fiddling with the new Amazon web services bits but it's nearly there...

See you at the weekend (probably!)