二刷：委托

作者: 山猪打不过家猪 | 来源:发表于2022-12-02 12:07 被阅读0次

二刷：委托
【综】时空旅者
三级联动中追加下拉菜单的方法
C#（22）委托
原始类型与事情委托
委托与事件（二）
2018-10-11人生删除事务所
jQuery3
iOS对象间的通讯
二刷

1.委托

image.png

正确使用1：这里委托和普通工厂模式的本质区别在于：委托是传递了一个未执行的方法进去（类似于Python里面的直接将方法当做字符串传递给函数），等到需要使用的时候调用该方法；而简单工厂，传递的是已经实例化或者已经调用过的函数的返回结果，不能把一个为调用的方法名，传给另外一个方法来使用，可以把实例化好的对象传递，再来调用；

本质：使用委托类型的参数，封装了一个外部的方法，把这个方法传递到类的方法内部，在进行间接的调用；这就是日常工作中对委托的常规用法

1.1初识委托

本质其实是：传递了一个没有调用的带了参数的方法，等待需要使用的时候，调用委托方法来执行；

无返回值委托:Action

namespace DelegateDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.实例化Cal
            Cal objCal = new Cal();
            //2.创建一个无返回值的Action委托
            Action actDelegate = new Action(objCal.Say);
            //3.执行委托
            actDelegate();
            Console.ReadKey();
        }
    }
    public class Cal
    {
        public void Say()
        {
            Console.WriteLine("I am a Calculator");
        }
    }
}

image.png

有返回值委托：Fun<>

namespace DelegateDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Cal objCal = new Cal();
            Func<int, int, int> func1 = new Func<int, int, int>(objCal.Add);
            int a = 10;
            int b = 20;
            int z = 0;
            z = func1(a, b);
            Console.WriteLine(z);
            Console.ReadKey();
        }
    }
    class Cal
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }
}

使用lambda表达式的委托

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Action act1 = () => Console.WriteLine("我是无参，无返回值的委托");
            Action<string> act2 = (a) => Console.WriteLine($"{a}我是有参，无返回值的委托");
            Func<string> fun1 =()=>"我是无参数，有返回值的委托";
            Func<int, int, int> addSum = (a, b) => a + b;
            act1();//无参，无返
            act2("fxx"); //有参，无返
            Console.WriteLine(fun1()); //无参，有返
            int sum = addSum(1, 3);  //有参，有返
            Console.WriteLine(sum);
            Console.ReadKey();
        }
    }  
}
>>>
我是无参，无返回值的委托
fxx我是有参，无返回值的委托
我是无参数，有返回值的委托
4

1.2委托复用代码

namespace DelegateDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //使用模板方法
            //1、实例化工厂
            ProductFactory objFac = new ProductFactory();
            //2.实例化包装工厂
            WrapFactory objWrap = new WrapFactory();
            //3.准备委托类型的变量,和工厂模式的区别在于这里我们没有直接调用生产的方法，而是传递了方法进去，等到真正使用它的时候，才会调用,通过委托
            Func<Product> func1 = new Func<Product>(objFac.MakePizza);
            Func<Product> func2 = new Func<Product>(objFac.MakeCar);
            //4.调用模板方法
            Box box1 = objWrap.WrapProduct(func1);
            Box box2 = objWrap.WrapProduct(func2);
        }
    }
    //产品
    class Product
    {
        public string Name { get; set; }
    }
    //包装箱
    class Box
    {
        //产品类
        public Product Product { get; set; }
    }

    //包装工厂：把产品加上盒子
    class WrapFactory
    {
        //模板方法：接受一个名为getProduct的委托，
        public Box WrapProduct(Func<Product> getProduct)
        {
            Box box = new Box();
            //调用委托，获取一个产品，这里才会真正的调用生产产品的方法
            Product product = getProduct();
            //给盒子添加一个Product属性
            box.Product = product;
            return box;
        }
    }
    //产品工厂
    class ProductFactory
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }
        public Product MakeCar()
        {
            Product product = new Product();
            product.Name = "Car";
            return product;
        }
    }
}

和不使用委托的工厂模式对比

