CodeDom 中常用的 .NET 编码模式

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

private int m_Value;

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

Is Instance Of 模式

Is Instance Of 模式在 C# 中作为 `is` 关键字内置，并且也是 IL 的原生支持，但它并未在 CodeDom 中实现。该模式检查对象的类型是否实现、继承或等于查询的类型。

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

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

锁定模式

锁定模式内置于 C# 中，但并非 IL 的原生支持。该模式使用 `System.Threading.Monitor` 类锁定资源。

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

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

try
{
    // Contained statements...

}
finally
{
    System.Threading.Monitor.Exit(lockCachedExpr0);
}

可 Null 值类型属性模式

可 Null 值类型属性模式在 CLR 1.x（泛型和 Nullable<T> 之前）中使用，用于表示具有 null 值的类型属性。此模式主要在强类型数据集 (`Typed DataSets`) 中使用。

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

private int m_Value;

/// <summary>

/// See <see cref="IsValueNull" /> for information about this field.

/// </summary>

private bool m_IsValueNull = true;

public int Value
{
    get
    {
        if ((this.m_IsValueNull == true))
        {
            throw new System.InvalidOperationException("Can not" + 
                  " get value when it is null. Check for " + 
                  "nullability by calling IsValueNull.");
        }
        return this.m_Value;
    }
    set
    {
        this.m_Value = value;
        this.m_IsValueNull = false;
    }
}

/// <summary>

/// Gets whether the value of <see cref="Value" /> is null.

/// </summary>

/// <value>Whether the value of <see cref="Value" /> is null.</value>

public bool IsValueNull
{
    get
    {
        return this.m_IsValueNull;
    }
}

/// <summary>

/// Sets the value of <see cref="Value" /> to null.

/// </summary>

public void SetValueNull()
{
    this.m_IsValueNull = true;
}

观察者模式

观察者模式是一个经典模式，它允许订阅者收到值更改的通知。此实现允许通过事件来宣布属性值的更改。可以通过 `HasComments` 属性来控制生成成员的文档。

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

/// <summary>

/// Value for the property <see cref="MyValue" />.

/// </summary>

private int m_MyValue;

public int MyValue
{
    get
    {
        return this.m_MyValue;
    }
    set
    {
        if ((this.m_MyValue != value))
        {
            int oldValue = this.m_MyValue;
            this.m_MyValue = value;
            this.OnMyValueChanged(new MyValueChangedEventArgs(oldValue, 
                                                        this.m_MyValue));
        }
    }
}

/// <summary>

/// Occurs when the <see cref="MyValue" /> property is changed.

/// </summary>

public event MyValueChangedEventHandler MyValueChanged;

/// <summary>

/// Raises the <see cref="MyValueChanged" /> event.

/// </summary>

/// <param name="e">The value passed

/// for the event's e parameter.</param>

protected virtual void OnMyValueChanged(MyValueChangedEventArgs e)
{
    if ((this.MyValueChanged != null))
    {
        this.MyValueChanged(this, e);
    }
}

/// <summary>

/// Represents a method that takes a <see cref="System.Object" />

/// and <see cref="MyValueChangedEventArgs" />.

/// </summary>

/// <param name="sender">The event's originating object.</param>

/// <param name="e">The event's arguments.</param>

public delegate void MyValueChangedEventHandler(object sender, 
                                   MyValueChangedEventArgs e);

/// <summary>

/// Contains the arguments for events based

/// on the <see cref="MyValueChangedEventHandler" /> delegate.

/// </summary>

public class MyValueChangedEventArgs : System.EventArgs
{
    /// <summary>

    /// Value for the property <see cref="OldValue" />.

    /// </summary>

    private int m_OldValue;

    /// <summary>

    /// Value for the property <see cref="NewValue" />.

    /// </summary>

    private int m_NewValue;

    /// <summary>

    /// Initializes a new instance

    /// of the <see cref="MyValueChangedEventArgs" /> class.

    /// </summary>

    /// <param name="OldValue">The value before the change.</param>

    /// <param name="NewValue">The current value.</param>

    public MyValueChangedEventArgs(int OldValue, int NewValue)
    {
        this.m_OldValue = OldValue;
        this.m_NewValue = NewValue;
    }

    /// <summary>

