管道式编程：我原来是个水管工 (一)

最新推荐文章于 2023-08-30 18:08:52 发布
最新推荐文章于 2023-08-30 18:08:52 发布
阅读量213 收藏
点赞数
文章标签： java c# shell
原文链接：http://www.cnblogs.com/alala666888/archive/2012/03/13/2393386.html
版权

    昨天工作不忙，脑袋又开始抽抽了，从linux shell的管道想到java的piped stream，从.net的工作流想到了自来水管，从自来水管想到了一个城市复杂的下水道系统( 这都想的啥:( )。反正不管怎么说，最后还是相处了点东西，跟大家扯扯淡。

    作为一个程序员，我们写代码的时候经常会发现越写越乱，这一般是没有做好设计的缘故。怎么设计，简单的来说就是画一些流程图啊、类图什么的。不过有时候画了也不顶事，搞到最后还是很乱。其实我觉得画不画图无所谓，关键是脑子里要想清楚，想的太乱的时候可以画画图理一理思维，但最终还是要在脑子里搭个模型出来。软件系统说白了就是一个数据处理器，一坨数据进去，一坨数据出来。计算机最擅长的就是这个，话说回来它也只能干这个，别的也不会。基于此，我们也可以把某些软件系统看成一个下水道系统，数据就像污水，从各个地方流进来，最后汇总啊，处理啊，再最后就折腾到河里去了。当然也可以把某些软件系统看成一个供水系统，水从水库经过折腾，通过各种管子最后接到了你家的水龙头里面。下面的图演示了这两种结构。

    

 

    在污水处理系统里面，下水道可以看做初始输入，河是最终输出，中间的污水管和接头，以及污水处理厂都可以看做一个整体，抽象一下就是一个软件系统。在自来水系统里面，水库可以看做初始输入，水龙头是最终输出，中间的水管、自来水厂和接头也可以看做一个整体，同样可以抽象成一个软件系统。总而言之，我们这里的计算机就是排除掉初始输入和最终输出的中间的数据处理系统。基于此抽象，我们发现软件系统其实是很多管子连起来的。从另外一种角度讲，软件系统里面只有两种玩意，一个是管子，一个是接头，污水管和水管都可以看成管子(pipe)，污水处理厂、自来水厂和普通的接头我们都可以称之为连接头(joint)。进一步讲，程序员就像水管工，一部分负责造管子和连接头，其他的负责把这些管子和连接头连起来构成软件系统。或者说编程变成了两种活，一是造管子和连接头，二是连管子和连接头。


    好了，淡也扯的差不多了，开始干活，也就是用代码实现上面的东西，我们先从造管子和连接头开始。从上面的图我们可以看出来，管子可以分三种：

        1. 输入管道。污水处理系统里面那个连接下水道和接头的管子就是输入管道，因为下水道属于软件系统之外，所以管子从外部有输入，但是污水流入的接头在软件系统里面，所以没输出。
        2. 输出管道。 自来水系统里面连接水龙头的那个管子就是输出管道，水龙头属于软件系统之外，所以管子向外部有输出，但是连接的接头在软件系统里，所以没输入。
        3. 中间管道。在软件系统里面负责连接两个连接头，对外部无任何输入和输出。

    当然，上面的分类是基于管子对外部的可见性而言的，实际上，每个管子都有头和尾，也就是输入和输出，只不过内部的输入输出被实现封装起来了。我们将上面的三种管子变成类，下面是类图：

    

    剩下的就是连接头了，连接头比较简单，只有两种基本功能，一个是塞东西进去，一个是取东西出来，下面是简单的类图：    

    

    上面只说了一下基本结构和接口，所以比较简单，下面分析如何实现三种管道和连接头。在我的设计里，管道属于主动行为者，需要通过操作连接头推动或拉动数据的流动，而连接头一般只通过暴露一些操作给管道，比较被动，所以我们先实现连接头。(后面会提到一种主动的连接头，待会再说)。

    1. 连接头：

C# 
/// <summary>
/// 连接头
/// </summary>
/// <typeparam name="T">管道系统里流动的数据对象</typeparam>
    public abstract class Joint<T>
    {
/// <summary>
/// 一个数据从输入管道流进连接头
/// </summary>
/// <param name="t">数据对象</param>
        internal abstract void Add(T t);

/// <summary>
/// 一个数据从连接头流出到管道
/// </summary>
/// <returns>数据对象</returns>
        internal abstract T Get();
    }
Java 
/**
 * 连接头
 * @param <T> 管道系统里流动的数据对象
*/
public abstract class Joint<T> {

/** 一个数据从输入管道流进连接头
     * @param t 数据对象
*/
abstract void Add(T t);
/** 一个数据从连接头流出到管道
     * @return 数据对象
*/
abstract T Get();
}

   2. 管道：

        a) 输入管道: 构造时必须传入一个连接头作为参数，这样有数据到来时，管道会将数据推送进连接头。       

