23种设计模式--创建型模式

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.抽象工厂：

#region 4.抽象工厂(Abstract Factory)。其实就是工厂方法的加强版，区别在于工厂方法生产一类产品，抽象工厂生产多种类的产品。
    #region 抽象产品
    public interface IButton
    {
        void Display();
    }

    public interface ITextField
    {
        void Display();
    }

    public interface IComboBox
    {
        void Display();
    }


    #endregion


    #region 具体产品
    public class SpringButton : IButton
    {
        public void Display()
        {
            Console.WriteLine("显示浅绿色按钮...");
        }
    }

    public class SpringTextField : ITextField
    {
        public void Display()
        {
            Console.WriteLine("显示绿色边框文本框...");
        }
    }

    public class SpringComboBox : IComboBox
    {
        public void Display()
        {
            Console.WriteLine("显示绿色边框下拉框...");
        }
    }

    public class SummerButton : IButton
    {
        public void Display()
        {
            Console.WriteLine("显示浅蓝色按钮...");
        }
    }

    public class SummerTextField : ITextField
    {
        public void Display()
        {
            Console.WriteLine("显示蓝色边框文本框...");
        }
    }

    public class SummerComboBox : IComboBox
    {
        public void Display()
        {
            Console.WriteLine("显示蓝色边框下拉框...");
        }
    }

    #endregion

    #region 抽象工厂
    public interface ISkinFactory
    {
        IButton CreateButton();
        ITextField CreateTextField();
        IComboBox CreateComboBox();
    }
    #endregion

    #region 具体工厂

    // Spring皮肤工厂
    public class SpringSkinFactory : ISkinFactory
    {
        public IButton CreateButton()
        {
            return new SpringButton();
        }

        public IComboBox CreateComboBox()
        {
            return new SpringComboBox();
        }

        public ITextField CreateTextField()
        {
            return new SpringTextField();
        }
    }


    public class SummerSkinFactory : ISkinFactory
    {
        public IButton CreateButton()
        {
            return new SummerButton();
        }

        public IComboBox CreateComboBox()
        {
            return new SummerComboBox();
        }

        public ITextField CreateTextField()
        {
            return new SummerTextField();
        }
    }

    #endregion

    #endregion

5.原型模式：

#region 5.原型模式(Prototype)。使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

    /// <summary>
    /// 这里面引入一个浅复制和深复制的概念
    /// 浅复制，复制一个对象的时候，仅仅复制原始对象中所有的非静态类型成员和所有的引用类型成员的引用。
    /// 深复制，复制一个对象的时候，不仅复制所有非静态类型成员，还要复制所有引用类型成员的实际对象。
    /// </summary>

    public class WeeklyLog : ICloneable
    {
        public string Name { get; set; }
        public string Date { get; set; }
        public string Content { get; set; }
        public object Clone()
        {
            WeeklyLog result = new WeeklyLog();
            result.Name = this.Name;
            result.Date = this.Date;
            result.Content = this.Content;
            return result;
        }
    }

    #endregion

6.建造者模式：

#region 6.建造者模式(Builder)。将一个对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 建造者模式和抽象工厂模式很相似，工厂模式是通过工厂生产一系列的产品，而建造者模式是通过建造者获得一个完整的对象。
    /// <summary>
    /// 产品
    /// </summary>
    public class Actor 
    {
        public string Type { get; set; }
        public string Head { get; set; }
        public string Body { get; set; }
        public string Cloth { get; set; }
    }
    /// <summary>
    /// 抽象建造者
    /// </summary>
    public abstract class ActorBuilder 
    {
        protected Actor actor = new Actor();
        public abstract void BuildType();
        public abstract void BuildHead();
        public abstract void BuildBody();
        public abstract void BuildCloth();

        public Actor CreateActor() 
        {
            return actor;
        }
    }

    /// <summary>
    /// 具体建造者
    /// </summary>
    public class DiaosiBuilder : ActorBuilder
    {
        public override void BuildBody()
        {
            this.actor.Body = "干瘦的身体";
        }

        public override void BuildCloth()
        {
            this.actor.Cloth = "泛黄的白色T恤";
        }

        public override void BuildHead()
        {
            this.actor.Head = "三天没洗过的头";
        }

        public override void BuildType()
        {
            this.actor.Type = "屌丝";
        }
    }

    /// <summary>
    /// 具体建造者
    /// </summary>
    public class GaoFuShuaiBuilder : ActorBuilder
    {
        public override void BuildBody()
        {
            this.actor.Body = "又高又壮";
        }

        public override void BuildCloth()
        {
            this.actor.Cloth = "阿玛尼西装";
        }

        public override void BuildHead()
        {
            this.actor.Head = "888剪出来的发型";
        }

        public override void BuildType()
        {
            this.actor.Type = "高富帅";
        }
    }

    /// <summary>
    /// 指挥者
    /// </summary>
    public class ActorDirector 
    {
        public Actor Construct(ActorBuilder builder) 
        {
            builder.BuildType();
            builder.BuildHead();
            builder.BuildBody();
            builder.BuildCloth();

            return builder.CreateActor();
        }
    }
    #endregion