设计模式实践-工厂模式

场景

没种仪表工厂都实现了生产仪表的接口，不同的工厂生产不同仪表

实现代码

仪表接口：

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
using DesignPatterns.FactoryBase;

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

A工厂实现：

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

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

B工厂实现：

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

namespace DesignPatterns.Factory
{
    /// <summary>
    /// 仪表B工厂类
    /// </summary>
    public class MeterBFactory : IMeterFactory
    {
        /// <summary>
        /// 生产类型B仪表
        /// </summary>
        /// <returns>类型B仪表</returns>
        public IMeter CreateMeter()
        {
            return new MeterA();
        }
    }
}

相关调用

1
2
3
4
5
6
IMeterFactory meterAFactory = new MeterAFactory();
   IMeterFactory meterBFactory = new MeterBFactory();
   var meterA = meterAFactory.CreateMeter();
   var meterB = meterBFactory.CreateMeter();
   meterA.ShowType();
   meterB.ShowType();

Out：

1
2
Type A
Type B

展开全文 >>

设计模式实践-享元模式

场景

通过享元模式获取仪表对象

实现代码

享元接口

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace DesignPatterns.Flyweight
{
    /// <summary>
    /// 仪表享元接口
    /// </summary>
    public interface IFlyweight
    {
        /// <summary>
        /// 业务逻辑
        /// </summary>
        void Do();
    }
}

仪表对象

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
namespace DesignPatterns.Flyweight
{
    /// <summary>
    /// 仪表享元对象
    /// </summary>
    public class MeterFlyweight : IFlyweight
    {
        /// <summary>
        /// 外部状态id
        /// </summary>
        private string _idShare;

        /// <summary>
        /// 内部状态id
        /// </summary>
        private int _id;

        /// <summary>
        ///  Initializes a new instance of the <see cref="MeterFlyweight" /> class.
        /// </summary>
        /// <param name="id">仪表id</param>
        public MeterFlyweight(int id)
        {
            this._id = id;
            this._idShare = string.Format($"{id}_share");
            Console.WriteLine($"in MeterFlyweight, id: {this._id}");
        }

        /// <summary>
        /// 获取外部状态ID
        /// </summary>
        public string GetShareId => this._idShare;

        /// <summary>
        /// 获取内部状态ID
        /// </summary>
        public int GetId => this._id;

        /// <summary>
        /// 业务逻辑
        /// </summary>
        public void Do()
        {
            Console.WriteLine($"The id of meter is {this._id}");
        }
    }
}

非共享对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
namespace DesignPatterns.Flyweight
{
    /// <summary>
    /// 非共享仪表对象
    /// </summary>
    public class UnsharedMeterFlyweight : IFlyweight
    {
        /// <summary>
        /// 业务逻辑
        /// </summary>
        public void Do()
        {
            Console.WriteLine($"Unshared meter.");
        }
    }
}

享元工厂

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
namespace DesignPatterns.Flyweight
{
    /// <summary>
    /// 享元工厂
    /// </summary>
    public class FlyweightFactory
    {
        /// <summary>
        /// 享元集合
        /// </summary>
        private Dictionary<string, IFlyweight> _flyweights = new Dictionary<string, IFlyweight>();

        /// <summary>
        /// 获取享元仪表
        /// </summary>
        /// <param name="id">仪表ID</param>
        /// <returns>享元仪表接口</returns>
        public IFlyweight GetMeter(int id)
        {
            IFlyweight meter = null;
            if (!this._flyweights.TryGetValue($"{id}_share", out meter))
            {
                meter = new MeterFlyweight(id);
                this._flyweights.Add(((MeterFlyweight)meter).GetShareId, meter);
            }

            return meter;
        }
    }
}

相关调用

1
2
3
4
5
6
7
8
9
FlyweightFactory factory = new FlyweightFactory();
var meter1 = factory.GetMeter(1);
meter1.Do();
var meter2 = factory.GetMeter(2);
meter2.Do();
var meter3 = factory.GetMeter(3);
meter3.Do();
var meter4 = factory.GetMeter(1);
meter4.Do();

Out

1
2
3
4
5
6
7
in MeterFlyweight, id: 1
The id of meter is 1
in MeterFlyweight, id: 2
The id of meter is 2
in MeterFlyweight, id: 3
The id of meter is 3
The id of meter is 1

展开全文 >>

设计模式实践-迭代器模式

场景

实现迭代器模式，迭代仪表集合

