裝飾（Decorator）模式

1、 裝飾（Decorator）模式

　　裝飾（Decorator）模式又名包裝（Wrapper）模式[GOF95]。裝飾模式以對客戶端透明的方式擴展對象的功能，是繼承關係的一個替代方案。

2、 裝飾模式的結構

• 抽象構件（Component）角色：給出一個抽象接口，以規範準備接收附加責任的對象。
• 具體構件（Concrete Component）角色：定義一個將要接收附加責任的類。
• 裝飾（Decorator）角色：持有一個構件（Component）對象的實例，並定義一個與抽象構件接口一致的接口。
• 具體裝飾（Concrete Decorator）角色：負責給構件對象"貼上"附加的責任

 

       /// <summary>
    ///  裝飾（Decorator）模式
    ///  裝飾（Decorator）模式又名包裝（Wrapper）模式[GOF95]。
    ///  裝飾模式以對客戶端透明的方式擴展對象的功能，是繼承關係的一個替代方案。
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {  
            // 建立的書和視頻和顯示
            Book book = new Book("巴金", "家", 10);
            Video video = new Video("不詳","掃毒", 23, 120);
            book.Display();
            video.Display();

            // 查看圖書，而後借閱
            Console.WriteLine("\n查看圖書，而後借閱:");

            Borrowable borrowvideo = new Borrowable(book);
            borrowvideo.BorrowItem("小三");
            borrowvideo.BorrowItem("小四"); 

            borrowvideo.Display(); 
            Console.ReadLine();
        }
    }


    /// <summary>
    /// 抽象構件（Component）角色
    /// </summary>
    public abstract class LibraryItem
    {
        // 字段
        private int numCopies;
        // 屬性
        public int NumCopies
        {
            get { return numCopies; }
            set { numCopies = value; }
        }
        // 方法
        public abstract void Display();
    }

    /// <summary>
    /// 具體構件（Concrete Component）角色
    /// </summary>
    public class Book : LibraryItem
    {
        // 字段
        private string author;
        private string title;

        // 構造函數
        public Book(string author, string title, int numCopies)
        {
            this.author = author;
            this.title = title;
            this.NumCopies = numCopies;
        }

        // 函數
        public override void Display()
        {
            Console.WriteLine(" 書（Book） ------ ");
            Console.WriteLine(" 做者: {0}", author);
            Console.WriteLine(" 書名: {0}", title);
            Console.WriteLine(" # 副本: {0}", NumCopies);
        }
    }

    /// <summary>
    /// 具體構件（Concrete Component）角色
    /// </summary>
    public class Video : LibraryItem
    {
        // 字段
        private string director;
        private string title;
        private int playTime;

        // 構造函數
        public Video(string director, string title,int numCopies, int playTime)
        {
            this.director = director;
            this.title = title;
            this.NumCopies = numCopies;
            this.playTime = playTime;
        }

        // 方法
        public override void Display()
        {
            Console.WriteLine(" 視頻（Video） ----- ");
            Console.WriteLine(" 導演: {0}", director);
            Console.WriteLine(" 片名: {0}", title);
            Console.WriteLine(" # 副本: {0}", NumCopies);
            Console.WriteLine(" 時長: {0} 分鐘", playTime);
        }

    }

    /// <summary>
    /// 裝飾（Decorator）角色
    /// </summary>
    public abstract class Decorator : LibraryItem
    {
        // 字段
        protected LibraryItem libraryItem;

        // 構造函數
        public Decorator(LibraryItem libraryItem)
        { this.libraryItem = libraryItem; }

        // 方法
        public override void Display()
        { libraryItem.Display(); }

    }

    /// <summary>
    /// 具體裝飾（Concrete Decorator）角色
    /// </summary>
    public class Borrowable : Decorator
    {
        // 字段
        protected ArrayList borrowers = new ArrayList();

        // 構造函數
        public Borrowable(LibraryItem libraryItem)
            : base(libraryItem) { }

        // 方法
        public void BorrowItem(string name)
        {
            borrowers.Add(name);
            libraryItem.NumCopies--;
        }

        public void ReturnItem(string name)
        {
            borrowers.Remove(name);
            libraryItem.NumCopies++;
        }

        public override void Display()
        {
            base.Display();
            foreach (string borrower in borrowers)
                Console.WriteLine(" 借閱人: {0}", borrower);
        }
    }

