Let’s start by looking at a basic scenario:

public interface IAnimal
{
   void Eat();
}

public class Animal : IAnimal
{
   public virtual void Eat()
   {
      Concsole.WriteLine("Animal Eat");
   }
}

public class Mammal : Animal
{
   public override void Eat()
   {
      Concsole.WriteLine("Mammal Eat");
   }
}

When I execute the following code, the output (in the comments) should not be of a surprise.

var m = new Mammal();

m.Eat();                            //Output: Mammal Eat
((Animal)m).Eat();                  //Output: Mammal Eat
((IAnimal)m).Eat();                 //Output: Mammal Eat

So if I now change the Animal class to the following, what do you think the outputs will be?

public class Animal : IAnimal
{
   public virtual void Eat()
   {
      Concsole.WriteLine("Animal Eat Implicit");
   }

   void IAnimal.Eat()
   {
      Concsole.WriteLine("Animal Eat Explicit");
   }
}

If your thoughts are the same as the below, you are correct.

m.Eat();                            //Output: Mammal Eat
((Animal)m).Eat();                  //Output: Mammal Eat
((IAnimal)m).Eat();                 //Output: <strong>Animal Eat Explicit</strong>

Obviously, there is an inconsistency here. When you cast the object explicitly to the interface, the explicit interface implementations will take precedence over the implicit ones. But usually, when you have both implicit and explicit implementations in one class, you’d have the explicit implementations calling your implicit ones, resulting in the consistent outcome.

Let’s make another change to the Animal and Mammal class:

public class Animal : IAnimal
{
   public void Eat()
   {
      Concsole.WriteLine("Animal Eat");
   }
}

public class Mammal : Animal
{
   public new void Eat()
   {
      Concsole.WriteLine("Mammal Eat");
   }
}

I always feel uncomfortable hiding a base class’s methods, as seen from the following outputs, the inconsistency introduced is even worse and hard to detect most of the time.

m.Eat();                            //Output: Mammal Eat
((Animal)m).Eat();                  //Output: <strong>Animal Eat</strong>
((IAnimal)m).Eat();                 //Output: <strong>Animal Eat</strong>
Feed(m);                            //Output: <strong>Animal Eat</strong>

void Feed(IAnimal a)
{
   a.Eat();
}

Clearly, we’d like to avoid the above situation as much as possible, but sometimes you don’t have many alternatives, for example, you don’t have control over the base class.

What you can do to improve this situation is to re-implement the IAnimal interface on Mammal, which gives you slightly more consistent outputs:

public class Mammal : Animal, <strong>IAnimal</strong>
{
   public new void Eat()
   {
      Concsole.WriteLine("Mammal Eat");
   }
}

m.Eat();                            //Output: Mammal Eat
((Animal)m).Eat();                  //Output: <strong>Animal Eat</strong>
((IAnimal)m).Eat();                 //Output: Mammal Eat
Feed(m);                            //Output: Mammal Eat

void Feed(IAnimal a)
{
   a.Eat();
}

In summary, if you have control over both base and sub classes, use the following patterns to achieve the most consistent result:

public class Animal : IAnimal
{
   public virtual void Eat()
   {
      Concsole.WriteLine("Animal Eat");
   }

   void IAnimal.Eat()
   {
      Eat();
   }
}

public class Mammal : Animal
{
   public override void Eat()
   {
      Concsole.WriteLine("Mammal Eat");
   }
}

or, for some reasons, you really don’t want to make methods virtual, then try this:

public class Animal : IAnimal
{
   public void Eat()
   {
      ((IAnimal)this).Eat();
   }

   void IAnimal.Eat()
   {
      Concsole.WriteLine("Animal Eat");
   }
}

public class Mammal : Animal, IAnimal
{
   public new void Eat()
   {
      Concsole.WriteLine("Mammal Eat");
   }
}

Well-Known Text (WKT)

The WKT format is described in detail in OpenGIS Implementation Specification for Geographic Information – Simple Feature Access Part 1: Common Architecture.

Well-Known Binary (WKB)

The WKB format is also described in the above linked document. However, I think it’s helpful to include a diagram and some examples.

Examples

