设计模式-装饰模式

 我们要明白使用装饰模式目的是什么，只有搞清目的我们才有思路进行下一步设计，那么既然叫做装饰，他的核心功能肯定是装饰这个类的。

 我个人观点 装饰模式主要作用:

1：动态的为一个类添加功能（如果一个类不能被继承），并且可以随时撤销

2：改变类中某些对象并不影响其他的类

3：通过不同的具体装饰类来进行排列组合，创造更多的行为

我现在用笔的作用先简单的一步步说明装饰模式：

第一步： 定义一个接口 

 public interface IPen
   {
       string Write();
   }

 

第二步：基础类来实现这个接口（这个代表我们核心功能适用于普遍用户）

 public class DefalutPen:IPen
    {
       public string Write()
       {
           return "我的核心功能就是写字";
       }
    }

 第三步：现在这个功能已经适用于大多用户，那么现在突然有个用户需要验证之后我们才可以写字，此时我们只能进行扩展

  public class ValidationPen : IPen
    {
        private IPen pen;
        private string validInfo;
        public ValidationPen(IPen pen, string ValidInfo)
        {
            this.pen = pen;
            this.validInfo = ValidInfo;
        }

        public string Write()
        {
            string s = ValidPen() + " ";
            s += this.pen.Write();
            s = "验证类：" + s;
            return s;
        }

        private string ValidPen()
        {
            if (this.validInfo == "admin")
            {
                return "验证成功";
            }
            else
            {
                return "验证失败";
            }
        }

    }

 第四步：但是现在又有一部分人不需要验证，但是需要加密，然后才可以使用笔的功能，那么此时我们在次进行扩展

 public class EncryptionPen:IPen
   {
       private IPen pen;
       private string mode;

       public EncryptionPen(IPen pen, string Mode)
       {
           this.pen = pen;
           this.mode = Mode;
       }

       public string Write()
       {
           string s = Encryption() + " ";
           s += pen.Write();
           s = "加密类：" + s;
           return s;
       }

       private string Encryption()
       {
           string result = string.Empty;
           if (mode=="jm")
           {
               result = "正在加密";
           }
           else
           {
               result = "正在解密";
           }
           return result;
       }
   }

第五步：现在我们基本通过上述明白装饰模式的一个用法 现在看一下效果

第六步：回顾装饰模式作用：第一个：动态的为类添加额外的功能 比喻加密类，验证类，同时便于我们撤销。第二个：改变其中一个类并不影响其他类的功能，耦合性很低这是一个重大的优点。

第三个：根据不同的组合来实现更多的功能 我们可以把验证类和加密类当做参数传递 那么就会这个类的功能就有验证和加密了。有了很多的扩展性。

第七步：我们来看一个微软使用的装饰模式（Stream，DeflateStream(提供 Deflate算法压缩和解压缩的流方法)以及BufferedStream（缓冲流）） 我有选择的粘贴 大家如果有兴趣可以用反编译软件可以去看

 public abstract class Stream : IDisposable {
        public static readonly Stream Null = new NullStream();
        private const int _DefaultCopyBufferSize = 81920;
        [NonSerialized]
        private ReadWriteTask _activeReadWriteTask;
        [NonSerialized]
        private SemaphoreSlim _asyncActiveSemaphore;

        internal SemaphoreSlim EnsureAsyncActiveSemaphoreInitialized()
        {
         
            return LazyInitializer.EnsureInitialized(ref _asyncActiveSemaphore, () => new SemaphoreSlim(1, 1));
        }

        public abstract bool CanRead {
            [Pure]
            get;
        }

        public abstract bool CanSeek {
            [Pure]
            get;
        }
 public void CopyTo(Stream destination)
        {
            if (destination == null)
                throw new ArgumentNullException("destination");
            if (!CanRead && !CanWrite)
                throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_StreamClosed"));
            if (!destination.CanRead && !destination.CanWrite)
                throw new ObjectDisposedException("destination", Environment.GetResourceString("ObjectDisposed_StreamClosed"));
            if (!CanRead)
                throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnreadableStream"));
            if (!destination.CanWrite)
                throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnwritableStream"));
            Contract.EndContractBlock();

            InternalCopyTo(destination, _DefaultCopyBufferSize);
        }   
}

从上述代码可以看出Stream是一个抽象类（相当于我们的接口）但是Stream里面有抽象方法和虚方法两个模式（我们可以根据实际情况选择）再来看看一部DeflateStream类

public class DeflateStream : Stream {

        internal const int DefaultBufferSize = 8192;
        private Stream _stream;
        private CompressionMode _mode;
        private bool _leaveOpen;
        private Inflater inflater;
        private IDeflater deflater;        
        private byte[] buffer;
        
        private int asyncOperations; 
        private readonly AsyncCallback m_CallBack;
        private readonly AsyncWriteDelegate m_AsyncWriterDelegate;

        private IFileFormatWriter formatWriter;
        private bool wroteHeader;
        private bool wroteBytes;

        private enum WorkerType : byte { Managed, ZLib, Unknown };
        private static volatile WorkerType deflaterType = WorkerType.Unknown;


        public DeflateStream(Stream stream, CompressionMode mode)
            : this(stream, mode, false) {
        }              
        