实现代码

迭代器接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 迭代器接口
    /// </summary>
    public interface IIterator
    {
        /// <summary>
        /// 获取下一个
        /// </summary>
        /// <returns>仪表接口对象</returns>
        Meter Next();
    }
}

仪表迭代器实现

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
namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 仪表迭代器类
    /// </summary>
    public class MeterIterator : IIterator
    {
        /// <summary>
        /// 仪表聚合类
        /// </summary>
        private MeterAggregate _meterAggregate;

        /// <summary>
        /// 当前索引
        /// </summary>
        private int _current = -1;

        /// <summary>
        /// Initializes a new instance of the <see cref="MeterIterator" /> class.
        /// </summary>
        /// <param name="meterAggregate">仪表聚合类</param>
        public MeterIterator(MeterAggregate meterAggregate)
        {
            this._meterAggregate = meterAggregate;
        }

        /// <summary>
        /// 获取下个仪表
        /// </summary>
        /// <returns>仪表对象</returns>
        public Meter Next()
        {
            this._current++;
            return this._current >= this._meterAggregate.Count ? null : this._meterAggregate[this._current];
        }
    }
}

仪表聚合接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 仪表接口
    /// </summary>
    public interface IMeterAggregate
    {
        /// <summary>
        /// 创建迭代器
        /// </summary>
        /// <returns>迭代器</returns>
        IIterator CreateIterator();
    }
}

