c#泛型入门

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

namespace CsharpDataStructure
{
    class Program
    {
        //声明：本程序只说明几种常见委托和代理的使用，名称的定义不是很规范
        public delegate void MyAction<T>(T obj);//自己定义的委托，无返回值，只有一个泛型参数
        static void Main(string[] args)
        {
            var method=new MyAction<int>(PrintInt);
            var selectBig = new Func<List<int>,int,int>(SelectBig);//创建一个Func代理，参数有两个，一个是list，一个是int；返回值是int
            var boolMethod = new Predicate<int>(a => { return a > 3; });//创建一个Predicate类型的代理，只有一个参数int型，返回值默认bool型，
            var bigMethod = new Action<int,int>(ShowBig);//创建一个Action型的代理，有两个int类型参数，默认无返回值
            method(3);
            int i = 6;
            if (boolMethod(i))
            {
                Console.WriteLine(i);
            }
            bigMethod(6,7);
            List<int> mm = new List<int>() { 4, 6, 9, 8 };
            Console.WriteLine(selectBig(mm, 3));
            int[] number = new int[6] { 1, 2, 3, 4, 5 ,8};
            IEnumerable<int> result = Filter<int>(number, (int item) => { return item > 3; });//可枚举类型的拓展，方法是lambda表达式
            foreach (var item in result)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();
        }
        static void PrintInt(int i)
        {
            Console.WriteLine(i);
        }
        static void ShowBig(int m,int n)
        {
            if(m>=n)
                Console.WriteLine(m);
            else
                Console.WriteLine(n);
        }
        static int SelectBig(List<int> a,int b)
        {
            return a.Max()-b;
        }
        public static IEnumerable<T> Filter<T>(IEnumerable<T> ObjectList, Predicate<T>FilterFunc)//可枚举类型拓展：返回类型是可枚举的，参数一个是可枚举类型，一个是代理方法
        {
            List<T> ResultList = new List<T>();
            foreach (var item in ObjectList)
            {
                if (FilterFunc(item))
                {
                    ResultList.Add(item);
                }
            }
            return ResultList;
        }
    }
}

　　.NET类库在System名称空间，下定义了三种比较常用的泛型委托

Predicate<T>委托：

public delegate bool Predicate<T>(T obj);

这个委托描述的方法为接收一个T类型的参数，返回一个BOOL类型的值，一般用于比较方法

Action<T>委托

public delegate void Action<T>(T obj);

public delegate void Action<T1, T2>(T1 arg1, T2 arg2);

这个委托描述的方法，接收一个或多个T类型的参数（最多16个，我这里只写了两种类型的定义方式），没有返回值

Func<T>委托

public delegate TResult Func<TResult>();

public delegate TResult Func<T, TResult>(T arg);

这个委托描述的方法，接收零个或多个T类型的参数（最多16个，我这里只写了两种类型的定义方式），
与Action委托不同的是，它有一个返回值，返回值的类型为TResult类型的。