美文网首页
二刷：委托

二刷：委托

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

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

    相关文章

      网友评论

          本文标题：二刷：委托

          本文链接：https://www.haomeiwen.com/subject/sxeefdtx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|二刷：委托|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！