    /// Gets the value before the change.

    /// </summary>

    /// <value>The value before the change.</value>

    public virtual int OldValue
    {
        get
        {
            return this.m_OldValue;
        }
    }

    /// <summary>

    /// Gets the current value.

    /// </summary>

    /// <value>The current value.</value>

    public virtual int NewValue
    {
        get
        {
            return this.m_NewValue;
        }
    }
}

可序列化类型模式

这是 CLR 中的一个模式，它应用了框架中的四种不同类型的序列化之一：对于新序列化类型和继承序列化类型的类型，有 `Basic`、`Selective` 和 `Custom`。可以通过 `automaticComments` 参数来控制生成成员的文档。

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

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

    /// <summary>

    /// Initializes a new instance of the <see cref="MyType" /> class.

    /// </summary>

    /// <param name="info">The data needed

    /// to serialize or deserialize an object.</param>

    /// <param name="context">The source

    /// and destination of a given serialized stream.</param>

    /// <remarks>This member supports the .NET Framework

    /// infrastructure and is not intended

    /// to be used directly from your code.</remarks>

    protected MyType(System.Runtime.Serialization.SerializationInfo info, 
              System.Runtime.Serialization.StreamingContext context)
    {
        this.myField = ((int)(info.GetValue("myField", typeof(int))));
    }

    /// <summary>

    /// Populates a <see cref="System.Runtime.Serialization.
    ///                        SerializationInfo" />

    /// with the data needed to serialize the target object.

    /// </summary>

    /// <param name="info">The <see 
    /// cref="System.Runtime.Serialization.SerializationInfo" />

    /// to populate with data.</param>

    /// <param name="context">The destination (see <see 
    /// cref="System.Runtime.Serialization.StreamingContext" />)

    /// for this serialization.</param>

    /// <exception cref="System.ArgumentNullException">Thrown

    /// when the <paramref name="info" /> parameter is a null

    /// reference (Nothing in Visual Basic).</exception>

    [System.Security.Permissions.SecurityPermissionAttribute(
        System.Security.Permissions.SecurityAction.LinkDemand, 
        Flags=System.Security.Permissions.
              SecurityPermissionFlag.SerializationFormatter)]
    public virtual void GetObjectData(
           System.Runtime.Serialization.SerializationInfo 
           info, System.Runtime.Serialization.StreamingContext context)
    {
        if ((info == null))
        {
            throw new System.ArgumentNullException("info");
        }
        info.AddValue("myField", this.myField, typeof(int));
    }
}

单例模式

单例模式是一个经典模式，它允许一个类在应用程序中只有一个实例。此实现遵循最佳实践，并且是线程安全的。它还允许惰性加载或预加载实现。可以通过 `HasComments` 属性来控制生成成员的文档。

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

public class Foo
{
    private Foo()
    {
    }

    /// <summary>

    /// Gets the single instance of type <see cref="Foo" />.

    /// </summary>

    /// <value>The single instance of type <see cref="Foo" />.</value>

    public static Foo Instance
    {
        get
        {
            return InstanceContainer.Instance;
        }
    }

    class InstanceContainer
    {
        private static Foo m_Instance = new Foo();

        static InstanceContainer()
        {
        }

        private InstanceContainer()
        {
        }

        public static Foo Instance
        {
            get
            {
                return InstanceContainer.m_Instance;
            }
        }
    }
}

强类型集合模式

强类型集合模式是实现完全强类型化的一种麻烦。这是最常见的类型模式之一，也是可能拥有 1001 种不同实现的模式之一。此实现包括可选事件（在加载数据时可以静默它们）、完整的 `IList` 实现以及额外的便捷构造函数和方法，如 `AddRange` 和 `ToArray`。

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

/// <summary>

/// Represents a collection of <see cref="Int32" /> elements.

/// </summary>

[System.SerializableAttribute()]
public class Int32Collection : System.Collections.CollectionBase
{
    /// <summary>

    /// See <see cref="IsInLoad" /> for information about this field.

    /// </summary>

    private int m_IsInLoad;
    
    /// <summary>

    /// Initializes a new instance

    /// of the <see cref="Int32Collection" /> class.

    /// </summary>

    public Int32Collection()
    {
    }
    
    /// <summary>

    /// Initializes a new instance of the

