博客园_蜡笔小巢

《模式——工程化实现及扩展》示例代码下载

2012-04-17T02:38:00Z

大家好：

卓越-亚马逊
模式:工程化实现及扩展（设计模式C# 版）模式:工程化实现及扩展(设计模式Java版)
互动出版网（China-Pub）

模式:工程化实现及扩展（设计模式C# 版）模式:工程化实现及扩展(设计模式Java版)

京东

模式:工程化实现及扩展（设计模式C# 版）模式:工程化实现及扩展(设计模式Java版)

当当

模式:工程化实现及扩展（设计模式C# 版）模式:工程化实现及扩展(设计模式Java版)

两本书的示例代码下载

C#版以及我在用的TestDriven.NET工具、Java版

欢迎大家多提批评和意见，如果对于书籍和示例有更好的想法，也请留言，便于继续改进。

谢谢大家。

本文链接

有关《模式——工程化实现及扩展（设计模式C# 版）》一书中多个章节示例代码中缺少空格的公告

2012-04-11T07:50:00Z

大家好：

我是《模式——工程化实现及扩展》系列的作者王翔。

最近上市的《模式——工程化实现及扩展（设计模式C# 版）》一书中发现有些章节出现了示例代码中缺少空格的问题，尽管现在还没找到具体出错环节，但我最后一次复审时没有认真校对代码是最主要的原因，向大家致歉。也请大家购买前注意注意C#这本书的这个问题。

网上的示例代码是可以正常编译并进行单元测试的。

C#这本书出错原因初步估计是最终排版时，由于要对示例代码统一字体，做字体转换时导致代码中空格丢失有关。

《模式:工程化实现及扩展(设计模式Java版) 》经过重新梳理暂时还没有发现相同的问题，可能与我机器上Eclipse和Visual Studio默认字体不同有关。

联系出版社的编辑后，也建议大家以后写作时尽可能考虑用标宋和Times New Roman这两个标准字体写作。

本文链接

通过Java SE 7自带的监控服务（WatchService API）实现类似.NET FileWatcher的功能

2011-08-04T03:00:00Z

转自：王翔《模式——工程化实现及扩展》（设计模式Java 版）

http://www.cnblogs.com/callwangxiang/

Java SE 7 Tutorial中增加了一个监控目录变更情况的示例，用于介绍其新发布的WatchService API。

但对于用惯了.NET FileWatcher的用户而言，如果用于项目我认为它有两个欠缺：

1、应该提供一个独立线程后台运行机制，让这个监控过程自己在后台转，不影响前端处理

2、 Java不像.NET有内置的源生事件机制，不过可以借助它内置的Observer/Observable对象用观察者模式实现准事件

下面是把Java SE Tutorial示例中无关内容删除，补充上述两个扩展后的实现，因为这个API比较新，也希望能和大家多多探讨：

1、参考.NET定义事件参数对象

package marvellousworks.practicalpattern.concept.unittest;

import java.nio.file.WatchEvent.Kind;

/**
* 文件系统事件类型
* @author wangxiang
*
*/
public final class FileSystemEventArgs {
    private final String fileName;
    private final Kind<?> kind;

    public FileSystemEventArgs(String fileName, Kind<?> kind){
        this.fileName = fileName;
        this.kind = kind;
    }

    /**
     * 文件的路径
     */
    public String getFileName(){return fileName;}

    /**
     * 操作类型：变更、创建、删除
     */
    @SuppressWarnings("rawtypes")
    public Kind getKind(){return kind;}
}

2、定义DirectoryWatcher，用于监控某个文件夹，至于如何扩展FileWatcher则可以在这个基础上通过限定文件名称和操作类型的方式扩展

package marvellousworks.practicalpattern.concept.unittest;

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.WatchEvent;
import java.nio.file.WatchEvent.Kind;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.util.Observable;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

import static java.nio.file.StandardWatchEventKinds.*;

/**
* 监控一个目录内文件的更新、创建和删除事件（不包括子目录）
*
* 对于http://download.oracle.com/javase/tutorial/essential/io/notification.html进行了改造
* 使其更接近.NET的DirectoryWatcher使用习惯
*
* 由于java没有类似.NET源生的事件机制
* 因此实现上采用了Java SE自带的Observer/Observable对象对外抛出“假”事件
*
* 适于Java SE 7
*
* @author wangxiang
*
*/
public class DirectoryWatcher extends Observable{

