Click here to Skip to main content
11,720,785 members (76,522 online)
Click here to Skip to main content

Commonly Used .NET Coding Patterns in CodeDom

, 31 Oct 2006 142.2K 492 266
Rate this:
Please Sign up or sign in to vote.
A library of CodeDom templates of commonly used coding practices in .NET.

Table of contents

Introduction

The CLR and other .NET code contains many recurring patterns. As these patterns appear in code, they may also appear in code generated by CodeDom graphs, yet generating these patterns requires lot of work, which is quite repetitive. This library contains many pattern implementations for use in your own CodeDom generator, which could help you in decreasing the amount of code you write by thousands of lines.
If you believe there is a pattern that would be perfect for the library, leave a comment and chances are good it will be available, come the next release.

As of October 23, 2006, the project is hosted on CodePlex, with this article serving as an introduction to its abilities.

Argument Assertion patterns

The Argument Assertion patterns are recurring patterns from the CLR in which arguments are checked and exceptions such as ArgumentNullException are raised accordingly. The currently supported assertions are: NotNull, InRange, InLowerBound, InUpperBound, IsInstanceOf, EnumIsDefined and StringNotNullOrEmpty.

In order to include this pattern in your code, your code should look like this:

myMethod.Statements.Add(
    new CodePatternArgumentAssertNotNullStatement("myArgument"));
myMethod.Statements.Add(
    new CodePatternArgumentAssertInRangeStatement("myArgument",
        new CodeFieldReferenceExpression(
            new CodeTypeReferenceExpression("MyType"), "MinValue"), 
        new CodeFieldReferenceExpression(
            new CodeTypeReferenceExpression("MyType"), "MaxValue")));
myMethod.Statements.Add(
    new CodePatternArgumentAssertIsInstanceOfStatement(
                                         "myArgument", typeof(int)));

The code generated by above will be:

if ((myArgument == null))
{
    throw new System.ArgumentNullException("myArgument");
}
if (((myArgument > MyType.MaxValue) 
    || (myArgument < MyType.MinValue)))
{
    throw new System.ArgumentOutOfRangeException("myArgument");
}
if ((myArgument.GetType().IsInstanceOfType(typeof(int)) == false))
{
    throw new System.ArgumentException(string.Format(
              "The argument myArgument must be of type {0}.", 
              typeof(int).FullName), "myArgument");
}

The Assembly Information pattern

Added automatically by Visual Studio, an assembly is identifiable by a set of attributes. This pattern simplifies access to these attributes as properties of a class deriving from CodeCompileUnit.

In order to include this pattern in your code, your code should look like this:

CodePatternCompileUnit unit = new CodePatternCompileUnit();
unit.AssemblyVersion = new Version(1, 0);
unit.AssemblyTitle = "My assembly";
unit.CLSCompliant = true;

The code generated by above will be:

[assembly: System.Reflection.AssemblyVersionAttribute("1.0")]
[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0")]
[assembly: System.Reflection.AssemblyTitleAttribute("My assembly")]
[assembly: System.CLSCompliantAttribute(true)]

The Asynchronous Operation pattern

A recurring pattern from the CLR, asynchronous invocation of methods is required by many systems and components. The implementation presented here is the simplest one, which uses delegates. Documentation on the members generated can be controlled using the HasComments property.

In order to include this pattern in your code, your code should look like this:

type.Members.AddRange(new CodePatternAsyncOperation(myMethod));

The code generated by above will be:

/// <span class="code-SummaryComment"><summary>
</span>

The BeginProcess/EndProcess pattern

A recurring pattern from System.Data and System.Windows.Forms is the BeginProcess/EndProcess pattern, such as BeginLoad/EndLoad and BeginInit/EndInit. This pattern enables silencing of events with an intuitive interface. Documentation on the members generated can be controlled using the HasComments property.

In order to include this pattern in your code, your code should look like this:

type.Members.AddRange(new CodePatternBeginEndProcess("Init"));

The code generated by above will be:

/// <span class="code-SummaryComment"><summary>
</span>

Binary Operator patterns

Most binary operators are built into CodeDom, but some aren't. This pattern extends the normal CodeBinaryOperatorExpression to add more operators. Currently supported operator/s: BooleanExclusiveOr.

In order to include this pattern in your code, your code should look like this:

method.Statements.Add(
    new CodeConditionStatement(
        new CodePatternBinaryOperatorExpression(
           new CodeVariableReferenceExpression("bool1"), 
           CodePatternBinaryOperatorType.BooleanExclusiveOr,
           new CodeVariableReferenceExpression("bool2"))
        /* , Contained statements */));

The code generated by above will be:

if (((bool1 == true) && (bool2 == false)) || 
                ((bool1 == false) && (bool2 == true)))
{
    // Contained statements...
}

Code Access Security Decorator patterns

The model of declarative Code Access Security is widespread in the CLR and also very important in many differing situations.

In order to include this pattern in your code, your code should look like this:

UI ui = new DotNetZen.CodeDom.Patterns.Permissions.UI();
ui.Clipboard = 
  System.Security.Permissions.UIPermissionClipboard.AllClipboard;
myMethod.CustomAttributes.Add(new CodePatternCasAttribute(ui));

The code generated by above will be:

[System.Security.Permissions.UIPermissionAttribute(
   System.Security.Permissions.SecurityAction.Demand, 
   Clipboard=System.Security.Permissions.
             UIPermissionClipboard.AllClipboard)]
private void MyMethod()
{
}
Currently all of the Framework's declarative CAS attributes are supported and custom attribute abstractions can be created simply by inheriting from DotNetZen.CodeDom.Patterns.Permissions.Permission.

Compound Assignment patterns

No compound assignment operators are built into CodeDom. This pattern extends the normal CodeAssignStatement to add more operators. Currently supported operator/s: Add, Subtract, Multiply, Divide, Modulus, BitwiseAnd, BitwiseOr.

In order to include this pattern in your code, your code should look like this:

method.Statements.Add(
    new CodePatternCompoundAssignStatement(
        new CodeVariableReferenceExpression("foo"),
        CodePatternCompoundAssignmentOperatorType.Add,
        new CodeVariableReferenceExpression("bar")));

The code generated by above will be:

foo = (foo + bar);

The Cursor Lock pattern

A recurring pattern from System.Windows.Forms is the locking of a Form's Cursor property. This pattern is useful when the process contained within it is quite long.

In order to include this pattern in your code, your code should look like this:

method.Statements.AddRange(
    new CodePatternCursorLock(/* Contained statements */));

The code generated by above will be:

System.Windows.Forms.Cursor cursor0 = this.Cursor;

try
{
    this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
    
    // More code here...
}
finally
{
    this.Cursor = cursor0;
}

The Custom Attribute pattern

Most custom attributes derive from the same template. As a result, creating custom attributes can be a menial task. Documentation on the members generated can be controlled using the HasComments property and the SetComment method.

In order to include this pattern in your code, your code should look like this:

CodePatternCustomAttributeDeclaration attrib = 
      new CodePatternCustomAttributeDeclaration(
          "CoolMetaData",
          AttributeTargets.Struct | 
             AttributeTargets.Class | AttributeTargets.Enum,
          false, true,
          new CodeParameterDeclarationExpression(typeof(int), 
                                               "MetaData"));

attrib.SetComment("MetaData", "The metadata for the attribute");

The code generated by above will be:

[System.AttributeUsageAttribute(((System.AttributeTargets.Enum | 
                                  System.AttributeTargets.Struct) 
        | System.AttributeTargets.Class), 
        AllowMultiple=false, Inherited=true)]
public sealed class CoolMetaDataAttribute : System.Attribute
{
    /// <span class="code-SummaryComment"><summary>
</span>

The Custom Exception pattern

Most custom exceptions derive from the same template. As a result, creating custom exceptions can be a menial task. Documentation on the members generated can be controlled using the HasComments property and the SetComment method.

In order to include this pattern in your code, your code should look like this:

CodePatternCustomExceptionDeclaration exception = 
    new CodePatternCustomExceptionDeclaration("Foo",
        new CodeParameterDeclarationExpression(
                               typeof(int), "Bar"));

exception.SetComment("Bar", "A healthy snack-bar");

The code generated by above will be:

[System.SerializableAttribute()]
public class FooException : System.Exception
{
    /// <span class="code-SummaryComment"><summary>
</span>

The Delegate pattern

The Delegate pattern, also known as the EventHandler pattern, is a recurring pattern from the CLR, in which a delegate is created with an object and EventArgs, with a specialized EventArgs class. This pattern is useful for the quick creation of any delegate. Documentation on the members generated can be controlled using the HasComments property and the SetComment method.

In order to include this pattern in your code, your code should look like this:

CodePatternDelegate delegateType = new CodePatternDelegate(
    "ItemChanged",
    new CodeParameterDeclarationExpression(typeof(int), "OldValue"),
    new CodeParameterDeclarationExpression(typeof(int), "NewValue"));

delegateType.SetComment("OldValue", "The value before the change");
delegateType.SetComment("NewValue", "The value after the change");

nameSpace.Types.AddRange(delegateType);

The code generated by above will be:

/// <span class="code-SummaryComment"><summary>
</span>

The Disposable Type pattern

A recurring pattern from the CLR, this recommended pattern for use of the IDisposable interface is used to keep finalizers from running when the object has already been disposed. Documentation on the members generated can be controlled using the automaticComments parameter.
In order to implement the pattern in types that derive from types already implementing this pattern, use the DisposeImplementationType.Inherited value and only an override for void Dispose(bool) will be created.

In order to include this pattern in your code, your code should look like this:

CodePatternTypeDeclaration declaration = 
            new CodePatternTypeDeclaration("MyType");
// ...
declaration.ApplyDisposablePattern(
     new CodeInstanceReferenceExpression(new 
     CodeFieldReferenceExpression(new CodeThisReferenceExpression(), 
     "myReferenceTypeField"), typeof(object)), 
     new CodeInstanceReferenceExpression(new 
     CodeFieldReferenceExpression(new CodeThisReferenceExpression(), 
     "myValueTypeField"), typeof(int)));

The code generated by above will be:

public class MyType : System.IDisposable
{
    /// <span class="code-SummaryComment"><summary>
</span>

Please note that due to a bug in the .NET Framework, Creation of finalizers is impossible! Please vote on this issue on LadyBug.

The Event pattern

The Event pattern is a recurring pattern from System.Windows.Forms, in which an event has a special invoking method. This pattern is useful for the quick creation of any event. Documentation on the members generated can be controlled using the HasComments property.

In order to include this pattern in your code, your code should look like this:

type.Members.AddRange(new CodePatternEvent(
    "EventHappened", Scope.Instance, typeof(EventHandler)));

The code generated by above will be:

public event System.EventHandler EventHappened;

/// <span class="code-SummaryComment"><summary>
</span>

Please note that due to a bug in the .NET Framework, static events cannot be generated! Please vote on this issue on LadyBug.

Language restrictions: Visual Basic does not allow return values from events.

The Flags pattern

The Flags pattern is a recurring pattern from the entire CLR, in which an enum is flagged with the FlagsAttribute attribute. This pattern allocates values automatically and supports up to 63 values.
Each member's CodeMemberField object can be accessed using the Flags indexer.

In order to include this pattern in your code, your code should look like this:

nameSpace.Types.Add(new CodePatternFlags("MyFlags", 
                                      "A", "B", "C"));

The code generated by above will be:

[System.FlagsAttribute()]
public enum MyFlags : int
{
    A = 1,
    B = 2,
    C = 4,
}

The For Each pattern

The For Each pattern is built into C#, but is not native to IL. The pattern iterates over a collection that implements the System.IEnumerable interface. As the C# specification states, the implementation of the said interface is not required, but the implementation of the methods such as MoveNext and GetEnumerator are.

In order to include this pattern in your code, your code should look like this:

method.Statements.AddRange(new CodePatternForEach(
    new CodeTypeReference(typeof(int)), 
    new CodeVariableReferenceExpression("myCollection"),
    new CodeTypeReference("EnumeratorType")
    /* , Contained statements */));

The code generated by above will be:

System.Collections.IEnumerator enumerator0 = 
  ((System.Collections.IEnumerator)(myCollection)).GetEnumerator();

try
{
    for (; enumerator0.MoveNext();)
    {
        int element0 = ((int)(enumerator0.Current));
        // Contained statements ...
    }
}
finally
{
    if (((enumerator0 != null) && 
          enumerator0.GetType().IsInstanceOfType(
                      typeof(System.IDisposable))))
    {
        ((System.IDisposable)(enumerator0)).Dispose();
    }
}

The Get Property/Field pattern

The Get Property/Field pattern is a recurring pattern from the entire CLR, in which a private field is exposed using a property with a get accessor.

In order to include this pattern in your code, your code should look like this:

type.Members.AddRange(new CodePatternGetField("Value", 
    new CodeTypeReference(typeof(int)), Scope.Instance));

The code generated by above will be:

private int m_Value;

public int Value
{
    get
    {
        return this.m_Value;
    }
}

The Is Instance Of pattern

The Is Instance Of pattern is built into C# as the is keyword, and is also native to IL, yet it is not implemented in CodeDom. The pattern checks whether an object's type implements, inherits or is the queried type.

In order to include this pattern in your code, your code should look like this:

method.Statements.Add(new CodePatternIsInstExpression(
          new CodeVariableReferenceExpression("myVariable"),
          new CodeTypeReference(typeof(IMyInterface))));

The code generated by above will be:

myVariable.GetType().IsInstanceOfType(typeof(IMyInterface))

The Lock pattern

The Lock pattern is built into C#, but is not native to IL. The pattern locks a resource using the System.Threading.Monitor class.

In order to include this pattern in your code, your code should look like this:

method.Statements.AddRange(new CodePatternLock(
          new CodeFieldReferenceExpression(
               new CodeThisReferenceExpression(), "SyncRoot")
          /* , Contained statements... */));

The code generated by above will be:

object lockCachedExpr0 = this.SyncRoot;
System.Threading.Monitor.Enter(lockCachedExpr0);

try
{
    // Contained statements...
}
finally
{
    System.Threading.Monitor.Exit(lockCachedExpr0);
}

The Nullable Value Type Property pattern

The Nullable Value Type Property pattern is used in CLR 1.x (pre-generics and Nullable<T>) to denote a value type property with a null value. This pattern is used predominately in Typed DataSets.

In order to include this pattern in your code, your code should look like this:

type.Members.AddRange(new CodePatternNullableProperty("Value", 
         new CodeTypeReference(typeof(int)), Scope.Instance));

The code generated by above will be:

private int m_Value;

/// <span class="code-SummaryComment"><summary>
</span>

The Observer pattern

The Observer pattern is a classic pattern which allows subscribers to be notified of the changes to a value. This implementation allows changes to the value of a property to be announced using an event. Documentation on the members generated can be controlled using the HasComments property.

In order to include this pattern in your code, your code should look like this:

type.Members.AddRange(new CodePatternObserver("MyValue", 
    new CodeTypeReference(typeof(int)), Scope.Instance));

The code generated by above will be:

/// <span class="code-SummaryComment"><summary>
</span>

The Serializable Type pattern

A pattern from the CLR, this pattern applies one of the four different types of serialization in the framework: Basic, Selective and Custom for types new to serialization and ones inheriting it. Documentation on the members generated can be controlled using the automaticComments parameter.

In order to include this pattern in your code, your code should look like this:

CodePatternTypeDeclaration declaration = 
                     new CodePatternTypeDeclaration("MyType");
decl.Members.Add(new CodeMemberField(typeof(int), "myField"));
decl.ApplySerializablePattern(SerializationType.NewCustom, "myField");

The code generated by above will be:

[System.SerializableAttribute()]
public class MyType : System.Runtime.Serialization.ISerializable
{
    private int myField;

    /// <span class="code-SummaryComment"><summary>
</span>

The Singleton pattern

The Singleton pattern is a classic pattern which allows a class to only have one instance in the application. This implementation follows the best practices and is thread-safe. It also allows lazy-loading or pre-loading implementation. Documentation on the members generated can be controlled using the HasComments property.

In order to include this pattern in your code, your code should look like this:

nameSpace.Types.Add(new CodePatternSingleton("Foo", 
                                   LoadType.LazyLoad));

The code generated by above will be:

public class Foo
{
    private Foo()
    {
    }

    /// <span class="code-SummaryComment"><summary>
</span>

The Typed Collection pattern

The Typed Collection pattern is a woe on the way to completely strongly typed implementations. This is one of the most common type patterns, and also one of those patterns which can have 1001 different implementations. This implementation includes optional events (with the ability to silence them when loading data), a complete IList implementation and additional convenience constructors and methods, such as AddRange and ToArray.

In order to include this pattern in your code, your code should look like this:

nameSpace.Types.Add(new CodePatternTypedCollection(
                      typeof(int), CollectionEvents.All));

The code generated by above will be:

/// <span class="code-SummaryComment"><summary>
</span>

Please note that a bug in the .NET Frameworks up to (and not including) 2.0 does not allow for creation of parameter arrays, which means that the pattern is incomplete when used with these versions.

Unary Operator patterns

No unary operators are built into CodeDom. This pattern extends the normal CodeBinaryOperatorExpression to add more operators. Currently supported operator/s: BooleanNot, BooleanIsTrue, IsNull, NotNull.

In order to include this pattern in your code, your code should look like this:

method.Statements.Add(
    new CodeConditionStatement(
        new CodePatternBinaryOperatorExpression(
            CodePatternUnaryOperatorType.BooleanNot,
            new CodeVariableReferenceExpression("bool1"))
        /* , Contained statements */));

The code generated by above will be:

if (bool1 == false)
{
    // Contained statements...
}

The Using pattern

The Using pattern is built into C#, but is not native to IL. The pattern uses a resource that implements the System.IDisposable interface, then releases it.

In order to include this pattern in your code, your code should look like this:

method.Statements.AddRange(new CodePatternUsing(
    new CodeVariableDeclarationStatement(
                typeof(System.Drawing.Image), "image"),
    ResourceType.ReferenceType
    /* , Contained statements... */));

The code generated by above will be:

System.Drawing.Image image;

try
{
    // Contained statements...
}
finally
{
    if ((image != null))
    {
        ((System.IDisposable)(image)).Dispose();
    }
}

XML Comment patterns

XML comments are the standard method of writing member comments which are descriptive and easy to parse using tool such as NDoc. The currently supported tags and their class equivalents are:

  • <summary> - SummaryStatements.
  • <c> - TextAsCodeExpression.
  • <code> - MultilineTextAsCodeStatements.
  • <example> - ExampleStatements.
  • <exception> - ExceptionStatements.
  • <list> - ListStatements.
  • <para> - ParagraphExpression.
  • <param> - ParameterStatements.
  • <paramref> - ParameterReferenceExpression.
  • <remarks> - RemarksStatements.
  • <returns> - ReturnsStatements.
  • <see> - SeeExpression.
  • <seealso> - SeeAlsoStatements.
  • <value> - ValueStatements.
Also, there are several templates: CommentsForConstructor, CommentsForMethod, CommentsForProperty and CommentsForIndexer.

On a side note, Sandcastle has been released by Microsoft, but it has not yet been finalized. Once it is, classes will be added to support the more advanced features it offers.

History

  • 2006-10-31 - Version 1.8.
    1. The Code Access Security Decorator Patterns have been added.
    2. The Assembly Information Pattern has been added.
    3. Security demand added to GetObjectData in the Serializable Type Pattern.
    4. XML Comment Patterns moved to the .Xml namespace and had their CodeXmlComment prefix removed (too long).
    5. Binaries now target .NET 2.0 instead of .NET 1.1, but they are mostly still backwards compatible.
  • 2006-09-23: Version 1.7.
    1. The Nullable Value Type Property Pattern has been added.
    2. The Enum.IsDefined and String.IsNullOrEmpty assertions have been added.
    3. The Serializable Type Pattern has been added.
    4. The Disposable Type Pattern is now a part of CodePatternTypeDeclaration.
  • 2006-04-29: Version 1.6.
    1. The Asynchronous Operation Pattern has been added.
    2. The Disposable Type Pattern has been added.
    3. The XML Comment Patterns have been added.
    4. Automatic documentation of the Begin/End Process, Custom Attribute, Custom Exception, Delegate, Event, Observer, Singleton, and Typed Collection patterns.
    5. The Unary Operators IsNull and NotNull have been added.
    6. You can now access each flag's CodeMemberField in the Flags Pattern.
    7. The Singleton Pattern (Lazy Load) no longer publicly exposes the internally used class InstanceContainer.
    8. The Typed Collection Pattern's ToArray method has been fixed.
    9. 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.
  • 2006-03-31: Version 1.5.
    1. The Typed Collection pattern has been added.
    2. The Argument Assertion patterns have been added.
    3. Assembly and all types are now CLSCompliant.
    4. All types are now marked as Serializable.
    5. The Custom Attribute pattern now produces sealed attributes, to increase the efficiency of generated code.
    6. Several overload additions and bug fixes.
  • 2006-02-10: Version 1.4.
    1. Compatible with generation for Visual Basic.
    2. Custom Exception pattern altered to take CodeParameterDeclarationExpressions instead of CodePatternGetFields.
    3. The Event pattern now has an overload that takes a delegate type (and deduces the parameters and the return type).
    4. The For Each pattern now works according to the C# specifications.
    5. Several bug fixes.
  • 2006-01-28: Version 1.3.
    1. Assembly renamed to DotNetZen.CodeDom.Patterns.
    2. The Custom Attribute pattern has been added.
    3. The Custom Exception pattern has been added.
  • 2006-01-13: Version 1.2.
    1. Binary and unary operator patterns have been added.
    2. Compound assignment patterns have been added.
  • 2005-11-11: Version 1.1.
    1. The Cursor Lock pattern now changes the cursor back to its original icon, rather than Cursors.Default.
    2. The For Each pattern has been added.
    3. The Is Instance Of pattern has been added.
    4. Boolean flags for scope are now implemented using the Scope enumeration.
    5. Boolean flags for the resource type on the Using pattern are now implemented using the ResourceType enumeration.
    6. Boolean flags for the load type on the Singleton pattern are now implemented using the LoadType enumeration.
  • 2005-10-30: Initial release.

Creative Commons License
This work is licensed under a Creative Commons Attribution 2.5 License
(Can copy, distribute, derive, use commercially; Must attribute to author)

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

Share

About the Author

Omer van Kloeten
Web Developer
Israel Israel
Omer van Kloeten is a senior .NET consultant and a lecturer at the Sela Group.

My blogs:
English: http://weblogs.asp.net/OKloeten/
English and Hebrew: http://blogs.microsoft.co.il/blogs/omer

You can find more details about the Sela Group here:
http://www.sela.co.il

You may also be interested in...

Comments and Discussions

 
QuestionBug in CodePatternLock ? Pin
zebadiah8131-Oct-07 13:46
memberzebadiah8131-Oct-07 13:46 
GeneralUnary Pattern Pin
Gilesb4-Feb-07 5:01
memberGilesb4-Feb-07 5:01 
AnswerRe: Unary Pattern Pin
Omer van Kloeten4-Feb-07 5:54
memberOmer van Kloeten4-Feb-07 5:54 
GeneralRe: Unary Pattern Pin
Gilesb7-Feb-07 0:34
memberGilesb7-Feb-07 0:34 
I realised just after I made the post that the unary operator can be simulated by a binary operator with left had operand of zero.


i = (-j) ==> i = (0 - j)

Well that works for numbers.

Not sure about (-True) shouldn't that return False?
My Immediate window in VS2005 seems to disagree.

QuestionCan It be done with Codedom? Pin
mbkasi8-Nov-06 14:55
membermbkasi8-Nov-06 14:55 
AnswerRe: Can It be done with Codedom? Pin
Omer van Kloeten9-Nov-06 0:15
memberOmer van Kloeten9-Nov-06 0:15 
Generalsuggestion Pin
System.Object17-May-06 2:51
memberSystem.Object17-May-06 2:51 
AnswerRe: suggestion Pin
Omer van Kloeten17-May-06 8:13
memberOmer van Kloeten17-May-06 8:13 
GeneralRe: suggestion Pin
System.Object17-May-06 8:34
memberSystem.Object17-May-06 8:34 
GeneralRe: suggestion Pin
Omer van Kloeten17-May-06 8:46
memberOmer van Kloeten17-May-06 8:46 
GeneralRe: suggestion Pin
Efran Cobisi10-Oct-06 6:07
memberEfran Cobisi10-Oct-06 6:07 
AnswerRe: suggestion Pin
Omer van Kloeten10-Oct-06 7:04
memberOmer van Kloeten10-Oct-06 7:04 
Generalnullable property Pin
jonavi8-May-06 12:10
memberjonavi8-May-06 12:10 
AnswerRe: nullable property Pin
Omer van Kloeten8-May-06 17:41
memberOmer van Kloeten8-May-06 17:41 
Generalspectacular Pin
jonavi8-May-06 10:07
memberjonavi8-May-06 10:07 
GeneralRe: spectacular Pin
Omer van Kloeten8-May-06 17:53
memberOmer van Kloeten8-May-06 17:53 
GeneralAdding Region Pin
vbinfo15-Jan-06 22:11
membervbinfo15-Jan-06 22:11 
AnswerRe: Adding Region Pin
Omer van Kloeten16-Jan-06 6:22
memberOmer van Kloeten16-Jan-06 6:22 
GeneralRe: Adding Region Pin
vbinfo16-Jan-06 6:46
membervbinfo16-Jan-06 6:46 
AnswerRe: Adding Region Pin
Omer van Kloeten16-Jan-06 7:22
memberOmer van Kloeten16-Jan-06 7:22 
GeneralExcellent! Pin
Alexey A. Popov17-Nov-05 21:48
memberAlexey A. Popov17-Nov-05 21:48 
AnswerRe: Excellent! Pin
Omer van Kloeten18-Nov-05 0:00
memberOmer van Kloeten18-Nov-05 0:00 
GeneralDumb question Pin
smesser17-Nov-05 5:39
membersmesser17-Nov-05 5:39 
GeneralRe: Dumb question Pin
Tony Snearly17-Nov-05 6:52
memberTony Snearly17-Nov-05 6:52 
AnswerRe: Dumb question Pin
Omer van Kloeten17-Nov-05 8:34
memberOmer van Kloeten17-Nov-05 8:34 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.150901.1 | Last Updated 31 Oct 2006
Article Copyright 2005 by Omer van Kloeten
Everything else Copyright © CodeProject, 1999-2015
Layout: fixed | fluid