    /// <see cref="Int32Collection" /> class.

    /// </summary>

    /// <param name="values">A list of objects of type

    /// <see cref="Int32" /> to initialize

    /// the collection with.</param>

    public Int32Collection(params int[] values)
    {
        if ((values == null))
        {
            throw new System.ArgumentNullException("values");
        }
        this.InnerList.Capacity = values.Length;
        this.BeginLoad();
        try
        {
            this.AddRange(values);
        }
        finally
        {
            this.EndLoad();
        }
    }
    
    /// <summary>

    /// Initializes a new instance of the

    /// <see cref="Int32Collection" /> class.

    /// </summary>

    /// <param name="collection">An object of type

    /// <see cref="Int32Collection" /> containing

    /// objects to be copied into the new collection.</param>

    public Int32Collection(Int32Collection collection)
    {
        if ((collection == null))
        {
            throw new System.ArgumentNullException("collection");
        }
        this.InnerList.Capacity = collection.Count;
        this.BeginLoad();
        try
        {
            this.AddRange(collection);
        }
        finally
        {
            this.EndLoad();
        }
    }
    
    /// <summary>

    /// Gets or sets the <see cref="Int32" />

    /// at position <paramref name="index" />.

    /// </summary>

    /// <value>The <see cref="Int32" /> at position

    /// <paramref name="index" />.</value>

    /// <param name="index">The position

    /// of the <see cref="Int32" />.</param>

    public int this[int index]
    {
        get
        {
            return ((int)(this.List[index]));
        }
        set
        {
            this.List[index] = value;
        }
    }
    
    /// <summary>

    /// Gets an object that can be used

    /// to synchronize access to the collection.

    /// </summary>

    /// <value>An object that can be used to synchronize

    /// access to the collection.</value>

    public object SyncRoot
    {
        get
        {
            return this.List.SyncRoot;
        }
    }
    
    /// <summary>

    /// Occurs when the collection begins

    /// the process of removing all elements.

    /// </summary>

    /// <remarks>To indicate that clearing the collection

    /// is not possible, throw an exception

    /// from an attached method.</remarks>

    public event System.EventHandler Clearing;
    
    /// <summary>

    /// Occurs after the collection completes

    /// the process of removing all elements.

    /// </summary>

    public event System.EventHandler Cleared;
    
    /// <summary>

    /// Occurs when the collection begins

    /// the process of inserting an element.

    /// </summary>

    /// <remarks>To indicate that inserting this element is invalid,

    /// throw an exception from an attached method. To indicate

    /// that the element is simply invalid, use the

    /// <see cref="Validating" /> event.</remarks>

    public event EventHandler Inserting;
    
    /// <summary>

    /// Occurs after the collection completes

    /// the process of inserting an element.

    /// </summary>

    /// <remarks>To prevent the insertion from taking place,

    /// throw an exception from an attached method.</remarks>

    public event EventHandler Inserted;
    
    /// <summary>

    /// Occurs when the collection begins

    /// the process of removing an element.

    /// </summary>

    /// <remarks>To indicate that removing this element is invalid,

    /// throw an exception from an attached method. To indicate that

    /// the element is simply invalid, use the

    /// <see cref="Validating" /> event.</remarks>

    public event EventHandler Removing;
    
    /// <summary>

    /// Occurs after the collection completes

    /// the process of removing an element.

    /// </summary>

    /// <remarks>To prevent the removal from taking place,

    /// throw an exception from an attached method.</remarks>

    public event EventHandler Removed;
    
    /// <summary>

    /// Occurs when the collection begins the process

    /// of setting an element at a certain position.

    /// </summary>

    /// <remarks>To indicate that setting this element

    /// at this position is invalid, throw an exception from an attached

    /// method. To indicate that the element is simply invalid,

    /// use the <see cref="Validating" /> event.</remarks>

    public event SetEventHandler Setting;
    
    /// <summary>

    /// Occurs after the collection completes the process

    /// of setting an element at a certain position.

    /// </summary>

    /// <remarks>To prevent the settng action from taking

    /// place, throw an exception from an attached method.</remarks>

    public event SetEventHandler Set;
    
    /// <summary>

    /// Occurs when the collection asks for validation

    /// of an item that is to be added into it.