C# 
    /// <summary>
/// 输入管道
/// </summary>
/// <typeparam name="T"> 数据对象类型</typeparam>
    public class InPipe<T>
    {
/// <summary>
/// 构造方法
/// </summary>
/// <param name="joint">数据流向的连接头</param>
        public InPipe(Joint<T> joint)
        {
            _outJoint = joint;
        }

/// <summary>
/// 向管道塞入一个数据
/// </summary>
/// <param name="t"></param>
        public virtual void Push(T t)
        {
//将数据直接加入连接头
            _outJoint.Add(t);
        }

protected Joint<T> _outJoint = null;
    }
Java 
/** 
 * 输入管道
 * @param <T> 数据对象类型
*/
public class InPipe<T>
{
/** 构造方法
     * @param joint 数据流向的连接头
*/
public InPipe(Joint<T> joint)
    {
        _outJoint = joint;
    }

/** 向管道塞入一个数据
     * @param t
*/
public void Push(T t)
    {
//将数据直接加入连接头
        _outJoint.Add(t);
    }

protected Joint<T> _outJoint = null;
}

       b) 输出管道: 构造时也必须传入一个连接头作为参数，管道需要读数据时会从连接头获取。　　　 

C# 
    /// <summary>
/// 输出管道
/// </summary>
/// <typeparam name="T"></typeparam>
    public class OutPipe<T>
    {
/// <summary>
/// 构造方法
/// </summary>
/// <param name="joint">数据流入的连接头</param>
        public OutPipe(Joint<T> joint)
        {
            _inJoint = joint;
        }

/// <summary>
/// 从管道获取一个数据
/// </summary>
/// <returns></returns>
        public virtual T Pop()
        {
//从连接头获取一个数据返回
            return _inJoint.Get();
        }

protected Joint<T> _inJoint = null;
    }
Java 
/** 输出管道
 * @param <T> 数据对象类型
*/
public class OutPipe<T> {

/** 构造方法
     * @param joint 数据流入的连接头
*/
public OutPipe(Joint<T> joint) {
        _inJoint = joint;
    }

/** 从管道获取一个数据
     * @return
*/
public T Pop() {
//从连接头获取一个数据返回
        return _inJoint.Get();
    }

protected Joint<T> _inJoint = null;
}

       c) 中间管道: 构造时必须传入两个连接头，一个用来获取数据，一个用来塞入数据。　　　　

C# 
/// <summary>
/// 中间管道
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
    public abstract class MidPipe<T>
    {
/// <summary>
/// 构造方法
/// </summary>
/// <param name="inJoint">流入连接头</param>
/// <param name="outJoint">流出连接头</param>
        public MidPipe(Joint<T> inJoint, Joint<T> outJoint)
        {
            _inJoint = inJoint;
            _outJoint = outJoint;
        }

protected Joint<T> _inJoint = null;
protected Joint<T> _outJoint = null;
    }
Java 
/** 中间管道
 * @author shun.li
 *
 * @param <T> 数据类型
*/
public abstract class MidPipe<T> {    
/** 构造方法
     * @param inJoint 流入连接头
     * @param outJoint 流出连接头
*/
public MidPipe(Joint<T> inJoint, Joint<T> outJoint) {
        _inJoint = inJoint;
        _outJoint = outJoint;
    }

protected Joint<T> _inJoint = null;
protected Joint<T> _outJoint = null;
}

 

    线程安全连接头:上面的Joint只是抽象类，你可以用一个简单的队列实现之，也可以封装msmq或0mq之类的实现比较复杂的功能。下面提供一个简单的实现，此实现保证了线程安全性，所以可以同时连接多个输入管道或输出管道。
    

C# 
    /// <summary>
