Mise en cache des résultats de requête globale dans ASP.NET CORE

Le paradigme CQRS sous une forme ou une autre suppose que les appels de requête ne changeront pas l'état de l'application. C'est-à-dire que plusieurs appels à la même requête dans la même requête auront le même résultat.

Que toutes les interfaces utilisées dans le cadre de la requête soient de type IQuery ou IAsyncQuery:

public interface IQuery<TIn, TOut> { TOut Query(TIn input); } public interface IAsyncQuery<TIn, TOut>: IQuery<TIn, Task<TOut> { } 

Ces interfaces décrivent en détail la réception de données, par exemple, la réception de prix formatés en tenant compte des remises / bonus et tout le reste:

 public class ProductPriceQuery: IQuery<ProductDto,PricePresentationDto> { public ProductPriceQuery( IQuery<ProductDto, PriceWithSalesDto> priceWithSalesQuery, IQuery<PriceWithSalesDto, PricePresentationDto> pricePresentationQuery) { _priceWithSalesQuery = priceWithSalesQuery; _pricePresentationQuery = pricePresentationQuery; } public PricePresentationDto Query(ProductDto dto) { var withSales = _priceWithSalesQuery(dto); var result = _pricePresentationQuery(withSales); return result; } } 

Interfaces de pipeline

L'avantage de cette approche est l'uniformité des interfaces dans l'application, qui peuvent être construites dans le pipeline:

 public class Aggregate2Query<TIn, TOut1, TOut2> : BaseAggregateQuery<TIn, TOut2> { public Aggregate2Query( IQuery<TIn, TOut1> query0, IQuery<TOut1, TOut2> query1) : base(query0, query1){} } public abstract class BaseAggregateQuery<TIn, TOut> : IQuery<TIn, TOut> { private object[] queries { get; set; } protected BaseAggregateQuery(params object[] queries) { this.queries = queries; } public TOut Query(TIn input) => queries.Aggregate<object, dynamic>(input, (current, query) => ((dynamic) query).Query(current)); } 

Inscrivez-vous comme ceci:

 serviceCollection.AddScoped(typeof(Aggregate2Query<,,>)); 

Nous obtenons:

 public ProductPriceQuery( BaseAggregateQuery<ProductDto,PriceWithSalesDto,PricePresentationDto> query) { _aggregateQuery = query; } public PricePresentationDto Query(ProductDto dto) => _aggregateQuery.Query(dto); 

Idéalement, la programmation devrait se transformer en un assemblage du constructeur, mais en réalité c'est juste une belle astuce pour satisfaire la fierté du programmeur.

Décorateurs et ASP.NET CORE

La bibliothèque MediatR est construite précisément sur l'uniformité des interfaces et sur les décorateurs.

Les décorateurs vous permettent de suspendre certaines fonctions supplémentaires sur l'interface standard IQuery <TIn, TOut>, par exemple la journalisation:

 public class LoggingQuery<TIn,TOut>: IQuery<TIn,TOut> { public LoggingQuery(IQuery<TIn,TOut> priceQuery) { _priceQuery = priceQuery } public TOut Query(TIn input) { Console.WriteLine($"Query {_priceQuery.GetType()} Start"); var result= _priceQuery.Query(input); Console.WriteLine($"Query {_priceQuery.GetType()} End"); return result; } } 

Je vais omettre le fait que les décorateurs vous permettent d'écrire des fonctionnalités transversales en un seul endroit, plutôt que de les diffuser dans le programme, cela ne fait pas partie de la portée de cet article.

Le conteneur IoC standard fourni par .Net Core ne peut pas enregistrer les décorateurs. La difficulté est que nous avons deux implémentations de la même interface: la requête d'origine et le décorateur, et la même interface que le décorateur implémente vient au constructeur du décorateur. Le conteneur ne peut pas résoudre un tel graphique et génère une erreur de "dépendance circulaire".

Il existe plusieurs façons de résoudre ce problème. En particulier pour le conteneur .Net Core, la bibliothèque Scrutor est écrite, elle peut enregistrer des décorateurs:

  services.Decorate(typeof(IQuery<,>), typeof(LoggingQuery<,>)); 

Si vous ne souhaitez pas ajouter de dépendances supplémentaires au projet, vous pouvez écrire cette fonctionnalité vous-même, ce que j'ai fait. Avant de démontrer le code, discutons de la mise en cache des résultats de la requête dans le cadre d'une requête. Si vous devez ajouter la mise en cache et que la clé est la classe, vous devez remplacer GetHashCode et Equals, nous nous débarrasserons donc de la comparaison par référence.