    /// </summary>

    /// <remarks>If the item is invalid,

    /// throw an exception from an attached method.

    /// Checks that already take place are that the value is not a null

    /// reference (Nothing in Visual Basic) and that it is of/derives

    /// from <see cref="Int32" />.</remarks>

    public event ValidationEventHandler Validating;
    
    /// <summary>

    /// Begins the Load process.

    /// </summary>

    public virtual void BeginLoad()
    {
        this.m_IsInLoad = (this.m_IsInLoad + 1);
    }
    
    /// <summary>

    /// Ends the Load process.

    /// </summary>

    public virtual void EndLoad()
    {
        if ((this.m_IsInLoad != 0))
        {
            this.m_IsInLoad = (this.m_IsInLoad - 1);
        }
    }
    
    /// <summary>

    /// Gets whether the Load process has begun.

    /// </summary>

    /// <value>Whether the Load process has begun.</value>

    protected bool IsInLoad()
    {
        return (this.m_IsInLoad != 0);
    }
    
    /// <summary>

    /// Inserts an element into the collection at the specified index.

    /// </summary>

    /// <param name="index">The zero-based index at which

    /// <paramref name="value" /> should be inserted.</param>

    /// <param name="value">The <see cref="Int32" /> to insert.</param>

    /// <exception cref="System.ArgumentOutOfRangeException">

    /// <paramref name="index" /> is less than zero or is greater

    /// than <see cref="System.Collections.CollectionBase.Count" />.

    /// </exception>

    public void Insert(int index, int value)
    {
        this.List.Insert(index, value);
    }
    
    /// <summary>

    /// Removes the first occurrence of a specific

    /// <see cref="Int32" /> from the collection.

    /// </summary>

    /// <param name="value">The <see cref="Int32" />

    /// to remove from the collection.</param>

    public void Remove(int value)
    {
        this.List.Remove(value);
    }
    
    /// <summary>

    /// Determines whether an element is in the collection.

    /// </summary>

    /// <param name="value">The <see cref="Int32" />

    /// to locate in the collection.</param>

    /// <returns>true if <paramref name="value" />

    /// is found in the collection; otherwise, false.</returns>

    public bool Contains(int value)
    {
        return this.List.Contains(value);
    }
    
    /// <summary>

    /// Searches for the specified <see cref="Int32" />

    /// and returns the zero-based index of the first

    /// occurrence within the entire collection.

    /// </summary>

    /// <param name="value">The <see cref="Int32" />

    /// to locate in the collection.</param>

    /// <returns>The zero-based index of the first occurrence

    /// of <paramref name="value" /> within the entire collection,

    /// if found; otherwise, -1.</returns>

    public int IndexOf(int value)
    {
        return this.List.IndexOf(value);
    }
    
    /// <summary>

    /// Adds an object to the end of the collection.

    /// </summary>

    /// <param name="value">The <see cref="Int32" />

    /// to be added to the end of the collection.</param>

    /// <returns>The collection index at which the

    /// <paramref name="value" /> has been added.</returns>

    public int Add(int value)
    {
        return this.List.Add(value);
    }
    
    /// <summary>

    /// Adds the elements of an array to the end of the collection.

    /// </summary>

    /// <param name="values">The array whose elements should be

    /// added to the end of the collection.</param>

    /// <exception cref="System.ArgumentNullException">

    /// <paramref name="values" /> is a null reference

    /// (Nothing in Visual Basic).</exception>

    public void AddRange(int[] values)
    {
        if ((values == null))
        {
            throw new System.ArgumentNullException("values");
        }
        System.Collections.IEnumerator enumerator0 = 
           ((System.Collections.IEnumerable)(values)).GetEnumerator();
        try
        {
            for (
                ; (enumerator0.MoveNext() == true); 
                )
            {
                int element0 = ((int)(enumerator0.Current));
                this.List.Add(element0);
            }
        }
        finally
        {
            if (((enumerator0 != null) 
                && enumerator0.GetType().IsInstanceOfType(
                   typeof(System.IDisposable))))
            {
                ((System.IDisposable)(enumerator0)).Dispose();
            }
        }
    }
    
    /// <summary>

    /// Adds the elements of a collection to the end of the collection.

    /// </summary>

    /// <param name="collection">The collection whose elements