    private WatchService watcher;
    private Path path;
    private WatchKey key;
    private Executor executor = Executors.newSingleThreadExecutor();

    FutureTask<Integer> task = new FutureTask<Integer>(
            new Callable<Integer>(){
                public Integer call() throws InterruptedException{
                    processEvents();
                    return Integer.valueOf(0);}});

    @SuppressWarnings("unchecked")
    static <T> WatchEvent<T> cast(WatchEvent<?> event) {
        return (WatchEvent<T>) event;
    }

    public DirectoryWatcher(String dir) throws IOException {
        watcher = FileSystems.getDefault().newWatchService();
        path = Paths.get(dir);
        //    监控目录内文件的更新、创建和删除事件
        key = path.register(watcher, ENTRY_MODIFY, ENTRY_CREATE, ENTRY_DELETE);
    }

    /**
     * 启动监控过程
     */
    public void execute(){
        // 通过线程池启动一个额外的线程加载Watching过程
        executor.execute(task);
    }

    /**
     * 关闭后的对象无法重新启动
     * @throws IOException
     */
    public void shutdown() throws IOException {
        watcher.close();
        executor = null;
    }

    /**
     * 监控文件系统事件
     */
    void processEvents() {
        while (true) {
            // 等待直到获得事件信号
            WatchKey signal;
            try {
                signal = watcher.take();
            } catch (InterruptedException x) {
                return;
            }

            for (WatchEvent<?> event : signal.pollEvents()) {
                Kind<?> kind = event.kind();

                // TBD - provide example of how OVERFLOW event is handled
                if (kind == OVERFLOW) {
                    continue;
                }

                // Context for directory entry event is the file name of entry
                WatchEvent<Path> ev = cast(event);
                Path name = ev.context();
                notifiy(name.getFileName().toString(), kind);
            }
            //    为监控下一个通知做准备
            key.reset();
        }
    }

    /**
     * 通知外部各个Observer目录有新的事件更新
     */
    void notifiy(String fileName, Kind<?> kind){
        // 标注目录已经被做了更改
        setChanged();
        //     主动通知各个观察者目标对象状态的变更
        //    这里采用的是观察者模式的“推”方式
        notifyObservers(new FileSystemEventArgs(fileName, kind));
    }
}

3、单元测试

package marvellousworks.practicalpattern.concept.unittest;

import static org.junit.Assert.*;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

import org.junit.Test;
import static java.nio.file.StandardWatchEventKinds.*;

public class DirectoryWatcherFixture {

    private static final String DIR_PATH =System.getProperty("user.dir");
    private static final File DIR = new File(DIR_PATH);
    private static final String SUFFIX = ".txt";
    private static final String PREFIX = "test";
    private static final int ADD_TIMES = 3;

    /**
     * 观察者
     * @author wangxiang
     *
     */
    public class Logger implements Observer{
        @Override
        public void update(Observable observable, Object eventArgs) {
            FileSystemEventArgs args = (FileSystemEventArgs) eventArgs;
            System.out.printf("%s has been %s\n", args.getFileName(), args.getKind());
            assertTrue(args.getFileName().startsWith(PREFIX));
                assertEquals(ENTRY_CREATE, args.getKind());
        }
    }

    @Test
    public void testWatchFile() throws IOException, InterruptedException{
        DirectoryWatcher watcher = new DirectoryWatcher(DIR_PATH);
        Logger l1 = new Logger();
        watcher.addObserver(l1);
        watcher.execute();

        //    创建一系列临时文件
        List<String> files = new ArrayList<>();
        for(int i=0; i<ADD_TIMES; i++){
            files.add(File.createTempFile(PREFIX, SUFFIX, DIR).toString());
        }

        //    延迟等待后台任务的执行
        Thread.sleep(4000);
        watcher.shutdown();
        System.out.println("finished");
    }
}

Console窗口显示的测试内容

test5769907807190550725.txt has been ENTRY_CREATE
test4657672246246330348.txt has been ENTRY_CREATE
test1823102943601166149.txt has been ENTRY_CREATE
finished

