设计模式

Refactoring.Guru（设计模式学习）网站地址：https://refactoringguru.cn/

创建型模式

工厂方法模式

工厂方法模式是一种创建型设计模式，其在父类中提供一个创建对象的方法，允许子类决定实例化对象的类型。

class Program
{
    static void Main(string[] args)
    {
        new Client().Main();
    
        Console.ReadKey();
    }
    
    public interface IProduct
    {
        string Operation();
    }
    
    class ConcreteProduct1 : IProduct
    {
        public string Operation()
        {
            return "result of ConcreteProduct1";
        }
    }
    
    class ConcreteProduct2 : IProduct
    {
        public string Operation()
        {
            return "result of ConcreteProduct2";
        }
    }
    
    abstract class Creator
    {
        public abstract IProduct FactorMethod();
    
        public string SomeOperation()
        {
            var product = FactorMethod();
    
            var result = product.Operation();
    
            return result;
        }
    }
    
    class ConcreteCreator1 : Creator
    {
        public override IProduct FactorMethod()
        {
            return new ConcreteProduct1();
        }
    }
    
    class ConcreteCreator2 : Creator
    {
        public override IProduct FactorMethod()
        {
            return new ConcreteProduct2();
        }
    }
    
    class Client
    {
        public void Main()
        {
            ClientCode(new ConcreteCreator1());
    
            ClientCode(new ConcreteCreator2());
        }
    
        public void ClientCode(Creator creator)
        {
            Console.WriteLine(creator.SomeOperation());
        }
    }
}

抽象工厂模式

抽象工厂模式是一种创建型设计模式，它能创建一系列相关的对象，而无需指定其具体类。

class Program
{
    static void Main(string[] srgs)
    {
        Console.WriteLine("Hello world");
        
        new Client().Main();
    }
}

public interface IAbstractProductA
{
    string UsefulFunctionA();
}

class ConcreteProductA1 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "result productA1";
    }
}

class ConcretProductA2 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "result productA2";
    }
}

interface IAbstractProductB
{
    string UsefulFunctionB();

    string AnotherUsefulFunctionB(IAbstractProductA vcoll);
}

class ConcreteProductB1 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "result productB1";
    }

    public string AnotherUsefulFunctionB(IAbstractProductA vcoll)
    {
        return vcoll.UsefulFunctionA() + "B1";
    }
}

class ConcreteProductB2: IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "result productB2";
    }

    public string AnotherUsefulFunctionB(IAbstractProductA vcoll)
    {
        return vcoll.UsefulFunctionA() + "B2";
    }
}

interface IAbstractFactory
{
    IAbstractProductA CreateProductA();

    IAbstractProductB CreateProductB();
}
    
class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

    public IAbstractProductB CreateProductB()
    {
        return new ConcreteProductB1();
    }
}
    
class ConcreteFactory2: IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcretProductA2();
    }

    public IAbstractProductB CreateProductB()
    {
        return new ConcreteProductB2();
    }
}
    
class Client
{
    public void Main()
    {
        ClientCode(new ConcreteFactory1());
        
        ClientCode(new ConcreteFactory2());
    }
    
    public void ClientCode(IAbstractFactory factory)
    {
        Console.WriteLine(factory.CreateProductB().UsefulFunctionB());
        Console.WriteLine(factory.CreateProductB().AnotherUsefulFunctionB(factory.CreateProductA()));
    }
}

生成器模式

原型模式

单例模式

单例模式是一种创建型设计模式，让你能够保证一个类只有一个实例，并提供一个访问该实例的全局节点。

单线程

public class Singleton
{
    private Singleton()
    {
    }

    private static Singleton _instance;

    public static Singleton GetInstance()
    {
        return _instance ??= new Singleton();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello World!");
        
        Singleton s1 = Singleton.GetInstance();
        Singleton s2 = Singleton.GetInstance();

        if (s1 == s2)
        {
            Console.WriteLine("yes");
        }
        else
        {
            Console.WriteLine("no");
        }
    }
}

多线程（线程安全的）

public class Singleton
{
    private Singleton()
    {
    }

    private static Singleton _instance;

