C#管道式编程的介绍与实现

受 F# 中的管道运算符和 C# 中的 LINQ 语法,管道式编程为 C# 提供了更加灵活性的功能性编程。通过使用 扩展函数 可以将多个功能连接起来构建成一个管道。

前言

在 C# 编程中,管道式编程(Pipeline Style programming)其实存在已久,最明显的就是我们经常使用的 LINQ。在进入 DotNetCore 世界后, 这种编程方式就更加明显,比如各种中间件的使用。通过使用这种编程方式,大大提高了代码的可维护性,优化了的业务的组合方式。

管道式编程具有如下优点:

  • 创建一个流畅的编程范例,将语句转换为表达式并将它们链接在一起
  • 用线性排序替换代码嵌套
  • 消除变量声明 - 甚至不需要 var
  • 提供某种形式的可变不变性和范围隔离
  • 将结构代码编写成具有明确职责的小 lambda 表达式
  • ......

初体验

基础实现

在该示例中,我们通过构建一个 double->int->string 的类型转换的管道来将一个目标数据最终转化为一个字符串。

首先,我们需要定义一个功能接口,用于约束每个功能函数的具体实现,示例代码如下所示:

public interface IPipelineStep<INPUT, OUTPUT>
{
 OUTPUT Process(INPUT input);
}

然后,我们定义两个类型转换的功能类,继承并实现上述接口,示例代码如下所示:

public class DoubleToIntStep : IPipelineStep<double, int>
{
 public int Process(double input)
 {
 return Convert.ToInt32(input);
 }
}

public class IntToStringStep : IPipelineStep<int, string>
{
 public string Process(int input)
 {
 return input.ToString();
 }
}

接着,定义一个扩展函数,用于连接上述的各个功能函数,示例代码如下所示:

public static class PipelineStepExtensions
{
 public static OUTPUT Step<INPUT, OUTPUT>(this INPUT input, IPipelineStep<INPUT, OUTPUT> step)
 {
 return step.Process(input);
 }
}

最后,我们就可以构建一个完整的管道,用于我们的数据类型转换,示例代码如下所示:

class Program
{
 static void Main(string[] args)
 {
 double input = 1024.1024;

 // 构建并使用管道
 string result = input.Step(new DoubleToIntStep())
    .Step(new IntToStringStep());
 Console.WriteLine(result);
 }
}

此时,我们成功将一个 double 类型的数据转化为了 string 类型。通过介绍上述示例,我们可以简单将管道式编程概括为:定义功能接口 -> 实现功能函数 -> 组装功能函数 。

依赖注入

上述代码在一般的情况下是可以正常运行的,但是如果希望以 依赖注入(DI) 的方式注入的话,我们就需要将我们的管道组装进行封装,方便作为一个统一的服务注入到系统中。

首先,我们需要定义一个抽线类,用于管道组装的抽象封装,示例代码如下所示:

public abstract class Pipeline<INPUT,OUTPUT>
{
 public Func<INPUT, OUTPUT> PipelineSteps { get; protected set; }

 public OUTPUT Process(INPUT input)
 {
 return PipelineSteps(input);
 }
}

然后,我们就可以创建一个继承上述抽象类的具体管道组装类,示例代码如下所示:

public class TrivalPipeline : Pipeline<double, string>
{
 public TrivalPipeline()
 {
 PipelineSteps = input => input.Step(new DoubleToIntSetp())
     .Step(new IntToStringStep());
 }
}

最后,我们可以将 TrivalPipeline 这个具体的管道注入到我们的系统中。同样的,我们也可以直接使用,示例代码如下所示:

class Program
{
 static void Main(string[] args)
 {
 double input = 1024.1024;

 // 需要安装 Microsoft.Extensions.DependencyInjection
 var services = new ServiceCollection();
 services.AddTransient<TrivalPipeline>();
 var provider = services.BuildServiceProvider();

 var trival = provider.GetService<TrivalPipeline>();
 string result = trival.Process(input);
 Console.WriteLine(result);
 }
}

条件式组装

上述两个示例代码展示的管道组装式不带任何条件限制的, 无论参数是否合法都是这样组装进管道,但是在实际的开发过程中,我们需要对一定的业务模块进行条件性组装,所以这个时候我们就需要完善一下我们的代码。

