设计模式实践-原型模式

场景

使用原型模式获取命令对象

实现代码

命令对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
namespace DesignPatterns.Prototype
{
    /// <summary>
    /// 命令对象
    /// </summary>
    public class Command : PrototypeBase
    {
        /// <summary>
        /// Gets or sets 命令头
        /// </summary>
        private string _commandHeader = "固定命令头";

        /// <summary>
        /// Gets or sets 命令校验部分
        /// </summary>
        public string CommandCheck { get; set; }

        /// <summary>
        /// Gets or sets 命令内容
        /// </summary>
        public string CommandContent { get; set; }
    }
}

原型对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace DesignPatterns.Prototype
{
    /// <summary>
    /// 原型接口 
    /// </summary>
    public class PrototypeBase
    {
        /// <summary>
        /// 获取原型
        /// </summary>
        /// <returns>原型对象</returns>
        public object CloneObject()
        {
            return this.MemberwiseClone();
        }
    }
}

相关调用

1
2
3
4
Prototype.Command command = new Prototype.Command();
Prototype.Command command1 = (Prototype.Command) command.CloneObject();
Prototype.Command command2 = (Prototype.Command)command.CloneObject();
Prototype.Command command3 = (Prototype.Command)command.CloneObject()

展开全文 >>

设计模式实践-简单工厂

场景

每种仪表都实现了统一的接口，设计一个工厂，生产不同的仪表

实现代码

仪表接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表接口
    /// </summary>
    public interface IMeter
    {
        /// <summary>
        /// 显示仪表类型
        /// </summary>
        void ShowType();
    }
}

仪表A实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using System;

namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表类型A
    /// </summary>
    internal class MeterA : IMeter
    {
        /// <summary>
        /// 显示仪表类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Type A");
        }
    }
}

仪表B实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表类型B
    /// </summary>
    internal class MeterB : IMeter
    {
        /// <summary>
        /// 显示仪表类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Type B");
        }
    }
}

工厂接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 工厂接口
    /// </summary>
    public interface IMeterFactory
    {
        /// <summary>
        /// 生产仪表类型A
        /// </summary>
        /// <returns>仪表类型</returns>
        IMeter CreateMeterA();

        /// <summary>
        /// 生产仪表类型B
        /// </summary>
        /// <returns>仪表类型</returns>
        IMeter CreateMeterB();

        /// <summary>
        /// 根据需要的仪表类型生产仪表
        /// </summary>
        /// <param name="meterType">仪表类型</param>
        /// <returns>仪表对象</returns>
        IMeter CreateMeterByType(MeterType meterType);
    }
}

工厂实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表工厂类
    /// </summary>
    public class MeterFactory : IMeterFactory
    {
        /// <summary>
        /// 生产类型A仪表
        /// </summary>
        /// <returns>类型A仪表</returns>
        public IMeter CreateMeterA()
        {
            return new MeterA();
        }

        /// <summary>
        /// 生产类型B仪表
        /// </summary>
        /// <returns>类型B仪表</returns>
        public IMeter CreateMeterB()
        {
            return new MeterB();
        }
    }
}

使用枚举类型生产仪表

仪表类型枚举：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表类型枚举类
    /// </summary>
    public enum MeterType
    {
        /// <summary>
        /// 类型A 
        /// </summary>
        TypeA,

        /// <summary>
        /// 类型B 
        /// </summary>
        TypeB
    }
}

生产仪表方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
......
        /// <summary>
        /// 根据需要的仪表类型生产仪表
        /// </summary>
        /// <param name="meterType">仪表类型</param>
        /// <returns>仪表对象</returns>
        public IMeter CreateMeterByType(MeterType meterType)
        {
            switch (meterType)
            {
                case MeterType.TypeA:
                    return new MeterA();
                case MeterType.TypeB:
                    return new MeterB();
                default:
                    return null;
            }
        }
......

静态工厂

静态工厂实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
namespace DesignPatterns.SimpleFactory
{
    public static class StaticMeterFactory
    {
        public static IMeter CreateMeterA()
        {
            return new MeterA();
        }

