C#委托笔记

委托好像是C指针的升级版，可以定向到一个方法的位置

    //委托的实际运用
            Calculator ca = new Calculator();
            Action action = new Action(ca.Report);
            action.Invoke();//委托调用方法
            action();
            ca.Report();
            //对于有参数的委托的运用
            Func<int, int, int> func1 = new Func<int, int, int>(ca.Add);
            Func<int, int, int> func2 = new Func<int, int, int>(ca.Sub);
            int x = 100;
            int ys = 200;
            int z = 0;
            z = func1.Invoke(x,ys);
            Console.WriteLine(z);

  class Calculator
    { 
    public void Report()
        {
            Console.WriteLine("I hava die");
        }


        public int Add(int a ,int b)
        {
            int result = a + b;
            return result;
        }


        public int Sub(int a,int b)
        {
            int result = a - b;
            return result;
        }
    }

看起来就是用了INvoke这个方法间接调用其他方法，就是Action是无参方法，Func是调用有参的

自定义委托

自定义委托///
    public delegate double Calc(double x, double y);

委托的声明要与类的方法和返回值类型相同

  //对于委托的运用
            Calculators calculators = new Calculators();
            Calc calc1 = new Calc(calculators.Add);
            Calc calc2 = new Calc(calculators.Mul);
            Calc calc3 = new Calc(calculators.Sub);
            double a = 100;
            double b = 200;
            double c2 = 0;
            c2 = calc1.Invoke(a, b);
            Console.WriteLine("自定义泛型1的结果是" + c2);

            c2 = calc2.Invoke(a, b);
            Console.WriteLine("自定义泛型2的结果是" + c2);

            c2 = calc3.Invoke(a, b);
            Console.WriteLine("自定义泛型3的结果是" + c2);

 class Calculators
    {
        public double Add(double x,double y)
        {
            return x + y;
        }

        public double Sub(double x,double y)
        {
            return x - y;
        }

        public double Mul(double x,double y)
        {
            return x * y;
        }

    }

下面来看看委托的实际运用————作为参数调用方法

            ///泛型的实际调用 ///


            ProductFactory productFactory = new ProductFactory();
            WrapFactory warpfactory = new WrapFactory();

            Func<Product> func12 = new Func<Product>(productFactory.MakePizza);
            Func<Product> func22= new Func<Product>(productFactory.MakeTocar);

            Box box1 = warpfactory.WrapProduct(func12);
            Box box2 = warpfactory.WrapProduct(func22);

            Console.WriteLine(box1.Product.Name);
            Console.WriteLine(box2.Product.Name);

class Product   {
            public string Name { get; set; }
        }

        class Box
        {
            public Product Product { get; set; }
        }


        class  WrapFactory
        {
            public Box WrapProduct(Func<Product> getProduct)
            {
                Box box = new Box();

                Product product = getProduct.Invoke();
                box.Product = product;
                return box;
            }
        }


        class ProductFactory
        {
            public Product MakePizza()
            {
                Product product = new Product();
                product.Name = "Pizza";
                return product;
            }


            public Product MakeTocar()
            {
                Product product = new Product();
                product.Name = "Tot Car";
                return product;
            }
        }

看起来很麻烦