Nhibernate Fetch-ThenFetch的流畅包装器

我有一个通用存储库，其中包含一个返回IQueryable的查询方法。在我的呼叫代码中，我可以这样做

_repository.Query<MyClass>(x=>x.EntityId == 1).Fetch(x=>x.MyClassChild).ToList()

\u repository.Query（x=>x.EntityId==1）.Fetch（x=>x.MyClassChild）.ToList（）

然而，我将无法测试调用代码（据我所知）。所以我试着做以下几点

public class Repository : IRepository
{
....
    public FetchedResult<TQueried, TRelated> ThenFetch<TQueried, TFetch, TRelated>(INhFetchRequest<TQueried, TFetch> query, Expression<Func<TFetch, TRelated>> relatedObjectSelector)
    {
        INhFetchRequest<TQueried, TRelated> nhFetchRequest = query.ThenFetch(relatedObjectSelector);
        return new FetchedResult<TQueried, TRelated>(this, nhFetchRequest);
    }

    public FetchedResult<TOriginating, TRelated> Fetch<TOriginating, TRelated>(IQueryable<TOriginating> query, Expression<Func<TOriginating, TRelated>> relatedObjectSelector)
    {
        INhFetchRequest<TOriginating, TRelated> nhFetchRequest = query.Fetch(relatedObjectSelector);
        return new FetchedResult<TOriginating, TRelated>(this, nhFetchRequest);
    }
}

公共类存储库：IRepository
{
....
public FetchedResult ThenFetch（inFetchRequest查询，表达式相关的ObjectSelector）
{
INhFetchRequest nhFetchRequest=query.ThenFetch（relatedObjectSelector）；
返回新的FetchedResult（此为nhFetchRequest）；
}
public FetchedResult Fetch（IQueryable查询、表达式相关ObjectSelector）
{
INhFetchRequest nhFetchRequest=query.Fetch（relatedObjectSelector）；
返回新的FetchedResult（此为nhFetchRequest）；
}
}

--

公共类FetchedResult
{
专用只读IRepository存储库；
私有只读请求查询；
公共FetchedResult（IRepository存储库，INhFetchRequest查询）
{
_存储库=存储库；
_查询=查询；
}
public-FetchedResult-ThenFetch（表达式相关对象选择器）
{
返回_repository.ThenFetch（_query，relatedObjectSelector）；
}
}

因此，对Fetch的第一个调用可以工作，但对repositor.ThenFetch的调用接受INhFetchRequest查询，但返回INhFetchRequest。因此，我不能使用FetchedResult再次调用ThenFetch

我认为这就是问题所在。在这一点上，我的大脑相当混乱。如果有人能帮助让我知道，我可以尝试提供更多或更好的信息

现在我知道我可以使用statics来实现它，但是，我的目标是能够模拟要获取的调用

谢谢

---

Raif

好吧，我虚弱的大脑终于找到了解决办法。经过一段无聊的通勤之后，我意识到问题在于泛型在对象级别而不是方法级别。以下是我的解决方案。我可能会在博客上说的事情，在这种情况下，稍后我会包括链接

public class Repository : IRepository
{
....
    public FetchQuery QueryFetch<ENTITY>(Expression<Func<ENTITY, bool>> where = null) where ENTITY : Entity
    {
        var query = _unitOfWork.CurrentSession.Query<ENTITY>();
        var queryable = where == null ? query : query.Where(where);
        return new FetchQuery(this, queryable);
    }

    public FetchedResult ThenFetch<TQueried, TFetch, TRelated>(INhFetchRequest<TQueried, TFetch> query, Expression<Func<TFetch, TRelated>> relatedObjectSelector)
    {
        INhFetchRequest<TQueried, TRelated> nhFetchRequest = query.ThenFetch(relatedObjectSelector);
        return new FetchedResult(this, nhFetchRequest);
    }

    public FetchedResult ThenFetchMany<TQueried, TFetch, TRelated>(INhFetchRequest<TQueried, TFetch> query, Expression<Func<TFetch, IEnumerable<TRelated>>> relatedObjectSelector)
    {
        INhFetchRequest<TQueried, IEnumerable<TRelated>> nhFetchRequest = query.ThenFetch(relatedObjectSelector);
        return new FetchedResult(this, nhFetchRequest);
    }

    public FetchedResult Fetch<TOriginating, TRelated>(IQueryable<TOriginating> query, Expression<Func<TOriginating, TRelated>> relatedObjectSelector)
    {
        INhFetchRequest<TOriginating, TRelated> nhFetchRequest = query.Fetch(relatedObjectSelector);
        return new FetchedResult(this, nhFetchRequest);
    }

    public FetchedResult FetchMany<TOriginating, TRelated>(IQueryable<TOriginating> query, Expression<Func<TOriginating, IEnumerable<TRelated>>> relatedObjectSelector)
    {
        INhFetchRequest<TOriginating, TRelated> nhFetchRequest = query.FetchMany(relatedObjectSelector);
        return new FetchedResult(this, nhFetchRequest);
    }
}

