23种设计模式--结构型模式

7.适配器模式

#region 7.适配器模式(Adapter):将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作。
    /// <summary>
    /// 抽象适配类
    /// </summary>
    public interface IScoreOperation
    {
        // 成绩排序
        int[] Sort(int[] array);
        // 成绩查找
        int Search(int[] array, int key);
    }

    /// <summary>
    /// 适配器：成绩操作适配器类
    /// </summary>
    public class OperationAdapter : IScoreOperation
    {
        private QuickSortHelper sortTarget;
        private BinarySearchHelper searchTarget;

        public OperationAdapter()
        {
            sortTarget = new QuickSortHelper();
            searchTarget = new BinarySearchHelper();
        }

        public int Search(int[] array, int key)
        {
            return searchTarget.BinarySearch(array, key);
        }

        public int[] Sort(int[] array)
        {
            return sortTarget.QuickSort(array);
        }
    }

    #region 适配者

    /// <summary>
    /// 适配者A：快速排序类
    /// </summary>
    public class QuickSortHelper
    {
        public int[] QuickSort(int[] array)
        {
            Sort(array, 0, array.Length - 1);
            return array;
        }

        public void Sort(int[] array, int p, int r)
        {
            int q = 0;
            if (p < r)
            {
                q = Partition(array, p, r);
                Sort(array, p, q - 1);
                Sort(array, q + 1, r);
            }
        }

        public int Partition(int[] array, int p, int r)
        {
            int x = array[r];
            int j = p - 1;

            for (int i = p; i <= r - 1; i++)
            {
                if (array[i] <= x)
                {
                    j++;
                    Swap(array, j, i);
                }
            }

            Swap(array, j + 1, r);
            return j + 1;
        }

        public void Swap(int[] array, int i, int j)
        {
            int t = array[i];
            array[i] = array[j];
            array[j] = t;
        }
    }

    public class BinarySearchHelper
    {
        public int BinarySearch(int[] array, int key)
        {
            int low = 0;
            int high = array.Length - 1;

            while (low <= high)
            {
                int mid = (low + high) / 2;
                int midVal = array[mid];

                if (midVal < key)
                {
                    low = mid + 1;
                }
                else if (midVal > key)
                {
                    high = mid - 1;
                }
                else
                {
                    return 1;   // 找到元素返回1
                }
            }

            return -1;  // 未找到元素返回-1
        }
    }

    #endregion 




    #endregion

8.桥接模式

#region 8.桥接模式(Bridge)。将抽象部分与其实现部分分离，使得他们都可以独立地变化。桥接模式主要使用抽象关联取代传统的多重继承，将类之间的静态继承关系转换为动态地对象组合关系。

    /// <summary>
    /// 抽象抽象类
    /// </summary>
    public abstract class Image 
    {
        protected ImageImplementor imageImpl;
        public void SetImageImplementor(ImageImplementor imageImpl) 
        {
            this.imageImpl = imageImpl;
        }

        public abstract void ParstFile(string fileName);
    }


    public class PngImage : Image
    {
        public override void ParstFile(string fileName)
        {
            imageImpl.DoPaint();
            Console.WriteLine("{0} : 格式为PNG",fileName);
        }
    }

    public class BMPImage : Image
    {
        public override void ParstFile(string fileName)
        {
            imageImpl.DoPaint();
            Console.WriteLine("{0} : 格式为BMP",fileName);
        }
    }

    public class GifImage : Image
    {
        public override void ParstFile(string fileName)
        {
            imageImpl.DoPaint();
            Console.WriteLine("{0} : 格式为Gif",fileName);
        }
    }



    /// <summary>
    /// 抽象实现类
    /// </summary>
    public abstract class ImageImplementor 
    {
        public abstract void DoPaint();
    }

    #region 具体实现类

    public class WindowsImplementor : ImageImplementor
    {
        public override void DoPaint()
        {
            Console.WriteLine("在Windows系统中显示图像");
        }
    }

    public class LinuxImplementor : ImageImplementor
    {
        public override void DoPaint()
        {
            Console.WriteLine("在Linux系统中显示图像");
        }
    }

    public class UnixImplementor : ImageImplementor
    {
        public override void DoPaint()
        {
            Console.WriteLine("在Unix系统中显示图像");
        }
    }
    #endregion






    #endregion

9.组合模式