        public static IMeter CreateMeterB()
        {
            return new MeterB();
        }

        public static IMeter CreateMeterByType(MeterType meterType)
        {
            switch (meterType)
            {
                case MeterType.TypeA:
                    return new MeterA();
                case MeterType.TypeB:
                    return new MeterB();
                default:
                    return null;
            }
        }
    }
}

相关调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
IMeterFactory meterFactory = new MeterFactory();
var meterA = meterFactory.CreateMeterA();
var meterB = meterFactory.CreateMeterB();
meterA.ShowType();
meterB.ShowType();

meterA = meterFactory.CreateMeterByType(MeterType.TypeA);
meterB = meterFactory.CreateMeterByType(MeterType.TypeB);
meterA.ShowType();
meterB.ShowType();

meterA = StaticMeterFactory.CreateMeterA();
meterB = StaticMeterFactory.CreateMeterB();
meterA.ShowType();
meterB.ShowType();

Out：

1
2
3
4
5
6
Type A
Type B
Type A
Type B
Type A
Type B

展开全文 >>

设计模式实践-状态模式

场景

仪表状态上线、发送、离线状态切换

实现代码

上下文对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
namespace DesignPatterns.State
{
    /// <summary>
    /// 维护状态类
    /// </summary>
    public class Context
    {
        /// <summary>
        /// 状态
        /// </summary>
        private IState _state;

        /// <summary>
        /// Initializes a new instance of the <see cref="Context" /> class.
        /// </summary>
        /// <param name="state">状态对象</param>
        public Context(IState state)
        {
            this._state = state;
        }

        /// <summary>
        /// 获取状态
        /// </summary>
        /// <returns>返回状态</returns>
        public IState GetState()
        {
            return this._state;
        }

        /// <summary>
        /// 设置状态
        /// </summary>
        /// <param name="state">状态</param>
        public void SetState(IState state)
        {
            this._state = state;
            if (this._state == null)
            {
                Console.WriteLine("状态为空");
                return;
            }

            Console.WriteLine("当前状态：" + this._state.GetType().ToString());
        }

        /// <summary>
        /// 请假
        /// </summary>
        public void Request()
        {
            this._state.Handle(this);
        }
    }
}

在线状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace DesignPatterns.State
{
    /// <summary>
    /// 在线状态
    /// </summary>
    public class OnlineState : IState
    {
        /// <summary>
        /// 在线状态下执行上下文
        /// </summary>
        /// <param name="context">上下文对象</param>
        public void Handle(Context context)
        {
            context.SetState(new SendState());
        }
    }
}

发送状态对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace DesignPatterns.State
{
    /// <summary>
    /// 发送状态
    /// </summary>
    public class SendState : IState
    {
        /// <summary>
        /// 发送状态下执行上下文
        /// </summary>
        /// <param name="context">上下文对象</param>
        public void Handle(Context context)
        {
            context.SetState(new Offline());
        }
    }
}

下线状态对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
namespace DesignPatterns.State
{
    /// <summary>
    /// 离线状态
    /// </summary>
    public class Offline : IState
    {
        /// <summary>
        /// 离线状态下执行上下文
        /// </summary>
        /// <param name="context">上下文对象</param>
        public void Handle(Context context)
        {
            Console.WriteLine("状态结束");
            context.SetState(null);
        }
    }
}

相关调用

1
2
3
4
5
IState state = new OnlineState();
Context context = new Context(state);
context.Request();
context.Request();
context.Request();

Out:

1
2
3
4
当前状态：DesignPatterns.State.SendState
当前状态：DesignPatterns.State.Offline
状态结束
状态为空

展开全文 >>

设计模式实践-策略模式

场景

使用不同策略封装命令

实现代码

命令封装接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace DesignPatterns.Strategy
{
    /// <summary>
    /// 命令封装接口
    /// </summary>
    public interface IPacket
    {
        /// <summary>
        /// 分装数据
        /// </summary>
        /// <returns>数据对象</returns>
        void Packet();
    }
}

