Fluid Wrapper pour Nhibernate Fetch ThenFetch

Question

J'ai un référentiel générique avec une méthode de requête qui renvoie IQueryable. Dans mon code d'appel que je peux faire quelque chose comme ce

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

Cependant, je serais alors incapable de tester le code d'appel (pour autant que je sache). Donc, je suis en train de faire ce qui suit

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); 
    } 
} 

-

public class FetchedResult<TQueried, TRelated> 
{ 
    private readonly IRepository _repository; 
    private readonly INhFetchRequest<TQueried, TRelated> _query; 

    public FetchedResult(IRepository repository, INhFetchRequest<TQueried, TRelated> query) 
    { 
     _repository = repository; 
     _query = query; 
    } 

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

Ainsi, le premier appel à Fetch œuvres, mais l'appel à repositor.ThenFetch prend une requête INhFetchRequest mais retourne un INhFetchRequest. Je ne peux donc pas utiliser FetchedResult pour appeler le ThenFetch une deuxième fois.

Je pense que c'est le problème. Mon cerveau est assez démêlé à ce stade. Si quelqu'un peut m'aider à le faire savoir, je peux essayer de donner plus d'informations ou de meilleures informations.

Maintenant, je sais que je peux le faire en utilisant cependant statics, mon objectif ici est de pouvoir se moquer des appels à récupérer.

Merci,

Raif

Answer 1

Alrighty, mon cerveau faible a finalement saisi la solution. Après un trajet ennuyeux comme l'enfer, j'ai réalisé que le problème était que les génériques étaient au niveau de l'objet plutôt qu'au niveau de la méthode. Ce qui suit est ma solution. Je peux bloguer sur ladite question dans ce cas, plus tard, je vais inclure le lien

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(); 
    } 
} 

utilisation

serait la suivante

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

Je trouve que les déclarations génériques sont un peu bavard, mais il fonctionne Freakin et je le laisse pour le moment. Toutes les suggestions, bien sûr, seraient les bienvenues.

Raif