/// 线程安全连接头
/// </summary>
/// <typeparam name="T"></typeparam>
    public class ConcurrentJoint<T> : Joint<T>
    {
internal override void Add(T t)
        {
lock (_queue)
            {
                _queue.Enqueue(t);
            }
        }

internal override T Get()
        {
lock (_queue)
            {
return _queue.Dequeue();
            }
        }

private Queue<T> _queue = new Queue<T>();
    }
Java 
/** 线程安全连接头
 * @param <T>
*/
public class ConcurrentJoint<T> extends Joint<T> {

    @Override
void Add(T t) {
synchronized (_queue) {
            _queue.add(t);
        }
    }

    @Override
    T Get() {
synchronized (_queue) {
return _queue.remove();
        }
    }

private Queue<T> _queue = new LinkedList<T>();
}

    推拉模式：除了连接头外，MidPipe也是个抽象类。如果不是，内部管道其实什么都做不了，因为无论是别人想要数据，还是别人给它数据，它都无法知道。管道内的数据流动模式有两种：

    1. 推。污水系统就是一个推的管道系统，人们把污水倒入，污水会主动流动，知道最终流入河里。
    2. 拉。供水系统则相反，是一个拉的管道系统，人们打开水龙头，水才开始从源头流向水龙头。
    下面提供两种实现，注意每种模式都对应一套内部节点和连接头。
    1. 推实现：
    

C# 
/// <summary>
/// 推模式连接头
/// </summary>
/// <typeparam name="T"></typeparam>
    public class PushJoint<T> : Joint<T>
    {
internal override void Add(T t)
        {
lock(_queue)
            {
                _queue.Enqueue(t);
            }

//:通知别人有数据进入
            if (_addCallback != null)
            {
                _addCallback();
            }
        }

internal override T Get()
        {
lock (_queue)
            {
return _queue.Dequeue();
            }
        }

/// <summary>
/// 设置数据塞入回调方法
/// </summary>
        public Action AddCallback
        {
set { _addCallback = value; }
        }

private Queue<T> _queue = new Queue<T>();
private Action _addCallback = null;
    }

/// <summary>
/// 推模式中间管道
/// </summary>
/// <typeparam name="T"></typeparam>
    public class PushMidPipe<T> : MidPipe<T>
    {
public PushMidPipe(PushJoint<T> inJoint, Joint<T> outJoint)
            : base(inJoint, outJoint)
        {
            inJoint.AddCallback = Flush;
        }

/// <summary>
/// 刷新方法
/// </summary>
        private void Flush()
        {
//:从流入连接头获取数据塞入流出连接头
            T t = _inJoint.Get();
            _outJoint.Add(t);
        }
    }
Java 
/**
 * 推模式中间管道
 * @param <T>
*/
public class PushJoint<T> extends Joint<T> {

    @Override
void Add(T t) {
synchronized(_queue) {
            _queue.add(t);
        }

//:通知别人有数据进入
        if(_addRunnable != null) {
            _addRunnable.run();
        }
    }

    @Override
    T Get() {
synchronized(_queue) {
return _queue.remove();
        }
    }

/** 设置塞入新数据时的回调对象
     * @param r
*/
void setAddRunnable(Runnable r) {
        _addRunnable = r;
    }

private Queue<T> _queue = new LinkedList<T>();    
private Runnable _addRunnable = null;

}
public class PushMidPipe<T> extends MidPipe<T> implements Runnable {
public PushMidPipe(PushJoint<T> inJoint, Joint<T> outJoint) {
super(inJoint, outJoint);
        inJoint.setAddRunnable(this);
    }

    @Override
public void run() {
//:从流入连接头获取数据塞入流出连接头
        T t = _inJoint.Get();
        _outJoint.Add(t);        
    }
}

   注意：推模式在应用时有两种情况:

   　　1)完全主动。这种情况下基本的输出管道已经满足不了要求，因为根本没人调用它的Pop方法。以污水系统为例，在完全主动模式下，排放管无人操作，污水留到它的输入连接头时将自动流到河里，而不是等人开一下排污口放水。所以将输出管道改为如下的实现：
           

C# 
/// <summary>
/// 完全主动推模式的输出管道
/// </summary>
/// <typeparam name="T"></typeparam>
    public class PushOutPipe<T> : OutPipe<T>
    {
public PushOutPipe(PushJoint<T> inJoint)
            : base(inJoint)
        {
            inJoint.AddCallback = Flush;
        }

/// <summary>
/// 刷新方法
/// </summary>
        private void Flush()
        {
//:从流入连接头获取数据塞入流出连接头
            T t = _inJoint.Get();

//TODO:下面是处理数据t的代码
        }

public override T Pop()
        {
throw new InvalidOperationException("主动推模式下无法获取数据");
        }
    }
