class Program
    {
        static void Main(string[] args)
        {
            Director director = new Director(new ConcreteBuilder());
            director.ConStruct();
 
            Console.Read();
        }
    }
 
    public class Director
    {
        //指导者需要持有建造器的引用
        private Builder builders;
 
        //指定具体的建造器
        public Director(Builder builder)
        {
            this.builders = builder;
        }
 
        //间接调用建造器的方法
        public void ConStruct()
        {
            builders.BuildPart();
        }
 
    }
 
    /// <summary>
    /// 建造器
    /// </summary>
    public abstract class Builder
    {
       public abstract void BuildPart();
    }
 
    /// <summary>
    /// 具体的建造器
    /// </summary>
    public class ConcreteBuilder : Builder
    {
        //建造器需要持有产品的引用
        private Product resultProduct;
 
        public override void BuildPart()
        {
            Console.WriteLine("BuilderPartA");
        }
 
        /// <summary>
        /// 返回产品
        /// </summary>
        /// <returns></returns>
        public Product GetResult()
        {
            return resultProduct;
        }
    }
 
    /// <summary>
    /// 产品
    /// </summary>
    public class Product
    {
 
    }

class Program
    {
        static void Main(string[] args)
        {
            //准备测试数据
            ExportHeaderModel ehm = new ExportHeaderModel();
            ehm.DepId = "一分公司";
            ehm.ExportDate = "2010-05-18";
 
            Dictionary<String, List<ExportDataModel>> dicData = new Dictionary<String, 

List<ExportDataModel>>();

List<ExportDataModel> list = new List<ExportDataModel>();

ExportDataModel edm1 = new ExportDataModel();
edm1.ProductId = "产品001号";
edm1.Price = 100;
edm1.Amount = 80;

ExportDataModel edm2 = new ExportDataModel();
edm2.ProductId = "产品002号";
edm2.Price = 99;
edm2.Amount = 55;

//把数据组装起来
list.Add(edm1);
list.Add(edm2);

dicData.Add("销售记录表", list);

ExportFooterModel efm = new ExportFooterModel();
efm.ExportUser = "张三";

//测试输出到文本文件
TxtBuilder txtBuilder = new TxtBuilder();
//创建指导者对象
Director director = new Director(txtBuilder);
director.Construct(ehm, dicData, efm);
Console.WriteLine("输出到文本文件的内容：\n" + txtBuilder.GetResult());

Console.WriteLine("--------------------------------------------------------");

//测试输出到xml文件
XmlBuilder xmlBuilder = new XmlBuilder();

Director director2 = new Director(xmlBuilder);
director2.Construct(ehm, dicData, efm);

//xmlBuilder.BuildHeader(ehm);
//xmlBuilder.BuildBody(dicData);
//xmlBuilder.BuildFooter(efm);

//把要输出的内容输出到控制台看看
Console.WriteLine("输出到XML文件的内容：\n" + xmlBuilder.GetResult());

Console.Read();
}
}

#region 指导者

/// <summary>
/// 指导者，指导使用构建器的接口来构建输出的文件的对象
/// </summary>
public class Director
{

/// <summary>
/// 持有当前需要使用的构建器对象
/// </summary>
private Builder builder;

/// <summary>
/// 构造方法，传入构建器对象
/// </summary>
/// <param name="builder"></param>
public Director(Builder builder)
{
this.builder = builder;
}

/// <summary>
/// 指导构建器构建最终的输出的文件的对象
/// </summary>
/// <param name="ehm">文件头的内容</param>
/// <param name="dicData">数据的内容</param>
/// <param name="efm">文件尾的内容</param>
public void Construct(ExportHeaderModel ehm, Dictionary<String,

List<ExportDataModel>> dicData,

ExportFooterModel efm)
{
//可以在这进行校验

//1：先构建Header
builder.BuildHeader(ehm);

//实现一个Header的后处理

//可以在这里实现一些业务

//2：然后构建Body
builder.BuildBody(dicData);

//3：然后构建Footer
builder.BuildFooter(efm);
}
}
#endregion

#region Builder接口

/// <summary>
/// 构建器接口，定义创建一个输出文件对象所需的各个部件的操作
/// </summary>
public interface Builder
{
/// <summary>
/// 构建输出文件的Header部分
/// </summary>
/// <param name="ehm"></param>
void BuildHeader(ExportHeaderModel ehm);

/// <summary>
/// 构建输出文件的Body部分
/// </summary>
/// <param name="mapData"></param>
void BuildBody(Dictionary<string, List<ExportDataModel>> dicData);

/// <summary>
/// 构建输出文件的Footer部分
/// </summary>
/// <param name="efm"></param>
void BuildFooter(ExportFooterModel efm);
}
#endregion

#region ConcreteBuilder 导出到Txt

/// <summary>
/// 实现导出数据到文本文件的的构建器对象
/// </summary>
public class TxtBuilder : Builder
{
/// <summary>
/// 用来记录构建的文件的内容，相当于产品
/// </summary>
private StringBuilder strBuilder = new StringBuilder();
public void BuildBody(Dictionary<string, List<ExportDataModel>> dicData)
{
foreach (var tblName in dicData.Keys)
{
strBuilder.Append(tblName + "\n");
foreach (ExportDataModel edm in dicData.Values.FirstOrDefault())
{
strBuilder.Append(edm.ProductId + "," + edm.Price + "," + edm.Amount);
}
}
}

public void BuildFooter(ExportFooterModel efm)
{
strBuilder.Append(efm.ExportUser);
}

public void BuildHeader(ExportHeaderModel ehm)
{
strBuilder.Append(ehm.DepId + "," + ehm.ExportDate + "\n");
}

public string GetResult()
{
return strBuilder.ToString();
}
}
#endregion