抽象命令封装类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
namespace DesignPatterns.Strategy
{
    /// <summary>
    /// 命名打包抽象类
    /// </summary>
    public abstract class AbstractPacket
    {
        /// <summary>
        /// 命令长度
        /// </summary>
        protected int Len;

        /// <summary>
        /// 命令数组
        /// </summary>
        protected byte[] Datas = new byte[256];

        /// <summary>
        /// 获取命令长度
        /// </summary>
        /// <returns></returns>
        public int GetLen()
        {
            return this.Len;
        }

        /// <summary>
        /// 获取命令
        /// </summary>
        /// <returns></returns>
        public byte[] GetDatas()
        {
            return this.Datas;
        }
    }
}

命令A封装实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
namespace DesignPatterns.Strategy
{
    /// <summary>
    /// A命令打包类
    /// </summary>
    public class PacketA : AbstractPacket, IPacket
    {
        /// <summary>
        /// 打包命令
        /// </summary>
        public void Packet()
        {
            this.Len = 20;
            for (int i = 0; i < this.Len; i++)
            {
                this.Datas[i] = 0x00;
            }
        }
    }
}

命令B封装实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
namespace DesignPatterns.Strategy
{
    /// <summary>
    /// B命令打包类
    /// </summary>
    public class PacketB : AbstractPacket, IPacket
    {
        /// <summary>
        /// 打包命令
        /// </summary>
        public void Packet()
        {
            this.Len = 50;
            for (int i = 0; i < this.Len; i++)
            {
                this.Datas[i] = 0x10;
            }
        }
    }
}

相关调用

1
2
3
4
5
6
IPacket packetA = new PacketA();
IPacket packetB = new PacketB();
packetA.Packet();
packetB.Packet();
Console.WriteLine(((AbstractPacket)packetA).GetLen());
Console.WriteLine(((AbstractPacket)packetB).GetLen());

Out:

1
2
20
50

展开全文 >>

设计模式实践-访问者模式

场景

访问仪表对象和传感器对象

实现代码

访问者接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
namespace DesignPatterns.Visitor
{
    /// <summary>
    /// 访问者接口
    /// </summary>
    public interface IVisitor
    {
        /// <summary>
        /// 访问仪表对象
        /// </summary>
        /// <param name="meter">仪表对象</param>
        void Visit(Meter meter);

        /// <summary>
        /// 访问温度传感器对象
        /// </summary>
        /// <param name="tempSensor">温度传感器</param>
        void Visit(TempSensor tempSensor);

        /// <summary>
        /// 访问压力传感器
        /// </summary>
        /// <param name="pressSensor">压力传感器</param>
        void Visit(PressSensor pressSensor);
    }
}

访问者实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
namespace DesignPatterns.Visitor
{
    /// <summary>
    /// 访问者模式
    /// </summary>
    public class Visitor : IVisitor
    {
        public void Visit(Meter meter)
        {
            Console.WriteLine($"获取仪表数据：{meter.GetData()}");
        }

        public void Visit(TempSensor tempSensor)
        {
            Console.WriteLine($"获取仪表数据：{tempSensor.GetData()}");
        }

        public void Visit(PressSensor pressSensor)
        {
            Console.WriteLine($"获取仪表数据：{pressSensor.GetData()}");
        }
    }
}

被访问对象接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace DesignPatterns.Visitor
{
    /// <summary>
    /// 需要访问的对象接口
    /// </summary>
    public interface ISubject
    {
        /// <summary>
        /// 接受访问者
        /// </summary>
        /// <param name="visitor">访问者对象</param>
        void Accept(IVisitor visitor);
    }
}

仪表对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
namespace DesignPatterns.Visitor
{
    /// <summary>
    /// 仪表对象
    /// </summary>
    public class Meter : ISubject
    {
        /// <summary>
        /// 获取仪表数据
        /// </summary>
        /// <returns>仪表数据</returns>
        public string GetData()
        {
            return "仪表数据";
        }

        /// <summary>
        /// 接受访问者
        /// </summary>
        /// <param name="visitor">仪表访问者对象</param>
        public void Accept(IVisitor visitor)
        {
            visitor.Visit(this);
        }
    }
}

