设计模式---建造型（2）

4 建造者模式

• 将复杂的对象构建与其表示相分离，使得同样的构建过程可以创建不同的对象表示。

        public class Product
        {
            public string PartA{get;set;}
            public string PartB{get;set;}            
        }
        
        public abstract class Bulder
        {            
            public abstract void BuildPartA();
            public abstract void BuildPartB();
            
            public abstract Product BuildProduct();
        }
        
        public class BulderSon1 : Bulder
        {
            private Product product=new Product();
            
            public override void BuildPartA()
            {
                this.product.PartA="BulderSon1.PartA";
            }
            public override void BuildPartB()
            {
                this.product.PartB="BulderSon1.PartB";
            }
            
            public Product BuildProduct()
            {
                return this.product;
            }
        }
        
        public class BulderSon2 : Bulder
        {
            private Product product=new Product();
            
            public override void BuildPartA()
            {
                this.product.PartA="BulderSon2.PartA";
            }
            public override void BuildPartB()
            {
                this.product.PartB="BulderSon2.PartB";
            }
            
            public Product BuildProduct()
            {
                return this.product;
            }
        }
        
        public class Director
        {
            public void Construct(Builder builder)
            {
                builder.BuildPartA();
                builder.BuildPartB();
            }        
        }

---

5 原型模式

• 用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。
• 分为浅克隆、深克隆。
• 二者的区别：浅拷贝是指当对象的字段值被拷贝时，字段引用的对象不会被拷贝。
• 例如，如果一个对象有一个指向字符串的字段，并且我们对该对象做了一个浅拷贝，那么这两个对象将引用同一个字符串。
• 而深拷贝是对对象实例中字段引用的对象也进行拷贝，如果一个对象有一个指向字符串的字段，
• 并且我们对该对象进行了深拷贝的话，那么我们将创建一个对象和一个新的字符串，新的对象将引用新的字符串。
• 也就是说，执行深拷贝创建的新对象和原来对象不会共享任何东西，改变一个对象对另外一个对象没有任何影响，
• 而执行浅拷贝创建的新对象与原来对象共享成员，改变一个对象，另外一个对象的成员也会改变。

        //浅克隆
        public  class Prototype ：ICloneable
        {
            public int A{ get; set;}
            public string Str{ get; set;}
            
            public BasePrototype(int a,string str)
            {
                this.A=a;
                this.Str=str;
            }
            
            public  Object Clone()
            {
                return (Object)this.MemberwiseClone();
            }
            
        }

        //深克隆
        public  class Prototype ：ICloneable
        {
            public int A{ get; set;}
            public string Str{ get; set;}
            
            public BasePrototype(int a,string str)
            {
                this.A=a;
                this.Str=str;
            }
            public  Object Clone()
            {
                Prototype obj = new Prototype(this.A,this.Str);            
                return obj;
                
            }
        }

---

6 单例模式

1. 确保一个类只有一个实例；
2. 它必须自行创建这个实例；        
3. 提供一个访问它的全局访问点；

• 单线程下单例模式实现：

        public class Single
        {
            //1确保一个类只有一个实例
            private static Single uniqueInstance;
            //2它必须自行创建这个实例
            private Single()
            {
            }
            //3提供一个访问它的全局访问点
            public static Singleton GetInstance()
            {            
                if (uniqueInstance == null)
                {
                    uniqueInstance = new Singleton();
                }
                return uniqueInstance;
            }
        
        }

• 多线程下单例模式实现：

        

        public class Single
        {
            //1确保一个类只有一个实例
            private static Single uniqueInstance;
            // 定义一个标识确保线程同步
            private static readonly object locker = new object();
            //2它必须自行创建这个实例
            private Single()
            {
            }
            //3提供一个访问它的全局访问点
            public static Single GetInstance()
            {    
                lock(locker)
                {
                    if (uniqueInstance == null)
                    {
                        uniqueInstance = new Single();
                    }
                }
                return uniqueInstance;
            }
        
        }