    /// should be added to the end of the collection.</param>

    /// <exception cref="System.ArgumentNullException">

    /// <paramref name="collection" /> is a null reference

    /// (Nothing in Visual Basic).</exception>

    public void AddRange(Int32Collection collection)
    {
        if ((collection == null))
        {
            throw new System.ArgumentNullException("collection");
        }
        System.Collections.IEnumerator enumerator1 = 
           ((System.Collections.IEnumerable)
            (collection.InnerList)).GetEnumerator();
        try
        {
            for (
                ; (enumerator1.MoveNext() == true); 
                )
            {
                int element1 = ((int)(enumerator1.Current));
                this.List.Add(element1);
            }
        }
        finally
        {
            if (((enumerator1 != null) 
                && enumerator1.GetType().IsInstanceOfType(
                   typeof(System.IDisposable))))
            {
                ((System.IDisposable)(enumerator1)).Dispose();
            }
        }
    }
    
    /// <summary>

    /// Copies the entire collection to a compatible one-dimensional

    /// <see cref="System.Array" />, starting at the specified

    /// <paramref name="index" /> of the target array.

    /// </summary>

    /// <param name="array">The one-dimensional

    /// <see cref="System.Array" />

    /// that is the destination of the elements copied from collection.

    /// The <see cref="System.Array" /> must

    /// have zero-based indexing.</param>

    /// <param name="index">The zero-based index in <paramref
    /// name="array" /> at which copying begins.</param>

    /// <exception cref="System.ArgumentNullException"><paramref
    /// name="array" /> is a null reference

    /// (Nothing in Visual Basic).</exception>

    /// <exception cref="System.ArgumentOutOfRangeException">

    /// <paramref name="index" /> is less than zero.</exception>

    /// <exception cref="System.ArgumentException"><paramref
    /// name="array" /> is multidimensional.</exception>

    /// <exception cref="System.ArgumentException">

    /// <paramref name="index" />

    /// is equal to or greater than the length

    /// of <paramref name="array" />.</exception>

    /// <exception cref="System.ArgumentException">The number

    /// of elements in the source collection

    /// is greater than the available space

    /// from <paramref name="index" /> to the end of the destination

    /// <paramref name="array" />.</exception>

    /// <remarks>The specified array's elements must be of type

    /// <see cref="Int32" /> or any of its derivatives.</remarks>

    public void CopyTo(System.Array array, int index)
    {
        this.List.CopyTo(array, index);
    }
    
    /// <summary>

    /// Copies the elements of the collection

    /// to a new <see cref="Int32" /> array.

    /// </summary>

    /// <returns>An array of <see cref="Int32" /> containing

    /// copies of the elements of the collection.</returns>

    public int[] ToArray()
    {
        return ((int[])(this.InnerList.ToArray(typeof(Int32))));
    }
    
    /// <summary>

    /// Raises the <see cref="Clearing" /> event.

    /// </summary>

    protected override void OnClear()
    {
        if (((this.IsInLoad() == false) 
            && (this.Clearing != null)))
        {
            this.Clearing(this, System.EventArgs.Empty);
        }
    }
    
    /// <summary>

    /// Raises the <see cref="Cleared" /> event.

    /// </summary>

    protected override void OnClearComplete()
    {
        if (((this.IsInLoad() == false) 
            && (this.Cleared != null)))
        {
            this.Cleared(this, System.EventArgs.Empty);
        }
    }
    
    /// <summary>

    /// Raises the <see cref="Inserting" /> event.

    /// </summary>

    /// <param name="index">The zero-based index at which

    /// to insert <paramref name="value" />.</param>

    /// <param name="value">The new value of the element

    /// at <paramref name="index" />.</param>

    protected override void OnInsert(int index, object value)
    {
        if (((this.IsInLoad() == false) 
            && (this.Inserting != null)))
        {
            this.Inserting(this, new EventArgs(index, ((int)(value))));
        }
    }
    
    /// <summary>

    /// Raises the <see cref="Inserted" /> event.

    /// </summary>

    /// <param name="index">The zero-based index at which

    /// to insert <paramref name="value" />.</param>

    /// <param name="value">The new value of the element

    /// at <paramref name="index" />.</param>