namespace DelegateDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //使用模板方法
            //1、实例化工厂
            ProductFactory objFac = new ProductFactory();
            //2.实例化包装工厂
            WrapFactory objWrap = new WrapFactory();
            //4.直通过工厂生产好产品（和委托的区别）
            Product pizza = objFac.MakePizza();
            Product car = objFac.MakeCar();
            //5.传递产品好的产品进去，包装已经生产好的产品
            Box b1 = objWrap.WrapProduct(pizza);
            Box b2= objWrap.WrapProduct(car);
            //6.查看产品
            Console.WriteLine(b1.Product.Name);
            Console.WriteLine(b2.Product.Name);
            Console.ReadKey();
        }
    }
    //产品
    class Product
    {
        public string Name { get; set; }
    }
    //包装箱
    class Box
    {
        //产品类
        public Product Product { get; set; }
    }

    //包装工厂：把产品加上盒子
    class WrapFactory
    {
        public Box WrapProduct(Product objPro)
        {
            Box box = new Box();
            box.Product = objPro;//获取一个生产好的产品
            return box;
        }
    }
    //产品工厂
    class ProductFactory
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }
        public Product MakeCar()
        {
            Product product = new Product();
            product.Name = "Car";
            return product;
        }
    }
}

1.3使用委托的简单工厂和不是使用委托的对比

image.png

1.4委托的另一个使用场景：回调

namespace DelegateDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //使用模板方法
            //1、实例化工厂
            ProductFactory objFac = new ProductFactory();
            //2.实例化包装工厂
            WrapFactory objWrap = new WrapFactory();
            //3.准备委托类型的变量,和工厂模式的区别在于这里我们没有直接调用生产的方法，而是传递了方法进去，等到真正使用它的时候，才会调用,通过委托
            Func<Product> func1 = new Func<Product>(objFac.MakePizza);
            Func<Product> func2 = new Func<Product>(objFac.MakeCar);
            //实例化logger
            Logger logger = new Logger();
            Action<Product> log = new Action<Product>(logger.Log);
            //4.调用模板方法
            Box box1 = objWrap.WrapProduct(func1, log);
            Box box2 = objWrap.WrapProduct(func2, log);
            //5.查看 产品
            Console.WriteLine(box1.Product.Name);
            Console.WriteLine(box2.Product.Name);
            Console.ReadKey();
        }
    }

    //用来记录程序的运行状态：外部方法
    class Logger
    {
        //记录当前产品被生产的时间
        public void Log(Product product)
        {
            Console.WriteLine("Product'{0}' created at {1}.Price is {2}", product.Name, DateTime.UtcNow, product.Price);   
        }
    }

    //产品
    class Product
    {
        public string Name { get; set; }
        public float Price { get; set; }
    }
    //包装箱
    class Box
    {
        //产品类
        public Product Product { get; set; }
    }

    //包装工厂：把产品加上盒子
    class WrapFactory
    {
        //模板方法：接受一个名为getProduct的委托，
        public Box WrapProduct(Func<Product> getProduct,Action<Product> logCallBack)
        {
            Box box = new Box();
            //调用委托，获取一个产品，这里才会真正的调用生产产品的方法
            Product product = getProduct();
            if (product.Price>50)
            {
                logCallBack(product);
            }
            //给盒子添加一个Product属性
            box.Product = product;
            return box;
        }
    }
    //产品工厂
    class ProductFactory
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            product.Price = 12;
            return product;
        }
        public Product MakeCar()
        {
            Product product = new Product();
            product.Name = "Car";
            product.Price = 100;
            return product;
        }
    }
}

image.png

2.委托的高级使用

2.1 多播委托

image.png

2.2使用接口来代替委托

namespace DelegateDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            IProductFactory pizzaFactory = new PizzaFactory();
            IProductFactory carFactory = new CarFactory();
            WrapFactory wrapFactory = new WrapFactory();
            Box b1 = wrapFactory.WrapProduct(carFactory);
            Box b2 = wrapFactory.WrapProduct(pizzaFactory);

            Console.WriteLine(b1.Product.Name);
            Console.WriteLine(b1.Product.Name);


        }
    }
    //工厂接口
    interface IProductFactory
    {
        Product Make();
    }
    //PIZZA工厂
    class PizzaFactory : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }
    }
    //CAR工厂
    class CarFactory : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "Car";
            return product;
        }
    }
    //产品
    class Product
    {
        public string Name { get; set; }
    }
    //包装箱
    class Box
    {
        //产品类
        public Product Product { get; set; }
    }
    //包装工厂：把产品加上盒子
    class WrapFactory
    {
        public Box WrapProduct(IProductFactory productFactory)
        {
            Box box = new Box();
            Product product = productFactory.Make();
            box.Product = product;
            return box;
        }
    }
}