本文链接

原型模式要克隆什么？

2011-07-02T15:06:00Z

转自：《模式——工程化实现及扩展》（设计模式C#版和Java版）

http://www.cnblogs.com/callwangxiang/

原型模式梗概：它构造的过程就是选择一个对象（被称为原型对象或“样本”），通过调用它的“克隆”方法就获得一个和它一样的对象，一般我们称这个克隆出的结果为 “副本”。

项目中，原型模式有些悲哀，因为它总是被大家忘掉。但在.NET Framework/JVM底层，克隆本身又是个By Design的内置机制，客户端、服务器端传递业务对象本身就是咫尺天涯，克隆对象必不可少。

软件系统中往往总存在某个不稳定的业务领域，其中类型的变化和扩充别频繁，不仅是继承深度上的，还有可能是来自于平级类型的宽度上的。按照前面的思路，为了尽量让客户程序构造它们的时候不必与每个具体类型产生深度或广度上的直接依赖，需要借助其他对象来封装这个new()的过程。之前我们介绍过简单工厂、工厂方法模式和抽象工厂模式，但如果对象类型的变化相对太频繁，有时候“没完没了”地为它们创建各种工厂不值得。

经典原型模式用的就是这个思路：

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

仔细解读还可以发现尽管一般设计模式书籍的示例都会克隆整个目标实例，但在经典原型模式的介绍中并没有这个要求。与生活中的克隆技术一样，有的科学家在克隆羊、克隆牛甚至在偷偷摸摸的克隆人，但还有很多科学家专注于克隆人体的一部分，比如：心脏、上肢……，实际项目中我们使用原型模式时也可以借鉴这个思路，

比如：

一个复杂对象的可能提供clone()方法克隆整个对象
也可以同时提供clonePartA()、clonePartB()等方法克隆出局部对象
进一步，甚至可以克隆出相对独立的其他类型，就好像我们克隆一个博文对象，克隆的不是整个博文、也不是其中的文字、插图，而是在1024 x 768分辨率下这篇博文的在IE 8.0下一个截图（Image类型）

另外，有的时候我们需要构造不是“若只如初见”的类型实例，而是需要构造与某个对象“当时”状态一样的实例。

本文链接

难念的经——Java命名规范

2011-06-14T02:50:00Z

最近在对书稿的Java分册代码进行统稿。

因为现在看到的《Code Conventions for the Java TM Programming Language》还是上世纪的，最近一次修订是1999年，所以就咨询了很多专门做Java的朋友。

大家很热心，各位朋友推荐推荐看了很多资料，《实现模式》、Java SDK的源码以及AspectJ、Hibernate，结果越念越糊涂。

看了几个库，就连Java SE标准库自己的源码命名风格也是百花齐放。

有的开始参考C#，用Ixxxx表示接口，有的还是沿用现有的。
对于内部类的命名就更有意思了。
而且命名Control类的时候，有的用现在分词、有的用过去分词，有的用使能动词....

难道Java自己的标准库不是ORACLE（以前是SUN）一家生产的？

我其实只想知道有关泛型、事件、反射、标注、配置文件节点的一个官方命名规范。

本文链接

C# 实现设计模式应该不拘一格

2011-06-12T04:56:00Z

如同每个人都有其个性一样，每种开发语言也有自己的个性。

项目中，我们固然可以机械地将一种语言的开发经验套用到另一种语言，但效果不一定好，因为：

· 语言有自己的短处：用短处去实现不仅费时费力，结果也不理想

· 语言有自己的长处：但为了沿用以前的经验削足适履，没有用到语言的精要，结果是暴殄天物

相信你也发现了，用一个语言写Hello world是一回事、写一个应用是一回事、写好一个应用则完全是另一回事，这就是工程化代码和“玩具”代码的区别。教科书上的知识落实到工程不能按图索骥，需要考虑开发语言和目标环境，设计模式也不例外。

也许你会觉用泛型、委托、事件、属性、配置文件等方式实现与《设计模式》介绍的内容不一致，但别忘了《设计模式》一书出版至今已近20年，其间无论是开发语言还是技术平台已经“换了人间”，GOF 23个模式的思想不仅影响着我们更影响着走在技术前沿的语言设计者、平台设计者，他们也在工作中潜移默化的把模式思想融入自己的工作成果，作为用户我们“推却”别人的盛情，所有事情都从“车轮”做起，多少有点不经济。

