当先锋百科网

首页 1 2 3 4 5 6 7

c#设计模式学习总结(创建型)

设计模式：面向对象语言开发过程中，遇到的种种场景和问题，提出了解决方案和思路，沉淀下来就变成了设计模式。具体的招数，解决具体问题的具体招数。

设计模式分类：

  1. 创建型设计模式：关注对象的创建
  2. 结构型设计模式：关注类与类之间的关系
  3. 行为型设计模式：关注对象与行为的分离

没有什么设计模式是完美无缺的，一个设计模式就是解决一类问题的，通常设计模式在解决一类问题的同时，还会带来别的问题，设计者要做的就是扬长避短，充分发挥其长处。

 

单例模式

 在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性、以及良好的效率。

代码实现：

单线程中的单例模式：

    /// <summary>
    /// 单线程单例实例
    /// </summary>
    class SingleThreadd_Singleton
    {
        //全局唯一静态
        private static SingleThreadd_Singleton _Singleton = null;
        private SingleThreadd_Singleton()
        {
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }

        /// <summary>
        /// 公开的静态方法提供对象实例
        /// </summary>
        /// <returns></returns>
        public static SingleThreadd_Singleton CreateInstance()
        {
            if (_Singleton == null)
            {
                _Singleton = new SingleThreadd_Singleton();
            }
            return _Singleton;
        }
    }

实例的创建：

执行结果：

实例被创建了一次，两次返回的实例为同一个实例。

 

多线程中的单例模式：

    /// <summary>
    /// 多线程单例实例
    /// </summary>
    class MultiThread_Singleton
    {
        //全局唯一静态 volatile存进线程安全,让线程按照顺序执行
        private static volatile MultiThread_Singleton _Singleton = null;
        private static readonly object Singleton_Lock = new object();
        private MultiThread_Singleton()
        {
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }

        /// <summary>
        /// 公开的静态方法提供对象实例
        /// </summary>
        /// <returns></returns>
        public static MultiThread_Singleton CreateInstance()
        {
            if (_Singleton == null)
            {
                lock (Singleton_Lock)//保证任意时刻只有一个线程进入lock范围
                {
                    Console.WriteLine("lock进入一次");
                    if (_Singleton == null)
                    {
                        _Singleton = new MultiThread_Singleton();
                    }
                }
            }
            return _Singleton;
        }
    }

实例的创建：

执行结果：

实例也是只被构造了一次。

 

单例模式可以避免重复创建对象，但是可会常驻内存，占用内存资源。

 

原型模式

换个方式创建对象，不走构造函数，而是内存拷贝。

代码实现：

    /// <summary>
    /// 原型模式实例
    /// </summary>
    class Prototype
    {
        public int Age { get; set; }
        public string Name { get; set; }

        private Prototype()
        {
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }

        //初始化一个Student对象
        private static Prototype _Prototype = new Prototype
        {
            Age = 20,
            Name = "张三"
        };

        public static Prototype GetInstance()
        {
            Prototype prototype = (Prototype)_Prototype.MemberwiseClone();
            Console.WriteLine("原型对象和拷贝后的对象是否为同一对象: " + object.ReferenceEquals(_Prototype, prototype));
            return prototype;
        }
    }

实例的创建：

执行结果：

返回的对象实例是由原型对象拷贝后生成的，原型对象和拷贝后的对象虽然值相同，但属于两个不同的对象。

 

工厂方法模式

在软件系统中，由于需求的变化，“对象的具体实现”经常面临着剧烈的变化，但它却有比较稳定的接口。

为了应为这样的变化，提供一种封装机制来隔离出“这个易变对象的变化”，从而保持系统中“其他依赖对象”不随需求的变化而变化。

 

代码实现：

App.config添加配置项：

<appSettings>
    <add key="No1" value="HongQiCarFactory"/>
    <add key="No2" value="BMWCarFactory"/>
</appSettings>

CarFactory类：

 public abstract class CarFactory
    {
        public abstract Car CarCreate();
    }

 Car类：

 public abstract class Car
    {
        public abstract void StartUp();
        public abstract void Run();
        public abstract void Stop();
    }

HongQiCarFactory类：

 public class HongQiCarFactory : CarFactory
    {
        public override Car CarCreate()
        {
            return new HongQiCar();
        }
    }

BMWCarFactory类：

public class BMWCarFactory : CarFactory
    {
        public override Car CarCreate()
        {
            return new BMWCar();
        }
    }

HongQiCar类：

public class HongQiCar : Car
    {
        public override void StartUp()
        {
            Console.WriteLine("Test HongQiCar start-up speed!");
        }
        public override void Run()
        {
            Console.WriteLine("The HongQiCar run is very quickly!");
        }
        public override void Stop()
        {
            Console.WriteLine("The slow stop time is 3 second ");
        }
    }

BMWCar类：

public class BMWCar : Car
    {
        public override void StartUp()
        {
            Console.WriteLine("The BMWCar start-up speed is very quickly");
        }

        public override void Run()
        {
            Console.WriteLine("The BMWCar run is quitely fast and safe!!!");
        }

        public override void Stop()
        {
            Console.WriteLine("The slow stop time is 2 second");
        }
    }

Program类：

                Console.WriteLine("Please Enter Factory Method No:");
                Console.WriteLine("******************************");
                Console.WriteLine("no         Factory Method");
                Console.WriteLine("1          HongQiCarFactory");
                Console.WriteLine("2          BMWCarFactory");
                Console.WriteLine("******************************");
                int no = Int32.Parse(Console.ReadLine().ToString());
                string factoryType = ConfigurationManager.AppSettings["No" + no];
                //CarFactory factory = new HongQiCarFactory();
                CarFactory factory = (CarFactory)Assembly.Load("FactoryMehtod").CreateInstance("FactoryMehtod." + factoryType);
                Car car = factory.CarCreate();
                car.StartUp();
                car.Run();
                car.Stop();

执行结果：

 

工厂方法模式要点：

主要用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系会导致软件的脆弱。

通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展的策略，较好地解决了这种紧耦合关系。

工厂方法模式解决“单个对象”的需求变化，抽象工厂模式解决“系列对象”的需求变化，建造者模式解决“对象部分”的需求变化。

 

参考链接：

https://www.cnblogs.com/abcdwxc/archive/2007/10/30/942834.html