Extension d'Ardalis.Specification pour NHibernate avec Linq, Criteria API et Query Over

Ardalis.Specification est une bibliothèque puissante qui active le modèle de spécification pour interroger les bases de données, principalement conçu pour Entity Framework Core, mais je vais ici montrer comment vous pouvez étendre Ardalis.Specification pour l'utiliser NHibernate également en tant qu'ORM.

Ce billet de blog suppose que vous avez une certaine expérience avec Ardalis.Specification et que vous souhaitez l'utiliser dans un projet utilisant NHibernate. Si vous n'êtes pas encore familier avec Ardalis.Specification, rendez-vous sur la documentation pour en savoir plus.

Tout d'abord, dans NHibernate, il existe trois manières intégrées différentes d'effectuer des requêtes

• Linq pour interroger (en utilisant IQueryable)
• API Critères
• Requête terminée

Je vais vous expliquer comment étendre Ardalis.Specification pour gérer les 3 manières, mais comme Linq to Query fonctionne également avec IQueryable comme Entity Framework Core, je vais d'abord passer en revue cette option.

Linq pour interroger

Il existe une petite nuance entre Entity Framework Core et NHIbernate lorsqu'il s'agit de créer des relations de jointure. Dans Entity Framework Core, nous avons des méthodes d'extension sur IQueryable : Include et ThenInclude (ce sont également les noms de méthodes utilisés dans Ardalis.Specification).

Fetch, FetchMany, ThenFetch et ThenFetchMany sont des méthodes spécifiques à NHibernate sur IQueryable qui effectuent des jointures. L'IEvaluator nous donne l'extensibilité dont nous avons besoin pour invoquer la bonne méthode d'extension lorsque nous travaillons avec NHibernate.

Ajoutez une implémentation de IEvaluator comme suit :

public class FetchEvaluator : IEvaluator
{
   private static readonly MethodInfo FetchMethodInfo = typeof(EagerFetchingExtensionMethods)
        .GetTypeInfo().GetDeclaredMethods(nameof(EagerFetchingExtensionMethods.Fetch))
        .Single();

   private static readonly MethodInfo FetchManyMethodInfo = typeof(EagerFetchingExtensionMethods)
       .GetTypeInfo().GetDeclaredMethods(nameof(EagerFetchingExtensionMethods.FetchMany))
       .Single();

   private static readonly MethodInfo ThenFetchMethodInfo
       = typeof(EagerFetchingExtensionMethods)
           .GetTypeInfo().GetDeclaredMethods(nameof(EagerFetchingExtensionMethods.ThenFetch))
           .Single();

   private static readonly MethodInfo ThenFetchManyMethodInfo
       = typeof(EagerFetchingExtensionMethods)
           .GetTypeInfo().GetDeclaredMethods(nameof(EagerFetchingExtensionMethods.ThenFetchMany))
           .Single();

    public static FetchEvaluator Instance { get; } = new FetchEvaluator();

    public IQueryable<T> GetQuery<T>(IQueryable<T> query, ISpecification<T> specification) where T : class
    {
        foreach (var includeInfo in specification.IncludeExpressions)
        {
            query = includeInfo.Type switch
            {
                IncludeTypeEnum.Include => BuildInclude<T>(query, includeInfo),
                IncludeTypeEnum.ThenInclude => BuildThenInclude<T>(query, includeInfo),
                _ => query
            };
        }

        return query;
    }

    public bool IsCriteriaEvaluator { get; } = false;

    private IQueryable<T> BuildInclude<T>(IQueryable query, IncludeExpressionInfo includeInfo)
    {
        _ = includeInfo ?? throw new ArgumentNullException(nameof(includeInfo));

        var methodInfo = (IsGenericEnumerable(includeInfo.PropertyType, out var propertyType)
            ? FetchManyMethodInfo 
            : FetchMethodInfo);

       var method = methodInfo.MakeGenericMethod(includeInfo.EntityType, propertyType);

       var result = method.Invoke(null, new object[] { query, includeInfo.LambdaExpression });
        _ = result ?? throw new TargetException();

        return (IQueryable<T>)result;
    }

    private IQueryable<T> BuildThenInclude<T>(IQueryable query, IncludeExpressionInfo includeInfo)
    {
        _ = includeInfo ?? throw new ArgumentNullException(nameof(includeInfo));
        _ = includeInfo.PreviousPropertyType ?? throw new ArgumentNullException(nameof(includeInfo.PreviousPropertyType));

        var method = (IsGenericEnumerable(includeInfo.PreviousPropertyType, out var previousPropertyType)
            ? ThenFetchManyMethodInfo
            : ThenFetchMethodInfo);

        IsGenericEnumerable(includeInfo.PropertyType, out var propertyType);

        var result = method.MakeGenericMethod(includeInfo.EntityType, previousPropertyType, propertyType)
            .Invoke(null, new object[] { query, includeInfo.LambdaExpression });

        _ = result ?? throw new TargetException();

        return (IQueryable<T>)result;
    }

