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

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];
        }
    }