#region ConcreteBuilder 导出到XML文件

/// <summary>
/// 实现导出数据到XML文件的的构建器对象
/// </summary>
public class XmlBuilder : Builder
{
/// <summary>
/// 用来记录构建的文件的内容，相当于产品
/// </summary>
private StringBuilder strBuilder = new StringBuilder();

public void BuildHeader(ExportHeaderModel ehm)
{
strBuilder.Append("<?xml version='1.0' encoding='gb2312'?>\n");
strBuilder.Append("<Report>\n");
strBuilder.Append(" <Header>\n");
strBuilder.Append(" <DepId>" + ehm.DepId + "</DepId>\n");
strBuilder.Append(" <ExportDate>" + ehm.ExportDate + "</ExportDate>\n");
strBuilder.Append(" </Header>\n");
}

public void BuildBody(Dictionary<string, List<ExportDataModel>> dicData)
{
strBuilder.Append(" <Body>\n");
foreach (var tblName in dicData.Keys)
{
strBuilder.Append(" <Datas TableName=\"" + tblName + "\">\n");
foreach (ExportDataModel edm in dicData.Values.FirstOrDefault())
{
strBuilder.Append(" <Data>\n");
strBuilder.Append(" <ProductId>" + edm.ProductId +

"</ProductId>\n");
strBuilder.Append(" <Price>" + edm.Price + "</Price>\n");
strBuilder.Append(" <Amount>" + edm.Amount + "</Amount>\n");
strBuilder.Append(" </Data>\n");
}
strBuilder.Append(" </Datas>\n");
}
strBuilder.Append(" </Body>\n");
}

public void BuildFooter(ExportFooterModel efm)
{
//对象的创建过程

//不是由自己来创建对象，而是使用其它组件创建的对象
//比如：简单工厂、工厂方法
MyFooter mf = FooterFactory.createMyFooter();

//组件组装过程
strBuilder.Append(mf.GenHeader(efm));
}

public string GetResult()
{
return strBuilder.ToString();
}

}

/// <summary>
/// XML 文件尾工厂
/// </summary>
public class FooterFactory
{
public static MyFooter createMyFooter()
{
return new MyFooter();
}
}

/// <summary>
/// XML 具体实现
/// </summary>
public class MyFooter
{
public String GenHeader(ExportFooterModel efm)
{
String str = " <Footer>\n";
str += " <ExportUser>" + efm.ExportUser + "</ExportUser>\n";
str += " </Footer>\n";
str += "</Report>\n";
return str;
}
}
#endregion

#region 产品

/// <summary>
/// 文件头部分
/// </summary>
public class ExportHeaderModel
{
/// <summary>
/// 分公司或门市点编号
/// </summary>
public String DepId { get; set; }
/// <summary>
/// 导出数据的日期
/// </summary>
public String ExportDate { get; set; }
}

/// <summary>
/// 文件体部分
/// </summary>
public class ExportDataModel
{
/// <summary>
/// 产品编号
/// </summary>
public string ProductId { get; set; }
/// <summary>
/// 产品价格
/// </summary>
public int Price { get; set; }
/// <summary>
/// 产品数量
/// </summary>
public int Amount { get; set; }
}

/// <summary>
/// 文件尾部分
/// </summary>
public class ExportFooterModel
{
/// <summary>
/// 输出人
/// </summary>
public String ExportUser { get; set; }
}
#endregion

class Program
    {
        static void Main(string[] args)
        {
            Facade facade = new Facade();
            facade.Test();
 
            Console.ReadKey();
        }
    }
 
    public class Facade
    {
        public void Test()
        {
            IAModuleApi aapi=new AModuleApi();
            aapi.TestA();
            IBModuleApi bapi=new BModuleApi();
            bapi.TestB();
            ICModuleApi capi = new CModuleApi();
            capi.TestC();
        }
    }
 
    public interface IAModuleApi
    {
        void TestA();
    }
 
    public class AModuleApi:IAModuleApi
    {
        public void TestA()
        {
            Console.WriteLine("使用了AModuleApi");
        }
    }
 
    public interface IBModuleApi
    {
        void TestB();
    }
 
    public class BModuleApi : IBModuleApi
    {
        public void TestB()
        {
            Console.WriteLine("使用了BModuleApi");
        }
    }
 
    public interface ICModuleApi
    {
        void TestC();
    }
 
    public class CModuleApi : ICModuleApi
    {
        public void TestC()
        {
            Console.WriteLine("使用了CModuleApi");
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            //创建需要被适配的对象
            Adaptee adaptee = new Adaptee();
            //创建客户端需要调用的接口对象
            ITarget traget = new Adapter(adaptee);
            //请求处理
            traget.Request();
            Console.ReadKey();
        }
    }
 
 
    public interface ITarget
    {
        void Request();
    }
 
    /// <summary>
    /// 已存在的接口，需要被适配
    /// </summary>
    public class Adaptee
    {
        public void SpecificRequest()
        {
            Console.WriteLine("调用老系统功能");
        }
    }
 
    /// <summary>
    /// 适配器
    /// </summary>
    public class Adapter : ITarget
    {
        /// <summary>
        /// 持有需要被适配的接口对象
        /// </summary>
        Adaptee adaptee = null;
 
        /// <summary>
        /// 构造函数，传入需要被适配的对象
        /// </summary>
        /// <param name="adaptee"></param>
        public Adapter(Adaptee adaptee)
        {
            this.adaptee = adaptee;
        }
 
        public void Request()
        {
            //转调
            adaptee.SpecificRequest();
        }
    }