    private static bool IsGenericEnumerable(Type type, out Type propertyType)
    {
        if (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
        {
            propertyType = type.GenericTypeArguments[0];

            return true;
        }

        propertyType = type;

        return false;
    }
}

Ensuite, nous devons configurer ISpecificationEvaluator pour utiliser notre FetchEvaluator (et d'autres évaluateurs). Nous ajoutons une implémentation ISpecificationEvaluator comme suit avec les évaluateurs configurés dans le constructeur. WhereEvaluator, OrderEvaluator et PaginationEvaluator sont tous dans Ardalis.Specification et fonctionnent également bien avec NHibernate.

public class LinqToQuerySpecificationEvaluator : ISpecificationEvaluator
{
    private List<IEvaluator> Evaluators { get; } = new List<IEvaluator>();

    public LinqToQuerySpecificationEvaluator()
    {
        Evaluators.AddRange(new IEvaluator[]
        {
            WhereEvaluator.Instance,
            OrderEvaluator.Instance,
            PaginationEvaluator.Instance,
            FetchEvaluator.Instance
        });
    }


    public IQueryable<TResult> GetQuery<T, TResult>(IQueryable<T> query, ISpecification<T, TResult> specification) where T : class
    {
        if (specification is null) throw new ArgumentNullException(nameof(specification));
        if (specification.Selector is null && specification.SelectorMany is null) throw new SelectorNotFoundException();
        if (specification.Selector is not null && specification.SelectorMany is not null) throw new ConcurrentSelectorsException();

        query = GetQuery(query, (ISpecification<T>)specification);

        return specification.Selector is not null
            ? query.Select(specification.Selector)
            : query.SelectMany(specification.SelectorMany!);
    }

    public IQueryable<T> GetQuery<T>(IQueryable<T> query, ISpecification<T> specification, bool evaluateCriteriaOnly = false) where T : class
    {
        if (specification is null) throw new ArgumentNullException(nameof(specification));

        var evaluators = evaluateCriteriaOnly ? Evaluators.Where(x => x.IsCriteriaEvaluator) : Evaluators;

        foreach (var evaluator in evaluators)
           query = evaluator.GetQuery(query, specification);

        return query;
    }
}

Nous pouvons maintenant créer une référence à LinqToQuerySpecificationEvaluator dans notre référentiel qui peut ressembler à ceci :

public class Repository : IRepository
{
    private readonly ISession _session;
    private readonly ISpecificationEvaluator _specificationEvaluator;

    public Repository(ISession session)
    {
        _session = session;
        _specificationEvaluator = new LinqToQuerySpecificationEvaluator();
    } 

    ... other repository methods

    public IEnumerable<T> List<T>(ISpecification<T> specification) where T : class
    {
        return _specificationEvaluator.GetQuery(_session.Query<T>().AsQueryable(), specification).ToList();
    }

    public IEnumerable<TResult> List<T, TResult>(ISpecification<T, TResult> specification) where T : class
    {    
        return _specificationEvaluator.GetQuery(_session.Query<T>().AsQueryable(), specification).ToList();
    }

    public void Dispose()
    {
        _session.Dispose();
    }
}

C'est tout. Nous pouvons désormais utiliser Linq to Query dans nos spécifications, comme nous le faisons habituellement avec Ardalis.Spécification :

public class TrackByName : Specification<Core.Entitites.Track>
{
    public TrackByName(string trackName)
    {
        Query.Where(x => x.Name == trackName);
    }
}

Maintenant que nous avons abordé les requêtes basées sur Linq, passons à la gestion de l'API Criteria et de Query Over, qui nécessitent une approche différente.

Mélanger Linq, critères et requêtes dans NHibernate

Étant donné que l'API Criteria et Query Over ont leur propre implémentation pour générer du SQL et n'utilisent pas IQueryable, ils sont incompatibles avec l'interface IEvaluator. Ma solution consiste à éviter d'utiliser l'interface IEvaluator pour ces méthodes dans ce cas, mais plutôt à me concentrer sur les avantages du modèle de spécification. Mais je veux aussi pouvoir mixer
Linq to Query, Criteria et Query Over with dans ma solution (si vous n'avez besoin que d'une seule de ces implémentations, vous pouvez choisir selon vos meilleurs besoins).

Pour pouvoir faire cela, j'ajoute quatre nouvelles classes qui héritent de la spécification ou de la spécification

REMARQUE : L'assembly dans lequel vous définissez ces classes a besoin d'une référence à NHibernate car nous définissons des actions pour Criteria et un QueryOver, qui peuvent être trouvés dans NHibernate

public class CriteriaSpecification<T> : Specification<T>
{
    private Action<ICriteria>? _action;
    public Action<ICriteria> GetCriteria() => _action ?? throw new NotSupportedException("The criteria has not been specified. Please use UseCriteria() to define the criteria.");
    protected void UseCriteria(Action<ICriteria> action) => _action = action;
}

public class CriteriaSpecification<T, TResult> : Specification<T, TResult>
{
    private Action<ICriteria>? _action;
    public Action<ICriteria> GetCriteria() => _action ?? throw new NotSupportedException("The criteria has not been specified. Please use UseCriteria() to define the criteria.");
    protected void UseCriteria(Action<ICriteria> action) => _action = action;
}

public class QueryOverSpecification<T> : Specification<T>
{
    private Action<IQueryOver<T, T>>? _action;
    public Action<IQueryOver<T, T>> GetQueryOver() => _action ?? throw new NotSupportedException("The Query over has not been specified. Please use the UseQueryOver() to define the query over.");
    protected void UseQueryOver(Action<IQueryOver<T, T>> action) => _action = action;
}

public class QueryOverSpecification<T, TResult> : Specification<T, TResult>
{
    private Func<IQueryOver<T, T>, IQueryOver<T, T>>? _action;
    public Func<IQueryOver<T, T>, IQueryOver<T, T>> GetQueryOver() => _action ??  throw new NotSupportedException("The Query over has not been specified. Please use the UseQueryOver() to define the query over.");
    protected void UseQueryOver(Func<IQueryOver<T, T>, IQueryOver<T, T>> action) => _action = action;
}

Ensuite, nous pouvons utiliser la correspondance de modèles dans notre référentiel pour changer la façon dont nous effectuons les requêtes avec NHibernate

public IEnumerable<T> List<T>(ISpecification<T> specification) where T : class
{
    return specification switch
    {
        CriteriaSpecification<T> criteriaSpecification => 
            _session.CreateCriteria<T>()
                .Apply(query => criteriaSpecification.GetCriteria().Invoke(query))
                .List<T>(),

        QueryOverSpecification<T> queryOverSpecification => 
            _session.QueryOver<T>()
                .Apply(queryOver => queryOverSpecification.GetQueryOver().Invoke(queryOver))
                .List<T>(),

        _ => _specificationEvaluator.GetQuery(_session.Query<T>().AsQueryable(), specification).ToList()
    };
}

public IEnumerable<TResult> List<T, TResult>(ISpecification<T, TResult> specification) where T : class
{

    return specification switch
    {
        CriteriaSpecification<T, TResult> criteriaSpecification => 
            _session.CreateCriteria<T>()
                .Apply(query => criteriaSpecification.GetCriteria().Invoke(query))
                .List<TResult>(),

        QueryOverSpecification<T, TResult> queryOverSpecification =>
            _session.QueryOver<T>()
                .Apply(queryOver => queryOverSpecification.GetQueryOver().Invoke(queryOver))
                .List<TResult>(),

        _ => _specificationEvaluator.GetQuery(_session.Query<T>().AsQueryable(), specification).ToList()
    };
}

La méthode Apply() ci-dessus est une méthode d'extension qui simplifie la requête en une seule ligne :

public static class QueryExtensions
{
    public static T Apply<T>(this T obj, Action<T> action)
    {
        action(obj);
        return obj;
    }

    public static TResult Apply<T, TResult>(this T obj, Func<T, TResult> func)
    {
        return func(obj);
    }
}

Exemple de spécification de critères

REMARQUE : L'assembly dans lequel vous définissez ces classes a besoin d'une référence à NHibernate lorsque nous définissons des actions pour les critères, qui peuvent être trouvées dans NHibernate

public class TrackByNameCriteria : CriteriaSpecification<Track>
{
    public TrackByNameCriteria(string trackName)
    {
        this.UseCriteria(criteria => criteria.Add(Restrictions.Eq(nameof(Track.Name), trackName)));
    }
}

Exemple de requête sur spécification

REMARQUE : L'assembly dans lequel vous définissez ces classes a besoin d'une référence à NHibernate lorsque nous définissons des actions pour un QueryOver, qui peut être trouvé dans NHibernate

public class TrackByNameQueryOver : QueryOverSpecification<Track>
{
    public TrackByNameQueryOver(string trackName)
    {
        this.UseQueryOver(queryOver => queryOver.Where(x => x.Name == trackName));
    }
}

En étendant Ardalis.Specification pour NHibernate, nous ouvrons la possibilité d'utiliser Linq to Query, l'API Criteria et Query Over, le tout dans un seul modèle de référentiel. Cette approche offre une solution hautement adaptable et puissante pour les utilisateurs de NHibernate

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!