Omer van Kloeten's .NET Zen : CodeDOM Adventures

[Updated (1.8)] Commonly Used .NET Coding Patterns in CodeDom

Omer van Kloeten — Tue, 31 Oct 2006 16:46:24 GMT

The latest update (1.8) of my article Commonly Used .NET Coding Patterns in CodeDom is now out.
Changes made since 1.7:

The Code Access Security Decorator Patterns have been added.
The Assembly Information Pattern has been added.
Security demand added to GetObjectData in the Serializable Type Pattern.
Xml Comment Patterns moved to .Xml namespace and had their CodeXmlComment prefix removed (too long).
Binaries now target .NET 2.0 instead of .NET 1.1, but they are still mostly backwards compatible.

The project is now hosted on CodePlex, complete with forums, an rss feed, an issue tracker and the whole nine yards. As always, suggestions are more than welcome.

CodeDom Tip: Cache Reusable Objects

Omer van Kloeten — Thu, 26 Oct 2006 01:23:07 GMT

Because CodeDom is so verbose and uses a massive grid of objects to represent code structures, it also has many small reusable objects, such as CodeTypeReference objects. Many people overlook this fact because there are so many object being created anyway, but sometimes a certain object will be used over and over. Since both the creation of these objects takes time and they also take up memory as unnecessary copies, consider creating a cache.

For example, for the next release of the CodeDom Patterns library, I've created a cache for CodeTypeReference objects:

using System;
using System.Collections.Generic;
using System.CodeDom;

namespace DotNetZen.CodeDom
{
    /// <summary>
    /// Acts as a cache for <see cref="CodeTypeReference"/> objects.
    /// </summary>
    public static class CodeTypeReferenceStore
    {
        private static Dictionary<RuntimeTypeHandle, CodeTypeReference> typeReferences = 
            new Dictionary<RuntimeTypeHandle, CodeTypeReference>();
        private static Dictionary<string, CodeTypeReference> nameReferences = 
            new Dictionary<string, CodeTypeReference>();

        /// <summary>
        /// Gets a <see cref="CodeTypeReference"/> by the <see cref="Type"/> it should reference.
        /// </summary>
        /// <param name="type">The type being referenced.</param>
        /// <returns>A <see cref="CodeTypeReference"/> object.</returns>
        public static CodeTypeReference Get(Type type)
        {
            RuntimeTypeHandle handle = type.TypeHandle;

            if (!typeReferences.ContainsKey(handle))
            {
                typeReferences.Add(handle, new CodeTypeReference(type));
            }

            return typeReferences[handle];
        }

        /// <summary>
        /// Gets a <see cref="CodeTypeReference"/> by the name of the <see cref="Type"/> it should reference.
        /// </summary>
        /// <param name="type">The name of the type being referenced.</param>
        /// <returns>A <see cref="CodeTypeReference"/> object.</returns>
        public static CodeTypeReference Get(string typeName)
        {
            if (!nameReferences.ContainsKey(typeName))
            {
                nameReferences.Add(typeName, new CodeTypeReference(typeName));
            }

            return nameReferences[typeName];
        }
    }
}

[Updated (1.7)] Commonly Used .NET Coding Patterns in CodeDom

Omer van Kloeten — Thu, 05 Oct 2006 20:42:00 GMT

It's been a while, but the latest update (1.7) of my article Commonly Used .NET Coding Patterns in CodeDom is now out.
Changes made since 1.6:

The Nullable Value Type Property Pattern has been added.
The Enum.IsDefined and String.IsNullOrEmpty assertions have been added.
The Serializable Type Pattern has been added.
The Disposable Type Pattern is now a part of CodePatternTypeDeclaration.

I'd love to hear any and all opinions.

Fast Generic Dynamic Property Access with C# - Now With 10% More Awesome!

Omer van Kloeten — Wed, 21 Jun 2006 05:59:00 GMT

After reading James Nies's great piece, Fast Dynamic Property Access with C#, which gives a great performance alternative for repetative reflection tasks, I started reading the comments and found two forks from it, one for more than just properties by Seth Heeren and the other being an implementation that supports generics (and sports better performance, of course) by Tobias Hertkorn, all of the above being excellent work.
These, in turn, got me to start thinking there had to be a better way to create the dynamic assembly than having to hack pieces of IL, so I just decided to generate a CodeDom graph on the fly.
This is my first time creating on-the-fly assemblies and it really wasn't so difficult - just a matter of setting the CompilerParameters.GenerateInMemory property to true.

Although it's more maintainable and is less likely to break in future CLR versions, it's slower than the previous version, given the fact that there's a compiler involved, but once you get over that hurdle (say, by caching the original object), it's about the same if not better.
Here is the source of the modified GenericPropertyAccessor.cs, but the rest you need to download from the previous article.

Last bit: During work on my code, I've come across yet another bug in CodeDom, "The C# CodeDom provider does not work correctly with PrivateImplementationType with TypeArguments", which has been flagged as fixed in the next version. Another bug in CodeDom - who'd've thunk?

[Updated (1.6)] Commonly Used .NET Coding Patterns in CodeDom (now under a CC license)

Omer van Kloeten — Mon, 08 May 2006 18:17:00 GMT

The latest update (1.6) of my article Commonly Used .NET Coding Patterns in CodeDom is now out.
Major changes made since 1.5:

The Asynchronous Operation pattern has been added.
The Disposable Type pattern has been added.
The XML Comment patterns have been added.
Automatic documentation of the Begin/End Process, Custom Attribute, Custom Exception, Delegate, Event, Observer, Singleton, and Typed Collection patterns.
The Unary operators IsNull and NotNull have been added.
Several bug fixes.
The work is now licensed under the Creative Commons Attribution 2.5 License: You can copy, freely distribute, derive, and even use the code in a commercial product, but you must attribute it to the author (that is, me).

As always, I'm looking for new ideas to add, so let me know if you think of anything else you'd like to add to the package.
The formatting is a little screwey, especially in the code samples, but it's ok.

Please note that the new license now permits free use of this code in commercial products. If you decide to use the library, I'd love to know about it. :)

Half-Baked

Omer van Kloeten — Sat, 08 Apr 2006 15:10:00 GMT

Whenever I have to write a large project using CodeDom (and this doesn't happen as often as you'd think), I almost always find something lacking. It's as if the whole of CodeDom is half baked.

What's bugging me the most is that even with the framework's latest version, 2.0, when Microsoft had the chance to fix things up, they decided, for reasons unknown to anyone outside the company to only implement the new features and fix very few bugs.
Microsoft developers, on their blogs, keep saying that they want not only software to be built with the framework, but also tools. One of the greatest tool-making capabilities they placed in the framework is CodeDom and I'm very appreciative of it, but when such a feature lacks in so many areas, it in several occasions becomes unusable.

What brought this on? Here are the two latest bugs I found and reported:

(Previously, and then some, and then some more, and one more to boot)

CodeDom Reflection Generator

Omer van Kloeten — Fri, 07 Apr 2006 16:12:00 GMT

As a step to further promote correct writing of generators using CodeDom, I've created a utility that takes an entire assembly and creates typed methods that create every type in it, invoke every method, reference every member, etc..

Now wait a second and try and understand what I just wrote up there. Give up? That's ok, I gave before you did. Let's just take an example and it'll all be clear:

Take the Chars indexer for System.String. To access it, I would have to write an awefully long and untyped piece of code:

System.CodeDom.CodeIndexerExpression expression =
 new System.CodeDom.CodeIndexerExpression(new System.CodeDom.CodePropertyReferenceExpression(myStringObjectReference, "Chars"), positionExpression);

Using the reflected assembly, I could simply write:

System.CodeDom.CodeIndexerExpression expression = System.ReflectedString.Properties.ReferenceIndexerChars(myStringObjectReference, positionExpression);

Let's look at the greater scale now. Again, take .NET 1.1's String class as an example. After putting mscorlib through the tool, you will receive a class named ReflectedString in an assembly named [CodeDomReflection]mscorlib.dll that knows exactly how not only the String class works, but the whole of the mscorlib assembly and can strongly reference every single part of it. Also, a complete documentation xml file is included for Intellisense's sake.

The version I'm placing online for download is a perliminary beta. I've tested it on the entire framework and it worked great, but things may always break. Please let me know if they do.
Here are the bits. To do some magic, just use DotNetZen.CodeDom.Reflect assembly [strong name key file] (Yes, you can sign your assembly with a strong name key file so you could use it from your own signed generators).

[Updated (1.5)] Commonly Used .NET Coding Patterns in CodeDom

Omer van Kloeten — Mon, 03 Apr 2006 11:29:00 GMT

I have uploaded another update (1.5) to my article: Commonly Used .NET Coding Patterns in CodeDom.
Major changes made since 1.4:

The Typed Collection pattern has been added.
The Argument Assertion patterns have been added.
Assembly and all types are now CLSCompliant.
All types are now marked as serializable.
The Custom Attribute pattern now produces sealed attributes, to increase the efficiency of generated code.
Several overload additions and bug fixes.

Upcoming features:

Automatic documentation of members.
Async patterns.
Dispose pattern.
Serialization pattern.
And more...

Visualizers

Omer van Kloeten — Fri, 03 Mar 2006 16:03:00 GMT

I really like the idea of visualizers that has been implemented in Visual Studio 2005 and have wanted to write some for quite some time.
So I have added to the mix another passion of mine - CodeDom and therefore present:

The CodeDom Visualizer

The Visualizer will use all of the languages you have defined on your computer (using machine.config) to represent the unit, namespace, type, member, statement or expression.
You can download from here: ~~http://spaz.ice.org/code/cdv/cdvis.zip~~.
To install, simply drag the binaries to %DEVPATH%\Common7\Packages\Debugger\Visualizers.
[Update: Haibo Luo has a really cool visualizer for dynamic methods. I have a feeling I'll need it some day... :)]

What's next?

[Updated (1.4)] Commonly Used .NET Coding Patterns in CodeDom

Omer van Kloeten — Sat, 11 Feb 2006 13:16:00 GMT

I have uploaded another update (1.4) to my article: Commonly Used .NET Coding Patterns in CodeDom.
Major changes made since 1.2:

Now compatible with generation for Visual Basic. Sorry about that.
The Custom Attribute pattern has been added.
The Custom Exception pattern has been added.
The For Each pattern now works according to the C# specifications.
Interface more intuitive.
Lots of bug fixes.

I'm always looking for new ideas to add, so let me know if you think of anything else you'd like to add to the package.

Also, there's a conversation in the comments on how to add these as macros for Visual Studio.NET 2003 (to act as code snippets).