温度传感器对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
namespace DesignPatterns.Visitor
{
    /// <summary>
    /// 温度传感器类
    /// </summary>
    public class TempSensor : ISubject
    {
        /// <summary>
        /// 获取温度
        /// </summary>
        /// <returns>温度数据</returns>
        public string GetData()
        {
            return "温度";
        }

        /// <summary>
        /// 接受访问者
        /// </summary>
        /// <param name="visitor">温度传感器访问者对象</param>
        public void Accept(IVisitor visitor)
        {
            visitor.Visit(this);
        }
    }
}

压力传感器对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
namespace DesignPatterns.Visitor
{
    /// <summary>
    /// 压力传感器类
    /// </summary>
    public class PressSensor : ISubject
    {
        /// <summary>
        /// 获取压力值
        /// </summary>
        /// <returns>压力值</returns>
        public string GetData()
        {
            return "压力";
        }

        /// <summary>
        /// 访问者对象
        /// </summary>
        /// <param name="visitor">压力传感器访问者对象</param>
        public void Accept(IVisitor visitor)
        {
            visitor.Visit(this);
        }
    }
}

相关调用

1
2
3
4
5
6
7
8
Visitor.Meter meter = new Visitor.Meter();
Visitor.PressSensor pressSensor = new PressSensor();
Visitor.TempSensor tempSensor = new TempSensor();

IVisitor visitor = new Visitor.Visitor();
meter.Accept(visitor);
pressSensor.Accept(visitor); 
tempSensor.Accept(visitor);

Out:

1
2
3
获取仪表数据：仪表数据
获取仪表数据：压力
获取仪表数据：温度

展开全文 >>

设计模式实践-模版方法模式

场景

解析不同协议

实现代码

协议解析抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
namespace DesignPatterns.TemplateMethod
{
    /// <summary>
    /// 抽象解包类
    /// </summary>
    public abstract class AbstractUnpack
    {
        /// <summary>
        /// 解析数据
        /// </summary>
        public abstract void UnpackData();

        /// <summary>
        /// 解包地址
        /// </summary>
        protected void UnpackAddress()
        {
            Console.WriteLine("解包地址");
        }

        /// <summary>
        /// 校验数据
        /// </summary>
        protected void CheckData()
        {
            Console.WriteLine("验证CRC");
        }
    }
}

A协议解析类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
namespace DesignPatterns.TemplateMethod
{
    /// <summary>
    /// A协议解包类
    /// </summary>
    public class UnpackA : AbstractUnpack
    {
        /// <summary>
        /// 解包数据
        /// </summary>
        public override void UnpackData()
        {
            this.UnpackAddress();
            this.CheckData();
            Console.WriteLine("解包A协议数据");
        }
    }
}

B协议解析类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
namespace DesignPatterns.TemplateMethod
{
    /// <summary>
    /// B协议解包类
    /// </summary>
    public class UnpackB : AbstractUnpack
    {
        /// <summary>
        /// 解包数据
        /// </summary>
        public override void UnpackData()
        {
            this.UnpackAddress();
            this.CheckData();
            Console.WriteLine("解包A协议数据");
        }
    }
}

相关调用

1
2
3
4
AbstractUnpack unpackA = new UnpackA();
AbstractUnpack unpackB = new UnpackB();
unpackA.UnpackData();
unpackB.UnpackData();

Out:

1
2
3
4
5
6
解包地址
验证CRC
解包A协议数据
解包地址
验证CRC
解包A协议数据

展开全文 >>

设计模式实践-抽象工厂

场景

定义厂家接口，每个厂家可以生产自己的仪表和传感器

实现代码

仪表接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace DesignPatterns.FactoryBase
{
    /// <summary>
    /// 仪表接口
    /// </summary>
    public interface IMeter
    {
        /// <summary>
        /// 显示仪表类型
        /// </summary>
        void ShowType();
    }
}

仪表A实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using System;

namespace DesignPatterns.FactoryBase
{
    /// <summary>
    /// 仪表类型A
    /// </summary>
    internal class MeterA : IMeter
    {
        /// <summary>
        /// 显示仪表类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Type A");
        }
    }
}