#region 9.组合模式(Composite)。 组合多个对象形成树形结构以表示具有"整体-部分"关系的层次结构。

    /// <summary>
    /// 抽象构件类
    /// </summary>
    public abstract class AbstractFile 
    {
        protected string name;
        protected AbstractFile(string name) 
        {
            this.name = name;
            Console.WriteLine("抽象类的构造方法");
        }
        public abstract void Add(AbstractFile file);
        public abstract void Remove(AbstractFile file);
        public abstract AbstractFile GetChild(int index);
        public abstract void KillVirus();

    }

    #region 叶子构件

    public class ImageFile : AbstractFile
    {
        public ImageFile(string name) : base(name)
        {
            Console.WriteLine("实现类的构造方法");
        }

        public override void Add(AbstractFile file)
        {
            Console.WriteLine("对不起，系统不支持该方法! ");
        }

        public override AbstractFile GetChild(int index)
        {
            Console.WriteLine("对不起，系统不支持该方法! ");
            return null;
        }

        public override void KillVirus()
        {
            Console.WriteLine("-------对图像文件'{0}进行杀毒'",name);
        }

        public override void Remove(AbstractFile file)
        {
            Console.WriteLine("对不起，系统不支持该方法! ");
        }
    }

    public class TextFile : AbstractFile
    {
        public TextFile(string name) : base(name)
        {
        }

        public override void Add(AbstractFile file)
        {
            Console.WriteLine("对不起，系统不支持该方法! ");
        }

        public override AbstractFile GetChild(int index)
        {
            Console.WriteLine("对不起，系统不支持该方法! ");
            return null;
        }

        public override void KillVirus()
        {
            Console.WriteLine("-------对文本文件'{0}进行杀毒'", name);
        }

        public override void Remove(AbstractFile file)
        {
            Console.WriteLine("对不起，系统不支持该方法! ");
        }
    }

    public class VideoFile : AbstractFile
    {
        public VideoFile(string name) : base(name)
        {
        }

        public override void Add(AbstractFile file)
        {
            Console.WriteLine("对不起，系统不支持该方法! ");
        }

        public override AbstractFile GetChild(int index)
        {
            Console.WriteLine("对不起，系统不支持该方法! ");
            return null;
        }

        public override void KillVirus()
        {
            Console.WriteLine("-------对音频文件'{0}进行杀毒'", name);
        }

        public override void Remove(AbstractFile file)
        {
            Console.WriteLine("对不起，系统不支持该方法! ");
        }
    }

    #endregion
    /// <summary>
    /// 容器构件
    /// </summary>
    public class Folder : AbstractFile
    {
        public Folder(string name) : base(name)
        {
        }
        private IList<AbstractFile> fileList = new List<AbstractFile>();

        public override void Add(AbstractFile file)
        {
            fileList.Add(file);
        }

        public override AbstractFile GetChild(int index)
        {
            return fileList[index];
        }

        public override void KillVirus()
        {
            Console.WriteLine("----对文件夹'{0}'进行杀毒",name);
            foreach (var item in fileList) 
            {
                item.KillVirus();
            }
        }

        public override void Remove(AbstractFile file)
        {
            fileList.Remove(file);
        }
    }

    public class NothingFile : ImageFile
    {
        public NothingFile(string name) : base(name)
        {
            Console.WriteLine("NothingFile构造函数");
        }
    }


    #endregion

10.装饰模式

#region 10.装饰模式(Decorator)。动态地给一个对象增加一些额外的职责。
    
    /// <summary>
    /// 抽象构件
    /// </summary>
    public abstract class Component 
    {
        public abstract void Dispaly();
    }

    #region 具体构件
    public class Window : Component
    {
        public override void Dispaly()
        {
            Console.WriteLine("显示窗体");
        }
    }

    public class TextBox : Component
    {
        public override void Dispaly()
        {
            Console.WriteLine("显示文本框");
        }
    }

    public class ListBox : Component
    {
        public override void Dispaly()
        {
            Console.WriteLine("显示列表框");
        }
    }

    #endregion 

    /// <summary>
    /// 抽象装饰
    /// </summary>
    public class ComponentDecorator : Component
    {
        private Component component;

        public ComponentDecorator(Component component) 
        {
            this.component = component;
            
        }
        public override void Dispaly()
        {
            component.Dispaly();
        }
    }

    /// <summary>
    /// 具体装饰
    /// </summary>
    public class ScrollBarDecorator : ComponentDecorator
    {
        public ScrollBarDecorator(Component component) : base(component)
        {

        }
        public override void Dispaly()
        {
            this.SetScrollBar();
            base.Dispaly();
        }
        public void SetScrollBar() 
        {
            Console.WriteLine("为构件增加滚动条");
        }
    }

    public class BlackBorderDecorator : ComponentDecorator
    {
        public BlackBorderDecorator(Component component) : base(component)
        {

        }
        public override void Dispaly()
        {
            this.SetBlacktBorder();
            base.Dispaly();
        }

        public void SetBlacktBorder() 
        {
            Console.WriteLine("为构件增加黑色边框。！");
        }
        
    }


    #endregion

11.外观模式

