C#泛型

为什么会出现泛型

在泛型还没有出来之前，使用那些为不同类型设计的方法（比如ArrayList）和只有传参不同，其他逻辑都相同的方法时，都会想到所有类型的基类object，看似完美的解决了问题。

但是还是有大问题会出现：

1.会因为没有记住使用的类型而出错，造成类型不兼容；

2.类型强制转换出错；

3.值类型和引用类型的互化即装箱拆箱使系统性能下降。

        public void Do()
        {
            GetArrayList(1);
            GetArrayList("123");
            GetArrayList(true);
            B b = new B();
            GetArrayList(b);
        }
        public void GetArrayList(object obj)
        {
            
        }

泛型的出现很好的解决这个问题。

泛型怎么使用

泛型有两种形式：泛型类型（包括类、接口、委托和结构——没有泛型枚举）和泛型方法。两者都是表示API的基本方法（不管是指单独的泛型方法还是完整的泛型类型），在平时期望出现一个普通类型的地方，用一个类型参数。类型参数是真实类型的占位符。在泛型声明中，类型参数要放在一对尖括号内，并以逗号分隔。

举个例子C#自带的集合类Dictionary<TKey,TValue>，实例化的时候一般都是下面这样，在Dictionary <TKey,TValue>中，类型参数是TKey和TValue。使用泛型类型或方法时，要用真实的类型代替。string替代TKey，int替代TValue

Dictionary<string, int> dic1 = new Dictionary<string, int>();
dic1.Add("a", 1);
dic1.Add("b", 2);
Dictionary<int, bool> dic2 = new Dictionary<int, bool>();
dic2.Add(1, true);
dic2.Add(2, false);

感兴趣的话可以，F12看一下Dictionary<TKey,TValue>如何声明泛型类型，实现泛型接口，声明无参构造函数。

这里有个小常识：在向其他人描述泛型类型时，通常使用of来介绍类型参数或实参，因此List<T>读作list of T。

类型的命名规范：虽然可以使用带有T、U和V这样的类型参数的类型，但从中根本看不出实际指的是什么，也看不出它们应该如何使用。相比之下，像Dictionary<TKey,TValue>这样的命名就要好得多，TKey明显代表键的类型，而TValue代表值的类型。如果只有一个类型参数，而且它的含义很清楚，那么一般使用T（List<T>就是一个很好的例子）

类型约束

到目前为止说的泛型可以指定任意类型，他们未做约束。但是我们在工作中经常想指定规则值接受引用类型或者值类型，从而接受有效类型的实参。

1. 引用类型约束

确保使用的类型实参是引用类型，类型实参任何类、接口、数组、委托等

public class ReturnResult<T> where T : class
{
     List<T> ts = new List<T>();
}

2.值类型约束

确保使用的类型参数是值类型。

public class ReturnResult<T> where T : struct
{
      .......  
}

使用的话就是 ReturnResult<int> result = new ReturnResult<int>();在平时的使用中用的比较少

3.构造函数类型约束

确保类型实参有一个无参的构造函数，必须是所有类型参数最后一个约束

    /// <summary>
    /// 有无参构造函数的泛型约束
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ReturnResult<T> where T : new()
    {
        
    }
    public class Person
    {
        public string Id { get; set; }
        public string Name { get; set; }
        //增加无参的构造函数
        public Person()
        {
        }
    }
    public class Test
    {
        public void GetTest()
        {
            //实例化
            ReturnResult<Person> result = new ReturnResult<Person>();
        }
    }

4.转换类型约束

确保一个类型的实参必须转化为另一种类型的实参，摘自《深入理解C#》一书的一个图片

5.组合约束

应用中可能存在多个约束的可能性，当我们把不通类型的约束组合在一起时，就要考虑他们之间的共存问题了。显然没有一个类型即是引用类型有是值类型，这种组合就是错误的；如果存在多个约束组合，类应该出现在接口的前面，不能多次指向同一个接口，new（）放在最后，不同的类型可以有不同的约束，分别由单独的where引入，来看一些例子

    //有效的
    class D<T> where T : class, IDisposable, new() { }
    class E<T> where T : struct, IDisposable { }
    class F<T, U> where T : class where U : struct { }
    class G<T, U> where T : Stream where U : IDisposable { }
    //无效的
    class H<T> where T : class, struct { }
    class I<T> where T : class, Stream { }
    class J<T> where T : new(), class { }
    class M<T, U> where T : struct where U : class,T { }