3、 裝飾模式應當在什麼狀況下使用

在如下狀況下應當使用裝飾模式：

1. 須要擴展一個類的功能，或給一個類增長附加責任。
2. 須要動態地給一個對象增長功能，這些功能能夠再動態地撤銷。
3. 須要增長由一些基本功能的排列組合而產生的很是大量的功能，從而使繼承關係變得不現實。

　　4. 若是隻有一個 具體構件（Concrete Component）角色 的時候 能夠不要抽象構件（Component）角色

            //建立ConcreteComponent和兩個修飾符
            ConcreteComponent c = new ConcreteComponent();
            ConcreteDecoratorA d1 = new ConcreteDecoratorA();
            ConcreteDecoratorB d2 = new ConcreteDecoratorB();

            // 連接修飾符
            d1.SetComponent(c);
            d2.SetComponent(d1);

            d2.Operation(); 

   /// <summary>
    /// 抽象構件（Component）角色
    /// </summary>
    public abstract class Component
    {
        // 方法
        public abstract void Operation();
    }
    // "具體構建"
    public class ConcreteComponent : Component
    {
        // 方法
        public override void Operation()
        {
            Console.WriteLine("具體對象的操做");
        }
    }
    // 裝飾（Decorator）角色
    public abstract class Decorators : Component
    {
        // 字段
        protected Component component;
        // 方法
        public void SetComponent(Component component)
        {
            this.component = component;
        }
        public override void Operation()
        {
            if (component != null)
                component.Operation();
        }
    }

    // "具體裝飾A"
    class ConcreteDecoratorA : Decorators
    {
        private string addedState;
        public override void Operation()
        {
            base.Operation();
            addedState = "new state";
            Console.WriteLine("具體裝飾對象A的操做");
        }
    }

    // "具體裝飾B"
    public class ConcreteDecoratorB : Decorators
    {
        public override void Operation()
        {
            base.Operation();
            AddedBehavior();
            Console.WriteLine("具體裝飾對象B的操做");
        }
        void AddedBehavior()
        {
        }
    }

  
            Console.WriteLine("\n=========搭配衣服=============\n");

            Person xc = new Person("鳥人-安德森"); 
            TShirts tx = new TShirts();
            BigTrouser kk = new BigTrouser();

            tx.Decorate(xc);
            kk.Decorate(tx);
            kk.Show();


    /// <summary>
    /// 若是隻有一個 具體構件（Concrete Component）角色 的時候 
    /// 能夠不要抽象構件（Component）角色
    /// </summary>
    public class Person
    {
        public Person()
        { }
        private string name; 
        public Person(string name)
        {
            this.name = name;
        }
        public virtual void Show()
        {
            Console.WriteLine("裝扮的{0}", name);
        }
    }
   
    ///裝飾（Decorator）角色
    public class Finery : Person
    {
        protected Person component; 
        //打扮
        public void Decorate(Person component)
        {
            this.component = component;
        }
        public override void Show()
        {
            if (component != null)
                component.Show();
        }
    }

    /// <summary>
    /// 具體裝飾
    /// </summary>
    public class TShirts : Finery
    {
        public override void Show()
        {
            Console.WriteLine("大T恤");
            base.Show();
        }
    }

    /// <summary>
    /// 具體裝飾
    /// </summary>
    public class BigTrouser : Finery
    {
        public override void Show()
        {
            Console.WriteLine("大垮褲");
            base.Show();
        }
    }