项目中，我们应该用最“C#”的方式将自己对于设计模式的理解铸入自己的成果，而且实现上务求简洁、直接。

本文链接

继承——若只如初见

2011-06-06T04:13:00Z

相信在开始学习C++、Java、C#等面向对象语言的时候，你总是先接触到继承概念。

老师或书籍总是通过继承让我们相信面向对象开发可以大大节省编码量，因为需要一个新特性的类型时，扩展并添加一两个方法就可以了。

但工作几年后，我们自己逐渐发现继承不总是那么好，尤其当你的设计处于继承结构的底层的时候，每次修改总是牵扯面太大,不愿意或者不敢去修改这些内容。然后，我们借鉴Delphi早期类库设计的技巧，把底层类的大部分方法都定义为虚方法，结果随着项目代码规模的扩大，开发期最灵活的设计往往到了生产环境却造成最难排查的问题。

最后，我们接受了基于接口编程的思路。设计模式也一直倡导组合优于继承的概念，尤其在C#、Java等语言彻底不支持多继承之后，我们才把目光从“堆积”类变成“捆绑”接口。

如果在一开始学习的时候就有人提示一下多好。

继承若只如初见。

本文链接

《模式——工程化实现及扩展》（设计模式C# 版）《原型模式 Prototype》——“自我检验" 参考答案

2011-06-02T07:35:00Z

转自：《模式——工程化实现及扩展》（设计模式C# 版）

http://www.cnblogs.com/callwangxiang/

http://www.cnblogs.com/callwangxiang/archive/2011/06/02/ExerciseAAPrototype.html的参考答案

参考答案

1、修改Enterprise类，提供符合申报条件的有选择的序列化

[Serializable]
class Enterprise : ISerializable
{
    const string NameItem = "NAME";
    const string ProjectsItem = "PROJECTS";
    const string StaffItem = "STAFF";
    const string ProjectManagerItem = "PM";

    private readonly Certification ProfessionalPm =
        new Certification()
            {
                Name = ProjectManagerItem,
                Qualification = QualificationOptions.Professional
            };

    public string Name { get; set; }
    public Project[] Projects { get; set; }
    public Employee[] Staff { get; set; }

    /// <summary>
    /// 构造函数
    /// </summary>
    public Enterprise()
    {
    }

    /// <summary>
    /// 构造函数
    /// 还原过程
    /// </summary>
    /// <param name="info"></param>
    /// <param name="context"></param>
    protected Enterprise(SerializationInfo info, StreamingContext context)
    {
        Name = info.GetString(NameItem);
        Projects = (Project[])info.GetValue(ProjectsItem, typeof(Project[]));
        Staff = (Employee[])info.GetValue(StaffItem, typeof(Employee[]));

    }
/// <summary>
    /// 原型方法
    /// </summary>
    /// <returns></returns>
    /// <remarks>作为示例，没有抽象独立的原型类型接口IPrototype</remarks>
    public Enterprise Clone()
    {
        var graph = SerializationHelper.SerializeObjectToString(this);
        return SerializationHelper.DeserializeStringToObject<Enterprise>(graph);

    }
/// <summary>
    /// 自定义序列化过程
    /// </summary>
    /// <param name="info"></param>
    /// <param name="context"></param>
    public void GetObjectData(SerializationInfo info, StreamingContext context)

