23種設計模式--建立型

阿新 • • 發佈：2020-07-29

1.單例模式：

#region 1.單例模式(Singleton),確保某一個類只有一個例項，而且自行例項化並向整個系統提供這個例項，這個類稱為單例類。所以單例模式應該具備以下幾點①私有化的建構函式 ②私有化的例項成員物件 ③對外提供獲取當前例項的方法。
    public class HungerSingleton 
    {
        private static HungerSingleton instance = new HungerSingleton();
        private HungerSingleton() { }
        public HungerSingleton GetHungerSingleton()
        {
             
return instance;
        }
    }

    public class LazySingleton 
    {
        private LazySingleton instance = null;
        private Object objLock = new object();
        private LazySingleton() { }
        public LazySingleton GetLazySingleton() 
        {
            if (instance == null)
            {
                 
lock (objLock) 
                {
                    if (instance == null) 
                    {
                        instance = new LazySingleton();
                    }
                }
            }
            return instance;
        }
    }

    #endregion

確保某一個類只有一個例項，而且自行例項化並向整個系統提供這個例項，這個類稱為單例類。所以單例模式應該具備以下幾點①私有化的建構函式 ②私有化的例項成員物件 ③對外提供獲取當前例項的方法。

2.簡單工廠模式：

#region 2.簡單工廠模式(Simple Factory)。定義一個工廠類，它可以根據引數的不同返回不同類的例項，被建立的例項通常具有共同的父類。一般簡單工廠的建立例項的方法都是一個靜態方法。
    public class ChartFactory 
    {
        public static IChartable GetChart(string type) 
        {
            IChartable chart = null;
            if (type.Equals("histogram", StringComparison.OrdinalIgnoreCase)) ;
            {
                chart = new HistogramChart();
                Console.WriteLine("初始化柱狀圖完成...");
            }
            if (type.Equals("line", StringComparison.OrdinalIgnoreCase)) ;
            {
                chart = new LineChart();
                Console.WriteLine("初始化折線圖完成...");
            }
            if (type.Equals("pie", StringComparison.OrdinalIgnoreCase)) ;
            {
                chart = new PieChart();
                Console.WriteLine("初始化餅狀圖完成...");
            }
            return chart;
        }
    }

    #endregion

定義一個工廠類，它可以根據引數的不同返回不同類的例項，被建立的例項通常具有共同的父類。一般簡單工廠的建立例項的方法都是一個靜態方法。

3.工廠方法：

#region 3.工廠方法(Factory Method)。 定義一個用於建立物件的介面，讓子類決定將哪一個類例項化。

    /// <summary>
    /// 抽象產品
    /// </summary>
    public interface ILogger 
    {
        void WriteLog();
    }

    #region 具體產品
    public class FileLogger : ILogger
    {
        public void WriteLog()
        {
            Console.WriteLine("檔案日誌記錄....");
        }
    }

    public class DatabaseLogger : ILogger
    {
        public void WriteLog()
        {
            Console.WriteLine("資料庫日誌記錄...");
        }
    }



    #endregion

    /// <summary>
    /// 抽象工廠
    /// </summary>
    public interface ILoggerFactory 
    {
        ILogger CreateLogger();
    }

    /// <summary>
    /// 具體工廠
    /// </summary>
    public class FileLoggerFactory : ILoggerFactory
    {
        public ILogger CreateLogger()
        {
            ILogger logger = new FileLogger();
            return logger;
        }
    }
    /// <summary>
    /// 具體工廠
    /// </summary>
    public class DatabaseLoggerFactory : ILoggerFactory
    {
        public ILogger CreateLogger()
        {
            ILogger logger = new DatabaseLogger();
            return logger;
        }
    }



    #endregion

定義一個用於建立物件的介面，讓子類決定將哪一個類例項化。

