C# 如何避免与QueryOver的重复

我有两种方法，不喜欢重复：

public Order LatestOrderOver(decimal amount)
{
    return session.QueryOver<Order>()
        .Where(o => o.Amount > amount)
        .OrderBy(sr => sr.CompleteUtcTime).Desc
        .Take(1)
        .SingleOrDefault<Order>();
}

public Order LatestAmericanOrderOver(decimal amount)
{
    return session.QueryOver<Order>()
        .Where(o => o.Amount > amount && o.Country == "USA")
        .OrderBy(sr => sr.CompleteUtcTime).Desc
        .Take(1)
        .SingleOrDefault<Order>();
}

public Order LatestOrderOver（十进制金额）
{
return session.QueryOver（）
其中（o=>o.金额>金额）
.OrderBy（sr=>sr.CompleteTTime）.Desc
.采取（1）
.SingleOrDefault（）；
}
公共秩序延误（十进制金额）
{
return session.QueryOver（）
其中（海外=>海外金额>金额和海外国家==“美国”）
.OrderBy（sr=>sr.CompleteTTime）.Desc
.采取（1）
.SingleOrDefault（）；
}

---

当查询结束时使用了类似的条件（在Where子句中）和类似的选项时，避免重复的最佳方法是什么？

如果使用Linq to对象，可以重构委托：

private Order LatestOrderOver(Func<Order, bool> f) {
  return
    session.QueryOver<Order>()
    .Where(f)
    .OrderBy(sr => sr.CompleteUtcTime).Desc
    .Take(1)
    .SingleOrDefault<Order>();
}

public Order LatestOrderOver(decimal amount) {
  return LatestOrderOver(o => o.Amount > amount);
}

public Order LatestAmericanOrderOver(decimal amount) {
  return LatestOrderOver(o => o.Amount > amount && o.Country == "USA");
}

private Order LatestOrderOver（函数f）{
返回
session.QueryOver（）
.其中（f）
.OrderBy（sr=>sr.CompleteTTime）.Desc
.采取（1）
.SingleOrDefault（）；
}
公共秩序延期（十进制金额）{
返回LatestOrderOver（o=>o.Amount>Amount）；
}
公共秩序延误（十进制金额）{
返回最晚的存储版本（o=>o.Amount>Amount&&o.Country==“USA”）；
}

---

否则，只需将

Func

更改为

Expression

就可以了，但我对此没有太多经验。

除了Guffa的建议之外，您对扩展方法有何看法

public static class QueryOverExtensions
{
    public static Order LastOrder(this IQueryOver<Order, Order> query)
    {
        return query
            .Where(o => o.Amount > amount)
            .OrderBy(sr => sr.CompleteUtcTime).Desc
            .Take(1)
            .SingleOrDefault<Order>();
    }

    // Other query over extension methods
}

公共静态类QueryOverExtensions
{
公共静态订单LastOrder（此IQueryOver查询）
{
返回查询
其中（o=>o.金额>金额）
.OrderBy（sr=>sr.CompleteTTime）.Desc
.采取（1）
.SingleOrDefault（）；
}
//对扩展方法的其他查询
}

然后您可以将您的方法编写为：

public Order LatestOrderOver(decimal amount)
{
    return session.QueryOver<Order>()
       .LastOrder();
}

public Order LatestAmericanOrderOver()
{
    return session.QueryOver<Order>()
        .Where(o => o.Country == "USA")
        .LastOrder();
}

public Order LatestOrderOver（十进制金额）
{
return session.QueryOver（）
.LastOrder（）；
}
公共秩序晚报
{
return session.QueryOver（）
.其中（o=>o.国家==“美国”）
.LastOrder（）；
}

为什么不直接使用

NHibernate.Linq

命名空间中的

FirstOrDefault（）

而不是

Take（1）.SingleOrDefault（）

？注意：我不是nhibernate的人。@hIpPy这不是Linq，而是QueryoverAPI。这些方法看起来就像Linq方法。所有这些都是在

IQueryOver

接口上定义的，该接口不是从

IEnumerable

或

IQueryable

继承的。这是一个好主意，但我在Where子句中仍然有重复项。在我的实例中，where子句更为复杂，包含相似的元素和不同的元素。现在呢？我已经将commonwhere子句移动到扩展方法中。请注意，我不是100%确定这将与QueryOver一起工作。它与（NHibernate）Linq一起工作。你可以用Linq写

.Where（o=>）.Where（o=>）.Where…

。呵呵，刚刚意识到Guffa提到了同样的事情：）这是个好主意，但我在Where子句中仍然有重复。在我的实例中，where子句更为复杂，其中包含相似的元素和不同的元素it@MichaelHedgpeth：您还可以拆分条件，在私有方法中有一个

Where

，在调用它的每个方法中有一个

Where

。