仪表B实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatterns.FactoryBase
{
    /// <summary>
    /// 仪表类型B
    /// </summary>
    internal class MeterB : IMeter
    {
        /// <summary>
        /// 显示仪表类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Type B");
        }
    }
}

传感器接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatterns.FactoryBase
{
    /// <summary>
    /// 传感器接口
    /// </summary>
    public interface ISensor
    {
        /// <summary>
        /// 显示传感器类型
        /// </summary>
        void ShowType();
    }
}

传感器A实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatterns.FactoryBase
{
    /// <summary>
    /// 传感器类型A
    /// </summary>
    internal class SensorA : ISensor
    {
        /// <summary>
        /// 显示传感器类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Sensor A");
        }
    }
}

传感器B实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatterns.FactoryBase
{
    /// <summary>
    /// 传感器类型B
    /// </summary>
    internal class SensorB : ISensor
    {
        /// <summary>
        /// 显示传感器类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Sensor B");
        }
    }
}

工厂接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using DesignPatterns.FactoryBase;

namespace DesignPatterns.AbstarctFactory
{
    /// <summary>
    /// 工厂接口
    /// </summary>
    public interface IFactory
    {
        /// <summary>
        /// 生产仪表
        /// </summary>
        /// <returns>仪表类型</returns>
        IMeter CreateMeter();

        /// <summary>
        /// 生产传感器
        /// </summary>
        /// <returns>传感器类型</returns>
        ISensor CreateSensor();
    }
}

A工厂实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DesignPatterns.FactoryBase;

namespace DesignPatterns.AbstarctFactory
{
    /// <summary>
    /// A工厂类
    /// </summary>
    public class FactoryA : IFactory
    {
        /// <summary>
        /// 生产仪表
        /// </summary>
        /// <returns>仪表类型A</returns>
        public IMeter CreateMeter()
        {
            return new MeterA();
        }

        /// <summary>
        /// 生产传感器
        /// </summary>
        /// <returns>传感器类型A</returns>
        public ISensor CreateSensor()
        {
            return new SensorA();
        }
    }
}

B工厂实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DesignPatterns.FactoryBase;

namespace DesignPatterns.AbstarctFactory
{
    /// <summary>
    /// B工厂类型
    /// </summary>
    public class FactoryB : IFactory
    {
        /// <summary>
        /// 生产仪表
        /// </summary>
        /// <returns>仪表类型B</returns>
        public IMeter CreateMeter()
        {
            return new MeterB();
        }

        /// <summary>
        /// 生产传感器
        /// </summary>
        /// <returns>传感器类型B</returns>
        public ISensor CreateSensor()
        {
            return new SensorB();
        }
    }
}

相关调用

1
2
3
4
5
6
7
8
9
10
11
12
var factoryA = new FactoryA();
      var factoryB = new FactoryB();

      var meterA = factoryA.CreateMeter();
      var sensorA = factoryA.CreateSensor();
      meterA.ShowType();
      sensorA.ShowType();

      var meterB = factoryB.CreateMeter();
      var sensorB = factoryB.CreateSensor();
      meterB.ShowType();
      sensorB.ShowType();

Out：

1
2
3
4
Meter A
Sensor A
Meter B
Sensor B

展开全文 >>

设计模式实践-桥接模式

场景

M每种仪表可选N种通信方式

实现代码

通信器接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace DesignPatterns.Bridge
{
    /// <summary>
    /// 通信器接口
    /// </summary>
    public interface ICommunicator
    {
        /// <summary>
        /// 发送信息
        /// </summary>
        /// <param name="message">信息内容</param>
        void Communicate(string message);
    }
}

串口通信实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace DesignPatterns.Bridge
{
    /// <summary>
    /// 串口通信器
    /// </summary>
    internal class SerialCommunicator : ICommunicator
    {
        /// <summary>
        /// 向串口发送信息
        /// </summary>
        /// <param name="message">信息内容</param>
        public void Communicate(string message)
        {
            Console.WriteLine($"使用串口通信，通信内容为：{message}");
        }
    }
}

