深入理解C#管道式编程
作者:hippiezhou 发布时间:2023-03-18 20:54:25
前言
在 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);
}
}
}
来源:https://www.cnblogs.com/hippieZhou/p/11174644.html
猜你喜欢
- 在Springboot+Mybatis-plus不使用SQL语句进行多表添加操作我所遇到的问题准备工作在测试环境下模拟思维分解一下:创建出一
- 企业级的系统和我们平常桌面、手机上运行的软件有着很重要的区别,其中比较重要的一点就是环境(包括第三方的系统的不同接口以及各系统的不同版本、安
- 本文实例为大家分享了JavaWeb实现注册用户名检测的具体代码,供大家参考,具体内容如下案例说明实现一个可以异步获取用户名是否被注册的小案例
- 面向对象有封装、继承、多态这三个特性,面向对象编程按照现实世界的特点来管理复杂的事物,把它们抽象为对象,具有自己的状态和行为,通过对消息的反
- SpringBoot集成Redis 1.添加redis依赖<dependency> <groupId
- 本文实例为大家分享了C#实现简易点餐功能的具体代码,供大家参考,具体内容如下图示效果实现过程1.设计界面2.设计控件及其属性3.实现点击事件
- 第一节 接口慨述接口(interface)用来定义一种程序的协定。实现接口的类或者结构要与接口的定义严格一致。有了这个协定,就可以抛开编程语
- 主要技术实现:spring、 springmvc、 redis、 springboot、 mybatis 、sessi
- 水印种类及功能介绍 PDF水印分为两种:文本水印和图片水印。文本水印一般被用在商业领域,提醒读者该文档是受版权保护的,其他人不能抄
- .Net为我们提供了众多的泛型集合。比如,Stack<T>先进后出,Queue<T>先进先出,List<T&g
- PUT和Delete请求使用在Form表单中,只支持get和post方式,而为了实现put方式我们可以通过如下三个步骤实现1)SpringM
- 1.1、Web Service基本概念Web Service也叫XML Web Service WebService是一种可以接收从Inte
- spring Boot 熟悉后,集成一个外部扩展是一件很容易的事,集成Redis也很简单,看下面步骤配置:一、添加pom依赖
- 任务超时处理是比较常见的需求,比如在进行一些比较耗时的操作(如网络请求)或者在占用一些比较宝贵的资源(如数据库连接)时,我们通常需要给这些操
- 在传统的单服务架构中,一般来说,只有一个服务器,那么不存在 Session共享问题,但是在分布式/集群项目中,Session 共享则是一个必
- 本文实例讲述了Java高级特性之反射机制。分享给大家供大家参考,具体如下:老规矩我们还是先提出几个问题,一门技术必然要能解决一定的问题,才有
- 本文实例讲述了Android编程之消息机制。分享给大家供大家参考,具体如下:一、角色描述1.Looper: 一个线程可以产生一个Looper
- 安装完 Android Studio 后启动,却报错如下:failed to create jvm error code -4这一般应是内存
- 主要是因为GZipStream的构造函数中第一个需要传入一个Stream,第二个是指定操作方式:压缩还是解压缩。当时的疑问点主要有:1.我传
- 子类重新实现父类的方法称重写;重写时可以修改访问权限修饰符和返回值,方法名和参数类型及个数都不可以修改;仅当返回值为类类型时,重写的方法才可