匿名方法与泛型编程(写给自己看的)

class Delegates
    ...{
        event System.EventHandler C;
        
        public void A()
        ...{         
            
            this.C += delegate ...{ Console.WriteLine("Hello,Ken"); };
        }
        //匿名方法使用"内联"方式来编写代码,并将代码直接与委托实例相关联,使得更加直观和方便

        //匿名方法的几个相关问题:
        //1.参数列表
        //如上,如果用不到参数可以省略参数列表,
        //      否则要指定Delegate的参数列表相同()
        //2.返回值
        //如果委托类型返回值为void,则匿名方法就不能返回任何值
        //如果返回值不为void,则匿名方法里返回值必须和委托类型返回值兼容
    public delegate int FunCount(int a);
        public static void Caculate(int[] array, FunCount func)
        ...{
            for (int i = 0; i < array.Length; i++)
                Console.WriteLine(func(array[i]));
        }

        public static void UseDelegate()
        ...{
            Caculate(new int[]...{1,2,3,4,5,6},delegate(int i) ...{ return i+100; });
        }

        //3.外部变量
        //一些局部变量和参数可能被匿名方法所使用,他们被称为"匿名方法的外部变量",其生命周期会延长,到委托不被引用为止
        public delegate double Function(int x);
        public static void Foo(double factor)
        ...{
            Console.WriteLine(factor);
            Function f = delegate(int x)
            ...{
                factor += 0.2;
                return x * factor;
            };
           
            f(5);
            Console.WriteLine(factor);
        }

       
    }

 

//class C<U,V>{}
    //class D:C<string ,int>{}
    //class E<U,V>:C<U ,V>{}
    //class F<U,V>:C<string,int>{}
    //class G:C<U,V>{}非法,本身是具体类,C是泛型(不是具体类),不会实例化父类
    //基类如果是泛型类,它的类型参数要么已经实例化,要么来源于子类声明的类型参数(如class E<U,V>:C<U ,V>{})

    //类型成员
    //泛型类型的成员可以使用泛型类型声明中的类型参数.但类型参数如果没有任何约束,则只能在该类型使用从object继承的共有成员.

    //泛型接口

    //泛型委托
    delegate bool Predicate<T>(T value);

    //只支持"在方法声明上包含类型参数"---即泛型方法;泛型方法既可以包含在泛型类型中,也可以包含在非泛型类型中

    //泛型方法的重载
    //void F2<T>(int x)
    //void F2(int x)构成重载
    //void F3<T>(T t)where T:A  T继承于A
    //void F3<T>(T t)where T:B不够成重载


    //泛型方法的重写
    //约束被默认继承,不可以添加新的约束

    //泛型约束
    //都要显式约束,以维护类型安全

    //构造器约束只支持无参的构造器
    //class C<T> where T:new(){//可以T t=new T();} 无参无参无参无参无参

    //值类型约束,class ...where T:struct{}不能使用引用类型

    class Generics
    {
        //泛型类型实例化
        public static void Main()
        {
            //MyStack<int> x = new MyStack<int>();
            //x.MyPush(17);

            //Predicate<int> p1 = new Predicate<int>(Func);

            int? x = 11;
            int? y = null;
            int? z = x + y;
            Console.WriteLine(z);

            Delegates.Foo(12);

            Console.ReadLine();
        }
    }
    class MyStack<T>//T类型
    {
        private T[] store;
        private int size;
        public MyStack()
        {
            store = new T[10];
            size = 0;
        }
        public void MyPush(T x)
        {
            store[size++] = x;
        }
        public T MyPop()
        {
            return store[--size];
        }
    }