TCP通信实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace DesignPatterns.Bridge
{
    /// <summary>
    /// TCP通信器
    /// </summary>
    internal class TcpCommunicator : ICommunicator
    {
        /// <summary>
        /// 向TCP发送信息
        /// </summary>
        /// <param name="message">信息内容</param>
        public void Communicate(string message)
        {
            Console.WriteLine($"使用TCP通信，通信内容为：{message}");
        }
    }
}

仪表接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace DesignPatterns.Bridge
{
    /// <summary>
    /// 仪表接口
    /// </summary>
    internal interface IMeter
    {
        /// <summary>
        /// 仪表通信函数
        /// </summary>
        /// <param name="communicator">通信器</param>
        void UseCommunicator(ICommunicator communicator);
    }
}

仪表A实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace DesignPatterns.Bridge
{
    /// <summary>
    /// 仪表A实现
    /// </summary>
    internal class MeterA : IMeter
    {
        /// <summary>
        /// 仪表A通信实现
        /// </summary>
        /// <param name="communicator">通信器</param>
        public void UseCommunicator(ICommunicator communicator)
        {
            communicator.Communicate("A类仪表数据");
        }
    }
}

仪表B实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace DesignPatterns.Bridge
{
    /// <summary>
    /// 仪表B接口
    /// </summary>
    internal class MeterB : IMeter
    {
        /// <summary>
        /// 仪表B通信实现
        /// </summary>
        /// <param name="communicator">通信器</param>
        public void UseCommunicator(ICommunicator communicator)
        {
            communicator.Communicate("B类仪表数据");
        }
    }
}

相关调用

1
2
3
4
5
6
7
8
9
10
IMeter meterA = new MeterA();
IMeter meterB = new MeterB();
ICommunicator tcpSender = new TcpCommunicator();
ICommunicator serialSender = new SerialCommunicator();

meterA.UseCommunicator(tcpSender);
meterA.UseCommunicator(serialSender);

meterB.UseCommunicator(tcpSender);
meterB.UseCommunicator(serialSender);

Out

1
2
3
4
使用TCP通信，通信内容为：A类仪表数据
使用串口通信，通信内容为：A类仪表数据
使用TCP通信，通信内容为：B类仪表数据
使用串口通信，通信内容为：B类仪表数据

展开全文 >>

设计模式实践-Builder

场景

根据不同的指挥者构建不同的命令内容

实现代码

命令类：

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace DesignPatterns.Builder
{
    /// <summary>
    /// 命令类型
    /// </summary>
    public class Command
    {
        /// <summary>
        /// Gets or sets 命令内容
        /// </summary>
        public string Content { get; set; }
    }
}

命令建造者接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
namespace DesignPatterns.Builder
{
    /// <summary>
    ///     命令构建者接口
    /// </summary>
    internal interface ICommandBuilder
    {
        /// <summary>
        ///     构建报头
        /// </summary>
        void BuildHeader();

        /// <summary>
        ///     构建报文
        /// </summary>
        void BuildPackets();

        /// <summary>
        ///     在尾部添加CRC校验
        /// </summary>
        void BuildEndByCrc();

        /// <summary>
        ///     在尾部添加奇偶校验
        /// </summary>
        void BuildEndByOddEven();

        /// <summary>
        ///     获取命令
        /// </summary>
        /// <returns>命令对象</returns>
        Command GetCommand();
    }
}

命令建造者实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
namespace DesignPatterns.Builder
{
    /// <summary>
    /// 命令构造者实现类
    /// </summary>
    internal class CommandBuilder : ICommandBuilder
    {
        /// <summary>
        /// 命令对象
        /// </summary>
        private Command _command;

        /// <summary>
        /// 构建命令头
        /// </summary>
        public void BuildHeader()
        {
            this._command = new Command
            {
                Content = "报文头|"
            };
        }

        /// <summary>
        /// 构建命令内容
        /// </summary>
        public void BuildPackets()
        {
            this._command.Content += "报文内容|";
        }