Méthodes de mise en cache

Je vais vous présenter un exemple de cache simple:

 //Cache ConcurrentDictionary<Key,Value> _cache { get; } //Key public class Key { //ReSharper-generated code protected bool Equals(Key other) { return Field1 == other.Field1 && Field2 == other.Field2; } //ReSharper-generated code public override bool Equals(object obj) { if (ReferenceEquals(null, obj)) return false; if (ReferenceEquals(this, obj)) return true; if (obj.GetType() != this.GetType()) return false; return Equals((Key) obj); } //ReSharper-generated code public override int GetHashCode() { unchecked { return (Field1 * 397) ^ Field2; } } public int Field1 { get; set; } public int Field2 { get; set; } } //Value irrelevant 

Lors de la recherche d'une valeur, la méthode GetHashCode est d'abord appelée pour trouver le panier souhaité, puis, si le panier contient plusieurs éléments, Equals est appelé pour comparaison. Voyez si vous ne comprenez pas très bien comment cela fonctionne.

ReSharper génère lui-même ces méthodes, mais nous implémentons la mise en cache globalement, le programmeur qui a implémenté l'interface IQuery <TIn, TOut>, et en général l'interface IQuery <TIn, TOut>, n'oublions pas SRP. Par conséquent, la génération de méthodes par le resharper ne nous convient pas.

Lorsque nous traitons des fonctionnalités de bout en bout, les frameworks AOP viennent à la rescousse. EqualsFody, un plugin pour Fody, réécrit IL, remplaçant Equals et GetHashCode dans les classes marquées avec l'attribut EqualsAttribute.

Afin de ne pas marquer chaque Dto avec cet attribut, nous pouvons réécrire un peu l'interface IQuery

 public IQuery<TIn,TOut> where TIn : CachedDto{ } [Equals] public class CachedDto{ } 

Désormais, tous les Dto vont définitivement redéfinir les méthodes nécessaires, et nous n'avons pas besoin d'ajouter un attribut à chaque DTO d'entrée (il sera repris de la classe de base). Si la réécriture d'IL ne vous convient pas, implémentez CachedDto comme ceci (utilisez le contexte dans lequel les méthodes de classe de base sont appelées):

 public class CachedDto{ public override bool Equals(object x) => DeepEquals.Equals(this,x); public override int GetHashCode() => DeepHash.GetHashCode(this); } 

DeepEquals.Equals et DeepHash.GetHashCode utilisent la réflexion, il sera plus lent que Fody, il n'est pas fatal pour les applications d'entreprise.

Mais souvenez-vous de SRP, IQuery ne doit pas savoir qu'il est mis en cache.

La meilleure solution serait d'implémenter IEqualityComparer. Le dictionnaire le prend dans le constructeur et l'utilise lors de l'insertion / suppression / recherche.

  public class EqualityComparerUsingReflection<TKey> : IEqualityComparer<TKey> { public bool Equals(TKey x, TKey y) => DeepEqualsCommonType(x, y); public int GetHashCode(TKey obj) => Hash.GetHashCode(obj); } 

Maintenant, vous pouvez lever la contrainte sur TIn, nous avons atteint ce que nous voulions. Écrivons un décorateur de mise en cache:

  public class BaseCacheQuery<TIn, TOut> : IQuery<TIn, TOut> { private readonly ConcurrentDictionary<TIn, TOut> _cache; private readonly IQuery<TIn, TOut> _query; protected BaseCacheQuery( IQuery<TIn, TOut> query, IConcurrentDictionaryFactory<TIn, TOut> factory) { _cache = factory.Create(); _query = query; } public TOut Query(TIn input) => _cache .GetOrAdd(input, x => _query.Query(input)); } 

Faites attention à IConcurrentDictionaryFactory, le but de cette fabrique est de fournir une instance du dictionnaire, mais pourquoi ne pas simplement le créer dans le constructeur?

Premièrement, DI et SRP, il est tout à fait possible que vous ayez besoin d'ajouter une autre implémentation de comparateur (par exemple, plus facile pour certains types de DTO) ou de changer complètement l'implémentation, et deuxièmement, une situation est possible lorsque le cache commence à ralentir en raison de la réflexion et de l'abstraction fuite. Je vais faire des compromis et si Equals sont remplacés dans Dto et GetHashCode n'utilisera pas le "heavy" EqualityComparer.

