WebCast听课录(3)

课程名:C#面向对象设计模式纵横谈2. Singleton件(创建型模式)

 

模式分类

 

从目的来看:

创建型(Creational)模式:负责对象创建。

结构型(Structural)模式:处理类与对象间的组合。

行为型(Behavioral)模式:类与对象交互中的职责分配。

          

从范围来看:

类模式处理类与子类的静态关系。

对象模式处理对象间的动态关系。

 

动机(Motivation

 

在软件系统中,经常有这样一些特殊的类,必须保证它们在系统中只存在一个实例,才能确保它们的逻辑正确性、以及良好的效率。如何绕过常规的构造器,提供一种机制来保证一个类只有

一个实例?这应该是类设计者的责任,而不是使用者的责任。

 

意图(Intent

 

保证一个类仅有一个实例,并提供一个该实例的全局访问点。——《设计模式》GoF

 

结构(Structure

 

单线程Singleton 模式实现

     /// <summary>
    
/// 单线程Singleton类
    
/// </summary>

    
public   class  Singleton
    
{
        
private static Singleton instance = null;

        
private Singleton()
        
{
        }


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

                
return instance;
            }

        }

        
static void Main(string[] args)
        
{
            Singleton st1 
= Singleton.Instance;

            Singleton st2 
= Singleton.Instance;

            Console.WriteLine(Object.ReferenceEquals(st1,st2)
==true);


        }


单线程Singleton模式的几个要点

 

. Singleton 模式中的实例构造器可以设置为protected以允许子类派生。

 

. Singleton 模式一般不要支持ICloneable接口,因为这可能会导致多个对象实例,与Singleton模式的初衷违背。

 

. Singleton 模式一般不要支持序列化,因为这也有可能导致多个对象实例,同样与Singleton模式的初衷违背。因为序列化对象到磁盘后,再反序列化就可以生成一个新对象出来,并且是原对象的深度拷贝。

 

. Singletom 模式只考虑到了对象创建的管理,没有考虑对象销毁的管理。就支持垃圾回收的平台和对象的开销来讲,我们一般没有必要对其销毁进行特殊的管理。

 

. 不能应对多线程环境:在多线程环境下,使用Singleton模式仍然有可能得到Singleton类的多个实例对象。

 

多线程Singleton 模式实现

/// <summary>
    
/// 多线程Singleton类
    
/// </summary>

     public   class  Singleton
    
{
        
private static volatile Singleton instance = null;

        
private static object lockHelper = new object();

        
private Singleton()
        
{
        }


        
public static Singleton Instance
        
{
            
get
            
{
                
if(instance==null)
                
{
                    
lock(lockHelper)
                    
{//双检查
                        if(instance==null)
                        
{
                            instance 
= new Singleton();
                        }


                    }

                }

                
return instance;
            }

        }

        
    }


其中,volatile 关键字指示字段可由操作系统、硬件或并发执行的线程在程序中进行修改。

 

使用.NET类型初始化机制实现多线程Singleton 模式

 

使用了静态构造器,.net framework可以提供内建的机制确保多线程访问时不会产生多个实例。

/// <summary>
    
/// 多线程Singleton类
    
/// </summary>

     public   class  Singleton
    
{
        
public static readonly Singleton Instance = new Singleton();

        
private Singleton()
        
{
        }
        
    }


与下面的类是等同的:

/// <summary>
    
/// 多线程Singleton类
    
/// </summary>


    
public   class  Singleton
    
{
        
public static readonly Singleton Instance;

        
static  Singleton()
        
{
            Instance 
= new Singleton();
        }
    
    
        
private Singleton()
        
{
        }

    }



Singleton模式扩展

 

. 将一个实例扩展到n个实例,例如对象池的实现。

 

. new 构造器的调用转移到其他类中,例如多个类协同工作环境中,某个局部环境只需要拥有某个类的一个实例。

 

. 理解和扩展Singleton模式的核心是“如何控制用户使用new对一个类的实例构造器的任意调用”。

.NET框架中的Singleton应用

            Class1 c1  =   new  Class1();
            Class1 c2 
=   new  Class1();

            Type t1 
=  c1.GetType();
            Type t2 
=  c2.GetType();

            
if (t1 == t2)
                Console.WriteLine(
" type equal " );


 

这里GetType()内部就是扩展了Singleton模式,从而确保只有一种type。再例如:HttpContext.Current也是一个Singleton的实例。



课后心得:

 

1使用了静态构造器,.net framework可以提供内建的机制确保多线程访问时不会产生多个实例。

 

2,初步了解使用idasm查看汇编出的代码结构,如下图:

2006101301.JPG

3,思考:

 

考虑单线程的Singleton模式:

public   class  Singleton
    
{
        
private static  Singleton instance;

        
private int x;
        
private int y;
      
        
private Singleton(int x,int y)
        
{
            
this.x = x;
            
this.y = y;
        }


        
public int X
        
{
            
get
            
{
                
return this.x;
            }

        }


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

            
return instance;
        }

    }


        
static   void  Main( string [] args)
        
{
            Singleton st1 
= Singleton.GetInstance(100,200);

            Singleton st2 
= Singleton.GetInstance(399,399);

Console.WriteLine(st1.X);

            Console.WriteLine(st2.X);
        }



会是什么结果呢?答案是都是100,因为.net的内建机制可以确保只会调用一次实例化过程,而不会受到你以后传的参数的影响。那你硬是想以后的参数修改也要有效,怎么办呢?很简单,只要修改如下:

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  staticSingleton
    
{

        
private int x;
        
private int y;

        
public static readonly staticSingleton  Instance = new staticSingleton();
        
public int X
        
{
            
get
            
{
                
return this.x;
            }

            
set
            
{
                
this.x = x;
            }

        }


        
public int Y
        
{
            
get
            
{
                
return this.y;
            }

            
set
            
{
                
this.y = y;
            }

        }


        
private staticSingleton()
        
{
        }

    }

        
static   void  Main( string [] args)
        
{
            staticSingleton st1 
= staticSingleton.Instance;
            st1.X 
= 100;
            st1.Y 
= 200;

            Console.WriteLine(st1.X);
        }

你可能感兴趣的:(cast)