通过委托执行多个函数

已于 2024-07-10 17:14:27 修改
阅读量383 收藏 5
点赞数 10
分类专栏： #浅谈系列 C#学习笔记 文章标签： c# 数据结构
于 2024-07-10 15:29:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aflashstar/article/details/140323350
版权

文章目录

一、通过委托执行多个函数

假设我们在某个场景下需要运行一个逻辑：
关闭破真空-关闭吸真空-打开吸真空-延时200ms-处理其他逻辑-关闭吸真空-打开破真空-延时200ms-关闭破真空
其中每一个的执行都有可能是失败的（比如真空表值异常、通讯失败等原因），失败后就要报警等待人工检查处理而不应该继续往下执行

【以下代码比较长，但都是最简单的模型示例而已，请耐心看完】

我们常规的做法一般是这样：

public bool Run()
{
    bool flag = false;
    flag = CloseBreakVacuum();
    if (!flag)
    {
        return false;
    }
    flag = CloseSuctionVacuum();
    if (!flag)
    {
        return false;
    }
    flag = OpenSuctionVacuum();
    if (!flag)
    {
        return false;
    }
    Delay(200);
    OtherLogic();
    flag = CloseSuctionVacuum();
    if (!flag)
    {
        return false;
    }
    flag = OpenBreakVacuum();
    if (!flag)
    {
        return false;
    }
    Delay(200);
    flag = CloseBreakVacuum();
    if (!flag)
    {
        return false;
    }
    return flag;
}

public bool CloseBreakVacuum()
{
    // TODO..关闭破真空，读真空表气压值判断是否关闭成功
    return true;
}
public bool CloseSuctionVacuum()
{
    // TODO..关闭吸真空，读真空表气压值判断是否关闭成功
    return true;
}
public bool OpenBreakVacuum()
{
    // TODO..打开破真空，释放产品时防止产品黏在吸嘴上，读真空表气压值判断是否成功释放到产品
    return true;
}
public bool OpenSuctionVacuum()
{
    // TODO..打开吸真空，吸取产品，读真空表气压值判断是否成功吸取到产品
    return true;
}
public void Delay(int ms)
{
    // TODO..延时指定时间
}
public void OtherLogic()
{
    // TODO..处理其他逻辑
}

可以看出来这样的可读性太差了，那么如何优化呢？我们可以使用委托的做法：

public bool Run()
{
    bool flag = false;
    foreach (var func in new Func<bool>[] { CloseBreakVacuum, CloseSuctionVacuum, OpenSuctionVacuum })
    {
        flag = func();
        if(!flag)
        {
            return false;
        }
    }

    Delay(200);
    OtherLogic();

    foreach (var func in new Func<bool>[] { CloseSuctionVacuum, OpenBreakVacuum })
    {
        flag = func();
        if (!flag)
        {
            return false;
        }
    }

    Delay(200);

    foreach (var func in new Func<bool>[] { CloseBreakVacuum })
    {
        flag = func();
        if (!flag)
        {
            return false;
        }
    }

    return true;
}

public bool CloseBreakVacuum()
{
    // TODO..关闭破真空，读真空表气压值判断是否关闭成功
    return true;
}
public bool CloseSuctionVacuum()
{
    // TODO..关闭吸真空，读真空表气压值判断是否关闭成功
    return true;
}
public bool OpenBreakVacuum()
{
    // TODO..打开破真空，释放产品时防止产品黏在吸嘴上，读真空表气压值判断是否成功释放到产品
    return true;
}
public bool OpenSuctionVacuum()
{
    // TODO..打开吸真空，吸取产品，读真空表气压值判断是否成功吸取到产品
    return true;
}
public void Delay(int ms)
{
    // TODO..延时指定时间
}
public bool OtherLogic()
{
    // TODO..处理其他逻辑
    return true;
}

这样看，很明显，结构化的代码可读性是不是更加强了