public class FetchedResult
{
    private readonly IRepository _repository;
    private object _query;
    public FetchedResult(IRepository repository, object query)
    {
        _repository = repository;
        _query = query;
    }

    public FetchedResult ThenFetch<TQueried, TFetch, TRelated>(Expression<Func<TFetch, TRelated>> relatedObjectSelector)
    {
        return _repository.ThenFetch((INhFetchRequest<TQueried, TFetch>)_query, relatedObjectSelector);
    }

    public FetchedResult ThenFetchMany<TQueried, TFetch, TRelated>(Expression<Func<TFetch, IEnumerable<TRelated>>> relatedObjectSelector)
    {
        return _repository.ThenFetchMany((INhFetchRequest<TQueried, TFetch>)_query, relatedObjectSelector);
    }

    public List<TOriginating> ToList<TOriginating>()
    {
        return ((IQueryable<TOriginating>)_query).ToList();
    }
}

public class FetchQuery
{
    private readonly IRepository _repository;
    private readonly object _query;

    public FetchQuery(IRepository repository, object query)
    {
        _repository = repository;
        _query = query;
    }

    public FetchedResult Fetch<TOriginating, TRelated>(Expression<Func<TOriginating, TRelated>> relatedObjectSelector)
    {
        return _repository.Fetch((IQueryable<TOriginating>)_query, relatedObjectSelector);
    }

    public FetchedResult FetchMany<TOriginating, TRelated>(Expression<Func<TOriginating, IEnumerable<TRelated>>> relatedObjectSelector)
    {
        return _repository.FetchMany((IQueryable<TOriginating>)_query, relatedObjectSelector);
    }

    public List<TOriginating> ToList<TOriginating>()
    {
        return ((IQueryable<TOriginating>) _query).ToList();
    }
}

公共类存储库：IRepository
{
....
public FetchQuery QueryFetch（表达式where=null）where ENTITY:ENTITY
{
var query=_unitOfWork.CurrentSession.query（）；
var queryable=where==null？查询：query.where（where）；
返回新的FetchQuery（this，queryable）；
}
public FetchedResult ThenFetch（inFetchRequest查询，表达式相关的ObjectSelector）
{
INhFetchRequest nhFetchRequest=query.ThenFetch（relatedObjectSelector）；
返回新的FetchedResult（此为nhFetchRequest）；
}
public FetchedResult ThenFetchMany（inFetchRequest查询，表达式相关的ObjectSelector）
{
INhFetchRequest nhFetchRequest=query.ThenFetch（relatedObjectSelector）；
返回新的FetchedResult（此为nhFetchRequest）；
}
public FetchedResult Fetch（IQueryable查询、表达式相关ObjectSelector）
{
INhFetchRequest nhFetchRequest=query.Fetch（relatedObjectSelector）；
返回新的FetchedResult（此为nhFetchRequest）；
}
public FetchedResult FetchMany（IQueryable查询、表达式关联对象选择器）
{
INhFetchRequest nhFetchRequest=query.FetchMany（relatedObjectSelector）；
返回新的FetchedResult（此为nhFetchRequest）；
}
}
公共类FetchedResult
{
专用只读IRepository存储库；
私有对象查询；
公共FetchedResult（IRepository存储库、对象查询）
{
_存储库=存储库；
_查询=查询；
}
public-FetchedResult-ThenFetch（表达式相关对象选择器）
{
返回_repository.ThenFetch（（INhFetchRequest）_query，relatedObjectSelector）；
}
public FetchedResult ThenFetchMany（表达式相关对象选择器）
{
返回_repository.ThenFetchMany（（inFetchRequest）_query，relatedObjectSelector）；
}
公众名单收费表（）
{
return（（IQueryable）u query.ToList（）；
}
}
公共类获取查询
{
专用只读IRepository存储库；
私有只读对象\u查询；
公共FetchQuery（IRepository存储库、对象查询）
{
_存储库=存储库；
_查询=查询；
}
public FetchedResult Fetch（表达式相关对象选择器）
{
return _repository.Fetch（（IQueryable）_query，relatedObjectSelector）；
}
公共FetchedResult FetchMany（表达式相关对象选择器）
{
return _repository.FetchMany（（IQueryable）_query，relatedObjectSelector）；
}
公众名单收费表（）
{
return（（IQueryable）u query.ToList（）；
}
}

用法如下

_repository.QueryFetch<InternetProfile>(x => x.CompanyId == Id ).FetchMany<InternetProfile, SiteProperty>(x => x.SiteProperties).ToList<InternetProfile>();

\u repository.QueryFetch（x=>x.CompanyId==Id）.FetchMany（x=>x.SiteProperties.ToList（）；

我确实发现泛型声明有点冗长，但它非常有效，我现在就不谈了。当然，欢迎提出任何建议

雷夫

_repository.QueryFetch<InternetProfile>(x => x.CompanyId == Id ).FetchMany<InternetProfile, SiteProperty>(x => x.SiteProperties).ToList<InternetProfile>();