Point (1 2) could be represented as:

0x01 01000000 000000000000F03F 0000000000000040

MultiPolygon (((1 1, 1 2, 2 2, 2 1, 1 1)), ((3 1, 4 2, 5 1, 3 1))) could be represented as:

0x01 06000000 02000000 (01 03000000 01000000 (05000000 (000000000000F03F 000000000000F03F 000000000000F03F 0000000000000040 0000000000000040 0000000000000040 0000000000000040 000000000000F03F 000000000000F03F 000000000000F03F)) (01 03000000 01000000 (04000000 (0000000000000840 000000000000F03F 0000000000001040 0000000000000040 0000000000001440 000000000000F03F 0000000000000840 000000000000F03F))

Note Spaces and parentheses are added for clarity. They are not part of the binary stream.

SQL Server Geometry & Geography

SQL Server 2008 uses its own binary encoding method to encode geometry and geography data.

Unfortunately, I haven’t managed to find any documentation describing how to decode such format fully.

Examples

Point (1 2) is represented as:

0x00000000010C 000000000000F03F 0000000000000040

MultiPolygon (((1 1, 1 2, 2 2, 2 1, 1 1)), ((3 1, 4 2, 5 1, 3 1))) is represented as:

0x000000000104 09000000 000000000000F03F 000000000000F03F 000000000000F03F 0000000000000040 0000000000000040 0000000000000040 0000000000000040 000000000000F03F 000000000000F03F 000000000000F03F 0000000000000840 000000000000F03F 0000000000001040 0000000000000040 0000000000001440 000000000000F03F 0000000000000840 000000000000F03F 020000000200000000020500000003000000FFFFFFFF0000000006000000000000000003000000000100000003

PostgreSQL & PostGIS

PostgreSQL uses its own binary format to encode geometry and geography data.

Unfortunately, I haven’t managed to find any documentation describing how to decode such format fully.

MySQL

MySQL uses its own binary format to encode geometry data.

Unfortunately, I haven’t managed to find any documentation describing how to decode such format fully.

SQLite & SpatiaLite

SpatiaLite uses its own binary format to encode geometry data. However, the format is very similar to WKB. Compared with WKB, this format explicitly exposes MBRs, which allows quick access to entities selected on a spatial basis, and partially balances the lacking of spatial indices. For more information, see SpatiaLite - spatial extensions for SQLite.

SDEBINARY

SDEBINARY is a compressed binary format used by ArcGIS to store geometry. It offers efficient storage and retrieval of spatial data by reducing the size of the geometry. The representation of SDEBINARY is described in here, and highlighted below:

Shapefile

Shapefile is a popular geospatial vector data format. It is developed and regulated by Esri as an open specification for data
interoperability among Esri and other software products.

The file then contains any number of variable-length records. Each record is prefixed with a record-header of 8 bytes:

Following the record header is the actual record:

The variable length record contents depend on the shape type. The following are the possible shape types:

OGC has developed a few very important standards and specifications that should be respected by any system trying to support geospatial data types.

• OpenGIS Geography Markup Language (GML) Encoding Standard
• OpenGIS Implementation Specification for Geographic Information – Simple Feature Access Part 1: Common Architecture
• OpenGIS Implementation Specification for Geographic Information – Simple Feature Access Part 2: SQL Option

Spatial Data Support in .NET & SQL Server 2008

For a .NET application to make use of the spatial types that are available in Microsoft’s SQL Server 2008, you need to either download and install the Microsoft SQL Server System CLR Types or manually deploy the following assemblies into your application’s directory:

• Microsoft.SqlServer.Types.dll
• SqlServerSpatial.dll

Microsoft.SqlServer.Types.dll is a .NET assembly and is installed into GAC (C:\Windows\assembly\) if the installer is used.

SqlServerSpatial.dll is a Windows native assembly and is available in three versions: x86, x64, and ia64. If you use the installer, it will be installed to C:\Windows\System32\ (x64 version), and C:\Windows\SysWOW64\ (x86 version). At runtime, the correct version will be selected automatically based on your application’s target platform. However, if you decide to manually deploy this assembly, you need to place the right version in your application’s directory.

Basic API

The assembly Microsoft.SqlServer.Types.dll does not offer a variety of concrete spatial types, such as Point, Rectangle, and Polygon; instead, it only exposes SqlGeometry and SqlGeography as two sealed classes for representing all spatial shapes.

SqlGeometry is based on the planar model, which is a uniform 2-dimensional plane where you can define geometric data—points, lines, and polygons—using the x- and y-axis. SqlGeography is based on the geodetic model, which represents a round Earth scenario allowing you define geography data on the Earth’s surface using latitude and longitude.

The easiest way to create a geometry (or geography) feature is to use the static methods on SqlGeometry (or SqlGeography): GeomFromGml(), ST*FromText(), and ST*FromWKB(). These methods are based on the standards: GML (Geographic Markup Language), WKT (Well-Known Text) and WKB (Well-Known Binary) respectively.

Builder

For each model mentioned above, Microsoft.SqlServer.Types also exposes a builder class: SqlGeometryBuilder and SqlGeographyBuilder respectively, for creating various kinds of spatial shapes. The following example shows how to create a line from Point (1, 1) to Point (5, 5):

SqlGeometryBuilder builder = new SqlGeometryBuilder();
builder.SetSrid(0);
builder.BeginGeometry(OpenGisGeometryType.LineString);
builder.BeginFigure(1, 1);
builder.AddLine(5, 5);
builder.EndFigure();
builder.EndGeometry();

var lineA = builder.ConstructedGeometry;

When building a spatial feature, the following methods must be called in the specified order:

1. SetSrid(...)
2. BeginGeometry(...) / BeginGeography(...)
3. BeginFigure(...)
4. …
5. EndFigure()
6. EndGeometry() / EndGeography()

Depending on the OpenGisGeometryType (or OpenGisGeographyType) value you specified when you first call BeginGeometry (or BeginGeography), you may need to call the methods from Step 2 through to Step 6 multiple times to construct a valid spatial feature. For example, the following code constructs a MultiLineString:

var builder = new SqlGeometryBuilder();
builder.SetSrid(0);
builder.BeginGeometry(OpenGisGeometryType.MultiLineString);

builder.BeginGeometry(OpenGisGeometryType.LineString);
builder.BeginFigure(1, 1);
builder.AddLine(5, 5);
builder.EndFigure();
builder.EndGeometry();

builder.BeginGeometry(OpenGisGeometryType.LineString);
builder.BeginFigure(1, 5);
builder.AddLine(5, 1);
builder.EndFigure();
builder.EndGeometry();

builder.EndGeometry();

var multiLineString = builder.ConstructedGeometry;

Note Don’t forget to call the last EndGeometry (or EndGeography). Begin* and End* always go in pairs.

Once a spatial feature is successfully constructed and returned via the property ConstructedGeometry (or ConstructuedGeography), you cannot reuse the same builder instance to build other spatial features, i.e. you can no longer invoke any of the above methods; otherwise, a FormatException will be thrown.

Spatial Operations

Once spatial features are created, you can use them to perform spatial operations, such as calculating areas and testing for intersections. For example, the following code prints True indicating lineA and lineB intersect:

Note When performing spatial operations involving multiple spatial features, their SRIDs must be the same. Otherwise, the operations will return NULL.

Serialization

Since both SqlGeometry and SqlGeography are marked as Serializable, their instances can be serialized for communication across networks.

More Information

Please refer to the book Beginning Spatial with SQL Server 2008 for more information.

Wrapping the Basic API

Although the types exposed by Microsoft.SqlServer.Types are sufficient for creating and manipulating spatial features, they form a very loose API and rely heavily on runtime checks. In addition, the basic API exposes SQL data types instead of .NET primitive types, e.g. SqlBoolean versus bool, which makes the coding experience a little awkward. Therefore, it would be beneficial to create a suite of wrapper classes to enable strong type checking and operation IntelliSense based on spatial feature types; for example, calling STCentroid() on a point does not make any sense.

Compared with reading a blog or search through a forum, reading a good book is still the best way to learn something. Books provide structured content that helps you learning things in a more systematic manner and understanding the ins and outs of a problem.

Okay, enough said, here is the list of books I have read (not word by word of course, and not all chapters are worth reading):

Inside the Microsoft Build Engine: Using MSBuild and Team Foundation Build

It’s an outstanding book on MSBuild and Team Foundation Build. Regardless of your experience with these topics, you will find something useful in this book.

I also see this book as a must have for all .NET developers whether or not you are responsible for build automation.

Deploying .NET Applications: Learning MSBuild and ClickOnce

Another great book on MSBuild.

It also includes information on ClickOnce deployment.

Pro .NET 4 Parallel Programming in C#

t’s a great book that covers both the old and new ways of doing parallel programming in .NET 4, including topics such as TPL, concurrent collections, synchronization primitives, task schedulers, testing and debugging parallel applications, and some common parallel algorithms.

Another must read for all .NET developers, as like it or not, you cannot escape from parallel programming nowadays.

Essential Windows Communication Foundation for .NET Framework 3.5

Although a little out-dated, it is still relevant and has very good explanation on the basics of WCF, especially in the first 10 chapters. However, it is a little light on the security and extensibility topics.

Professional WCF 4 – Windows Communication Foundation with .NET 4

WCF security is covered extensively in this book—with three chapters ranging from the basic security concepts to advanced federation authentication scenarios.

This book also includes a chapter describing the Windows Azure platform, which is an added bonus.

Again, the drawback of this book is the lack of coverage on WCF extensibility.

Windows Communication Foundation 3.5 Unleashed

Finally, a book provides extensive coverage on extending and customizing WCF! Topics on other aspects of WCF are quite good also.

I hope it can be updated soon to include things in WCF 4.

Challenge 1: List all the character escape sequences

This may not be as easy as you think. If you can come up with the following list without consulting the language spec, congratulations!

Solution:

A few things to note:

• Each N represents a valid hex digit, i.e. [0-9a-fA-F]
• \x can consume up to 4 characters. For example, if you want to print the Unicode \xFF followed by two “F” characters, do NOT write as "\xFFFF", which means the Unicode character \xFFFF; instead, write "\x00FFFF" or "\xFF" + "FF"
• \UNNNNNNNN is used for generating a pair of surrogates (a high and a low surrogate). Since .NET only supports high surrogate ranging from U+D800 to U+DBFF, and low surrogate ranging from U+DC00 to U+DFFF, the maximum you can specify using \U is \U0010FFFF. Any number larger than that results in a compile error.
• \UNNNNNNNN occupies two characters, so the string length is one character longer than you’d expect. Of course, you cannot assign it to a char.
• Unlike C/C++ or Java, C# does NOT support octal escapes.

Challenge 2: Convert an escaped character to its escape sequence

When you write Console.WriteLine("Title:\r\n\tHello World!"), it prints out:

The challenge is to write code so that the program outputs "Title:\r\n\tHello World!" in the console at runtime, i.e.

Solution:

The most obvious way is to use string.Replace(), e.g. string.Replace("\r", @"\r").

public static string Escape(string input)
{
    string result = input;

    result = result.Replace("\\", @"\\");    // This needs to be done first!
    result = result.Replace("\"", @"\""");
    result = result.Replace("\a", @"\a");
    result = result.Replace("\b", @"\b");
    result = result.Replace("\f", @"\f");
    result = result.Replace("\n", @"\n");
    result = result.Replace("\r", @"\r");
    result = result.Replace("\t", @"\t");
    result = result.Replace("\v", @"\v");
    result = result.Replace("\0", @"\0");

    return result;
}

Or, if you prefer regular expression, here is another way with slightly more code:

public static class StringExtensions
{
    private static Dictionary _escapeMapping = new Dictionary()
    {
        {"\\\\", @"\\"},
        {"\"", @"\"""},
        {"\a", @"\a"},
        {"\b", @"\b"},
        {"\f", @"\f"},
        {"\n", @"\n"},
        {"\r", @"\r"},
        {"\t", @"\t"},
        {"\v", @"\v"},
        {"\0", @"\0"},
    };

    private static Regex escapeRegex = new Regex(string.Join("|", _escapeMapping.Keys.ToArray()));

    public static string Escape(this string input)
    {
        return escapeRegex.Replace(input, EscapeMatchEval);
    }

    private static string EscapeMatchEval(Match match)
    {
        if (_escapeMapping.ContainsKey(match.Value))
        {
            return _escapeMapping[match.Value];
        }
        return _escapeMapping[Regex.Escape(match.Value)];
    }
}

There is also the third way: by using CodeDom and letting .NET handle those replacements for us.

public static string Escape(string input)
{
    using (var writer = new StringWriter())
    {
        using (var provider = new Microsoft.CSharp.CSharpCodeProvider())
        {
            provider.GenerateCodeFromExpression(new System.CodeDom.CodePrimitiveExpression(input), writer, null);
        }

        return writer.ToString();
    }
}

Although the third way seems pretty cool, it has a few catches. Since CodeDom is really meant for generating code, its engine does a few optimizations; for example, breaking up a long string into multiple shorter ones that are joined by the string concatenation operator, i.e. + in C#. Also, if you try to use Microsoft.VisualBasic.VBCodeProvider instead of the CSharp one, you will end up with outputting Global.Microsoft.VisualBasic.ChrW(13) for \r for example. Finally, due to the limitation in CodeDom, the third way cannot deal with the escape sequences: \a, \b, \f, and \v.

At this point, you may notice that none of the three methods deals with Unicode. But you can easily extend them or create a separate one to deal with escaping Unicode characters. See below as an example:

public static string EscapeUnicode(string input)
{
    var builder = new StringBuilder();
    for (int i = 0; i < input.Length; i++)
    {
        if (char.IsSurrogatePair(input, i))
        {
            builder.Append("\\U" + char.ConvertToUtf32(input, i).ToString("X8"));
            i++;  //skip the next char
        }
        else
        {
            int charVal = char.ConvertToUtf32(input, i);
            if (charVal > 127)
            {
                builder.Append("\\u" + charVal.ToString("X4"));
            }
            else
            {
                //an ASCII character
                builder.Append(input[i]);
            }
        }
    }

    return builder.ToString();
}

Challenge 3: Convert an escape sequence to the escaped character

It’s the reverse of the challenge 2, and it’s a lot more interesting! …well, only so if you can come up with more than one way.

Let’s say if you are reading a file that contains escape sequences, when the content is read into a string, escape sequences are treated as individual characters and are escaped in memory, e.g. \n in file becomes \\n in memory. Now what you need to do is to convert \\n back to \n in memory at runtime to represent a new line character.

Solution:

You may still resort to string.Replace() and regular expressions (needed to handle Unicode), but there is a much better and more elegant way doing it.

public static string ParseString(string input)
{
    var provider = new Microsoft.CSharp.CSharpCodeProvider();
    var parameters = new System.CodeDom.Compiler.CompilerParameters()
    {
        GenerateExecutable = false,
        GenerateInMemory = true,
    };

    var code = @"
        namespace Tmp
        {
            public class TmpClass
            {
                public static string GetValue()
                {
                    return """ + input + @""";
                }
            }
        }";

    var compileResult = provider.CompileAssemblyFromSource(parameters, code);

    if (compileResult.Errors.HasErrors)
    {
        throw new ArgumentException(compileResult.Errors.Cast<System.CodeDom.Compiler.CompilerError>().First(e => !e.IsWarning).ErrorText);
    }

    var asmb = compileResult.CompiledAssembly;
    var method = asmb.GetType("Tmp.TmpClass").GetMethod("GetValue");

    return method.Invoke(null, null) as string;
}

Since .NET offers a few ways to load an assembly, and different ways result in different outcomes, it’s always a little bit confusing after some time not working in that domain. The good thing is, there are plenty of helpful materials on the Internet, especially the following articles, so I decided to put them all in one place for future reference.

• Assembly.LoadFrom (MSDN)
• LoadFile vs. LoadFrom (Suzanne Cook’s .NET CLR Notes)
• Choosing a Binding Context (Suzanne Cook’s .NET CLR Notes)

Other notes:

• To manually load an assembly from GAC, you have to specify the FULL name of the assembly.
• You can’t selectively unload one or more assemblies from a AppDomain, you have to unload the whole AppDomain instead. Therefore, if you don’t want to pollute your main AppDomain with the assemblies you want to unload at a later stage, create a new one. I wrote the following code to do that:

First, create a class called AssemblyAnalyzerGateway. This class requires a type argument, and optionally takes an AppDomain object as its constructor parameter. The type argument specifies the type of the analyzer to create in the specified AppDomain (or a new AppDomain if nothing is specified), and the analyzer will be the one driving the actual assembly analysis.

Note that for objects to be accessible from outside their living AppDomains, they have to be either serializable or inherited from MarshalByRefObject. Here I constrain it to be MarshalByRefObject only, so there is no de/serialization happening.

Note also that AssemblyAnalyzerGateway implements IDisposable, so when it’s disposed, it unloads the AppDomain even when the AppDomain is not created by the analyzer.

public class AssemblyAnalyzerGateway<T> : IDisposable
    where T : MarshalByRefObject
{
    public AssemblyAnalyzerGateway()
        : this(null)
    {
    }

    public AssemblyAnalyzerGateway(AppDomain workDomain)
    {
        if (workDomain == null)
        {
            workDomain = AppDomain.CreateDomain("Assembly Analysis Domain");
        }

        this.WorkDomain = workDomain;

        var analyzerType = typeof(T);
        this.Analyzer = workDomain.CreateInstanceFromAndUnwrap(analyzerType.Assembly.Location,
            analyzerType.FullName, true,
            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.CreateInstance,
            null, null, System.Globalization.CultureInfo.CurrentCulture, null) as T;
    }

    public AppDomain WorkDomain { get; private set; }

    public T Analyzer { get; private set; }

    #region IDisposable Members

    private bool _disposed;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            AppDomain.Unload(WorkDomain);
        }

        _disposed = true;
    }

    #endregion
}

Now, let’s move to the analyzer that does the actual assembly analysis. There are a few things to note here:

1. as mentioned before, the analyzer needs to be inherited from MarshalByRefObject;
2. it must have a parameterless constructor, which doesn’t have to be public though;
3. all of its exposed methods should be instance methods, NOT static. However, if you think some of these methods could be used elsewhere, feel free to redirect the calls. Since the analyzer is created in a separate AppDomain, any objects or types it references will be created in that domain as well.

public class AssemblyAnalyzer : MarshalByRefObject
{
    private AssemblyAnalyzer() { }

    public void AnalyzeAssembly(string asmbPath)
    {
        Assembly asmb = LoadAssemblyAt(asmbPath);
        ...
    }
}

Finally, to use the above code:

using (var gateway = new AssemblyAnalyzerGateway<AssemblyAnalyzer>())
{
    return gateway.Analyzer.AnalyzeAssembly(asmbPath);
}

or if you don’t want throw away the AppDomain immediately, but keep it for other analysis:

AppDomain.CurrentDomain.AssemblyResolve += AppDomain_AssemblyResolve;
AppDomain workDomain = AppDomain.CreateDomain("Assembly Analysis Domain");

var analyzer = new AssemblyAnalyzerGateway<AssemblyAnalyzer>(workDomain);
var anotherAnalyzer = new AssemblyAnalyzerGateway<MyOtherAssemblyAnalyzer>(workDomain);

try
{
    ...
}
finally
{
    AppDomain.Unload(workDomain);
    AppDomain.CurrentDomain.AssemblyResolve -= AppDomain_AssemblyResolve;
}

Which makes me wondering: what’s so difficult about writing a good syntax highlighter—hundreds of notepad like applications do it. Is this about the compatibility between WL Writer and WordPress, or else? (… knowing that the Windows Live team has officially killed Spaces and tries to move everyone to WordPress)

The good thing is that WordPress does provide a nice syntax highlighting mechanism, by using the tag [/sourcecode], which is developed my Alex Gorbatchev. This tool supports a good range of languages, and does a great job formatting and displaying code snippets. However, it doesn’t provide design time (WYSIWYG) support, and you can’t seem to use it inside WL Writer, as the writer ignores the tag and escapes all the characters, especially after a post is downloaded and opened for editing inside the writer.

Furthermore, writing and editing blog posts on the WordPress website isn’t a good experience either, especially when you’re trying to edit HTML directly—the cursor jumps up and down causing a lot of frustrations. Finally when you trying to post the blog with code snippets, 80% chances are that you lose leading spaces and indentations in your code…

Why WordPress and/or WL Writer cannot provide a decent syntax highlighter?

I can understand that CodeDom is a little old (came with .NET FX 2.0), and is slow on catching up fast evolving language features, such as LINQ, lambda expressions, and XML literals (VB 9+), but it’s still a great mechanism to generate language independent code, and should be kept up-to-date as much as possible.

In the following, I’d like to summarize some of the language features that aren’t supported by CodeDom, together with the suggested workarounds. Note that CodeDom should only cover the concepts and features exposed by most languages (at least .NET languages). Since I have limited experience with Visual C++ and F#, I’ll only include the features that are present in both C# and VB.NET.

Note: LINQ, lambda expressions, extension methods are not included in the following list.

Partial method

Partial method is a new feature that comes with .NET FX 3.5, so there is no support for it in CodeDom.

new CodeSnippetTypeMember(string.Format("{0}{0}partial void Initialize();", IndentText))

new CodeSnippetTypeMember(string.Format("{0}{0}Partial Private Sub Initialize()" + Environment.NewLine + "{0}{0}End Sub", Indent))

Different accessibility modifiers on the getter and setter of a property

This feature is quite useful for protect object encapsulation. For example:
C#:

public string Name
{
   get { ... }
   protected set { ... }
}

VB.NET:

Public Property Name() As String
   Get
      ...
   End Get
   Protected Set(ByVal value As String)
      ...
   End Set
}

Same as before, the only way to generate this code is to use code snippet, which is NOT language independent and defeats the purpose of using CodeDom in the first place.

However, a good programmer must not surrender to this, and should still use CodeDom to generate as much language independent code as possible, e.g. property name (to avoid name clashing with keywords), property type (to avoid hard-coding generic type argument syntax), and get and set statements.

The trick is to use the following extension methods to convert CodeDom statements and expressions to text.

public static string Serialize(this CodeDomProvider provider, CodeExpression expr)
{
   using (TextWriter writer = new StringWriter())
   {
      provider.GenerateCodeFromExpression(expr, writer, new CodeGeneratorOptions());
      return writer.ToString();
   }
}

public static string Serialize(this CodeDomProvider provider, CodeStatement stmt)
{
   using (TextWriter writer = new StringWriter())
   {
      provider.GenerateCodeFromStatement(stmt, writer, new CodeGeneratorOptions());
      return writer.ToString();
   }
}

Then we only need to take care of the keywords, see below:

var builder = new StringBuilder();

var propTypeText = _provider.Serialize(new CodeTypeReferenceExpression(propertyType));
var propNameText = _provider.Serialize(new CodeVariableReferenceExpression(name.UppercaseFirstChar()));

var getStmt = new CodeMethodReturnStatement(...);
var setStmt = new CodeMethodInvokeExpression(...);

switch (_outputLanguage)
{
   case OutputLanguage.CSharp:
      builder.Append("{0}{0}public ").Append(propTypeText).Append(" ").AppendLine(propNameText);
      builder.AppendLine("{0}{0}{{");

      builder.AppendLine("{0}{0}{0}get");
      builder.AppendLine("{0}{0}{0}{{");
      builder.Append("{0}{0}{0}{0}").Append(_provider.Serialize(getStmt));
      builder.AppendLine("{0}{0}{0}}}");

      builder.AppendLine("{0}{0}{0}protected set");
      builder.AppendLine("{0}{0}{0}{{");
      builder.Append("{0}{0}{0}{0}").Append(_provider.Serialize(setStmt)).AppendLine(";");
      builder.AppendLine("{0}{0}{0}}}");

      builder.AppendLine("{0}{0}}}");
      break;
   case OutputLanguage.VB:
      builder.Append("{0}{0}Public Property ").Append(propNameText).Append("() As ").AppendLine(propTypeText);

      builder.AppendLine("{0}{0}{0}Get");
      builder.Append("{0}{0}{0}{0}").Append(_provider.Serialize(getStmt));
      builder.AppendLine("{0}{0}{0}End Get");

      builder.Append("{0}{0}{0}Protected Set(ByVal value As ").Append(propTypeText).AppendLine(")");
      builder.Append("{0}{0}{0}{0}").AppendLine(_provider.Serialize(setStmt));
      builder.AppendLine("{0}{0}{0}End Set");

      builder.AppendLine("{0}{0}End Property");
      break;
}

var property = new CodeSnippetTypeMember(string.Format(builder.ToString(), Indent));

Structure Constraint

Generate for C#:

var typeParam = new CodeTypeParameter(“T”)
{
   Constraints = { ” struct” }, //Note the SPACE before ‘struct’
};

Generate for VB.NET:

var typeParam = new CodeTypeParameter(“T”)
{
   Constraints = { ” Structure” }, //Note the SPACE before ‘Structure’
};

Constants inside a function

Since MemberAttributes.Const is only supported on CodeTypeMember, you have to use code snippet again in this case. However, a good thing is that the keyword (const) spells the same in C# and VB.NET, so you can use the lower case version for both.

Block – using

Generate try … finally … instead. For example:

using (TextWriter w = new StringWriter())
{
}

can be rewritten as:

TextWriter w = new StringWriter();
try
{
}
finally
{
   w.Dispose();
}

Block – foreach

Use enumerator instead. For example:

foreach (var item in myList)
{
}

can be rewritten as:

var enumerator = myList.GetEnumerator();
while(enumerator.MoveNext())
{
   var item = enumerator.Current;
}

Block – lock

This one took me a little bit time to find a workaround. The trick is to use the Monitor class from the System.Threading namespace, see the following example:

lock (obj)
{
}

can be rewritten as:

object copyObj = obj;
System.Threading.Monitor.Enter(copyObj);
try
{
}
finally
{
   System.Threading.Monitor.Exit(copyObj);
}

Ternary operator

Generate if … else … instead.

That’s it for now! I’ll keep extending this post if I find more unsupported features in CodeDom, and their workarounds.

In the past, I have also given advice to friends and people who came to me asking for tips and tricks about job search and interview. Although I’m not a company’s CEO nor HR manager, most of my advice is aligned with what I read on the aforementioned website. The only difference is that my advice was more geared towards university graduates, whose first language isn’t English, but even so, it still applies to the “general” majority. So I think it’s necessary to reiterate those 6 tips and to add some of my personal views:

Don’t Mess Up Your Resume

Spelling and grammar errors are your biggest enemy. Replying on tools is simply NOT enough, you should always, always, proofread your resume yourself; or get somebody else to do it for you if he/she speaks better English.

Focus on the first page of your resume. In addition to your personal info, only write down what you think the most important things are—things that make you stand out from the crowd.

Be Smart and Get Things Done

Build a personal website, join and be active in professional social networks, e.g. LinkedIn, and online communities, e.g. MSDN forums, Code Project, and Stack Overflow. Nowadays, employers will not only look at your paper resume, but also your footprints on the Internet.

Check Your Ego

Don’t be arrogant nor too modest. Find a balance to sell yourself.

Learn People Language, Too

Also, learn some psychology and body language. They will help you greatly during interviews.

Be Prepared to Prove Yourself in the Interview

Practice, practice and practice. If your English isn’t good enough or you easily become nervous in situations like this, practice in front of a mirror, family members, friends or even neighbors, ask them to throw interview questions at you.

Also, you should prepare answers for commonly asked questions, such as “What do you know about our company?”, “How do other people describe you?”, “Why do you think we should hire you?”, “What are you good at?”, “What are you not good at?”, “What are your short-term (and long-term) plans?”…

Finally, pick up a computer text book to review some basics, such as data structures, algorithms, Boolean logics, basic programming concepts and terminologies. Remember to review the coding standards and good coding habits as well, since more and more employers like to give you some programming quiz to do during interviews.

Don’t Fake It

Stick to what you know and what you are good at, and just say “I don’t know” when you don’t know. Never, ever, lie about it!