但好处还不止这个，我们再发散下思维，每一步都可能错误，假设是通讯丢包出错，那我们再执行一次是不是就可能成功了？好了，现在欠收拾的产品经理新增了需求，每一步如果重复失败三次（次数需要可以修改）才认为是失败。
那原来的代码可能是这样处理的：

int retryTimes = 3; //重试次数
int errorCount = 0; //失败次数

public bool Run()
{
    bool flag = false;
    errorCount = 0;
    while (errorCount < retryTimes && !flag)
    {
        flag = CloseBreakVacuum();
        errorCount++;
    }
    if (!flag)
    {
        return false;
    }
    errorCount = 0;
    while (errorCount < retryTimes && !flag)
    {
        flag = CloseSuctionVacuum();
        errorCount++;
    }
    if (!flag)
    {
        return false;
    }
    errorCount = 0;
    while (errorCount < retryTimes && !flag)
    {
        flag = OpenSuctionVacuum();
        errorCount++;
    }
    if (!flag)
    {
        return false;
    }

    Delay(200);
    OtherLogic();

    errorCount = 0;
    while (errorCount < retryTimes && !flag)
    {
        flag = CloseSuctionVacuum();
        errorCount++;
    }
    if (!flag)
    {
        return false;
    }
    while (errorCount < retryTimes && !flag)
    {
        flag = OpenBreakVacuum();
        errorCount++;
    }
    if (!flag)
    {
        return false;
    }
    
    Delay(200);

    while (errorCount < retryTimes && !flag)
    {
        flag = CloseBreakVacuum();
        errorCount++;
    }
    if (!flag)
    {
        return false;
    }

    return true;
}

public bool CloseBreakVacuum()
{
    // TODO..关闭破真空，读真空表气压值判断是否关闭成功
    return true;
}
public bool CloseSuctionVacuum()
{
    // TODO..关闭吸真空，读真空表气压值判断是否关闭成功
    return true;
}
public bool OpenBreakVacuum()
{
    // TODO..打开破真空，释放产品时防止产品黏在吸嘴上，读真空表气压值判断是否成功释放到产品
    return true;
}
public bool OpenSuctionVacuum()
{
    // TODO..打开吸真空，吸取产品，读真空表气压值判断是否成功吸取到产品
    return true;
}
public void Delay(int ms)
{
    // TODO..延时指定时间
}
public void OtherLogic()
{
    // TODO..处理其他逻辑
}

而使用委托后可以这样处理：

int retryTimes = 3; //重试次数

public bool Run()
{
    bool flag = false;
    foreach (var func in new Func<bool>[] { CloseBreakVacuum, CloseSuctionVacuum, OpenSuctionVacuum })
    {
        flag = RetryFunc(func, retryTimes);
        if(!flag)
        {
            return false;
        }
    }

    Delay(200);
    OtherLogic();

    foreach (var func in new Func<bool>[] { CloseSuctionVacuum, OpenBreakVacuum })
    {
        flag = RetryFunc(func, retryTimes);
        if (!flag)
        {
            return false;
        }
    }

    Delay(200);

    foreach (var func in new Func<bool>[] { CloseBreakVacuum })
    {
        flag = RetryFunc(func, retryTimes);
        if (!flag)
        {
            return false;
        }
    }

    return true;
}

protected bool RetryFunc(Func<bool> func, int retryTimes = 3)
{
    bool flag = false;
    int errorCount = 0;
    while (errorCount < retryTimes && !flag)
    {
        flag = func();
        errorCount++;
    }
    return flag;
}