    {
        info.AddValue(NameItem, Name);if ((Projects != null) && (Projects.Count() > 0))
        {
            var items = Projects.Where
                (
                    x =>
                    (DateTime.Now.Year - x.EndYear <= 2)
                    && x.Scale > 3000
                );
            if (items != null)
                info.AddValue(ProjectsItem, items.ToArray());
        }
        if (Staff != null)
        {
            var items =
                from employee in Staff
                where
                    (employee.Certificates != null)
                    && (employee.Certificates.Count() > 0)
                    && (employee.Certificates.Where(x =>
                        string.Equals(x.Name, ProjectManagerItem) &&
                        x.CompareTo(ProfessionalPm) >= 0).Count() > 0)

                select new Employee()
                {
                    Name = employee.Name,
                    Certificates = employee.Certificates.Where(x => x.CompareTo(ProfessionalPm) > 0).ToArray()
                };
            if ((items != null) && (items.Count() > 0))
                info.AddValue(StaffItem, items.ToArray());
        }
    }

2、准备测试数据

Enterprise enterprise;

[TestInitialize]
public void Initialize()
{
    var thisYear = DateTime.Now.Year;
    enterprise = new Enterprise()
                {
                    Name = "A",
                    Projects = new Project[]
                            {
                                //  金额不符合
                                new Project() {EndYear = thisYear, Scale = 1500},
                                //  符合
                                new Project() {EndYear = thisYear - 1, Scale = 3500},
                                //  时间不符合
                                new Project() {EndYear = thisYear - 3, Scale = 5000},
                                //  符合
                                new Project() {EndYear = thisYear - 1, Scale = 7500}
                            },
                    Staff = new Employee[]
                            {
                                // PM级别不符合
                                new Employee(){
                                    Name = "E1",
                                    Certificates = new Certification[]
                                                                {
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="ARCH",
                                                                            Qualification = QualificationOptions.Professional
                                                                        }
                                                                }
                                },
                                // 符合
                                new Employee(){
                                    Name = "E2",
                                    Certificates = new Certification[]
                                                                {
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Senior
                                                                        }
                                                                }
                                },
                                // 证书类别不符合
                                new Employee(){
                                    Name = "E3",
                                    Certificates = new Certification[]
                                                                {
                                                                    new Certification()
                                                                        {
                                                                            Name="ARCH",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="ARCH",
                                                                            Qualification = QualificationOptions.Senior
                                                                        }
                                                                }
                                },
                                // 符合
                                new Employee(){
                                    Name = "E4",
                                    Certificates = new Certification[]
                                                                {
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Professional
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Principal
                                                                        }
                                                                }
                                },

                            }
                };
}

3、执行单元测试

[TestMethod]
public void Test()
{
    Initialize();
    var clone = enterprise.Clone();
    Assert.AreEqual<string>(enterprise.Name, clone.Name);

    //  企业结项项目信息
    Assert.AreEqual<int>(2, clone.Projects.Count());

    //  企业人员信息
    Assert.AreEqual<int>(2, clone.Staff.Count());
}

Output窗口测试结果

------ Test started: Assembly: Prototype.Tests.dll ------

1 passed, 0 failed, 0 skipped, took 0.32 seconds (Ad hoc).

本文链接

《模式——工程化实现及扩展》（设计模式C# 版）《原型模式 Prototype》——“自我检验"

2011-06-02T07:28:00Z

转自：《模式——工程化实现及扩展》（设计模式C# 版）

http://www.cnblogs.com/callwangxiang/

自我检验

假设由你完成一个企业申报数据序列化的程序，企业信息实体需要按照“计算机信息系统集成资质”1级的要求将满足申报条件的信息序列化。请结合本章介绍的自定义深层复制方式，实现原型对象，并通过单元测试验证。

为了便于示例，对“计算机信息系统集成资质”1级的要求节选如下：

1、近三年内完成至少两项3000万元以上系统集成项目

2、具有计算机信息系统集成项目经理人数不少于25名，其中高级项目经理人数不少于8名

示例并不对企业整体是否满足申报要求进行审核，仅对满足申报要求的类成员进行筛选。示例涉及的数据结构如下，请改造Enterprise类为原型模式类型：

[Serializable]
class Project
{
    /// <summary>
    /// 结项年份
    /// </summary>
    public int EndYear { get; set; }

    /// <summary>
    /// 项目资金规模(万元)
    /// </summary>
    public double Scale { get; set; }
}

[Flags]
enum QualificationOptions
{
    Assisstant,      //  助理级
    Professional,    //  专家级
    Senior,          //  高级、资深级
    Principal        //  主任、主管级
}

[Serializable]
class Certification : IComparable<Certification>
{
    public string Name { get; set; }
    public QualificationOptions Qualification { get; set; }

    public int CompareTo(Certification other)
    {
        if(other == null) throw new ArgumentNullException("other");
        if(!string.Equals(other.Name, Name)) throw new NotSupportedException();
        if(Qualification == other.Qualification) return 0;
        return Qualification > other.Qualification ? 1 : -1;
    }
}