首先,我们需要修改上面的 Pipeline<INPUT,OUTPUT> 类,使其继承 IPipelineStep<INPUT, OUTPUT> 接口,示例代码如下所示:

public abstract class Pipeline<INPUT, OUTPUT> : IPipelineStep<INPUT, OUTPUT>
{
 public Func<INPUT, OUTPUT> PipelineSteps { get; protected set; }

 public OUTPUT Process(INPUT input)
 {
 return PipelineSteps(input);
 }
}

然后,我们定义一个带条件的管道装饰器类,示例代码如下所示:

public class OptionalStep<INPUT, OUTPUT> : IPipelineStep<INPUT, OUTPUT> where INPUT : OUTPUT
{
 private readonly IPipelineStep<INPUT, OUTPUT> _step;
 private readonly Func<INPUT, bool> _choice;

 public OptionalStep(Func<INPUT,bool> choice,IPipelineStep<INPUT,OUTPUT> step)
 {
 _choice = choice;
 _step = step;
 }

 public OUTPUT Process(INPUT input)
 {
 return _choice(input) ? _step.Process(input) : input;
 }
}

接着,我们定义一个新的功能类和支持条件判断的管道包装类,示例代码如下所示:

public class ThisStepIsOptional : IPipelineStep<double, double>
{
 public double Process(double input)
 {
 return input * 10;
 }
}

public class PipelineWithOptionalStep : Pipeline<double, double>
{
 public PipelineWithOptionalStep()
 {
 // 当输入参数大于 1024,执行 ThisStepIsOptional() 功能
 PipelineSteps = input => input.Step(new OptionalStep<double, double>(i => i > 1024, new ThisStepIsOptional()));
 }
}

最后,我们可以使用如下方式进行测试:

class Program
{
 static void Main(string[] args)
 {
 PipelineWithOptionalStep step = new PipelineWithOptionalStep();
 Console.WriteLine(step.Process(1024.1024)); // 输出 10241.024
 Console.WriteLine(step.Process(520.520)); // 输出 520.520
 }
}

事件监听

有的时候,我们希望在我们管道中执行的每一步,在开始和结束时,上层模块都能获得相应的事件通知,这个时候,我们就需要需改一下我们的管道包装器,使其支持这个需求。

首先,我们需要实现一个支持事件监听的具体功能类,示例代码代码如下所示:

public class EventStep<INPUT, OUTPUT> : IPipelineStep<INPUT, OUTPUT>
{
 public event Action<INPUT> OnInput;
 public event Action<OUTPUT> OnOutput;

 private readonly IPipelineStep<INPUT, OUTPUT> _innerStep;
 public EventStep(IPipelineStep<INPUT,OUTPUT> innerStep)
 {
 _innerStep = innerStep;
 }

 public OUTPUT Process(INPUT input)
 {
 OnInput?.Invoke(input);

 var output = _innerStep.Process(input);

 OnOutput?.Invoke(output);

 return output;
 }
}

然后,我们需要定义一个能够传递事件参数的管道包装器类,示例代码如下所示:

public static class PipelineStepEventExtensions
{
 public static OUTPUT Step<INPUT, OUTPUT>(this INPUT input, IPipelineStep<INPUT, OUTPUT> step, Action<INPUT> inputEvent = null, Action<OUTPUT> outputEvent = null)
 {
 if (inputEvent != null || outputEvent != null)
 {
  var eventDecorator = new EventStep<INPUT, OUTPUT>(step);
  eventDecorator.OnInput += inputEvent;
  eventDecorator.OnOutput += outputEvent;

  return eventDecorator.Process(input);
 }
 return step.Process(input);
 }
}

最后,上层调用就相对简单很多,示例代码如下所示:

public class DoubleStep : IPipelineStep<int, int>
{
 public int Process(int input)
 {
 return input * input;
 }
}

class Program
{
 static void Main(string[] args)
 {
 var input = 10;
 Console.WriteLine($"Input Value:{input}[{input.GetType()}]");
 var pipeline = new EventStep<int, int>(new DoubleStep());
 pipeline.OnInput += i => Console.WriteLine($"Input Value:{i}");
 pipeline.OnOutput += o => Console.WriteLine($"Output Value:{o}");
 var output = pipeline.Process(input);
 Console.WriteLine($"Output Value: {output} [{output.GetType()}]");
 Console.WriteLine("\r\n");

 //补充:使用扩展方法进行调用
 Console.WriteLine(10.Step(new DoubleStep(), i =>
 {
  Console.WriteLine($"Input Value:{i}");
 },
 o =>
 {
  Console.WriteLine($"Output Value:{o}");
 }));
 }
}