    protected override void OnInsertComplete(int index, object value)
    {
        if (((this.IsInLoad() == false) 
            && (this.Inserted != null)))
        {
            this.Inserted(this, new EventArgs(index, ((int)(value))));
        }
    }
    
    /// <summary>

    /// Raises the <see cref="Removing" /> event.

    /// </summary>

    /// <param name="index">The zero-based index at which

    /// <paramref name="value" /> can be found.</param>

    /// <param name="value">The value of the element to remove

    /// from <paramref name="index" />.</param>

    protected override void OnRemove(int index, object value)
    {
        if (((this.IsInLoad() == false) 
            && (this.Removing != null)))
        {
            this.Removing(this, new EventArgs(index, 
                         ((int)(value))));
        }
    }
    
    /// <summary>

    /// Raises the <see cref="Removed" /> event.

    /// </summary>

    /// <param name="index">The zero-based index at which

    /// <paramref name="value" /> can be found.</param>

    /// <param name="value">The value of the element

    /// to remove from <paramref name="index" />.</param>

    protected override void OnRemoveComplete(int index, object value)
    {
        if (((this.IsInLoad() == false) 
            && (this.Removed != null)))
        {
            this.Removed(this, new EventArgs(index, 
                        ((int)(value))));
        }
    }
    
    /// <summary>

    /// Raises the <see cref="Setting" /> event.

    /// </summary>

    /// <param name="index">The zero-based index at which

    /// <paramref name="oldValue" /> can be found.</param>

    /// <param name="oldValue">The value to replace

    /// with <paramref name="newValue" />.</param>

    /// <param name="newValue">The new value of the

    /// element at <paramref name="index" />.</param>

    protected override void OnSet(int index, 
              object oldValue, object newValue)
    {
        if (((this.IsInLoad() == false) 
            && (this.Setting != null)))
        {
            this.Setting(this, new SetEventArgs(index, 
                        ((int)(oldValue)), ((int)(newValue))));
        }
    }
    
    /// <summary>

    /// Raises the <see cref="Set" /> event.

    /// </summary>

    /// <param name="index">The zero-based index at which

    /// <paramref name="oldValue" /> can be found.</param>

    /// <param name="oldValue">The value to replace

    /// with <paramref name="newValue" />.</param>

    /// <param name="newValue">The new value of the element

    /// at <paramref name="index" />.</param>

    protected override void OnSetComplete(int index, 
              object oldValue, object newValue)
    {
        if (((this.IsInLoad() == false) 
            && (this.Set != null)))
        {
            this.Set(this, new SetEventArgs(index, 
                    ((int)(oldValue)), ((int)(newValue))));
        }
    }
    
    /// <summary>

    /// Raises the <see cref="Validating" /> event.

    /// </summary>

    /// <param name="value">The object to validate.</param>

    protected override void OnValidate(object value)
    {
        base.OnValidate(value);
        if ((value.GetType().IsInstanceOfType(typeof(int)) == false))
        {
            throw new System.ArgumentException(
                  string.Format("The argument" + 
                  " value must be of type {0}.", 
                  typeof(int).FullName), "value");
        }
        if (((this.IsInLoad() == false) 
            && (this.Validating != null)))
        {
            this.Validating(this, 
                new ValidationEventArgs(((int)(value))));
        }
    }
    
    /// <summary>

    /// Represents a method that takes a <see cref="System.Object" />

    /// and <see cref="EventArgs" />.

    /// </summary>

    /// <param name="sender">The event's originating object.</param>

    /// <param name="e">The event's arguments.</param>

    public delegate void EventHandler(object sender, EventArgs e);
    
    /// <summary>

    /// Contains the arguments for events based

    /// on the <see cref="EventHandler" /> delegate.

    /// </summary>

    public class EventArgs : System.EventArgs
    {
        /// <summary>

        /// Value for the property <see cref="Index" />.

        /// </summary>

        private int m_Index;
        
        /// <summary>

        /// Value for the property <see cref="Value" />.

        /// </summary>

        private int m_Value;
        
        /// <summary>

        /// Initializes a new instance

        /// of the <see cref="EventArgs" /> class.

        /// </summary>

        /// <param name="Index">The index of the value.</param>

        /// <param name="Value">The value raised by the event.</param>

