泛型

　　泛型是.net 2.0就有的特性，泛型在我们的平常的开发过程中使用得也非常多，为了更深刻地理解泛型，这篇文章就来总结一下。

什么是泛型

可以用下面2点来概括：

1，首先泛型也是一种类型(可以通过IL代码看出来)。

2，泛型提供了类型参数化的能力，允许用不同的类型进行实例化，可以简单地理解为：泛型是类型的模板。

 

为什么要使用泛型

下面通过一个demo来演示不使用泛型和使用泛型的实现，进而理解为什么要使用泛型。

 不使用泛型：

/// <summary>
/// 普通方法，使用ArrayList
/// </summary>
public static void MyNoGenericMethod()
{
    ArrayList arrayList = new ArrayList();
    arrayList.Add(1);//产生装箱
    arrayList.Add(2);//产生装箱
    arrayList.Add("3");//编译时没有提示错误

    var result = 0;
    foreach (int item in arrayList)
    {
        result += item;//运行时错误
    }
}

使用泛型：

/// <summary>
/// 泛型，使用List<T>
/// </summary>
/// <returns></returns>
public static void MyGenericMethod()
{
    List<int> list = new List<int>();
    list.Add(1);
    list.Add(2);
    //list.Add("3");//编译时就提示错误

    var result = 0;
    foreach (int item in list)
    {
        result += item;
    }
}

从上面这个例子可以看到，使用泛型一是保证了类型安全，二是提高了性能，因为避免了装箱和拆箱。

我们再来看一个例子，实现了一个int类型的栈，如下代码：

/// <summary>
/// int类型的Stack
/// </summary>
public class MyIntStack
{
    int stackPointer = 0;
    int[] stackArray;

    /// <summary>
    /// 入栈
    /// </summary>
    /// <param name="x"></param>
    public void Push(int x)
    { 
        
    }

    /// <summary>
    /// 出栈
    /// </summary>
    /// <returns></returns>
    public int Pop()
    { 
        
    }
}

假如要将数据类型改成float，就需要将代码copy一份并且将数据类型改成float，这样代码就重复了，时间长了很难维护，那有没有一种方法不需要copy代码呢？

假如引入了泛型，就不需要重复copy代码了，如下代码：

/// <summary>
/// 泛型的stack
/// </summary>
/// <typeparam name="T"></typeparam>
public class MyStack<T>
{
    int stackPointer = 0;
    T[] stackArray;

    /// <summary>
    /// 入栈
    /// </summary>
    /// <param name="x"></param>
    public void Push(T x)
    {

    }

    /// <summary>
    /// 出栈
    /// </summary>
    /// <returns></returns>
    public T Pop()
    {

    }
}

这样，下次再换成double类型都没有问题，所以这里体现了泛型带来的，代码复用的好处。

所以，综合上面两个例子，我们可以总结出，使用泛型可以带来以下好处：

1，代码(算法)复用。

2，类型安全。

3，提高性能，避免了装箱和拆箱。

4，扩展性。

泛型的本质

反编译上面示例的IL代码，如下图：

从上图的IL代码可以看出：

1，泛型其实也是一个类(class)。

2，泛型类型生成IL代码后跟普通类型的区别是，使用了占位符'<T>'。 

泛型类型 

声明泛型类型跟声明普通类型差不多，不同的地方在于，泛型在类名后面放一对尖括号，并且使用了类型参数。

泛型类型的创建过程如下图。

声明泛型类型：

/// <summary>
/// 声明泛型类
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
public class MyGenericClass<TRequest, TResponse>
    where TRequest : class
    where TResponse : class
{

}

 创建构造类型和实例：

//创建构造类型和实例
var item = new MyGenericClass<Request, Response>();

完整代码：

namespace ConsoleApplication11
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建构造类型和实例
            var item = new MyGenericClass<Request, Response>();

        }
    }

    /// <summary>
    /// 声明泛型类
    /// </summary>
    /// <typeparam name="T1"></typeparam>
    /// <typeparam name="T2"></typeparam>
    public class MyGenericClass<TRequest, TResponse>
        where TRequest : class
        where TResponse : class
    {

    }

    public class Request
    { 
        
    }

    public class Response
    { 
        
    }
}

泛型方法

泛型方法可以在泛型和非泛型类以及结构和接口中声明，如下图。

1，声明泛型方法

声明泛型方法要注意两点，封闭在圆括号里的方法参数，和封闭在尖括号里的类型参数，并且可以在方法参数后面放可选的约束子句。

如下代码：

/// <summary>
/// 泛型方法
/// </summary>
/// <typeparam name="T">类型参数</typeparam>
/// <param name="input">方法参数</param>
public static void MyGenericMethod<T>(T input) where T : class
{ 
    
}