Java 
/**
 * 完全主动推模式的输出管道
 *
*/
public class PushOutPipe<T> extends OutPipe<T> implements Runnable {

public PushOutPipe(PushJoint<T> inJoint) {
super(inJoint);
        inJoint.setAddRunnable(this);
    }

    @Override
public void run() {        
        T t = _inJoint.Get();
//TODO:下面是处理数据t的代码    
    }

}

       2)半主动。这种情况下，数据将会堆积到输出管道的输入连接头。以污水系统为例，污水将堆积在污水处理厂，知道有人主动打开排放管的口子(主动调用OutPipe的Pop)，污水才会留到河里。 

    2. 拉实现：
        

C# 
/// <summary>
/// 拉模式连接头
/// </summary>
/// <typeparam name="T"></typeparam>
    public class PullJoint<T> : Joint<T> where T : class
    {
internal override void Add(T t)
        {
lock (_queue)
            {
                _queue.Enqueue(t);
            }
        }

internal override T Get()
        {
//:没货了，通知输入管道开始拉货
            if (_queue.Count == 0 && _getCallback != null)
            {
                _getCallback();
            }

lock (_queue)
            {
if (_queue.Count == 0)
return null;
else
return _queue.Dequeue();
            }
        }

/// <summary>
/// 设置数据读取回调方法
/// </summary>
        public Action GetCallback
        {
set { _getCallback = value; }
        }

private Queue<T> _queue = new Queue<T>();
private Action _getCallback = null;
    }

/// <summary>
/// 拉模式中间管道
/// </summary>
/// <typeparam name="T"></typeparam>
    public class PullMidPipe<T> : MidPipe<T> where T : class
    {
public PullMidPipe(Joint<T> inJoint, PullJoint<T> outJoint)
            : base(inJoint, outJoint)
        {
            outJoint.GetCallback = PullData;
        }

/// <summary>
/// 从输入队列拉数据
/// </summary>
        private void PullData()
        {
//:从流入连接头获取数据塞入流出连接头
            T t = _inJoint.Get();
            _outJoint.Add(t);
        }
    }
Java 
/** 拉模式连接头
 * @param <T>
*/
public class PullJoint<T> extends Joint<T> {

    @Override
void Add(T t) {
synchronized(_queue) {
            _queue.add(t);
        }
    }

    @Override
    T Get() {
//:没货了，通知输入管道开始拉货
        if(_queue.size() == 0 && _getRunnable != null) {
            _getRunnable.run();
        }
synchronized(_queue) {
return _queue.remove();
        }
    }

/** 设置需要数据时的回调对象
     * @param r
*/
void setGetRunnable(Runnable r) {
        _getRunnable = r;
    }

private Queue<T> _queue = new LinkedList<T>();    
private Runnable _getRunnable = null;
}

/**
 * 完全主动推模式的输出管道
 *
*/
public class PushOutPipe<T> extends OutPipe<T> implements Runnable {

public PushOutPipe(PushJoint<T> inJoint) {
super(inJoint);
        inJoint.setGetRunnable(this);
    }

    @Override
public void run() {
        T t = _inJoint.Get();
//TODO:下面是处理数据t的代码    
    }

    @Override
public T Pop() {
throw new RuntimeException("主动推模式下无法获取数据");        
    }
}

 

    注意：拉模式在应用时也有两种情况:

   　　1)完全主动。这种情况下基本的输入管道已经满足不了要求，因为根本没人调用它的Push方法。以供水系统为例，在完全主动模式下，自来水厂的输入管完全自动化，当自来水厂需要水时水将自动从水库流入自来水厂。所以将输入管道改为如下的实现：
       

C# 
    /// <summary>
/// 完全主动拉模式的输入管道
/// </summary>
/// <typeparam name="T"></typeparam>
    public class PullOutPipe<T> : InPipe<T>
    {
public PullOutPipe(PullJoint<T> outJoint)
            : base(outJoint)
        {
            outJoint.GetCallback = PullData;
        }

private void PullData()
        {
//TODO:下面是获取数据的代码
            T t = default(T);

//将数据传递下去
            _outJoint.Add(t);
        }

public override void Push(T t)
        {
throw new InvalidOperationException("主动拉模式下无法塞入数据");
        }
    }