public bool CloseBreakVacuum()
{
    // TODO..关闭破真空，读真空表气压值判断是否关闭成功
    return true;
}
public bool CloseSuctionVacuum()
{
    // TODO..关闭吸真空，读真空表气压值判断是否关闭成功
    return true;
}
public bool OpenBreakVacuum()
{
    // TODO..打开破真空，释放产品时防止产品黏在吸嘴上，读真空表气压值判断是否成功释放到产品
    return true;
}
public bool OpenSuctionVacuum()
{
    // TODO..打开吸真空，吸取产品，读真空表气压值判断是否成功吸取到产品
    return true;
}
public void Delay(int ms)
{
    // TODO..延时指定时间
}
public bool OtherLogic()
{
    // TODO..处理其他逻辑
    return true;
}

好了，本文章就到这里了，具体区别，需要自己细细体悟，具体用法，需要举一反三

Aflashstar
关注
专栏目录
C++构造函数之委托构造函数
weixin_42561432的博客
12-15 1140
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、委托构造函数是什么？二、使用方式1.函数形式总结 前言 C++11新标准允许用户定义一个委托构造函数，来使用该类的其他构造函数执行自己的初始化过程，这样做的好处是是可以让代码更简洁，节省重复的代码。 提示：以下是本篇文章正文内容，下面案例可供参考 一、委托构造函数是什么？ 委托构造函数是C++11新允许的一种构造函数类型，区别于普通的构造函数，它可以使用所属类里的其他构造函数，类似于功能外包。 二、使用方式 1.函数形式
详解C#中通过委托来实现回调函数功能的方法
09-02
创建委托类型后，可以通过实例化委托来存储一个或多个方法的引用。例如： ```csharp delegate double ProcessDelegate(double param1, double param2); ``` 上面的`ProcessDelegate`定义了一个接受两个`double`...
[C++11] 理解委托构造函数
wangdsh的博客
04-05 1486
说明：委托构造函数是 C++11 引入的一种特殊类型的构造函数，它通过调用同一个类中的另一个构造函数来初始化对象。这种构造函数在声明时使用符号后跟其他构造函数的初始化列表，而不是在函数体内调用。委托构造函数的主要目的是避免代码重复，并简化多个构造函数之间的共同初始化逻辑。注意：这里所谓的性能提升本质上是减少了成员变量初始化的时间，在一些大型工程中，成员变量初始化往往是很大的，因此要做这样的优化。
c#入门-多播委托，匿名函数
zms9110750的博客
01-05 1042
使用 – =时，如果储存了这个值，那么会移除第一个。如果没有则无事发生。委托是引用类型，默认值是null。委托可以和null相加，不会出现异常。
C++委托构造函数
Enstein_Jun
02-20 6025
    在c++11中有一个新特性，就是委托构造函数。委托构造函数可以使用当前类的其他构造函数来帮助当前构造函数初始化。换而言之，就是可以将当前构造函数的部分(或者全部)职责交给本类的另一个构造函数。    我们先看看委托构造函数与普通构造函数的相同点与不同点。相同点： 两者都有一个成员初始值列表与一个函数体 不同点： 委托构造函数的成员初始值列表只有一个唯一的参数，就是构造函数(...
c#：委托与回调函数示例
abraham_ly的博客
06-21 3731
c#：委托与回调函数示例 上一篇文章已经给大家详细讲解过委托的意思，如何声明定义，如何通过委托调用函数，以及委托中的多播等……今天是刚刚学到委托新的用法——可以将方法当作参数来传递，并且不需用示例委托。所以今天来给大家再次拿出来详细讲解一下 一、委托 委托理解的追加 ​ （1）委托是c#实现回调函数的一种机制 ​ （2）使用委托就能讲方法当作变量来进行传递——这个是比较重要的 ​ （3）委托是引用类型，说白了委托是一种数据类型，什么数据类型——用户自定义类型，这种类型赋值赋值需要赋一个与之对应的方法，也就
立即执行函数
Triumph_light的博客
11-03 7180
简介
【C++】C++中的委托构造函数详解
qq_35902025的博客
10-23 7788
避免你有多个参数表不同但是逻辑相近（或者有公共部分）的构造函数的时候，一个逻辑写好几遍造成代码重复。Q:执行的顺序？A:先执行目标构造函数，再执行委托构造函数。
C++11 11-委托构造函数 Delegating constructors
wesigj的博客
10-17 1369
委托构造函数：在初始化列表中调用另一个构造函数，不能包含任何执行语句。普通构造函数：在函数体内包含初始化代码，可以包含执行语句。委托构造函数是 C++11 引入的特性，它允许程序员编写更简洁、更易于维护的代码，尤其是在处理具有多个构造函数的类时。通过使用委托构造函数，可以避免在多个构造函数中重复相同的初始化代码。委托构造函数的调用顺序是由你在类定义中指定的初始化列表决定的。这种机制允许你重用代码，减少重复的初始化代码，并保持代码的清晰和可维护性。
现代C++新特性 委托构造函数
神奇的小强
04-17 1064
文字版PDF文档链接：现代C++新特性(文字版)-C++文档类资源-CSDN下载 1.冗余的构造函 一个类有多个不同的构造函数在C++中是很常见的，例如： class X { public: X() : a_(0), b_(0.) { CommonInit(); } X(int a) : a_(a), b_(0.) { CommonInit(); } X(double b) : a_(0), ...
委托构造函数（C++）
Ivan_47的博客
04-25 1815
所谓委托构造函数即是使用它所属的类的其他构造函数执行它自己的初始化过程，或者说它将自己初始化的工作委托给了其他构造函数。 其形式是将构造函数初始化时的初始值列表替换为调用其委托的构造函数。例如： class Student{ public: //普通的构造函数 Student(string n1,int n2,int a):name(n1),num(n2),age(a) { cout << "调用普通构造函数" << endl; };
C#委托所蕴含的函数指针概念详细解析
09-05
同时，委托支持多播，即一个委托实例可以同时关联多个方法。然而，这种安全性和灵活性是以牺牲某些灵活性为代价的，比如不能像C++那样自由地处理内存地址。此外，C#不支持直接的函数指针操作，使得一些底层的优化和...
c#委托回调函数
04-24
下面是一个使用委托和回调函数实现多线程的例子，展示了如何在.NET 4.0中创建一个简单的控制台应用程序： ```csharp using System; using System.Threading; class Program { // 自定义委托 public delegate ...
Winform基于多线程实现每隔1分钟执行一段代码
09-04
总结起来，实现Winform应用中每隔1分钟执行一段代码，关键在于利用多线程和自定义定时器类，通过委托和事件机制来处理时间间隔到达时的回调。在实际项目中，还需要考虑线程安全、异常处理以及如何优雅地停止线程等...
深入委托与多播委托的详解
09-05
通过使用`+=`操作符，我们可以将多个方法添加到同一个委托实例中。当调用`MyTest`时，所有关联的方法都会被依次执行，这就是多播委托的核心特性。 多播委托的应用非常广泛，例如在事件处理中。在C#中，事件本质上...
掌握C#中的异步编程：async和await关键字详解
最新发布
Envyᥫᩣ的博客
11-15 521
随着互联网应用的不断发展，用户对应用程序响应速度的要求越来越高。传统的同步编程模型往往会导致UI界面冻结或者服务器资源被长时间占用。为了提升用户体验并优化资源利用率，异步编程成为了一种必要的编程方式。在C#中，async和await关键字提供了一种优雅的方式来实现异步编程。本文将详细介绍这两个关键字的使用方法及其背后的原理。
【C#设计模式(6)——适配器模式(Adapter Pattern)】
weixin_43626218的博客
11-12 323
C#设计模式(6)——适配器模式(Adapter Pattern)适配器模式主要用于在不修改现有类的情况下，使本来不包含的类可以一起工作。
C# VS的常用功能(一) 视图篇
咩咩觉主的博客
11-12 408
给新手一个良好的印象
每日一题——第一百二十一题
weixin_45778846的博客
11-07 1570
【代码】每日一题——第一百二十一题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值