输出结果如下图所示:

可迭代执行

可迭代执行是指当我们的管道中注册了多个功能模块时,不是一次性执行完所以的功能模块,而是每次只执行一个功能,后续功能会在下次执行该管道对应的代码块时接着执行,直到该管道中所有的功能模块执行完毕为止。该特性主要是通过 yield return 来实现。

首先,我们需要实现一个该特性的管道包装器类,示例代码如下所示:

public class LoopStep<INPUT, OUTPUT> : IPipelineStep<IEnumerable<INPUT>, IEnumerable<OUTPUT>>
{
 private readonly IPipelineStep<INPUT, OUTPUT> _internalStep;
 public LoopStep(IPipelineStep<INPUT,OUTPUT> internalStep)
 {
  _internalStep = internalStep;
 }

 public IEnumerable<OUTPUT> Process(IEnumerable<INPUT> input)
 {
  foreach (INPUT item in input)
  {
   yield return _internalStep.Process(item);
  }

  //等价于下述代码段
  //return from INPUT item in input
  //  select _internalStep.Process(item);
 }
}

然后,定义一个支持上述类型的功能组装的扩展方法,示例代码如下所示:

public static class PipelineStepLoopExtensions
{
 public static IEnumerable<OUTPUT> Step<INPUT, OUTPUT>(this IEnumerable<INPUT> input, IPipelineStep<INPUT, OUTPUT> step)
 {
  LoopStep<INPUT, OUTPUT> loopDecorator = new LoopStep<INPUT, OUTPUT>(step);
  return loopDecorator.Process(input);
 }
}

最后,上层调用如下所示:

class Program
{
 static void Main(string[] args)
 {
  var list = Enumerable.Range(0, 10);
  foreach (var item in list.Step(new DoubleStep()))
  {
   Console.WriteLine(item);
  }
 }
}

总结

通过上述 5 部分示例代码的不断改进,最终我们实现了一个支持依赖注入和条件式组装的管道,了解了如何进行管道式编程。掌握管道式编程可以让我们对整个项目的架构和代码质量都有很大帮助,感兴趣的朋友可以自行查阅相关资料进行深入研究。

相关参考

好了,以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对我们的支持。

(0)