2，调用泛型方法

var rq= new Request();
MyGenericMethod<Request>(rq);//原始调用

3，推断类型

因为编译器可以从我们传入的方法参数中推断出类型参数，所以有了推断类型我们的调用更简单，如下代码：

MyGenericMethod(rq);//推断类型

完整代码如下：

namespace ConsoleApplication13
{
    class Program
    {
        static void Main(string[] args)
        {
            //泛型方法
            var rq= new Request();
            MyGenericMethod<Request>(rq);//原始调用

            MyGenericMethod(rq);//推断类型

        }

        /// <summary>
        /// 泛型方法
        /// </summary>
        /// <typeparam name="T">类型参数</typeparam>
        /// <param name="input">方法参数</param>
        public static void MyGenericMethod<T>(T input) where T : class
        { 
            
        }

    }

    public class Request
    { 
        
    }
}

泛型接口

泛型接口的声明跟普通接口的声明差不多，不同的地方在于，泛型接口需要在接口名称之后的尖括号中有类型参数。

1，声明泛型接口

如下代码：

/// <summary>
/// 泛型接口
/// </summary>
/// <typeparam name="T">类型参数</typeparam>
public interface IMyGenericInterface<T>
{
    void ReturnIt(T input);

}

 2，实现泛型接口

/// <summary>
/// 泛型接口实现
/// </summary>
/// <typeparam name="T"></typeparam>
public class MyGenericInterfaceImpl<T> : IMyGenericInterface<T> where T:class
{
    public void ReturnIt(T input)
    { 
        
    }
}

 3，完整调用

namespace ConsoleApplication14
{
    class Program
    {
        static void Main(string[] args)
        {
            var rq = new Request();
            var m = new MyGenericInterfaceImpl<Request>();
            m.ReturnIt(rq);

        }
    }

    /// <summary>
    /// 泛型接口
    /// </summary>
    /// <typeparam name="T">类型参数</typeparam>
    public interface IMyGenericInterface<T>
    {
        void ReturnIt(T input);

    }

    /// <summary>
    /// 泛型接口实现
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class MyGenericInterfaceImpl<T> : IMyGenericInterface<T> where T:class
    {
        public void ReturnIt(T input)
        { 
            
        }
    }

    public class Request
    { 
        
    }
}

 

泛型委托

泛型委托的声明跟普通委托的声明也差不多，不同的点在于，泛型委托包括委托形参和类型参数。

1，声明泛型委托

如下代码：

namespace ConsoleApplication15
{
    class Program
    {
        static void Main(string[] args)
        {
            //调用泛型委托
            var myGenericDel = new MyGenericDel<string>(Simple.PrintString);
            myGenericDel += Simple.PrintUpperString;

            myGenericDel("Hello generic delegate!");
        }
    }

    /// <summary>
    /// 声明泛型委托
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="input"></param>
    public delegate void MyGenericDel<T>(T input);

    public class Simple
    {
        /// <summary>
        /// 声明方法匹配委托
        /// </summary>
        /// <param name="input"></param>
        public static void PrintString(string input)
        {
            Console.WriteLine(input);
        }

        /// <summary>
        /// 声明方法匹配委托
        /// </summary>
        /// <param name="input"></param>
        public static void PrintUpperString(string input)
        {
            Console.WriteLine(input.ToUpper());
        }

    }
}

2，Linq与泛型委托

说起泛型委托，就不得不提Linq中的泛型委托，.net 3.5为我们带来了Linq和lambda表达式。

这三个泛型委托在linq中经常用到。

 

1)Action委托

action表示无返回值的泛型委托。

如下代码：

/// <summary>
/// Action泛型委托
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="action"></param>
public static void TestAction<T>(Action<T> action, T input)
{
    action(input);
}

 2)Func委托

func表示有返回值的泛型委托。

如下代码：

//Func委托
var result = list.Where(p => p < 10).ToList();

 3)Predicate委托 

predicate表示返回bool值的泛型委托。

如下代码：

//Predicate委托
var result2 = list.Find(p => p == 100);

完整代码：

namespace ConsoleApplication16
{
    class Program
    {
        static void Main(string[] args)
        {
            //Linq与泛型委托
            var list = Enumerable.Range(0, 1000).ToList();

            //Action委托
            TestAction<int>(p => Console.WriteLine(p), 10);

            //Func委托
            var result = list.Where(p => p < 10).ToList();

            //Predicate委托
            var result2 = list.Find(p => p == 100);

            Console.ReadKey();
        }

        /// <summary>
        /// Action泛型委托
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="action"></param>
        public static void TestAction<T>(Action<T> action, T input)
        {
            action(input);
        }

    }
}

泛型结构

//不是很常用，暂时不总结。