设计模式速查版 - 结构型(下)

 

(接上篇)

5）外观模式（Facade Pattern）
6）享元模式（Flyweight Pattern）
7）代理模式（Proxy Pattern）

 

5.外观模式

1)简介:为子系统中的一组接口提供一个一致的界面.用来向外隐藏内部的具体细节.

2)结构图:

代码:

/// 子系统1 
public class SubSystem1 
{ 
    /// <summary></summary> 
    public void Operation1() 
    { 
        Console.Write("operation1..."); 
    } 
}

/// 子系统2 
public class SubSystem2 
{ 
    /// <summary></summary> 
    public void Operation2() 
    { 
        Console.Write("operation2..."); 
    } 
}

/// 子系统3 
public class SubSystem3 
{ 
    /// <summary></summary> 
    public void Operation3() 
    { 
        Console.Write("operation3..."); 
    } 
}

/// 外观类 
public class Facade 
{ 
    private SubSystem1 s1; 
    private SubSystem2 s2; 
    private SubSystem3 s3;

    public Facade() 
    { 
        s1 = new SubSystem1(); 
        s2 = new SubSystem2(); 
        s3 = new SubSystem3(); 
    
    }

    /// <summary></summary> 
    public void MethodA() 
    { 
        s1.Operation1(); 
        s2.Operation2(); 
        s3.Operation3(); 
    } 
    /// <summary></summary> 
    public void MethodB() 
    { 
    } 
}

class Program 
{ 
    static void Main(string[] args) 
    { 
        Facade facade = new Facade(); 
        facade.MethodA();

        //TODO 
        Console.ReadLine(); 
    } 
} 

4)适用:

当一个业务功能由多个独立负责的功能类组成,此时又不想暴露太多细节给用户,则可以考虑用外观模式给用户提供一个接口.这样可以降低类间的耦合性.

 

6. 享元模式

1)简介:才有缓存策略将相同对象缓存起来而不去生成新的对象.

2)结构图:

3)代码:

/// 享元对象工厂(缓存策略) 
   public class FlyweightFactory 
   { 
       /// 缓存表 
       private Dictionary<int, Flyweight> flyweights = new Dictionary<int, Flyweight>();

       /// <summary></summary> 
       public Flyweight GetFlyweight(int key) 
       { 
           if(!flyweights.ContainsKey(key)) 
               flyweights.Add(key, new ConcreteFlyweight()); 
           return (flyweights[key]); 
       } 
   }

   /// 享元抽象基类 
   public abstract class Flyweight 
   { 
   }

   /// 享元类 
   public class ConcreteFlyweight : Flyweight 
   {

   }

   /// 非享元类(不采取缓存策略) 
   public class UnsharedConcreteFlyweight : Flyweight 
   { 
    
   }

   class Program 
   { 
       static void Main(string[] args) 
       { 
           FlyweightFactory factory = new FlyweightFactory();

           Flyweight f1 = factory.GetFlyweight(1); 
           Flyweight f2 = factory.GetFlyweight(1); 
           Flyweight f3 = factory.GetFlyweight(3);

           Console.Write(Object.ReferenceEquals(f1,f2)); //TRUE 
           Console.Write(Object.ReferenceEquals(f1,f3)); //FALSE

//TODO 
           Console.ReadLine(); 
       } 
   } 

4)适用:

系统中需要生成同一个类(或相似类,可通过提取分离变成前者)的大量实例的时候可以考虑采用.缓存用到这个模式.

 

7.代理模式

1)简介:

为其他对象提供一种代理以控制对这个对象的访问.就是把一个类外面套个'马甲',用户只认识'马甲'而不认识这个类.

2)结构图:

 

3)代码:

/// 抽象基类,让Proxy和RealSubject继承,这样在用到RealSubject的地方就可以用到Proxy了 
    public abstract class Subject 
    { 
        /// <summary></summary> 
        public abstract void Request(); 
    }

    /// 真身 
    public class RealSubject : Subject 
    { 
        /// <summary></summary> 
        public override void Request() 
        { 
            Console.Write("you don not konw me"); 
        } 
    }

    /// 马甲 
    public class Proxy : Subject 
    { 
        private RealSubject realSubject = new RealSubject(); 
        /// <summary></summary> 
        public override void Request() 
        { 
            realSubject.Request(); 
        } 
    }

    class Program 
    { 
        static void Main(string[] args) 
        { 
            Proxy proxy = new Proxy(); 
            proxy.Request();

            //TODO 
            Console.ReadLine(); 
        } 
    }

4)适用:

1.向外界隐藏真实类. 2.可以在调用某个真实类的时候加业务逻辑,如权限控制,判断等.