    private static readonly object _lock = new object();

    public string Value { get; set; }

    public static Singleton GetInstance(string value)
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new Singleton {Value = value};
                }
            }
        }

        return _instance;
    }
}
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello World!");

        Thread t1 = new Thread(() => { TestSingleton("foo"); });

        Thread t2 = new Thread(() => { TestSingleton("bar"); });

        t1.Start();
        t2.Start();

        t1.Join();
        t2.Join();
    }

    private static void TestSingleton(string value)
    {
        Singleton singleton = Singleton.GetInstance(value);
        Console.WriteLine(singleton.Value);
    }
}

结构型模式

适配器模式

桥接模式

组合模式

装饰模式

外观模式

享元模式

代理模式

行为型模式

责任链模式

命令模式

迭代器模式

中介者模式

备忘录模式

观察者模式

观察者模式是一种行为设计模式，允许你定义一种订阅机制，可在对象事件发生时通知多个 “观察” 该对象的其他对象。

class Program
{
      static void Main(string[] args)
      {
          Console.WriteLine("Hello World!");

          var subject = new Subject();
          var observerA = new ConcreteObserverA();
          subject.Attach(observerA);

          var observerB = new ConcreteObserverB();
          subject.Attach(observerB);

          subject.SomeBusinessLogic();
          subject.SomeBusinessLogic();

          subject.Detach(observerB);

          subject.SomeBusinessLogic();
      }
  }

  public interface ISubject
  {
      void Attach(IObserver observer);

      void Detach(IObserver observer);

      void Notify();
  }

  public interface IObserver
  {
      void Update(ISubject subject);
  }

  public class Subject : ISubject
  {
      public int State { get; set; } = -0;

      private List<IObserver> _observers = new List<IObserver>();

      public void Attach(IObserver observer)
      {
          Console.WriteLine("Subject: Attached an observer.");

          _observers.Add(observer);
      }

      public void Detach(IObserver observer)
      {
          Console.WriteLine("Subject: Detached an observer.");

          _observers.Remove(observer);
      }

      public void Notify()
      {
          Console.WriteLine("Subject: Notifying observers...");

          foreach (var item in _observers)
          {
              item.Update(this);
          }
      }

      public void SomeBusinessLogic()
      {
          Console.WriteLine("\n Subject: I am doing something important.");

          State = new Random().Next(0, 10);

          Thread.Sleep(15);

          Console.WriteLine("Subject: My state has just changed to: " + State);

          Notify();
      }
  }

  class ConcreteObserverA : IObserver
  {
      public void Update(ISubject subject)
      {
          if ((subject as Subject).State < 3)
          {
              Console.WriteLine("ConcreteObserverA: Reacted to the event.");
          }
      }
  }

  class ConcreteObserverB : IObserver
  {
      public void Update(ISubject subject)
      {
          if ((subject as Subject).State == 0 || (subject as Subject).State >= 2)
          {
              Console.WriteLine("ConcreteObserverB: Reacted to the event.");
          }
      }
  }

状态模式

策略模式

模板方法模式

访问者模式

策略模式

策略模式：一个类的行为可以在运行时更改，策略模式将所有的行为一个个封装起来，让他们可以相互替换，而不影响调用者

使用场景
当一个功能在不同的场景下，需要不同的实现方式，类似这种情况就可以使用策略模式

优点

类的行为可以在运行时自由切换
降低了类的调用者和类的具体实现之间的耦合
避免了繁琐的条件判断，代码可读性更高
扩展性更好

缺点

策略类会增多

posted @ 2021-03-06 20:42 liujiangbo 阅读(107) 评论(0) 编辑收藏举报

刷新页面返回顶部

liujiangbo

设计模式

创建型模式

工厂方法模式

抽象工厂模式

生成器模式

原型模式

单例模式

结构型模式

适配器模式

桥接模式

组合模式

装饰模式

外观模式

享元模式

代理模式

行为型模式

责任链模式

命令模式

迭代器模式

中介者模式

备忘录模式

观察者模式

状态模式

策略模式

模板方法模式

访问者模式

策略模式

公告