标签: fluent

我相信这是小菜一碟,但我无法使用谷歌找到它.我需要从映射中排除一个类.我目前的配置是:

return Fluently.Configure()
      .Database(MsSqlConfiguration.MsSql2005.ConnectionString(c =>
                c.Is(@"Data Source=PC\SQLEXPRESS;......")))
            .Mappings(m =>
                m.AutoMappings.Add(
                AutoPersistenceModel.MapEntitiesFromAssemblyOf<Person2>()
                        .Where(t => t.Namespace == "ExampleData.HumansTest")
                        .UseOverridesFromAssemblyOf<PersonMappingOverrides>()
                        .ConventionDiscovery.AddFromAssemblyOf<PersonMappingOverrides>()
                        )
                     ).BuildConfiguration();

到目前为止工作得很好......但我有一些我不想映射的课程.有什么像:

PSEUDO代码:

return Fluently.Configure()
            .Database(MsSqlConfiguration.MsSql2005.ConnectionString(c =>
                c.Is(@".......")))
            .Mappings(m =>
                m.AutoMappings.Add(
                AutoPersistenceModel.MapEntitiesFromAssemblyOf<Person2>()
                        .Where(t => t.Namespace == "ExampleData.HumansTest")
                        .DO_NOT_MAP_CLASS<UnfinishedClass>
                        .UseOverridesFromAssemblyOf<PersonMappingOverrides>()
                        .ConventionDiscovery.AddFromAssemblyOf<PersonMappingOverrides>()
                        )
                     ).BuildConfiguration();

例如:我想有Add方法ICollection的自定义集合类来实现方法链接和流利的语言,所以我能做到这一点的:

randomObject.Add("I").Add("Can").Add("Chain").Add("This").

我可以想到一些选项,但它们很混乱,并涉及将ICollection包装在另一个界面中等等.

这是使用Fluent NHibernate完成的

我有一个NHibernate查找,它从一个表中检索数据.如果我使用生成的sql并通过查询分析器运行它,运行需要大约18ms.

使用NHProfiler,我得到的查询持续时间为~1800ms - 比sql长100倍!

Query duration
 - Database only:1800ms
 - Total: 1806ms

正在填充的对象包含一个子类,但是这个子进程是从NHibernate二级缓存加载的

正在返回的数据被分页(每个查询50个),尽管据我所知,这应该没有任何区别

我还有一个计数运行,再次,这在查询分析器中需要大约4ms,根据NHProfiler需要大约1800ms.

NH Profiler是显示查询执行时间还是检索的完整时间,映射类并构造对象图？如果它是前者 - 为什么它比直接运行查询需要更长的时间？

编辑:刚刚发现Ayende关于NH Profiler中给出的查询持续时间值的这篇文章:http://ayende.com/Blog/archive/2009/06/28/nh-prof-query-duration.aspx - 所以它绝对是需要很长时间的数据库查询

我们的实体拥有一组共同的属性.为了减少重复映射,我创建了一个映射标识和公共属性的基类ClassMap.对于每个实体的ClassMap,我只是对基类进行子类化,它运行良好.对于一个新项目,我们也让NH为我们生成数据库架构.问题是,列的顺序是这样的,即基本ClassMap中的属性首先出现,然后是子类中映射的任何内容.此构建的要求是列按特定顺序显示.

为了解决这个问题,我做了以下几点.

public class BaseMap<T> : ClassMap<T> where T : Entity
{
    public BaseMap()
    {
        Id(x => x.Id);
        MapEntity();
        Map(x => x.CommonProperty1);
        Map(x => x.CommonProperty2);
        Map(x => x.CommonProperty3);
    }

    protected virtual void MapEntity()
    {
    }
}

public class SomeEntityMap : BaseMap<SomeEntity>
{
    public SomeEntity()
    {
        base.MapEntity();
    }

    protected override void MapEntity()
    {
        Map(x => x.SomeEntityProperty1);
        Map(x => x.SomeEntityProperty2);
        Map(x => x.SomeEntityProperty3);        
    }
}

