泛型

泛型有下面3个好处：

1、实现了延迟申明（在创建泛型的时候，不需要指定类型，只需要一个占位符、而是在使用的时候指定。这对写代码程序升级来说是非常有用）

2、解决了OBJECT 装箱拆箱带来的性能损耗（泛型的编译是根据调用直接编译成目标代码、不需要转换）

3、类型安全（相对于OBJECT来说，泛型有约束WHERE，这样可以保证使用的时候符合规范。）

泛型是如何被设计出来的呢？

假如你有一个处理方法，同时可以接受N种类型的参数。处理过程是一样的。这个时候，你要用到的是重载，代码如下： 

            ///非泛型集合
            ArrayList list = new ArrayList();
            // 添加一个 int 到列表中
            list.Add(3);
            // 添加一个 string 到列表中
            list.Add("It is raining in Redmond.");

            int t = 0;
            // 进行计算
            foreach (int x in list)
            {
                t += x;
            }

1、在非泛型集合中。添加的是 OBJECT，添加的时候要装箱，使有的时候要拆箱。（这个过程如果是集合很大，性能损耗非常明显）

2、非泛型集合和泛型集合相比，强制约束了添加时的数据类型、这样就不用转成OBJECT，造成性能损耗。同时又起到了约束作用。

3、泛型集合有了强制约束的类型，在使用的时候就是安全的。

            //泛型方法
            List<int> list2 = new List<int>();
            list2.Add(1);
            list2.Add(2);

            int t2 = 0;
            // 进行计算
            foreach (int x in list2)
            {
                t2 += x;
            }

泛型参数：

泛型参数对于申明者来说是一个占位符、在实际使用中才会给出，具体类型。这是一种延迟申明的开发思想

在没有泛型参数的时候，我们必须这样用：（做重载）

  public static string ExecuteScalar(string Name)
        {
            return (string)Source(Name);
        }

        public static int ExecuteScalar(int Name)
        {
            return (int)Source(Name);
        }

        public static long ExecuteScalar(long Name)
        {
            return (long)Source(Name);
        }

或者是我们可以这样用：（利用OBJECT来进行装箱拆箱操作）

        public static object ExecuteScalarObject(object Name)
        {
            return Source(Name);
        }

泛型方法这样用：

        public static T ExecuteScalar<T>(T Name)
        {
            return (T)Source(Name);
        }

1、泛型参数定义在尖括号<>内，可以有1到N个。

2、支持类、接口、方法、委托

    /// <summary>
    ///单个泛型参数的接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IGenericInterface<T>
    {
        /// <summary>
        /// 多个泛型参数的方法
        /// </summary>
        /// <typeparam name="I"></typeparam>
        /// <typeparam name="S"></typeparam>
        /// <param name="iValue"></param>
        /// <param name="sValue"></param>
        /// <returns></returns>
        T GetList<I, S>(I iValue, S sValue);
    }

泛型约束：

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

 

 

 

 

 

 

对方法的约束：

        public static T ExecuteScalar<T>(T Name) where T : struct
        {
            return (T)Source(Name);
        }

对委托的约束：

public delegate void Del<T2>(T2 item) where T2 : struct;

类中T1约束为必须有无参构造函数：

    public class GenericClass<T1, S> where T1 : new()
    {
        public N Show<N>(N name)
        {
            return name;
        }


        public delegate void Del<T2>(T2 item) where T2 : struct;
        public static void Notify(int i) { }

        Del<int> m1 = new Del<int>(Notify);
    }

互相约束：T1约束S

    public class GenericClass<T1, S> where S : T1
    {
        public N Show<N>(N name)
        {
            return name;
        }


        public delegate void Del<T2>(T2 item) where T2 : struct;
        public static void Notify(int i) { }

        Del<int> m1 = new Del<int>(Notify);
    }