Le but de l'usine est de vérifier si les méthodes sont remplacées, si c'est le cas, pour retourner un dictionnaire standard en utilisant des méthodes redéfinies dans le DTO, non - un dictionnaire avec comparateur.

Inscription

Revenons à la façon d'enregistrer tout cela.

L'argument services de la méthode ConfigureServices est une collection de ServiceDescriptors, chaque descripteur contient des informations sur la dépendance enregistrée

 public class ServiceDescriptor{ // other methods /// <inheritdoc /> public ServiceLifetime Lifetime { get; } /// <inheritdoc /> public Type ServiceType { get; } /// <inheritdoc /> public Type ImplementationType { get; } /// <inheritdoc /> public object ImplementationInstance { get; } /// <inheritdoc /> public Func<IServiceProvider, object> ImplementationFactory { get; } // other methods } 

Ainsi, un nouveau ServiceDescriptor avec LifeTime = Scoped est ajouté à la collection de services.
ServiceType = typeof (IService), ImplementType = typeof (Service):

 services.AddScoped<IService,Service>(). 

La propriété ImplementationFactory vous permet de spécifier comment créer la dépendance, nous allons l'utiliser. J'écrirai une extension à IServiceCollection, qui trouvera tous les IQuery et IAsyncQuery dans les assemblages, suspendra les décorateurs et s'enregistrera.

  public static void AddCachedQueries(this IServiceCollection serviceCollection) { // Func<Type,bool>    IAsyncQuery var asyncQueryScanPredicate = AggregatePredicates( IsClass, ContainsAsyncQueryInterface); // Func<Type,bool>     IQuery var queryScanAssemblesPredicate =AggregatePredicates( IsClass, x => !asyncQueryScanPredicate(x), ContainsQueryInterface); //    IAsyncQuery    var asyncQueries = GetAssemblesTypes( asyncQueryScanPredicate, DestAsyncQuerySourceType); //    IQuery    var queries = GetAssemblesTypes( queryScanAssemblesPredicate, DestQuerySourceType); //   ConcurrentDictionary serviceCollection.AddScoped( typeof(IConcurrentDictionaryFactory<,>), typeof(ConcDictionaryFactory<,>)); //   services ServiceDescriptor'   IAsyncQuery serviceCollection.QueryDecorate(asyncQueries, typeof(AsyncQueryCache<,>)); //   services ServiceDescriptor'   IQuery serviceCollection.QueryDecorate(queries, typeof(QueryCache<,>)); } private static void QueryDecorate(this IServiceCollection serviceCollection, IEnumerable<(Type source, Type dest)> parameters, Type cacheType, ServiceLifetime lifeTime = ServiceLifetime.Scoped) { foreach (var (source, dest) in parameters) serviceCollection.AddDecorator( cacheType.MakeGenericType(source.GenericTypeArguments), source, dest, lifeTime); } private static void AddDecorator( this IServiceCollection serviceCollection, Type cacheType, Type querySourceType, Type queryDestType, ServiceLifetime lifetime = ServiceLifetime.Scoped) { //ReSharper disable once ConvertToLocalFunction Func<IServiceProvider, object> factory = provider => ActivatorUtilities.CreateInstance(provider, cacheType, ActivatorUtilities.GetServiceOrCreateInstance(provider, queryDestType)); serviceCollection.Add( new ServiceDescriptor(querySourceType, factory, lifetime)); } } 

La méthode AddDecorator mérite une attention particulière, nous utilisons ici les méthodes statiques de la classe ActivatorUtilities. ActivatorUtilities.CreateInstance accepte IServiceProvider, le type d'objet à créer et les instances de dépendance que cet objet accepte dans le constructeur (vous pouvez spécifier uniquement celles qui ne sont pas enregistrées, le reste sera autorisé par le fournisseur)

ActivatorUtilities.GetServiceOrCreateInstance - fait la même chose, mais ne permet pas de transmettre les dépendances manquantes au constructeur de l'objet créé. Si l'objet est enregistré dans le conteneur, il le créera simplement (ou retournera celui déjà créé), sinon, il créera l'objet, à condition qu'il puisse résoudre toutes ses dépendances

Ainsi, vous pouvez créer une fonction qui renvoie un objet cache et ajouter un descripteur décrivant cet enregistrement aux services.

Écrivons un test:

 public class DtoQuery : IQuery<Dto, Something> { private readonly IRepository _repository; public DtoQuery(IRepository repository) { _repository = repository; } public Something Query(Dto input) => _repository.GetSomething(); } //    private IQuery<Dto, Something> query { get; set; } public void TwoCallQueryTest() { var dto = new Dto {One = 1}; var dto1 = new Dto {One = 1}; //query -        query.Query(dto); query.Query(dto1); // : services.AddScoped<IRepository>(x => MockRepository.Object) RepositoryMock.Verify(x => x.GetSomething(), Times.Once); } 

ReposityMock - Mock de la bibliothèque Moq est drôle, mais pour tester combien de fois la méthode GetSomething () du référentiel a été appelée, il utilise également des décorateurs, bien qu'il les génère automatiquement à l'aide de Castle.Interceptor. Nous testons les décorateurs à l'aide de décorateurs.

C'est ainsi que vous pouvez ajouter la mise en cache de tous les résultats IQuery <TIn, TOut>, il est très gênant d'écrire autant de code pour implémenter un peu de fonctionnalité.

Autres solutions

Mediatr

Interface de la bibliothèque centrale:

 public interface IRequestHandler<in TRequest, TResponse> where TRequest : IRequest<TResponse> { Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken); } 

La principale fonctionnalité de MediatR consiste à ajouter des wrappers sur un IRequestHandler, par exemple, en implémentant un pipeline à l'aide de l'interface IPipelineBehavior, voici comment vous pouvez enregistrer CachePipelineBehaviour, il sera appliqué à toutes les interfaces IRequestHandler enregistrées:

 sc.AddScoped(typeof(IPipelineBehavior<,>), typeof(CachePipelineBehaviour<,>)); 

Nous implémentons le cache PipelineBehaviour:

 public class CachePipelineBehaviour<TDto, TResult> : IPipelineBehavior<TDto, TResult> { private readonly ConcurrentDictionary<TDto, Task<TResult>> _cache; public CachePipelineBehaviour( IConcurrentDictionaryFactory<TDto, Task<TResult>> cacheFactory) { _cache = cacheFactory.Create(); } public async Task<TResult> Handle(TDto request, CancellationToken cancellationToken, RequestHandlerDelegate<TResult> next) => await _cache.GetOrAdd(request, x => next()); } 

Le Dto de la demande, le jeton d'annulation et RequestHandlerDelegate arrivent à la méthode Handle. Ce dernier est juste un wrapper sur les prochains appels d'autres décorateurs et handler'a. MediatR scanne les assemblages et enregistre toutes les implémentations de l'interface elle-même. Pour l'utiliser, vous devez injecter IMediator et appeler la méthode Send en passant Dto:

 public async Task<IActionResult>([FromBody] Dto dto){ return Ok(mediator.Send(dto)); } 

MediatR lui-même le trouvera, trouvera une implémentation appropriée d'IRequestHabdler'a et appliquera tous les décorateurs (en plus de PipelineBehaviour, il existe également IPreRequestHandler et IPostRequestHandler)

Château de Windsor

La caractéristique du conteneur est la génération de wrappers dynamiques, c'est AOP dynamique.

Entity Framework l'utilise pour le chargement différé, dans le getter de propriété, la méthode Load de l'interface ILazyLoader est appelée, qui est injectée dans les classes de tous les wrappers sur les entités via l' implémentation du constructeur .

Pour configurer le conteneur avec la génération de wrappers, vous devez créer un intercepteur et l'enregistrer

  public class CacheInterceptor<TIn, TOut> : IInterceptor { private readonly ConcurrentDictionary<TIn, TOut> _cache; public CacheInterceptor( IConcurrentDictionaryFactory<TIn, TOut> cacheFactory) { _cache = cacheFactory.Create(); } public void Intercept(IInvocation invocation) { var input = (TIn) invocation.Arguments.Single(); if (_cache.TryGetValue(input, out var value)) invocation.ReturnValue = value; else { invocation.Proceed(); _cache.TryAdd(input, (TOut) invocation.ReturnValue); } } } 

L'interface IInvocation fournit des informations sur le membre de l'objet décoré qui a été consulté; le seul membre public de l'interface est la méthode Query, nous ne vérifierons donc pas que l'accès y a été enregistré, il n'y a pas d'autres options.

S'il y a un objet avec une telle clé dans le cache, remplissez la valeur de retour de la méthode (sans l'appeler), sinon, appelez la méthode Proceed, qui, à son tour, appellera la méthode décorée et remplira ReturnValue.

L'enregistrement des intercepteurs et le code complet peuvent être consultés sur Githab