C#_Delegate_泛型

//委托是一种数据类型  将方法作为参数进行传递

//我们定义委托 需要定义 委托的 返回值以及参数类型、个数

//利用delegate来定义

　　public delegate void GetSthDelegate();

　　void static Main()

　　{

　　　　GetSthDelegate gd=new GetSthDelegate(Function1);　　　

　　　　//GetSthDelegate gd=Function1;　

　　　　gd();　　//或者

　　　　gd.Invoke();

　　}

　　static void Function1()

　　{

　　　　print("This is f1.");

　　}

//委托类型当作参数来使用

//----------------------------Action委托

　　Action 系统预定义的委托类型　　　　无参数   无返回值

　　Action<int> a;　　//定义了一个委托变量  有一个int参数  无返回值

　　Action<string> a; //~~~~~~~~~~~~ ~~~~string~~ ~~~~

　　//系统自动匹配方法  

　　//Action 无返回值

　　Action<int,int> a;    //定义了一个有两个int参数委托变量  无返回值

　　//最大支持 16个参数

//---------------------多播委托--------------

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

namespace _09多播委托
{
    class Program
    {
        static void Main(string[] args)
        {
            //将多个方法赋值给同一个委托变量
            MyDelegate md = F1;
            md += F2;
            md += F3;

            //绑定到该委托变量上的所有方法都会被执行    顺序不一定
            md.Invoke("cheng");

            Console.WriteLine("---------------------------");

            md -= F2;           //将绑定的方法去除
            md.Invoke("Wang");
        }


       static void F1(string s)
        {
            Console.WriteLine(  "F1-->>{0}",s);
        }
       static void F2(string s) 
       {
           Console.WriteLine("F2+{0}",s);
       }
       static void F3(string s)
       {
           Console.WriteLine("F3++{0}",s);
       }
    }


    public delegate void MyDelegate(string str);

}

//--------------------匿名方法----------------

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

namespace _08匿名方法
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 委托就是一个继承自Delegate的类    必须赋值对应的对象

            ////委托类型只能赋值委托变量   Delegate1 d1=new Delegate(F1);    将方法作为委托的参数传递过去
            //Delegate1 d1 = F1;

            ////F1();

            //d1.Invoke();

            //Delegate2 d2 = F2;
            //d2.Invoke(12);

            //Delegate3 d3 = F3;
            //int x = d3.Invoke(12, 23);

            //Console.WriteLine(x);
            //Console.ReadKey(); 
            #endregion


            #region MyRegion
            //Delegate3 d3 = F3;

            //int x =d3(10, 28);
            //Console.WriteLine(x);
            #endregion


            #region 匿名方法和lambda表达式
            //匿名方法
            //Delegate1 d1 = delegate() {

            //    Console.WriteLine("我是匿名方法");

            //};
            //d1();

            //Delegate4 d4 = delegate(int c)
            //{
            //    return c * 2;
            //};
            //d4(20);

            //lambda 表达式
            //因为Delegate1 定义是无参数  无返回值  （） 为空表示无参数       参数 =>  方法体
            //Delegate1 d1 = () => { Console.WriteLine("我就是一个匿名函数"); };
            //d1();

            //Delegate2 d2 = x => { Console.WriteLine("aaa{0}aaa",x); };
            //d2(12);

            //Delegate3 d3 = (x, y) => { return x * y; };
                //Delegate3 d3 = (x, y) => x * y;
            //int result = d3(12, 2);
            //Console.WriteLine(result);

            Delegate4 d4=x=>10*x;
            int res = d4(10);
            Console.WriteLine(res);
            #endregion
        }

        static void F1()
        {
            Console.WriteLine("function1..");
        }

        static void F2(int n)
        {
            Console.WriteLine("-->{0}",n);
        }

        static int F3(int m,int n)
        {
            return m + n;
        }

    }

    public delegate void Delegate1();
    public delegate void Delegate2(int n);
    public delegate int Delegate3(int m,int n);
    public delegate int Delegate4(int n);
}

//---------------------自定义泛型------------------

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

namespace _10自定义泛型
{
    class Program
    {
        static void Main(string[] args)
        {
            //泛型是代码重用 也是算法重用       数据类型不同
            //MyClass<int> mcInt = new MyClass<int>(new int[] { 1,2,3,4,5,6});
            MyClass<string> mcStr = new MyClass<string>(new string[] { "Joe","Xu","Ling"});
            mcStr.Show();
        }
    }

    //自定义泛型的类     T  代表  Type  类型 
    class MyClass<T>
    {

        public MyClass(T[] shuzu)
        {
            this._shuzu = shuzu;
        }

        private T[] _shuzu;

        public void Show()
        {
            foreach (T item in _shuzu)
            {
                Console.WriteLine(item.ToString());
            }
        }
    }
}

//--------------------泛型约束-------------------------

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

namespace _11泛型约束
{
    class Program
    {
        static void Main(string[] args)
        {
            //在自定泛型之后   约束T可传入参数的数据类型

            //委托是针对一个方法多态   而接口可以针对n多个方法多态

            //pre练习
            //List<int> listInt = new List<int>();
            //listInt.Add(10);
            //listInt.Add(4);
            //listInt.Add(6);
            //listInt.Sort();
            //foreach (int item in listInt)
            //{
            //    Console.WriteLine(item);
            //}


            #region list排序

            //List<Person> listPerson = new List<Person>() { 
            //    new Person(){Name="wang",Age=32},
            //    new Person(){Name="ling",Age=23}
            //};
            ////要实现排序   需要实现IComparable
            //listPerson.Sort();
            //foreach (Person item in listPerson)
            //{
            //    Console.WriteLine("{0},{1}", item.Age, item.Name);
            //}
            //Console.WriteLine("--------------------------------------------");
            ////实现排序   也可以传递比较器
            //listPerson.Sort(new AscByAge());
            //foreach (Person item in listPerson)
            //{
            //    Console.WriteLine("{0},{1}", item.Age, item.Name);
            //} 
            #endregion

            //泛型约束         在泛型后面  添加   where   T   :     struct       //struct代表值类型   

            //不能限制具体的值类型   
            MyClass<double> testDou = new MyClass<double>();

            //在泛型后面添加   where T : class    //class代表T为引用类型        
            //在后面添加  where T  : IComparable     //代表T必须为实现某接口的类型
            TestClass<string> testStr = new TestClass<string>();

        }
    }



    //使用泛型约束   约束  T 只能是  值类型
    class MyClass<T> where T : struct
    {
 
    }

    //使用泛型约束   约束  T只能是 引用类型
    class TestClass<T> where T : class
    {
 
    }

    //约束  T 必须实现  IComparable
    class TestClass2<T> where T : IComparable
    {
 
    }




    //比较器
    class AscByAge : IComparer<Person>
    {
        public int Compare(Person x, Person y)
        {
            return y.Age - x.Age;
        }
    }

    //实现比较的泛型接口   传递的就是Person类型
    class Person:IComparable<Person>
    {
        private int _age;
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        //实现IComparable<Person>   实现泛型接口
        public int CompareTo(Person other)
        {
           // throw new NotImplementedException();
            return this.Age - other.Age;
        }
    }
}