[Serializable]
class Employee
{
    public string Name { get; set; }
    public Certification[] Certificates { get; set; }
}

[Serializable]
class Enterprise : ISerializable
{
    public string Name { get; set; }
    public Project[] Projects { get; set; }
    public Employee[] Staff { get; set; }
}

本文链接

《模式——工程化实现及扩展》（设计模式C# 版）《连贯接口 Fluent Interface》——“自我检验"参考答案

2011-05-31T15:27:00Z

转自：《模式——工程化实现及扩展》（设计模式C# 版）

http://www.cnblogs.com/callwangxiang/

http://www.cnblogs.com/callwangxiang/archive/2011/05/31/ExerciseAAFluentInterface.html的参考答案

参考答案

设计要点：

采用连贯接口设计表格的创建过程
由于表格Head涉及一层嵌套、Body涉及两层嵌套，因此为了便于调整和修改，每个节点元素类型都要保留回溯到父节点的引用

1、设计具有Fluent特征的抽象节点类型

/// <summary>
/// 修改后具有Fluent特征的集合类型
/// </summary>
/// <typeparam name="T">集合元素类型</typeparam>
/// <typeparam name="TParent">父节点类型</typeparam>
class FluentCollection<TElement, TParent>
where TElement : class
where TParent : class
{
protected List<TElement> list = new List<TElement>();
TParent parent;

public FluentCollection(TParent parent)
{
if(parent == null) throw new ArgumentNullException("parent");
this.parent = parent;
}

/// <summary>
/// 返回父节点
/// </summary>
public TParent Parent{get{ return parent;}}

/// <summary>
/// 如何获得一个TElement类型实例的委托
/// </summary>
public Func<TElement> GetInstance { get; set; }

/// <summary>
/// 具有fluent特征的追加操作
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public FluentCollection<TElement, TParent> Add(TElement t)
{
list.Add(t);
return this;
}

/// <summary>
/// 具有fluent特征的空置操作
/// </summary>
/// <returns></returns>
public FluentCollection<TElement, TParent> Skip
{
get
{
list.Add(GetInstance());
return this;
}
}

/// <summary>
/// 执行LINQ的foreach操作
/// </summary>
/// <param name="action"></param>
public void ForEach(Action<TElement> action)
{
list.ForEach(action);
}
}

/// <summary>
/// 父节点为table的元素
/// </summary>
class WithTableObject
{
Table table; // 父节点
public WithTableObject(Table table)
{
if(table == null) throw new ArgumentNullException("table");
this.table = table;
}

/// <summary>
/// 指向父节点——table
/// </summary>
public Table Parent{get{ return table;}}
}

2、定义各个节点类型

class Notation
{
public Notation(){Data = string.Empty;}
public Notation(string data) {Data = data; }
public string Data { get; private set; }
}

/// <summary>
/// n元素
/// </summary>
class Item : Notation
{
public Item():base(){}
public Item(string data) : base(data){}
}

/// <summary>
/// col 元素
/// </summary>
class Column : Notation
{
public Column():base(){}
public Column(string data) : base(data) { }
}

/// <summary>
/// line 元素
/// </summary>
class Line
{
FluentCollection<Item, Line> items;
Body body;

public Line(Body body)
{
if(body == null) throw new ArgumentNullException("body");
this.body = body;
items = new FluentCollection<Item, Line>(this)
{
GetInstance = () => { return new Item(); }
};
}

/// <summary>
/// 父节点
/// </summary>
public Body Body { get { return body; } }

public FluentCollection<Item, Line> Items { get { return items; } }

public Line NewLine{get{return body.NewLine;}}
}

/// <summary>
/// body 元素
/// </summary>
class Body : WithTableObject
{
List<Line> lines = new List<Line>();
public Body(Table table) : base(table){}

public Line NewLine
{
get
{
var line = new Line(this);
lines.Add(line);
return line;
}
}

public List<Line> Lines { get { return lines;}}
}