        public EventArgs(int Index, int Value)
        {
            this.m_Index = Index;
            this.m_Value = Value;
        }
        
        /// <summary>

        /// Gets the index of the value.

        /// </summary>

        /// <value>The index of the value.</value>

        public virtual int Index
        {
            get
            {
                return this.m_Index;
            }
        }
        
        /// <summary>

        /// Gets the value raised by the event.

        /// </summary>

        /// <value>The value raised by the event.</value>

        public virtual int Value
        {
            get
            {
                return this.m_Value;
            }
        }
    }
    
    /// <summary>

    /// Represents a method that takes a

    /// <see cref="System.Object" />

    /// and <see cref="SetEventArgs" />.

    /// </summary>

    /// <param name="sender">The event's originating object.</param>

    /// <param name="e">The event's arguments.</param>

    public delegate void SetEventHandler(object sender, 
                                         SetEventArgs e);
    
    /// <summary>

    /// Contains the arguments for events based on the

    /// <see cref="SetEventHandler" /> delegate.

    /// </summary>

    public class SetEventArgs : System.EventArgs
    {
        /// <summary>

        /// Value for the property <see cref="Index" />.

        /// </summary>

        private int m_Index;
        
        /// <summary>

        /// Value for the property <see cref="OldValue" />.

        /// </summary>

        private int m_OldValue;
        
        /// <summary>

        /// Value for the property <see cref="NewValue" />.

        /// </summary>

        private int m_NewValue;
        
        /// <summary>

        /// Initializes a new instance of the

        /// <see cref="SetEventArgs" /> class.

        /// </summary>

        /// <param name="Index">The zero-based index

        /// at which oldValue can be found.</param>

        /// <param name="OldValue">The value

        /// to replace with newValue.</param>

        /// <param name="NewValue">The new value

        /// of the element at index.</param>

        public SetEventArgs(int Index, int OldValue, int NewValue)
        {
            this.m_Index = Index;
            this.m_OldValue = OldValue;
            this.m_NewValue = NewValue;
        }
        
        /// <summary>

        /// Gets the zero-based index at which oldValue can be found.

        /// </summary>

        /// <value>The zero-based index at which

        /// oldValue can be found.</value>

        public virtual int Index
        {
            get
            {
                return this.m_Index;
            }
        }
        
        /// <summary>

        /// Gets the value to replace with newValue.

        /// </summary>

        /// <value>The value to replace with newValue.</value>

        public virtual int OldValue
        {
            get
            {
                return this.m_OldValue;
            }
        }
        
        /// <summary>

        /// Gets the new value of the element at index.

        /// </summary>

        /// <value>The new value of the element at index.</value>

        public virtual int NewValue
        {
            get
            {
                return this.m_NewValue;
            }
        }
    }
    
    /// <summary>

    /// Represents a method that takes a <see cref="System.Object" />

    /// and <see cref="ValidationEventArgs" />.

    /// </summary>

    /// <param name="sender">The event's originating object.</param>

    /// <param name="e">The event's arguments.</param>

    public delegate void ValidationEventHandler(object sender, 
                                        ValidationEventArgs e);
    
    /// <summary>

    /// Contains the arguments for events based

    /// on the <see cref="ValidationEventHandler" /> delegate.

    /// </summary>

    public class ValidationEventArgs : System.EventArgs
    {
        /// <summary>

        /// Value for the property <see cref="Value" />.

        /// </summary>

        private int m_Value;
        
        /// <summary>

        /// Initializes a new instance of the

        /// <see cref="ValidationEventArgs" /> class.

        /// </summary>

        /// <param name="Value">The value to be validated.</param>

        public ValidationEventArgs(int Value)
        {
            this.m_Value = Value;
        }
        
        /// <summary>

        /// Gets the value to be validated.

        /// </summary>

