设计模式_1_单例模式

1.面向对象，变化隔离出来，压缩到最小
类与对象的交互。

模式分类：
1.从目的来讲：
1.创建型：负责创建对象
2.结构型：处理类与对象之间的组合
3.行为型：类与对象交互中的职责分配。
2.从范围来讲：
1.类模式： 处理类与子类的静态关系。在编译的时候，就确定下来。
2.对象模式：对象之间的动态关系，运行在内存之间。

3.设计模式
（1）单例模式
动机：Motivation .
保证在系统中，只有一个实例，才能保证逻辑正确性，以及良好的效率。

单例模式：应该由设计者负责，类本身负责，而不是使用者的责任。

绕过常规的构造器，提供一种机制来保证一个类只有一个实例。

比如:
private string configs;
public string Configs{
    get{
        if(configs==null){
            configs=ReadConfigFormFile();
        }
        return configs;
    }
}

目的：
这个，如果是程序只有一个人开发的，也可以保证，只有一个实例。但是，你怎么保证，别人开发的时候，不会去new这个东西，去创建这个东西？

应该是设计者的责任，而不是使用者的责任，不是告诉使用者，只能创建一次。

绕过常规构造器，提供一个机制来保证一个类只有一个实例。
意图(Intent)：
    保证一个类只有一个实例，并提供一个该实例的全局访问点。

Singleton
    static instance()       return uniqueInstance
    SingletonOperation()
    GetSingletonData()
    -
    static uniqueinstance
    singletonData

使用静态的方式，来构造实例，把构造器的调用约束起来。

（1.1）单线程Singleton模式实现
    
    public class Singleton{
        private Singleton(){}
        private static Singleton instance;
        public static Singleton Instance{
            get{
                if(instance==null){
                    instance=new SingletonInstance();
                }
                return instance;
            }
        }
    }

单例设计模式：
版本一：
public class Singleton{
private Singleton(){}

private static Singleton instance;

public static Singleton Instance{
    get{
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

}
缺点：多线程不能使用。
如果线程一判断，instance==null,同时，线程二判断instance==null,那么，线程一和二，都会创建Singleton.不能保证只有一个实例。
版本二：
public class Singleton{
private Singleton(){}
private static volatile Singleton instance;
private static object lockHelper=new object();

public static Singleton Instance{
    get{
        if(instance==null){
            lock(lockHelper){
                if(instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

}
适合于多线程的经典实现。
版本三：
public class Singleton{
private Singleton(){}
public static readonly Singleton Instance=new Singleton();
}
缺点：不能提供参数化的构造器，如Singleton.Instance(100,200).
版本四：
单线程带参数Singleton模式
public class Singleton{
private Singleton(int x,int y){
this.x=x;
this.y=y;
}
int x;
int y;
private static Singleton instance;

public static Singleton GetInstance(int x,int y){
    if(instance==null){
        instance=new Singleton(x,y)
    }else{
        instance.x=x;
        instance.y=y;
    }
    return instance;
}

}
//推荐（剥离开 初始化与内存分配）
public class Singleton{
private Singleton(){}
public static readonly Singleton Instance=new Singleton();

int x;
int y;
public int X{get;set;}
public int Y{get;set;}

}
版本五：
多线程Sinleton模式，带参数和初始化。静态构造器，系统调用，不支持传参。这个时候需要传参，就往后延迟，提供方法，完成构造的状态。
public class Singleton{
private Singleton(){}
public static Singleton Instance=new Singleton();
int x;
int y;
public int X{get;set;}
public int Y{get;set;}
public void Init(FileStream stream){

}

}

public class Test{
public static void Main(){
Singleton t=Singleton.Instance();
t.Init(new FileStream(filetPath));
t.X=12;
t.Y=13;
}
}

c#中的构造器。
1.初始化，字段，资源的初始化
2.内存分配
把这两个剥离开来。
高手写的代码：看到你写的代码，哦，好简单啊。用简单的东西解决复杂的问题。
简洁就是美。
c#里面已经集成了好多设计模式，迭代器，设计模式会转化成语言的构造。
1.free lunch .
Singleton 是对于创建的实例的个数的控制。Singleton是一个实例，如果是两个呢，三个呢，也是可以控制的。
2.设计模式在不同的环境下，有不同的扩展。
3.扩展点
（1）将一个实例扩展到n个实例（固定个数的实例），例如对象池的出现。比如数据库连接对象，com+的实例对象，我就只用到200个对象，
比如系统初始化，我们new 10个对象，放在数据结构中，保存。但是实例构造器还是私有的。用户访问对象池的时候，轮询（栈的结构）的提供实例对象。实现资源的有效管理。
（2）将new构造器的调用转移到其他类中，例如多个类协同工作环境中，某个局部环境只需要拥有某个类的一个实例。
Singleton模式的几个特点：一个实例，私有构造器，在静态字段，静态方法，静态构造器中调用都好。
（3）理解和扩展Singleton的模式的核心是“如何控制用户使用new 对一个类的实例构造器的任意调用”

1. .net中Singleton的应用
   (1).GetType()
   public static void Main(){
   MyClass c1=new MyClass();
   MyClass c2=new MyClass();

        Type t1=c1.GetType();
        Type t2=c2.GetType();
    }
    如果c1和C2 是同一个类型，那么GetType() 后出来的就是同一个实例对象。系统保证，同一个类型，全局只有一个类型对象。

   1.Singleton模式的应用
   (1)object.GetType();全局领域Singleton
   (2)HttpContext.Current; 局部领域Singleton 模式。
   在Application ,Request,Response对象中,所访问的Context属性，都是全局唯一的一个HttpContext属性。是通过Singleton的模式扩展实现。
   (3)Remoting 的Singleton模式调用。
   (4)Singleton模式：创造型模式。
   2.Singleton模式的总结
   推荐书本：
   《设计模式：可复用面向对象软件的基础》GoF
   《面向对象分析与设计》Grady Booch
   《敏捷软件开发：原则、模式与实践》 Robert C.Martin
   《重构：改善既有代码的设计》 Martin Fowler
   《Refactoring to Patterns》Jshua Kerievsky
   问题回答：
   1.使用静态的计数器一样可以实现，单线程中只实例化一个对象的目的。不推荐

转载于:https://www.cnblogs.com/sujingnuli/p/9956942.html