/// <summary>
/// head 元素
/// </summary>
class Head : WithTableObject
{
FluentCollection<Column, Head> columns;

public Head(Table table) : base(table)
{
columns = new FluentCollection<Column, Head>(this)
{
GetInstance = () => { return new Column(); }
};
}

public FluentCollection<Column, Head> Columns { get { return columns; } }
}

class Table
{
string name;
Body body;
Head head;

public Table()
{
body = new Body(this);
head = new Head(this);
}

public Table Name(string name)
{
if(string.IsNullOrEmpty(name)) throw new ArgumentNullException("name");
this.name = name;
return this;
}

public override string ToString(){return name;}

public Body Body{get{ return body;}}
public Head Head{get{ return head;}}
}

3、定义生成电子表格的数据类型

4、单元测试

[TestClass]
public class FluentInterfaceFixture
{
TableWriter writer;

[TestInitialize]
public void Initialize()
{
writer = new TableWriter();
}

[TestMethod]
public void TestFullFillTable()
{
writer.Output(
new Table()
.Name("full fill")
.Head
.Columns
.Add(new Column("first"))
.Add(new Column("second"))
.Add(new Column("thrid"))
.Parent
.Parent
.Body
.NewLine.Items.Add(new Item("11")).Add(new Item("12")).Add(new Item("13")).Parent
.NewLine.Items.Add(new Item("21")).Add(new Item("22")).Add(new Item("23")).Parent
.Body
.Parent
);
}

[TestMethod]
public void TestSkipColumnTable()
{
writer.Output(
new Table()
.Name("skip columns")
.Head
.Columns
.Add(new Column("first"))
.Skip
.Add(new Column("thrid"))
.Parent
.Parent
.Body
.NewLine.Items.Add(new Item("11")).Add(new Item("12")).Add(new Item("13")).Parent
.NewLine.Items.Add(new Item("21")).Add(new Item("22")).Add(new Item("23")).Parent
.Body
.Parent
);
}

[TestMethod]
public void TestSkiItemsTable()
{
writer.Output(
new Table()
.Name("skip items")
.Head
.Columns
.Add(new Column("first"))
.Add(new Column("second"))
.Add(new Column("thrid"))
.Parent
.Parent
.Body
.NewLine.Items.Add(new Item("11")).Skip.Add(new Item("13")).Parent
.NewLine.Items.Add(new Item("21")).Add(new Item("22")).Skip.Parent
.Body
.Parent
);
}

[TestMethod]
public void TestSkipColumnsAndItemsTable()
{
writer.Output(
new Table()
.Name("skip columns and items")
.Head
.Columns
.Add(new Column("first"))
.Skip
.Add(new Column("thrid"))
.Parent
.Parent
.Body
.NewLine.Items.Add(new Item("11")).Skip.Add(new Item("13")).Parent
.NewLine.Items.Add(new Item("21")).Add(new Item("22")).Skip.Parent
.Body
.Parent
);
}
}

5、测试结果

------ Test started: Assembly: Concept.Tests.dll ------

<table>
<name>full fill</name>
<head>
<col>first</col><col>second</col><col>thrid</col>
</head>
<body>
<line>
<item>
<n>11</n><n>12</n><n>13</n>
</item>
<item>
<n>21</n><n>22</n><n>23</n>
</item>
</line>
</body>
</table>

<table>
<name>skip columns</name>
<head>
<col>first</col><col></col><col>thrid</col>
</head>
<body>
<line>
<item>
<n>11</n><n>12</n><n>13</n>
</item>
<item>
<n>21</n><n>22</n><n>23</n>
</item>
</line>
</body>
</table>

<table>
<name>skip items</name>
<head>
<col>first</col><col>second</col><col>thrid</col>
</head>
<body>
<line>
<item>
<n>11</n><n></n><n>13</n>
</item>
<item>
<n>21</n><n>22</n><n></n>
</item>
</line>
</body>
</table>

<table>
<name>skip columns and items</name>
<head>
<col>first</col><col></col><col>thrid</col>
</head>
<body>
<line>
<item>
<n>11</n><n></n><n>13</n>
</item>
<item>
<n>21</n><n>22</n><n></n>
</item>
</line>
</body>
</table>

4 passed, 0 failed, 0 skipped, took 1.29 seconds (MSTest 10.0).

测试确认Fluent接口的有效性

本文链接