这有效,但感觉就像一个黑客.除了黑客因素,这里有什么可能有问题吗？

我已经阅读过有关Fluent API的内容,其中代码可以像英语一样阅读,但我似乎无法找到它们的任何示例,因为我想知道它们是否是一种易于使用的界面的合理方法由非全职程序员组成的系统.有没有人有流畅的界面的例子？

我想知道您对使用流畅的界面模式重构一个长方法的看法.

http://en.wikipedia.org/wiki/Fluent_interface

流畅的模式不包括在重构书中.

例如,假设您有这么长的方法(因为它有很多东西,所以有很长的名字)

class TravelClub {

   Receipt buyAndAddPointsAndGetReceipt(long amount, long cardNumber) {
    buy(amount);
    accumulatePoints(cardNumber);
    return generateReceipt();

   }

   void buy(int amount) {...}

   void accumlatePoints(int cardNumber) {...}

   void generateRecepit() {...}

}

称为:

Receipt myReceipt = myTravelClub.buyAndAddPointsAndGetReceipt(543L,12345678L);

这可以重构为:

class TravelClub {

   TravelClub buy(long amount) {
    //buy stuff
    return this;
   }

   TravelClub accumulatePoints(long cardNumber) {
    //accumulate stuff
    return this;
   }

   Receipt generateReceipt() {
    return new Receipt(...);
   }


}

并称为:

Receipt myReceipt = myTravelClub.buy(543L).accumulatePoints(12345678L).generateReceipt();

从我的观点来看,分解long方法并分解其名称是一种非常好的方式.

你怎么看？

我有一个简单的标记构建器,如下所示:

public static MvcHtmlString Tag(this HtmlHelper helper, string tag, string content)
{
    var tagBuilder = new TagBuilder(tag){InnerHtml = content};
    return MvcHtmlString.Create(tagBuilder.ToString(TagRenderMode.NormalTag));
}

而且,我可以像这样使用它:

@Html.Tag("em", Model.Title)

产生:

<em>The Title</em>

如何编写它来使用Fluent语法,因此它的用法如下所示:

@Html.Tag("em").Content(Model.Title)

我创建了这个类是不可变的,并且具有流畅的API:

public final class Message {
    public final String email;
    public final String escalationEmail;
    public final String assignee;
    public final String conversationId;
    public final String subject;
    public final String userId;

    public Message(String email, String escalationEmail, String assignee, String conversationId, String subject, String userId) {
        this.email = email;
        this.escalationEmail = escalationEmail;
        this.assignee = assignee;
        this.conversationId = conversationId;
        this.subject = subject;
        this.userId = userId;
    }

    public Message() {
        email = "";
        escalationEmail = "";
        assignee = "";
        conversationId = "";
        subject = …

我将为我的应用程序创建自定义的流畅API.我决定检查现有库的代码,并在至少2个使用流畅api的项目中发现了一些怪物.

我看到有很多类和接口,只有通用类型的数量不同.

例如:在jOOQ库DerivedColumnList22中

在RxJava中:Action9

像这样的怪物的目的是什么？仅适用于性能案例吗？或者是流行api的一些共性和方式？

当你看到像这样的怪物时,用流畅的api实现自己的DSL看起来很可怕.

我有一个看起来像这样的类结构:

class Parent {
    public Parent(int property) { /* use property */}
}
class Son extends Parent {
    public Son(int parentProperty, String sonProperty) { 
        super(parentProperty);
        /* use son property */ 
    }
}

我想为这两个类创建构建器,以便:

class ParentBuilder {
    protected int parentProperty;

    public ParentBuilder parentProperty(int parentPropertyValue) {
        parentPropertyValue = parentPropertyValue;
        return this;
    }

    public Parent build() {
        return new Parent(parentProperty);
    }
}
class SonBuilder extends ParentBuilder {
    private String sonProperty;

    public SonBuilder sonProperty(String sonProperty) {
        this.sonProperty = sonProperty;
        return this;
    }

    @Override
    public …