        /// <summary>
        /// 构建CRC校验
        /// </summary>
        public void BuildEndByCrc()
        {
            this._command.Content += "CRC校验";
        }

        /// <summary>
        /// 构建奇偶校验
        /// </summary>
        public void BuildEndByOddEven()
        {
            this._command.Content += "奇偶校验";
        }

        /// <summary>
        /// 获取命令
        /// </summary>
        /// <returns>命令对象</returns>
        public Command GetCommand()
        {
            return this._command;
        }
    }
}

指挥者接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace DesignPatterns.Builder
{
    /// <summary>
    /// 指挥者接口
    /// </summary>
    public interface IDirector
    {
        /// <summary>
        /// 指挥建造
        /// </summary>
        /// <returns>命令对象</returns>
        Command Constuct();
    }
}

指挥者A实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatterns.FactoryBase
{
    /// <summary>
    /// 传感器类型A
    /// </summary>
    internal class SensorA : ISensor
    {
        /// <summary>
        /// 显示传感器类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Sensor A");
        }
    }
}

指挥者B实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatterns.FactoryBase
{
    /// <summary>
    /// 传感器类型B
    /// </summary>
    internal class SensorB : ISensor
    {
        /// <summary>
        /// 显示传感器类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Sensor B");
        }
    }
}

相关调用

1
2
3
4
5
6
DirectorA directorA = new DirectorA(new CommandBuilder());
DirectorB directorB = new DirectorB(new CommandBuilder());
var commandA = directorA.Constuct();
var commandB = directorB.Constuct();
Console.WriteLine(commandA.Content);
Console.WriteLine(commandB.Content);

Out：

1
2
报文头|报文内容|CRC校验
报文头|报文内容|奇偶校验

展开全文 >>

设计模式实践-责任链模式

场景

权限递推

实现代码

处理抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
namespace DesignPatterns.ChainResponsibility
{
    /// <summary>
    /// 处理者抽象类
    /// </summary>
    public abstract class Handler
    {
        /// <summary>
        /// 上级处理者
        /// </summary>
        protected Handler Successor;

        /// <summary>
        /// Initializes a new instance of the <see cref="Handler" /> class.
        /// </summary>
        /// <param name="successor">上级处理者</param>
        protected Handler(Handler successor)
        {
            this.Successor = successor;
        }

        /// <summary>
        /// 处理动作
        /// </summary>
        /// <param name="request">请求代码</param>
        public abstract void HandleRequest(int request);
    }
}

经理处理类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
namespace DesignPatterns.ChainResponsibility
{
    /// <summary>
    /// 经理
    /// </summary>
    public class ManagerHandler : Handler
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ManagerHandler" /> class.
        /// </summary>
        /// <param name="successor">经理上级</param>
        public ManagerHandler(Handler successor) : base(successor)
        {
        }

        /// <summary>
        /// 经理处理动作
        /// </summary>
        /// <param name="request">请求代码</param>
        public override void HandleRequest(int request)
        {
            if (request > 100)
            {
                Console.WriteLine("权限不足，由上级处理");
                this.Successor.HandleRequest(request);
            }
            else
            {
                Console.WriteLine($"由经理处理：{request}");
            }
        }
    }
}

Boss处理类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
namespace DesignPatterns.ChainResponsibility
{
    /// <summary>
    /// 老板
    /// </summary>
    public class BossHandler : Handler
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="BossHandler" /> class.
        /// </summary>
        /// <param name="successor">老板上级，为null</param>
        public BossHandler(Handler successor) : base(successor)
        {
        }

        /// <summary>
        /// 经理处理动作
        /// </summary>
        /// <param name="request">请求代码</param>
        public override void HandleRequest(int request)
        {
            Console.WriteLine($"由老板处理：{request}");
        }
    }
}

相关调用

1
2
3
4
Handler bossHandler = new BossHandler(null);
Handler managerHandler = new ManagerHandler(bossHandler);
managerHandler.HandleRequest(50);
managerHandler.HandleRequest(200);

Out

1
2
3
由经理处理：50
权限不足，由上级处理
由老板处理：200

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

那年二十七