        /// <value>The value to be validated.</value>

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

请注意，.NET Framework 2.0 及之前版本中的一个 bug 不允许创建参数数组，这意味着在这些版本中使用此模式是不完整的。

一元运算符模式

CodeDom 中没有内置一元运算符。此模式扩展了标准的 `CodeBinaryOperatorExpression` 以添加更多运算符。当前支持的运算符：`BooleanNot`、`BooleanIsTrue`、`IsNull`、`NotNull`。

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

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

}

Using 模式

Using 模式内置于 C# 中，但并非 IL 的原生支持。该模式使用实现 `System.IDisposable` 接口的资源，然后释放它。

要将此模式包含在您的代码中，您的代码应如下所示：

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

上述代码生成的将是：

System.Drawing.Image image;

try
{
    // Contained statements...

}
finally
{
    if ((image != null))
    {
        ((System.IDisposable)(image)).Dispose();
    }
}

XML 注释模式

XML 注释是编写描述性强且易于解析的成员注释的标准方法，可以使用 NDoc 等工具进行解析。当前支持的标签及其类等效项是：

• <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`。

顺便说一句，Microsoft 发布了 Sandcastle，但它尚未最终确定。一旦确定，将添加类来支持它提供的更高级功能。

历史

• 2006-10-31 - 版本 1.8。
  1. 已添加代码访问安全装饰器模式。
  2. 已添加程序集信息模式。
  3. 在可序列化类型模式的 `GetObjectData` 中添加了安全声明。
  4. XML 注释模式已移至 `.Xml` 命名空间，并删除了 `CodeXmlComment` 前缀（太长）。
  5. 二进制文件现在以 .NET 2.0 而不是 .NET 1.1 为目标，但它们在大多数情况下仍向后兼容。
• 2006-09-23：版本 1.7。
  1. 已添加可 Null 值类型属性模式。
  2. 已添加 `Enum.IsDefined` 和 `String.IsNullOrEmpty` 断言。
  3. 已添加可序列化类型模式。
  4. 可 Dispose 类型模式现已成为 `CodePatternTypeDeclaration` 的一部分。
• 2006-04-29：版本 1.6。
  1. 已添加异步操作模式。
  2. 已添加可 Dispose 类型模式。
  3. 已添加 XML 注释模式。
  4. 对 Begin/End Process、自定义特性、自定义异常、委托、事件、观察者、单例和强类型集合模式进行了自动文档化。
  5. 已添加一元运算符 `IsNull` 和 `NotNull`。
  6. 现在可以在 Flags 模式中访问每个标志的 `CodeMemberField`。
  7. 单例模式（惰性加载）不再公开内部使用的 `InstanceContainer` 类。
  8. 已修复强类型集合模式的 `ToArray` 方法。
  9. 该作品现已获得 Creative Commons Attribution 2.5 许可。您可以复制、自由分发、衍生甚至在商业产品中使用代码，但必须归功于作者。
• 2006-03-31：版本 1.5。
  1. 已添加强类型集合模式。
  2. 已添加参数断言模式。
  3. 程序集和所有类型现在都已 `CLSCompliant`。
  4. 所有类型现在都已标记为 `Serializable`。
  5. 自定义特性模式现在生成密封特性，以提高生成代码的效率。
  6. 添加了几个重载和错误修复。
• 2006-02-10：版本 1.4。
  1. 与 Visual Basic 的生成兼容。
  2. 自定义异常模式已从接受 `CodePatternGetFields` 更改为接受 `CodeParameterDeclarationExpressions`。
  3. 事件模式现在有一个接受委托类型的重载（并推断参数和返回类型）。
  4. ForEach 模式现在按照 C# 规范工作。
  5. 修复了几个 bug。
• 2006-01-28：版本 1.3。
  1. 程序集已重命名为 _DotNetZen.CodeDom.Patterns_。
  2. 已添加自定义特性模式。
  3. 已添加自定义异常模式。
• 2006-01-13：版本 1.2。
  1. 已添加二元和一元运算符模式。
  2. 已添加复合赋值模式。
• 2005-11-11：版本 1.1。
  1. 光标锁定模式现在会将光标改回其原始图标，而不是 `Cursors.Default`。
  2. 已添加 For Each 模式。
  3. 已添加 Is Instance Of 模式。
  4. 范围的布尔标志现在使用 `Scope` 枚举实现。
  5. Using 模式的资源类型的布尔标志现在使用 `ResourceType` 枚举实现。
  6. Singleton 模式的加载类型的布尔标志现在使用 `LoadType` 枚举实现。
• 2005-10-30：初始发布。

本作品获得 Creative Commons Attribution 2.5 License 许可。
(可复制、分发、衍生、商业使用；必须署名作者)