        public DeflateStream(Stream stream, CompressionMode mode, bool leaveOpen) {
           
            if(stream == null )
                throw new ArgumentNullException("stream");

            if (CompressionMode.Compress != mode && CompressionMode.Decompress != mode)
                throw new ArgumentException(SR.GetString(SR.ArgumentOutOfRange_Enum), "mode");

            _stream = stream;
            _mode = mode;
            _leaveOpen = leaveOpen;

            switch (_mode) {

                case CompressionMode.Decompress:

                    if (!_stream.CanRead) {
                        throw new ArgumentException(SR.GetString(SR.NotReadableStream), "stream");
                    }

                    inflater = new Inflater();

                    m_CallBack = new AsyncCallback(ReadCallback); 
                    break;

                case CompressionMode.Compress:

                    if (!_stream.CanWrite) {
                        throw new ArgumentException(SR.GetString(SR.NotWriteableStream), "stream");
                    }

                    deflater = CreateDeflater(null);
                    
                    m_AsyncWriterDelegate = new AsyncWriteDelegate(this.InternalWrite);
                    m_CallBack = new AsyncCallback(WriteCallback); 

                    break;                        

            }  // switch (_mode)

            buffer = new byte[DefaultBufferSize];
        }

        public DeflateStream(Stream stream, CompressionLevel compressionLevel)

            : this(stream, compressionLevel, false) {
        }

        // Implies mode = Compress
        public DeflateStream(Stream stream, CompressionLevel compressionLevel, bool leaveOpen) {

            if (stream == null)
                throw new ArgumentNullException("stream");

            if (!stream.CanWrite)
                throw new ArgumentException(SR.GetString(SR.NotWriteableStream), "stream");

            // Checking of compressionLevel is passed down to the IDeflater implementation as it
            // is a pugable component that completely encapsulates the meaning of compressionLevel.

            Contract.EndContractBlock();

            _stream = stream;
            _mode = CompressionMode.Compress;
            _leaveOpen = leaveOpen;

            deflater = CreateDeflater(compressionLevel);

            m_AsyncWriterDelegate = new AsyncWriteDelegate(this.InternalWrite);
            m_CallBack = new AsyncCallback(WriteCallback);
           
            buffer = new byte[DefaultBufferSize];
        }  
  public override bool CanWrite { 
            get {
                if( _stream == null) {
                    return false;                
                }
                
                return (_mode == CompressionMode.Compress && _stream.CanWrite);
            }
        }
}

这个类就是对流的扩展我们可以看出里面有大量的扩展主要是进行压缩和解压缩的方法

public sealed class BufferedStream : Stream {
    private const Int32 _DefaultBufferSize = 4096;
    private Stream _stream;                       
    private Byte[] _buffer;                              
    private readonly Int32 _bufferSize;                  
    private Int32 _readPos;                             
    private Int32 _readLen;                            
    private Int32 _writePos;                                      
    private BeginEndAwaitableAdapter _beginEndAwaitable;                                                        
    private Task<Int32> _lastSyncCompletedReadTask;                                                             
    private BufferedStream() { }
    public BufferedStream(Stream stream)

        : this(stream, _DefaultBufferSize) {
    }


    public BufferedStream(Stream stream, Int32 bufferSize) {

        if (stream == null)
            throw new ArgumentNullException("stream");

        if (bufferSize <= 0)
            throw new ArgumentOutOfRangeException("bufferSize", Environment.GetResourceString("ArgumentOutOfRange_MustBePositive", "bufferSize"));

        Contract.EndContractBlock();

        BCLDebug.Perf(!(stream is FileStream), "FileStream is buffered - don't wrap it in a BufferedStream");
        BCLDebug.Perf(!(stream is MemoryStream), "MemoryStream shouldn't be wrapped in a BufferedStream!");
        BCLDebug.Perf(!(stream is BufferedStream), "BufferedStream shouldn't be wrapped in another BufferedStream!");
        _stream = stream;
        _bufferSize = bufferSize;
        if (!_stream.CanRead && !_stream.CanWrite)
            __Error.StreamIsClosed();
    }
 public override bool CanWrite {
        [Pure]
        get { return _stream != null && _stream.CanWrite; }
    }
}

这个类主要针对缓冲流的。我们可以看出DeflateStream和BufferedStream没什么联系其中一个改变不会导致另一个的变化 而且很容易扩展。这三个类并不很全自己可以去研究

第八步：总结：

1：一个类不能被继承，但是我们还需要动态的添加额外的功能那么装饰模式就是我们的首选。

2：既然不用继承就可以额外添加功能，为嘛我们还是继承公共接口。 我个人觉得这样做的好处1是统一一种规范，2是如果我们装饰被装饰的类那么我们就可以把被装饰的类当参数传递，我们就统一了接口。

3：继承也能完成这些功能为啥要用装饰模式。 主要从耦合度考虑我们使用继承 那么会在底层进行大量的逻辑判断 这样一来代码就极难维护，用装饰模式就避免了这些问题，因为他们都具有自己不同的装饰功能，

还有就是如果使用继承，如果基类修改了那么所有的代码都有影响（也许其他类根本不需要，使用装饰模式完全可以不理会新添加的功能。只需要改动需要的装饰类）