泛型约束

    在定义泛型类时，可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制。如果客户端代码尝试使用某个约束所不允许的类型来实例化类，则会产生编译时错误。这些限制称为约束。约束是使用 where 上下文关键字指定的。下表列出了六种类型的约束：

T：结构	类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型.
T：类	类型参数必须是引用类型，包括任何类、接口、委托或数组类型。
T：new()	类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。
T：<基类名>	类型参数必须是指定的基类或派生自指定的基类。
T：<接口名称>	类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。
T：U	为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。这称为裸类型约束。

使用范例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Runtime.Serialization;

namespace DictionaryGrammar
{
    public class WhereUse
    {
        public static void Main()
        {
            //未设置泛型构造函数时
            //MyDictionarySecond<int, Comparer> mds = new MyDictionarySecond<int, Comparer>();
            //设置了带有参数的泛型构造函数

            //demo
            MyDictionaryDefault<MyCompare> mdd = new MyDictionaryDefault<MyCompare>(new MyCompare());
            mdd.PrintString();

            //demo
            MyDictionaryU<Comparer, IComparer> aa = new MyDictionaryU<Comparer, IComparer>(); 
        }
    }
    /// <summary>
    /// 约束泛型类型
    /// </summary>
    /// <typeparam name="T">T被约束为结构类型</typeparam>
    /// <typeparam name="U">U被约束为类</typeparam>
    public class MyDictionary<T, U>
        where T : struct
        where U : class
    {
    }

    /// <summary>
    /// T被限制为U类型或继承自U类型
    /// </summary>
    /// <typeparam name="T">T被限制为U类型或继承自U类型</typeparam>
    /// <typeparam name="U">U被约束为类</typeparam>
    public class MyDictionaryU<T, U>
        where T : U
        where U : class
    {
    }

    /// <summary>
    /// 多重约束
    /// </summary>
    /// <typeparam name="T">U被约束为结构</typeparam>
    /// <typeparam name="U">U必须实现IComparer, ISerializable两个接口</typeparam>
    public class MyDictionarySecond<T, U>
        where T : struct
        where U : IComparer, ISerializable
    {
    }

    /// <summary>
    /// 设置默认构造函数
    /// <remarks>
    /// new约束指定泛型类声明中的任何类型参数都必须具有公共的无参数构造函数
    /// </remarks>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class MyDictionaryDefault<T>
        where T : IComparer, new()
    {
        /// <summary>
        /// 泛型的构造函数，由于设置了默认参数，所以在使用此泛型时，必须要传入参数。
        /// </summary>
        /// <param name="tVar"></param>
        public MyDictionaryDefault(T tVar)
        {
            Console.WriteLine("调用泛型构造函数,类型为{0}", this.GetType());
        }
        /// <summary>
        /// 泛型中方法
        /// </summary>
        public void PrintString()
        {
            Console.WriteLine("Use Default T");
        }
    }

    //自定义类
    public class MyCompare : IComparer
    {
        //public MyCompare()
        //{
        //}

        ////如果要实现带参数的构造函数，必须要明文写出无参构造函数
        //public MyCompare(string aa)
        //{
        //}

        public int Compare(object x, object y)
        {
            if (x == y)
            {
                return 0;
            }
            else
            {
                return -1;
            }
        }
    }
}