相关推荐

  • C#管道式编程的介绍与实现

    受 F# 中的管道运算符和 C# 中的 LINQ 语法,管道式编程为 C# 提供了更加灵活性的功能性编程.通过使用 扩展函数 可以将多个功能连接起来构建成一个管道. 前言 在 C# 编程中,管道式编程(Pipeline Style programming)其实存在已久,最明显的就是我们经常使用的 LINQ.在进入 DotNetCore 世界后, 这种编程方式就更加明显,比如各种中间件的使用.通过使用这种编程方式,大大提高了代码的可维护性,优化了的业务的组合方式. 管道式编程具有如下优点: 创建一

  • 深入理解C#管道式编程

    目录 前言 基础实现 依赖注入 条件式组装 事件监听 可迭代执行 总结 前言 在 C# 编程中,管道式编程(Pipeline Style programming)其实存在已久,最明显的就是我们经常使用的 LINQ.在进入 DotNetCore 世界后, 这种编程方式就更加明显,比如各种中间件的使用.通过使用这种编程方式,大大提高了代码的可维护性,优化了的业务的组合方式. 管道式编程具有如下优点: 创建一个流畅的编程范例,将语句转换为表达式并将它们链接在一起 用线性排序替换代码嵌套 消除变量声明

  • Reactive反应式编程及使用介绍

    目录 前言 反应式编程简介 阻塞可能会浪费资源 使用异步来解决? 回调地狱的例子 与回调代码等效的Reactor代码示例 具有超时和回退的Reactor代码示例 CompletableFuture组合的例子 与未来代码等效的Reactor代码示例 从命令式到反应式编程 可组合性和可读性 类比装配线工作流程 操作符(运算符) 在你订阅之前什么都不会发生 背压 热与冷 前言 前一篇分析了Spring WebFlux的设计及实现原理后,反应式编程又来了,Spring WebFlux其底层还是基于Rea

  • Mybatis接口式编程的原理

    Mybatis 有两种实现方式 其一:通过xml配置文件实现 其二:面向接口编程的实现 前者原理在Mybatis运行套路里面大致说了一下,此节说的是后者,面向接口的编程,可以解决掉 namespace / 传入参数 / 返回值 / 与Sql关联Id 等四处风险. 意思就是,Mybatis配置文件Dao.xml找了一个接口作为自己的代言人,并告诉其他的Java对象,以后访问数据库不要再骚扰我这个Dao.xml文件了,你去找我的代言人助理它会全权负责的. 如果接口助理要全权负责Dao.xml文件的所

  • 关于UDP服务器客户端编程流程介绍

    目录 UDP编程流程 UDP服务端代码实现 UDP客户端代码实现 UDP服务端客户端代码详解 UDP编程流程 UDP提供的是无连接.不可靠的.数据报服务 UDP是尽最大能力进行传输,但是并不能保证可靠性,TCP的可靠性是因为一系列的机制保证可靠性,UDP丢包并不会重发,两种协议并没有优略之分,要区分不同的场景来区分,比如:进行文件传输,不能有数据丢失,TCP协议就更合 适,而进行实时视频通话,UDP会根据恒定的速率进行发送,这样的情况容许部分数据的丢失去追求更好的实时性,所以UDP更合适 流程:

  • 关于springboot响应式编程整合webFlux的问题

    在servlet3.0标准之前,是每一个请求对应一个线程.如果此时一个线程出现了高延迟,就会产生阻塞问题,从而导致整个服务出现严重的性能情况,因为一旦要调用第三方接口,就有可能出现这样的操作了.早期的处理方式只能是手工控制线程. 在servlet3.0标准之后,为了解决此类问题,所以提供了异步响应的支持.在异步响应处理结构中,可以将耗时操作的部分交由一个专属的异步线程进行响应处理,同时请求的线程资源将被释放,并将该线程返回到线程池中,以供其他用户使用,这样的操作机制将极大的提升程序的并发性能.

  • springboot3+r2dbc响应式编程实践

    目录 r2dbc 工程依赖 配置文件 配置类 bean DAO controller Spring boot3已经M1了,最近群佬们也开始蠢蠢欲动的开始整活Reactive+Spring Boot3,跟着大家的步伐,我也来整一篇工程入门,我们将用java17+Spring Boot3+r2dbc+Reactive栈来讲述,欢迎大家来讨论.(关于响应式,请大家异步到之前的文章里,有详细介绍.) r2dbc Reactor还有基于其之上的Spring WebFlux框架.包括vert.x,rxjav

  • 剖析Spring WebFlux反应式编程设计及工作原理

    目录 前言 接口抽象 WebServer ReactiveWebServerFactory HttpHandler 启动流程分析 ReactiveWebServerApplicationContext 前言 Spring 5发布有两年了,随Spring 5一起发布了一个和Spring WebMvc同级的Spring WebFlux.这是一个支持反应式编程模型的新框架体系.反应式模型区别于传统的MVC最大的不同是异步的.事件驱动的.非阻塞的,这使得应用程序的并发性能会大大提高,单位时间能够处理更多

  • Spring5新特性之Reactive响应式编程

    目录 1什么是响应式编程 2回顾Reactor 2.1什么是Reactor 2.2为什么是Reactor 2.3Reactor模式的经典实现—Netty 3Spring5中多Reactive的支持 3.1SpringWebflux 3.1.1依赖 3.1.2Controller代码 3.1.3测试 3.1.4SpringMVC和SpringWebFlux模式上的不同 3.2SpringDataReactiveRespositories 3.2.1依赖 3.2.2配置 3.3.3测试 4如何理解R

  • java9新特性Reactive Stream响应式编程 API

    目录 一.Java9ReactiveStreamAPI 二.Java响应式编程四大接口 2.1.SubscriberInterface(订阅者订阅接口) 2.2.SubscriptionInterface(订阅令牌接口) 2.3.PublisherInterface(发布者接口) 2.4.ProcessorInterface(处理器接口) 二.实战案例 实现订阅者SubscriberInterface SubmissionPublisher消息发布者 我计划在后续的一段时间内,写一系列关于jav

随机推荐