Java 
/**
 * 完全主动拉模式的输入管道
 *
*/
public class PullInPipe<T> extends InPipe<T> implements Runnable {

public PullInPipe(PullJoint<T> outJoint) {
super(outJoint);
        outJoint.setGetRunnable(this);
    }

    @Override
public void run() {
//TODO:下面是获取数据的代码
        T t = null;

//将数据传递下去
        _outJoint.Add(t);
    }

    @Override
public void Push(T t) {
throw new RuntimeException("主动拉模式下无法塞入数据");        
    }
}

       2)半主动。 这种情况和推模式类似，用一般的输入管道就可以了。   

本篇只扯了一些理论，下一篇将给出更多实用的例子。

转载于:https://www.cnblogs.com/alala666888/archive/2012/03/13/2393386.html

weixin_30724853
关注
管道编程：利用流畅的数据传递提升代码效率
TechPulseZ的博客
09-21 40
管道编程是一种高效、可重用和易于维护的编程模式，通过将数据在不同的处理阶段进行流动，提供了一种流畅的数据传递方式。在软件开发中，管道编程是一种强大的编程模式，它通过将数据在不同的处理阶段进行流动，提供了一种高效、可重用和易于维护的方式来处理数据。需要模块化和可组合的代码结构：管道编程可以将整个数据处理过程划分为多个独立的阶段，每个阶段都是独立的模块，可以根据需要进行组合和重用。提升代码的复用性和可扩展性：每个处理阶段都是独立的模块，可以根据需要添加、删除或替换特定的处理阶段，实现代码的复用和灵活的扩展。
【人工智能简史】第一章 引言 —— 人工智能的概念与定义、发展背景及相关领域、意义与价值
热门推荐
AI天才研究院
04-19 1万+
人工智能作为一个概念和研究领域最早可以追溯到20世纪40年代至50年代。1956年，达特茅斯会议被认为是人工智能研究的开端。此后，人工智能经历了几次高潮与低谷，形成了今天的研究格局。在人工智能的发展过程中，学者们提出了许多重要的思想和技术。例如，图灵测试、知识表示、自然语言处理、专家系统、遗传算法、神经网络、机器学习、深度学习等。这些技术逐渐演化成为现代人工智能的基础。起初，人工智能被定义为一种模拟智能生物的计算机程序，目的是让计算机能够完成像人类一样的思维与决策。
linux系统编程之管道（一）：匿名管道（pipe)
weixin_33701564的博客
07-15 128
一，什么是管道 管道是Linux支持的最初Unix IPC形式之一，具有以下特点： 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道； 只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）； 单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独...
管道编程
Cs121
03-26 2736
管道（有名）编程-是一种进程间的通信方式。未完...... 一个典型例子：（来自网络）+自己分析。       /*led_player服务器*/ /*实现对管道/tmp/led-control的监控*/ /*并实现对led的控制*/ #include /*标准输入输出*/ #include /*标准库*/ #include /* */ #include /*输入输出控
管道式编程(收藏)
acpgil1836的博客
07-19 177
参考：https://www.cnblogs.com/hippieZhou/p/11174644.html 摘录代码: 1.定义接口 public interface IPipelineStep<INPUT, OUTPUT> { OUTPUT Process(INPUT input); } 2.实现管道一 public class Dou...
C# 管道式编程
weixin_68436326的博客
06-20 798
转自：hippieZhoucnblogs.com/hippieZhou/p/11174644.html受 F# 中的管道运算符和 C# 中的 LINQ 语法，管道式编程为 C# 提供了更加灵活性的功能性编程。通过使用 扩展函数 可以将多个功能连接起来构建成一个管道。前言在 C# 编程中，管道式编程（Pipeline Style programming）其实存在已久，最明显的就是我们经常使用的 LI...
可控制管道内动态水流及左侧融合echarts图表（并自适应屏幕）
10-13
本项目聚焦于一个特定的需求——“可控制管道内动态水流及左侧融合echarts图表（并自适应屏幕）”，这涉及到几个关键的技术点，包括动态模拟、数据可视化和响应式设计。 首先，动态模拟管道内水流是工业场景中的一...
"UPStream: 加压配水管网的自动化水力设计
2017年5月4日收到2017年7月17日收到修订版，2017年保留字：给水管网水力设计压力管网MATLABEPANETa b st ra ct在工程应用中，加压配水管网的水力设计是一个耗时的过程，需要正确选择管径以满足某些法规约束。...
qml 简易管道流动效果
04-18
QML（Qt Meta Language）是Qt框架的一部分，它提供了一种声明式编程方式，用于创建富图形用户界面。在本文中，我们将深入探讨如何使用QML实现一个简易的管道流动效果，这个效果适用于工业组态应用，能够模拟液体或...
写写这几天的心得，口腔负压，跟编程一样繁琐的实际工程
huyawang01的博客
10-30 6166
很长时间以来，我都是在公司工作之余研究一下编程的东西，完全是自学为主，难是难，但是浓厚的兴趣让我从来没有停止过对这份兴趣的热爱。我一直都是一家口腔医疗器械的小客服，但是不知道是不是我只是止步于电脑前，前两天闲来无事，跟着公司的工程部出了几趟外勤，了解了一下他们天天口中说的负压。让我从编程又了解到了另外一个世界。 口腔负压一直是我们讨论的热点，口腔治疗中，对技术的攻克必然是我们执着的追求，但是能照
C#管道式编程的介绍与实现
12-31
受 F# 中的管道运算符和 C# 中的 LINQ 语法，管道式编程为 C# 提供了更加灵活性的功能性编程。通过使用 扩展函数 可以将多个功能连接起来构建成一个管道。 前言 在 C# 编程中，管道式编程（Pipeline Style programming）其实存在已久，最明显的就是我们经常使用的 LINQ。在进入 DotNetCore 世界后， 这种编程方式就更加明显，比如各种中间件的使用。通过使用这种编程方式，大大提高了代码的可维护性，优化了的业务的组合方式。 管道式编程具有如下优点： 创建一个流畅的编程范例，将语句转换为表达式并将它们链接在一起 用线性排序替换代码嵌套 消除变
Python-用于创建具有链式函数式编程数据管道的Python库
08-12
用于创建具有链式函数式编程数据管道的Python库
管道基本介绍.go
10-06
管道基本介绍
【java】WebSocket（一）——管道式编程
哈士奇
05-17 922
一、前言      我们现在的网络发展非常迅速，就拿小编经常玩的一个游戏来说吧——英雄联盟。这个游戏就是一个5V5的团队协作的游戏。他是一种基于帧同步完成的。这里我们说的websocket是一种管道式的同步，下面小编就向大家介绍一下。二、websocket是什么？      在传统的web的BS请求响应模式下，是如何实现实时通信，实现反推送的呢？      一般的我们使用http是单向的，comet
IPC之管道编程（1）
Flypei的博客
07-30 721
1、IPCIPC：是指进程间通信（Inter Process Cnmunication）。进程间相互通信的方式主要有以下6种： （1）管道（pipe）和有名管道（FIFO）。 （2）信号（signal） （3）消息队列 （4）共享内存 （5）信号量 （6）套接字（socket）2、进行进程间通信的目的（1）数据传输：一个进程需要将它的数据发送给另一个进程。 （2）资源共享：多个进程之间
系统编程人员要学会使用管道编程
bg2bkk的专栏
07-29 1188
在看洛杉矶大学的cs635课程课件时，有一个很简单的程序，模仿linux中的cat命令的， 链接为：http://cs.usfca.edu/~cruse/cs635/ 该程序内容为： //------------------------------------------------------------------- // mycat.c // // This program shows
编程中管道的基本原理和使用
最新发布
锕琅的博客
08-30 653
管道是进程间用于通信的一种方式。创建管道的进程是管道服务器。连接到管道的进程是管道客户端。一个进程将信息写入管道，然后另一个进程从管道读取信息。本概述介绍如何创建、管理和使用管道。有两种类型的管道：匿名管道和命名管道。匿名管道比命名管道需要更少的开销，但提供的服务有限。术语“管道”通常是指信息管道。从概念上讲，管道有两端。单向管道允许一端的进程向管道写入数据，并允许另一端的进程从管道读取数据。双向管道（或称双工管道）允许进程从管道的任意一端读取和写入。
C#管道式编程实践：从介绍到实现
管道式编程的核心思想是将一个操作的结果作为另一个操作的输入，形成一个数据流的链条。这种编程范式可以帮助我们： 1. 创建流畅的编程风格，使得语句变成表达式并链接在一起，使得代码更易于理解。 2. 减少代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值