4.抽象工廠：

  1 #region 4.抽象工廠(Abstract Factory)。其實就是工廠方法的加強版，區別在於工廠方法生產一類產品，抽象工廠生產多種類的產品。
  2     #region 抽象產品
  3     public interface IButton
  4     {
  5         void Display();
  6     }
  7 
  8     public interface ITextField
  9     {
 10         void Display();
 11     }
 12 
 13     public interface IComboBox
 14     {
 15         void Display();
 16     }
 17 
 18 
 19     #endregion
 20 
 21 
 22     #region 具體產品
 23     public class SpringButton : IButton
 24     {
 25         public void Display()
 26         {
 27             Console.WriteLine("顯示淺綠色按鈕...");
 28         }
 29     }
 30 
 31     public class SpringTextField : ITextField
 32     {
 33         public void Display()
 34         {
 35             Console.WriteLine("顯示綠色邊框文字框...");
 36         }
 37     }
 38 
 39     public class SpringComboBox : IComboBox
 40     {
 41         public void Display()
 42         {
 43             Console.WriteLine("顯示綠色邊框下拉框...");
 44         }
 45     }
 46 
 47     public class SummerButton : IButton
 48     {
 49         public void Display()
 50         {
 51             Console.WriteLine("顯示淺藍色按鈕...");
 52         }
 53     }
 54 
 55     public class SummerTextField : ITextField
 56     {
 57         public void Display()
 58         {
 59             Console.WriteLine("顯示藍色邊框文字框...");
 60         }
 61     }
 62 
 63     public class SummerComboBox : IComboBox
 64     {
 65         public void Display()
 66         {
 67             Console.WriteLine("顯示藍色邊框下拉框...");
 68         }
 69     }
 70 
 71     #endregion
 72 
 73     #region 抽象工廠
 74     public interface ISkinFactory
 75     {
 76         IButton CreateButton();
 77         ITextField CreateTextField();
 78         IComboBox CreateComboBox();
 79     }
 80     #endregion
 81 
 82     #region 具體工廠
 83 
 84     // Spring面板工廠
 85     public class SpringSkinFactory : ISkinFactory
 86     {
 87         public IButton CreateButton()
 88         {
 89             return new SpringButton();
 90         }
 91 
 92         public IComboBox CreateComboBox()
 93         {
 94             return new SpringComboBox();
 95         }
 96 
 97         public ITextField CreateTextField()
 98         {
 99             return new SpringTextField();
100         }
101     }
102 
103 
104     public class SummerSkinFactory : ISkinFactory
105     {
106         public IButton CreateButton()
107         {
108             return new SummerButton();
109         }
110 
111         public IComboBox CreateComboBox()
112         {
113             return new SummerComboBox();
114         }
115 
116         public ITextField CreateTextField()
117         {
118             return new SummerTextField();
119         }
120     }
121 
122     #endregion
123 
124     #endregion

其實就是工廠方法的加強版，區別在於工廠方法生產一類產品，抽象工廠生產多種類的產品。

5.原型模式：

 1 #region 5.原型模式(Prototype)。使用原型例項指定建立物件的種類，並且通過拷貝這些原型建立新的物件。
 2 
 3     /// <summary>
 4     /// 這裡面引入一個淺複製和深複製的概念
 5     /// 淺複製，複製一個物件的時候，僅僅複製原始物件中所有的非靜態型別成員和所有的引用型別成員的引用。
 6     /// 深複製，複製一個物件的時候，不僅複製所有非靜態型別成員，還要複製所有引用型別成員的實際物件。
 7     /// </summary>
 8 
 9     public class WeeklyLog : ICloneable
10     {
11         public string Name { get; set; }
12         public string Date { get; set; }
13         public string Content { get; set; }
14         public object Clone()
15         {
16             WeeklyLog result = new WeeklyLog();
17             result.Name = this.Name;
18             result.Date = this.Date;
19             result.Content = this.Content;
20             return result;
21         }
22     }
23 
24     #endregion

使用原型例項指定建立物件的種類，並且通過拷貝這些原型建立新的物件。

6.建造者模式：

 1 #region 6.建造者模式(Builder)。將一個物件的構建與它的表示分離，使得同樣的構建過程可以建立不同的表示。 建造者模式和抽象工廠模式很相似，工廠模式是通過工廠生產一系列的產品，而建造者模式是通過建造者獲得一個完整的物件。
 2     /// <summary>
 3     /// 產品
 4     /// </summary>
 5     public class Actor 
 6     {
 7         public string Type { get; set; }
 8         public string Head { get; set; }
 9         public string Body { get; set; }
10         public string Cloth { get; set; }
11     }
12     /// <summary>
13     /// 抽象建造者
14     /// </summary>
15     public abstract class ActorBuilder 
16     {
17         protected Actor actor = new Actor();
18         public abstract void BuildType();
19         public abstract void BuildHead();
20         public abstract void BuildBody();
21         public abstract void BuildCloth();
22 
23         public Actor CreateActor() 
24         {
25             return actor;
26         }
27     }
28 
29     /// <summary>
30     /// 具體建造者
31     /// </summary>
32     public class DiaosiBuilder : ActorBuilder
33     {
34         public override void BuildBody()
35         {
36             this.actor.Body = "乾瘦的身體";
37         }
38 
39         public override void BuildCloth()
40         {
41             this.actor.Cloth = "泛黃的白色T恤";
42         }
43 
44         public override void BuildHead()
45         {
46             this.actor.Head = "三天沒洗過的頭";
47         }
48 
49         public override void BuildType()
50         {
51             this.actor.Type = "屌絲";
52         }
53     }
54 
55     /// <summary>
56     /// 具體建造者
57     /// </summary>
58     public class GaoFuShuaiBuilder : ActorBuilder
59     {
60         public override void BuildBody()
61         {
62             this.actor.Body = "又高又壯";
63         }
64 
65         public override void BuildCloth()
66         {
67             this.actor.Cloth = "阿瑪尼西裝";
68         }
69 
70         public override void BuildHead()
71         {
72             this.actor.Head = "888剪出來的髮型";
73         }
74 
75         public override void BuildType()
76         {
77             this.actor.Type = "高富帥";
78         }
79     }
80 
81     /// <summary>
82     /// 指揮者
83     /// </summary>
84     public class ActorDirector 
85     {
86         public Actor Construct(ActorBuilder builder) 
87         {
88             builder.BuildType();
89             builder.BuildHead();
90             builder.BuildBody();
91             builder.BuildCloth();
92 
93             return builder.CreateActor();
94         }
95     }
96     #endregion