仪表聚合实现

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
namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 仪表实现类
    /// </summary>
    public class MeterAggregate : IMeterAggregate
    {
        /// <summary>
        /// 仪表集合
        /// </summary>
        private readonly IList<Meter> _meters = new List<Meter>();

        /// <summary>
        /// 获取仪表数量
        /// </summary>
        public int Count => this._meters.Count;
        
        /// <summary>
        /// 申明索引
        /// </summary>
        /// <param name="index">索引号</param>
        /// <returns>仪表对象</returns>
        public Meter this[int index]
        {
            get
            {
                return this._meters[index];
            }

            set
            {
                this._meters.Insert(index, value);
            }
        }

        /// <summary>
        /// 创建一个迭代器
        /// </summary>
        /// <returns>迭代器对象</returns>
        public IIterator CreateIterator()
        {
            return new MeterIterator(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
27
28
29
30
namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 仪表对象
    /// </summary>
    public class Meter
    {
        /// <summary>
        /// 仪表ID
        /// </summary>
        private int _id;

        /// <summary>
        /// Initializes a new instance of the <see cref="Meter" /> class.
        /// </summary>
        /// <param name="id">仪表id</param>
        public Meter(int id)
        {
            this._id = id;
        }

        /// <summary>
        /// 仪表动作
        /// </summary>
        public void Action()
        {
            Console.WriteLine($"MeterId: {this._id}");
        }
    }
}

相关调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Iterator.Meter meter1 = new Iterator.Meter(1);
Iterator.Meter meter2 = new Iterator.Meter(2);
Iterator.Meter meter3 = new Iterator.Meter(3);
Iterator.Meter meter4 = new Iterator.Meter(4);
Iterator.Meter meter5 = new Iterator.Meter(5);
Iterator.MeterAggregate meterAggregate = new Iterator.MeterAggregate();
meterAggregate[0] = meter1;
meterAggregate[1] = meter2;
meterAggregate[2] = meter3;
meterAggregate[3] = meter4;
meterAggregate[4] = meter5;

Iterator.MeterIterator meterIterator = new MeterIterator(meterAggregate);
while (true)
{
    var meter = meterIterator.Next();
    if (meter == null)
        break;
    meter.Action();
}

Out：

1
2
3
4
5
MeterId: 1
MeterId: 2
MeterId: 3
MeterId: 4
MeterId: 5

展开全文 >>

设计模式实践-中介者模式

场景

不同设备对象间通信

实现代码

中介者接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
namespace DesignPatterns.Mediator
{
    /// <summary>
    /// 中介者接口
    /// </summary>
    public interface IMediator
    {
        /// <summary>
        /// 向设备发送消息
        /// </summary>
        /// <param name="message">消息体</param>
        /// <param name="device">设备对象</param>
        void Send(string message, IDevice device);
    }
}

中介者实现

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
namespace DesignPatterns.Mediator
{
    /// <summary>
    /// 中介者
    /// </summary>
    public class Mediator : IMediator
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Mediator" /> class.
        /// </summary>
        public Mediator()
        {
        }

        /// <summary>
        /// Gets or sets 设备A对象
        /// </summary>
        public DeviceA DeviceA { get; set; }

        /// <summary>
        /// Gets or sets 设备B对象
        /// </summary>
        public DeviceB DeviceB { get; set; }

        /// <summary>
        /// 向设备发送数据
        /// </summary>
        /// <param name="message">消息体</param>
        /// <param name="device">设备对象</param>
        public void Send(string message, IDevice device)
        {
            if (device == this.DeviceA)
            {
                this.DeviceB.Notify(message);
            }
            else
            {
                this.DeviceA.Notify(message);
            }
        }
    }
}

设备接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
namespace DesignPatterns.Mediator
{
    /// <summary>
    /// 设备接口
    /// </summary>
    public interface IDevice
    {
        /// <summary>
        /// 接受消息
        /// </summary>
        /// <param name="message">消息体</param>
        void Notify(string message);

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="message">消息体</param>
        void Send(string message);
    }
}

设备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
34
35
36
37
38
39
40
namespace DesignPatterns.Mediator
{
    /// <summary>
    /// 设备A对象
    /// </summary>
    public class DeviceA : IDevice
    {
        /// <summary>
        /// 中介者对象
        /// </summary>
        private Mediator _mediator;

        /// <summary>
        /// Initializes a new instance of the <see cref="DeviceA" /> class.
        /// </summary>
        /// <param name="mediator">中介者对象</param>
        public DeviceA(Mediator mediator)
        {
            this._mediator = mediator;
        }

        /// <summary>
        /// 接收消息提示
        /// </summary>
        /// <param name="message">消息</param>
        public void Notify(string message)
        {
            Console.WriteLine($"Get message in A: {message}");
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="message">消息体</param>
        public void Send(string message)
        {
            this._mediator.Send(message, this);
        }
    }
}

设备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
namespace DesignPatterns.Mediator
{
    /// <summary>
    /// 设备A对象
    /// </summary>
    public class DeviceB : IDevice
    {
        /// <summary>
        /// 中介者对象
        /// </summary>
        private Mediator _mediator;

        /// <summary>
        /// Initializes a new instance of the <see cref="DeviceB" /> class.
        /// </summary>
        /// <param name="mediator">中介者对象</param>
        public DeviceB(Mediator mediator)
        {
            this._mediator = mediator;
        }

        /// <summary>
        /// 接收消息提示
        /// </summary>
        /// <param name="message">消息</param>
        public void Notify(string message)
        {
            Console.WriteLine($"Get message in B: {message}");
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="message">消息体</param>
        public void Send(string message)
        {
            this._mediator.Send(message, this);
        }
    }
}

相关调用

1
2
3
4
5
6
7
Mediator.Mediator mediator = new Mediator.Mediator();
DeviceA deviceA = new DeviceA(mediator);
DeviceB deviceB = new DeviceB(mediator);
mediator.DeviceA = deviceA;
mediator.DeviceB = deviceB;
deviceA.Send("发送消息");
deviceB.Send("发送消息");

Out：

1
2
Get message in B: 发送消息
Get message in 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
namespace DesignPatterns.Memento
{
    /// <summary>
    ///     配置文件类型
    /// </summary>
    public class ServerConfig
    {
        /// <summary>
        ///     Gets or sets IP
        /// </summary>
        public string Ip { get; set; }

        /// <summary>
        ///     Gets or sets Port
        /// </summary>
        public uint Port { get; set; }

        /// <summary>
        /// 重写ToString函数
        /// </summary>
        /// <returns>输出字符串</returns>
        public override string ToString()
        {
            return string.Format($"Ip: {this.Ip}, Port: {this.Port}");
        }
    }
}

配置拥有者类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
namespace DesignPatterns.Memento
{
    /// <summary>
    /// 需要做备忘的类
    /// </summary>
    public class Original
    {
        /// <summary>
        /// Gets or sets 服务器配置
        /// </summary>
        public ServerConfig ServerConfig { get; set; }

        /// <summary>
        /// 创建配置备忘
        /// </summary>
        /// <returns>配置备忘</returns>
        public ConfigMemento CreateMemento()
        {
            return new ConfigMemento(this.ServerConfig);
        }
    }
}

配置备忘类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
namespace DesignPatterns.Memento
{
    /// <summary>
    /// 配置备忘
    /// </summary>
    public class ConfigMemento
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ConfigMemento" /> class.
        /// </summary>
        /// <param name="serverConfig">配置文件对象</param>
        public ConfigMemento(ServerConfig serverConfig)
        {
            this.ServerConfig = serverConfig;
        }

        /// <summary>
        /// Gets or sets 配置文件
        /// </summary>
        public ServerConfig ServerConfig { 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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
namespace DesignPatterns.Memento
{
    /// <summary>
    /// 配置残酷
    /// </summary>
    public class ConfigStorage
    {
        /// <summary>
        /// 配置列表
        /// </summary>
        private readonly List<ConfigMemento> _configMementoes = new List<ConfigMemento>();

        /// <summary>
        /// 当前索引
        /// </summary>
        private int _current = -1;

        /// <summary>
        /// 设置配置项
        /// </summary>
        /// <param name="config">配置备忘</param>
        public void SetMemento(ConfigMemento config)
        {
            this._current ++;
            this._configMementoes.Add(config);
        }

        /// <summary>
        /// 重做
        /// </summary>
        /// <returns>配置项</returns>
        public ConfigMemento Do()
        {
            if (this._configMementoes.Count < 0)
                return null;
            if (this._current < 0 || this._current >= (this._configMementoes.Count - 1)) return null;
            this._current ++;
            return this._configMementoes[this._current];
        }

        /// <summary>
        /// 撤销
        /// </summary>
        /// <returns>配置项</returns>
        public ConfigMemento Undo()
        {
            if (this._configMementoes.Count < 0)
                return null;
            if (this._current <= 0 || this._current > (this._configMementoes.Count - 1)) return null;
            this._current--;
            return this._configMementoes[this._current];
        }
    }
}

相关调用

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
58
59
60
Original original = new Original();
original.ServerConfig = new ServerConfig
{
    Ip = "192.168.1.1",
    Port = 5000
}; ;
ConfigStorage configStorage = new ConfigStorage();
configStorage.SetMemento(original.CreateMemento());
original.ServerConfig = new ServerConfig
{
    Ip = "192.168.1.2",
    Port = 6000
}; 
configStorage.SetMemento(original.CreateMemento());
original.ServerConfig = new ServerConfig
{
    Ip = "192.168.2.1",
    Port = 1000
};
configStorage.SetMemento(original.CreateMemento());
original.ServerConfig = new ServerConfig
{
    Ip = "192.168.1.1",
    Port = 3000
}; 
configStorage.SetMemento(original.CreateMemento());
original.ServerConfig = new ServerConfig
{
    Ip = "192.168.1.127",
    Port = 5000
};
configStorage.SetMemento(original.CreateMemento());

var memento = configStorage.Undo();
Console.WriteLine(memento.ServerConfig.ToString());
memento = configStorage.Undo();
Console.WriteLine(memento.ServerConfig.ToString());
memento = configStorage.Undo();
Console.WriteLine(memento.ServerConfig.ToString());
memento = configStorage.Undo();
Console.WriteLine(memento.ServerConfig.ToString());
Console.WriteLine("---------------------");
memento = configStorage.Do();
Console.WriteLine(memento.ServerConfig.ToString());
memento = configStorage.Do();
Console.WriteLine(memento.ServerConfig.ToString());
memento = configStorage.Do();
Console.WriteLine(memento.ServerConfig.ToString());
memento = configStorage.Do();
Console.WriteLine(memento.ServerConfig.ToString());

Console.WriteLine("----------------");
memento = configStorage.Undo();
Console.WriteLine(memento.ServerConfig.ToString());
memento = configStorage.Undo();
Console.WriteLine(memento.ServerConfig.ToString());
memento = configStorage.Undo();
Console.WriteLine(memento.ServerConfig.ToString());
memento = configStorage.Undo();
Console.WriteLine(memento.ServerConfig.ToString());

Out：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Ip: 192.168.1.1, Port: 3000
Ip: 192.168.2.1, Port: 1000
Ip: 192.168.1.2, Port: 6000
Ip: 192.168.1.1, Port: 5000
---------------------
Ip: 192.168.1.2, Port: 6000
Ip: 192.168.2.1, Port: 1000
Ip: 192.168.1.1, Port: 3000
Ip: 192.168.1.127, Port: 5000
----------------
Ip: 192.168.1.1, Port: 3000
Ip: 192.168.2.1, Port: 1000
Ip: 192.168.1.2, Port: 6000
Ip: 192.168.1.1, Port: 5000

展开全文 >>

设计模式实践-观察者模式

场景

实现仪表时间的同步

实现代码

时间同步器接口

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.Observer
{
    /// <summary>
    /// 时间同步器接口
    /// </summary>
    public interface ITimeSynchronizer
    {
        /// <summary>
        /// 增加观察者
        /// </summary>
        /// <param name="observer">观察者对象</param>
        void Add(IMeterObserver observer);

        /// <summary>
        /// 删除观察者
        /// </summary>
        /// <param name="observer">观察者</param>
        void Del(IMeterObserver observer);

        /// <summary>
        /// 通知观察者同步时间
        /// </summary>
        void Notify();
    }
}

时间同步器对象

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
namespace DesignPatterns.Observer
{
    /// <summary>
    /// 时间同步器对象
    /// </summary>
    public class TimeSynchronizer : ITimeSynchronizer
    {
        /// <summary>
        /// 观察者列表
        /// </summary>
        private List<IMeterObserver> _meters = new List<IMeterObserver>();

        /// <summary>
        /// 增加观察者
        /// </summary>
        /// <param name="observer">观察者对象</param>
        public void Add(IMeterObserver observer)
        {
            this._meters.Add(observer);
        }

        /// <summary>
        /// 删除观察者
        /// </summary>
        /// <param name="observer">观察者对象</param>
        public void Del(IMeterObserver observer)
        {
            this._meters.Remove(observer);
        }

        /// <summary>
        /// 发送同步命令
        /// </summary>
        public void Notify()
        {
            foreach (var meter in this._meters)
            {
                meter.Update();
            }
        }
    }
}

仪表观察者接口

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace DesignPatterns.Observer
{
    /// <summary>
    /// 观察者接口
    /// </summary>
    public interface IMeterObserver
    {
        /// <summary>
        /// 同步时间
        /// </summary>
        void Update();
    }
}

仪表A

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
namespace DesignPatterns.Observer
{
    /// <summary>
    /// 仪表A观察者
    /// </summary>
    public class MeterA : IMeterObserver
    {
        /// <summary>
        /// 更新同步时间
        /// </summary>
        public void Update()
        {
            Console.WriteLine("同步时间");
        }
    }
}

仪表B

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
namespace DesignPatterns.Observer
{
    /// <summary>
    /// 仪表B观察者
    /// </summary>
    public class MeterB : IMeterObserver
    {
        /// <summary>
        /// 更新同步时间
        /// </summary>
        public void Update()
        {
            Console.WriteLine("同步时间");
        }
    }
}

相关调用

1
2
3
4
5
6
7
8
9
ITimeSynchronizer timeSynchronizer = new TimeSynchronizer();
timeSynchronizer.Add(new Observer.MeterA());
timeSynchronizer.Add(new Observer.MeterB());
timeSynchronizer.Add(new Observer.MeterA());
timeSynchronizer.Add(new Observer.MeterB());
timeSynchronizer.Add(new Observer.MeterA());
timeSynchronizer.Add(new Observer.MeterA());
timeSynchronizer.Add(new Observer.MeterB());
timeSynchronizer.Notify();

Out：

1
2
3
4
5
6
7
同步时间
同步时间
同步时间
同步时间
同步时间
同步时间
同步时间

展开全文 >>

设计模式实践-单例

场景

全局配置文件

实现代码

配置文件实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
namespace DesignPatterns.Singleton
{
    /// <summary>
    ///     配置文件类型
    /// </summary>
    public class ServerConfig
    {
        /// <summary>
        ///     Gets or sets IP
        /// </summary>
        public string Ip { get; set; }

        /// <summary>
        ///     Gets or sets Port
        /// </summary>
        public uint Port { 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
35
36
37
38
39
40
41
42
43
44
45
46
47
namespace DesignPatterns.Singleton
{
    /// <summary>
    /// ConfigSingleton Class
    /// </summary>
    public class ConfigSingleton
    {
        /// <summary>
        /// ConfigSingleton Instance  
        /// </summary>
        private static readonly ConfigSingleton Instance;

        /// <summary>
        /// Initializes static members of the <see cref="ConfigSingleton" /> class. 
        /// </summary>
        static ConfigSingleton()
        {
            Instance = new ConfigSingleton();
        }

        /// <summary>
        /// Prevents a default instance of the <see cref="ConfigSingleton" /> class from being created.
        /// </summary>
        private ConfigSingleton()
        {
            ServerConfig = new ServerConfig
            {
                Ip = "127.0.0.1",
                Port = 8000
            };
        }

        /// <summary>
        /// Gets ServerConfig
        /// </summary>
        public ServerConfig ServerConfig { get; }

        /// <summary>
        /// Get ConfigSingleton Instance
        /// </summary>
        /// <returns>ConfigSingleton Instance</returns>
        public static ConfigSingleton GetInstance()
        {
            return Instance;
        }
    }
}

相关调用

1
2
3
var config = ConfigSingleton.GetInstance().ServerConfig;
Console.WriteLine(config.Ip);
Console.WriteLine(config.Port);

Out:

1
2
127.0.0.1
8000

展开全文 >>

设计模式实践-适配器

场景

公司实现标准读卡器接口读卡，第三方读卡器实现其他接口，使用适配器适配第三方读卡器。

实现代码

标准读卡器接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace DesignPatterns.Adpater
{
    /// <summary>
    /// 读卡器接口
    /// </summary>
    public interface ICardReader
    {
        /// <summary>
        /// 读取数据
        /// </summary>
        void Read();
    }
}

其他读卡器接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace DesignPatterns.Adpater
{
    /// <summary>
    /// 其他读卡器接口
    /// </summary>
    internal interface IOtherCardReader
    {
        /// <summary>
        /// 从USB读取
        /// </summary>
        void ReadFromUsb();
    }
}

其他读卡器实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
namespace DesignPatterns.Adpater
{
    /// <summary>
    /// 其他读卡器的实现
    /// </summary>
    internal class OtherCardReader : IOtherCardReader
    {
        /// <summary>
        /// 从USB读取
        /// </summary>
        public void ReadFromUsb()
        {
            Console.WriteLine("read from Other");
        }
    }
}

其他读卡器适配器：

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
namespace DesignPatterns.Adpater
{
    /// <summary>
    ///     其他读卡器适配器
    /// </summary>
    internal class OtherCardReaderAdpater : ICardReader
    {
        /// <summary>
        ///     其他读卡器对象
        /// </summary>
        private readonly OtherCardReader _cardReader;

        /// <summary>
        ///     Initializes a new instance of the <see cref="OtherCardReaderAdpater" /> class.
        /// </summary>
        /// <param name="cardReader">其他读卡器</param>
        public OtherCardReaderAdpater(OtherCardReader cardReader)
        {
            this._cardReader = cardReader;
        }

        /// <summary>
        ///     从读卡器读取
        /// </summary>
        public void Read()
        {
            this._cardReader.ReadFromUsb();
        }
    }
}

相关调用

1
2
Adpater.ICardReader cardReader = new OtherCardReaderAdpater(new OtherCardReader());
      cardReader.Read();

Out：

1
read from Other

展开全文 >>

设计模式实践-代理模式

场景

在发送数据前和发送数据后调用方法

实现代码

发送接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace DesignPatterns.Proxy
{
    /// <summary>
    /// 发射器接口
    /// </summary>
    public interface ISender
    {
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="data">数据</param>
        void Send(string data);
    }
}

TCP发送类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace DesignPatterns.Proxy
{
    /// <summary>
    /// TCP发送器类型
    /// </summary>
    internal class TcpSender : ISender
    {
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="data">数据</param>
        public void Send(string data)
        {
            Console.WriteLine($"使用TCP发送数据: {data}");
        }
    }
}

代理发送类

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
namespace DesignPatterns.Proxy
{
    /// <summary>
    /// 发送器代理类
    /// </summary>
    public class SenderProxy : ISender
    {
        /// <summary>
        /// 发送器对象
        /// </summary>
        private readonly ISender _sender = new TcpSender();

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="data">数据</param>
        public void Send(string data)
        {
            this.BeforeSend();
            Console.WriteLine("在代理中发送数据");
            this._sender.Send(data);
            this.AfterSend();
        }

        /// <summary>
        /// 发送之前执行
        /// </summary>
        private void BeforeSend()
        {
            Console.WriteLine("发送数据之前");
        }

        /// <summary>
        /// 发送之后执行
        /// </summary>
        private void AfterSend()
        {
            Console.WriteLine("发送数据之后");
        }
    }
}

相关调用

1
2
ISender sender = new SenderProxy();
sender.Send("test data");

Out

1
2
3
4
5
The id of meter is 1
发送数据之前
在代理中发送数据
使用TCP发送数据: test data
发送数据之后

展开全文 >>

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

那年二十七