#region 11.外观模式(Facade)。外部与一个子系统的通信通过一个统一的外观角色进行，为子系统中的一组接口提供一个一致的入口。

    #region 子系统类
    /// <summary>
    /// 文件读取类：子系统A
    /// </summary>
    public class FileReader
    {
        public string Read(string fileNameSrc)
        {
            Console.WriteLine("读取文件，获取明文：");
            string result = string.Empty;
            using (System.IO.FileStream fsRead = new System.IO.FileStream(fileNameSrc, System.IO.FileMode.Open))
            {
                int fsLen = (int)fsRead.Length;
                byte[] heByte = new byte[fsLen];
                int r = fsRead.Read(heByte, 0, heByte.Length);
                result = System.Text.Encoding.UTF8.GetString(heByte);
            }

            return result;
        }
    }

    /// <summary>
    /// 数据加密类：子系统B
    /// </summary>
    public class CipherMachine
    {
        public string Encrypt(string plainText)
        {
            Console.WriteLine("数据加密，将明文转换为密文：");
            StringBuilder result = new StringBuilder();

            for (int i = 0; i < plainText.Length; i++)
            {
                string ch = Convert.ToString(plainText[i] % 7);
                result.Append(ch);
            }

            string encryptedResult = result.ToString();
            Console.WriteLine(encryptedResult);
            return encryptedResult;
        }
    }

    /// <summary>
    /// 文件保存类：子系统C
    /// </summary>
    public class FileWriter
    {
        public void Write(string encryptedStr, string fileNameDes)
        {
            Console.WriteLine("保存密文，写入文件：");
            byte[] myByte = System.Text.Encoding.UTF8.GetBytes(encryptedStr);
            using (System.IO.FileStream fsWrite = new System.IO.FileStream(fileNameDes, System.IO.FileMode.Append))
            {
                fsWrite.Write(myByte, 0, myByte.Length);
            };

            Console.WriteLine("写入文件成功：100%");
        }
    }
    #endregion

    /// <summary>
    /// 外观类
    /// </summary>
    public class EncryptFacade
    {
        private FileReader reader;
        private CipherMachine cipher;
        private FileWriter writer;

        public EncryptFacade()
        {
            reader = new FileReader();
            cipher = new CipherMachine();
            writer = new FileWriter();
        }

        public void FileEncrypt(string fileNameSrc, string fileNameDes)
        {
            string plainStr = reader.Read(fileNameSrc);
            string encryptedStr = cipher.Encrypt(plainStr);
            writer.Write(encryptedStr, fileNameDes);
        }
    }



    #endregion

12.享元模式

#region 12.享元模式(Flyweight)。 运用共享技术有效地支持大量细粒度对象的复用。

    public class Coordinates 
    {
        public int X { get; set; }
        public int Y { get; set; }
        public Coordinates() { }
        public Coordinates(int x, int y) 
        {
            this.X = x;
            this.Y = y;
        }
    }

    /// <summary>
    /// 抽象享元类
    /// </summary>
    public abstract class IgoChessman 
    {
        public abstract string GetColor();
        public void Display(Coordinates coord) 
        {
            Console.WriteLine("妻子颜色:{0},旗子位置:{1}", GetColor(), coord.X + "," + coord.Y);
        }
    }
    /// <summary>
    /// 具体享元类
    /// </summary>
    public class BlackChessman : IgoChessman
    {
        public override string GetColor()
        {
            return "黑色";
        }
    }

    /// <summary>
    /// 具体享元类
    /// </summary>
    public class WhiteChessman : IgoChessman
    {
        public override string GetColor()
        {
            return "白色";
        }
    }

    /// <summary>
    /// 享元工厂类
    /// </summary>
    public class IgoChessmanFactory 
    {
        private static readonly IgoChessmanFactory instance = new IgoChessmanFactory();
        private static Hashtable ht;//使用Hashtable来存储享元对象，充当享元池。

        private IgoChessmanFactory() 
        {
            ht = new Hashtable();
            IgoChessman blackChesssman = new BlackChessman();
            IgoChessman whiteChessman = new WhiteChessman();
            ht.Add("b", blackChesssman);
            ht.Add("w", whiteChessman);
        }

        public static IgoChessmanFactory GetInstance() 
        {
            return instance;
        }

        public IgoChessman GetIgoChessman(string color) 
        {
            IgoChessman chess = ht[color] as IgoChessman;
            return chess;
        }

    }


    #endregion

13.代理模式

#region 13.代理模式(Proxy)。给某一个对象提供一个代理，并由该代理对象控制对原对象的引用。

    /// <summary>
    /// 抽象代理
    /// </summary>
    public interface ISearcher 
    {
        string DoSearch(string userID, string keyword);
    }

    /// <summary>
    /// 被代理类
    /// </summary>
    public class RealSearcher
    {
        public string DoSearch(string userID, string keyword) 
        {
            Console.WriteLine("{0} 使用关键字 {1}",userID,keyword);
            return "返回具体内容";
        }
    }

    /// <summary>
    /// 具体代理类.
    /// </summary>
    public class ProxySearcher : ISearcher
    {
        private RealSearcher searcher = new RealSearcher();

        public string DoSearch(string userID, string keyword)
        {
            string result = searcher.DoSearch(userID, keyword);
            return result;
        }
    }




    #endregion