ASP.NET कोर में ग्लोबल क्वेरी परिणाम कैशिंग

एक रूप में CQRS प्रतिमान या कोई अन्य मानता है कि क्वेरी कॉल एप्लिकेशन की स्थिति को नहीं बदलेगी। यही है, एक ही क्वेरी के भीतर एक ही क्वेरी के लिए कई कॉल का एक ही परिणाम होगा।

क्वेरी के भाग के रूप में उपयोग किए जाने वाले सभी इंटरफ़ेस IQuery या IAsyncQuery प्रकार के होते हैं:

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

ये इंटरफेस पूरी तरह से डेटा की प्राप्ति का वर्णन करते हैं, उदाहरण के लिए, खाते की छूट / बोनस और बाकी सब में स्वरूपित कीमतों की प्राप्ति:

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

पाइप लाइन इंटरफेस

इस दृष्टिकोण का लाभ आवेदन में इंटरफेस की एकरूपता है, जिसे पाइपलाइन में बनाया जा सकता है:

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

इस तरह रजिस्टर करें:

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

हमें मिलता है:

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

आदर्श रूप से, प्रोग्रामिंग को निर्माता की एक विधानसभा में बदलना चाहिए, लेकिन वास्तव में यह प्रोग्रामर के गौरव को संतुष्ट करने के लिए एक सुंदर चाल है।

सज्जाकार और ASP.NET कोर

MediatR पुस्तकालय इंटरफेस की एकरूपता और सज्जाकारों पर सटीक रूप से बनाया गया है।

सज्जाकार आपको मानक IQuery <TIn, TOut> इंटरफ़ेस पर कुछ अतिरिक्त कार्यों को लटका देने की अनुमति देते हैं, उदाहरण के लिए लॉगिंग:

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

मैं इस तथ्य को छोड़ दूंगा कि सज्जाकार आपको पूरे कार्यक्रम में फैलने के बजाय एक स्थान पर क्रॉस-कटिंग कार्यक्षमता लिखने की अनुमति देते हैं, यह इस लेख के दायरे का हिस्सा नहीं है।

.Net कोर द्वारा प्रदान किया गया मानक IoC कंटेनर डेकोरेटर्स को पंजीकृत करने में सक्षम नहीं है। कठिनाई यह है कि हमारे पास एक ही इंटरफ़ेस के दो कार्यान्वयन हैं: मूल क्वेरी और डेकोरेटर, और एक ही इंटरफ़ेस जो डेकोरेटर इम्प्लांट्स डेकोरेटर के लिए आता है। कंटेनर ऐसे ग्राफ़ को हल नहीं कर सकता है और "परिपत्र निर्भरता" त्रुटि फेंकता है।

इस समस्या को हल करने के कई तरीके हैं। विशेष रूप से .Net कोर कंटेनर के लिए, स्क्रूटोर लाइब्रेरी को लिखा जाता है, यह सज्जाकारों को पंजीकृत कर सकता है:

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

यदि आप प्रोजेक्ट में अतिरिक्त निर्भरता नहीं जोड़ना चाहते हैं, तो आप इस कार्यक्षमता को स्वयं लिख सकते हैं, जो मैंने किया था। कोड प्रदर्शित करने से पहले, क्वेरी के भाग के रूप में क्वेरी परिणामों को कैशिंग करने पर चर्चा करते हैं। यदि आपको कैशिंग जोड़ने की आवश्यकता है और कुंजी वर्ग है, तो आपको GetHashCode और Equals को ओवरराइड करना होगा, इसलिए हम संदर्भ द्वारा तुलना से छुटकारा पा लेंगे।

कैशिंग तरीके

मैं एक साधारण कैश का एक उदाहरण प्रस्तुत करूंगा:

 //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 

एक मूल्य की खोज करते समय, GetHashCode विधि को पहले वांछित टोकरी को खोजने के लिए कहा जाता है, और फिर, यदि टोकरी में एक से अधिक तत्व हैं, तो बराबर को तुलना के लिए कहा जाता है। देखें कि क्या आप यह नहीं समझते हैं कि यह कैसे काम करता है।

ReSharper स्वयं इन विधियों को उत्पन्न करता है, लेकिन हम वैश्विक रूप से कैशिंग को कार्यान्वित करते हैं, प्रोग्रामर जिन्होंने IQuery <TIn, TOut> इंटरफ़ेस लागू किया है और सामान्य रूप से, IQuery <TIn, TOut> इंटरफ़ेस, SRP के लिए मत भूलना। इसलिए, पुनर्परि द्वारा तरीकों की पीढ़ी हमें शोभा नहीं देती है।

जब हम एंड-टू-एंड कार्यक्षमता से निपटते हैं, तो एओपी फ्रेमवर्क बचाव में आते हैं। EqualsFody, Fody के लिए एक प्लगइन, IL को फिर से लिखता है, EqualsAttribute विशेषता के साथ चिह्नित कक्षाओं में समान और GetHashCode को ओवरराइड करता है।

इस विशेषता के साथ प्रत्येक Dto को ध्वजांकित नहीं करने के लिए, हम IQuery इंटरफ़ेस को थोड़ा फिर से लिख सकते हैं

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

अब सभी Dto निश्चित रूप से आवश्यक तरीकों को फिर से परिभाषित करेंगे, और हमें प्रत्येक इनपुट DTO में एक विशेषता जोड़ने की आवश्यकता नहीं है (इसे बेस क्लास से उठाया जाएगा)। यदि पुनर्लेखन आईएल आपके लिए उपयुक्त नहीं है, तो कैश्ड्टो को इस तरह लागू करें (उस संदर्भ का उपयोग करें जिसमें आधार वर्ग विधियों को कहा जाता है):

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

DeepEquals.Equals और DeepHash.GetHashCode प्रतिबिंब का उपयोग करते हैं, यह फ़ोडी की तुलना में धीमा होगा, यह कॉर्पोरेट अनुप्रयोगों के लिए घातक नहीं है।

लेकिन SRP के बारे में याद रखें, IQuery को यह नहीं पता होना चाहिए कि यह कैश्ड है।

सबसे अच्छा समाधान IEqualityComparer को लागू करना होगा। डिक्शनरी इसे कंस्ट्रक्टर में ले जाती है और इसे डालने / हटाने / खोज करने पर उपयोग करती है।

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

अब आप TIn पर बाधा डाल सकते हैं, हमने वह हासिल किया जो हम चाहते थे। चलो एक कैशिंग डेकोरेटर लिखते हैं:

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

IConcurrentDictionaryFactory पर ध्यान दें, इस कारखाने का लक्ष्य डिक्शनरी का एक उदाहरण प्रदान करना है, लेकिन क्यों न केवल इसे कंस्ट्रक्टर में बनाया जाए?

सबसे पहले, DI और SRP, यह काफी संभव है कि आपको एक और तुलनात्मक कार्यान्वयन (उदाहरण के लिए, डीटीओ के कुछ प्रकारों के लिए आसान) को जोड़ना होगा या कार्यान्वयन को पूरी तरह से बदलना होगा, और दूसरी बात यह है कि ऐसी स्थिति संभव है जब प्रतिबिंब और अमूर्त के कारण कैश धीमा होने लगे। लीक। मैं समझौता करूंगा और अगर डोटो में बराबरी की छूट है और गेटशेडकोड ​​"हैवी" इक्वेलिटी.कॉम का उपयोग नहीं करेगा।

कारखाने का उद्देश्य यह जांचना है कि क्या तरीकों को ओवरराइड किया जाता है, यदि हां, तो डीटीओ में पुनर्परिभाषित तरीकों का उपयोग करके एक मानक शब्दकोश वापस करने के लिए, नहीं - तुलनित्र के साथ एक शब्दकोश।

पंजीकरण

आइए, यह सब कैसे रजिस्टर करें।

ConfigureServices विधि की सेवाओं का तर्क ServiceDescriptors का संग्रह है, प्रत्येक विवरणक में पंजीकृत निर्भरता के बारे में जानकारी होती है

 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 } 

इस प्रकार, LifeTime = Scoped के साथ एक नया ServiceDescriptor सेवा संग्रह में जोड़ा जाता है।
ServiceType = typeof (IService), ImplementType = typeof (सेवा):

 services.AddScoped<IService,Service>(). 

इम्प्लीमेंटेशन फैक्ट्री प्रॉपर्टी आपको निर्भरता बनाने के तरीके को निर्दिष्ट करने की अनुमति देती है; हम इसका उपयोग करेंगे। मैं IServiceCollection के लिए एक एक्सटेंशन लिखूंगा, जिसमें सभी IQuery और IAsyncQuery विधानसभाओं में मिलेंगे, डेकोरेटर्स को लटकाएंगे और रजिस्टर करेंगे।

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

AddDecorator पद्धति विशेष ध्यान देने योग्य है, यहां हम ActivatorUtilities क्लास के स्थिर तरीकों का उपयोग करते हैं। ActivatorUtilities.CreateInstance IServiceProvider स्वीकार करता है, बनाई जाने वाली वस्तु का प्रकार और निर्भरता उदाहरण है कि यह ऑब्जेक्ट कंस्ट्रक्टर में स्वीकार करता है (आप केवल उन लोगों को निर्दिष्ट कर सकते हैं जो पंजीकृत नहीं हैं, प्रदाता द्वारा अनुमति दी जाएगी)

ActivatorUtilities.GetServiceOrCreateInstance - वही करता है, लेकिन बनाए गए ऑब्जेक्ट के कंस्ट्रक्टर को लापता निर्भरता को पारित करने की अनुमति नहीं देता है। यदि ऑब्जेक्ट कंटेनर में पंजीकृत है, तो यह बस इसे बनाएगा (या पहले से बनाए गए एक को वापस लौटाएगा), यदि नहीं, तो ऑब्जेक्ट बनाएं, बशर्ते कि यह अपनी सभी निर्भरता को हल कर सके

इस प्रकार, आप एक फ़ंक्शन बना सकते हैं जो कैश ऑब्जेक्ट लौटाता है और सेवाओं में इस पंजीकरण का वर्णन करने वाला एक डिस्क्रिप्टर जोड़ता है।

आइए एक परीक्षण लिखें:

 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 - Moq लाइब्रेरी से मॉक मज़ेदार है, लेकिन यह परीक्षण करने के लिए कि रिपॉजिटरी के गेटस्मोमेल () विधि को कितनी बार कहा गया है, यह डेकोरेटर्स का भी उपयोग करता है, हालांकि यह कैसल.इंटरमीटर का उपयोग करके स्वचालित रूप से उन्हें उत्पन्न करता है। हम डेकोरेटर्स का उपयोग करके डेकोरेटर्स का परीक्षण करते हैं।

यह है कि आप सभी IQuery <TIn, TOut> परिणामों के कैशिंग को कैसे जोड़ सकते हैं, थोड़ा कार्यक्षमता को लागू करने के लिए इतना कोड लिखना बहुत असुविधाजनक है।

अन्य उपाय

MediatR

केंद्रीय पुस्तकालय इंटरफ़ेस:

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

MediatR की मुख्य कार्यक्षमता एक IRequestHandler पर रैपर को जोड़ना है, उदाहरण के लिए, IPipelineBehavior इंटरफ़ेस का उपयोग करके एक पाइपलाइन को लागू करना, यह है कि आप CachePipelineBehaviour को कैसे पंजीकृत कर सकते हैं, यह सभी पंजीकृत IRequestHandler इंटरफेस पर लागू होगा:

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

हम कैशिंग पाइपलाइन लागू करते हैं:

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

अनुरोध का Dto, रद्द करने का टोकन, और RequestHandlerDelegate हैंडल विधि के लिए आता है। उत्तरार्द्ध अन्य सज्जाकारों और हैंडलर की अगली कॉल पर सिर्फ एक आवरण है। MediatR असेंबली को स्कैन करता है और इंटरफ़ेस के सभी कार्यान्वयन को पंजीकृत करता है। उपयोग करने के लिए आपको IMediator को इंजेक्ट करने की आवश्यकता है, और उस पर भेजें विधि को कॉल करें Dto गुजर रहा है:

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

MediatR स्वयं इसे ढूंढेगा, IRequestHabdler का उपयुक्त कार्यान्वयन ढूंढेगा और सभी सज्जाकारों को लागू करेगा (PipelineBehaviour के अलावा, IPreRequestHandler और IPostRequestHandler भी है)

महल की हवा

कंटेनर की विशेषता गतिशील आवरण की पीढ़ी है, यह गतिशील एओपी है।

एंटिटी फ्रेमवर्क इसका उपयोग आलसी लोडिंग के लिए करता है, संपत्ति पाने वाले में, ILazyLoader इंटरफ़ेस की लोड विधि को कहा जाता है, जिसे कंस्ट्रक्टर के कार्यान्वयन के माध्यम से सभी रैपरों के वर्गों में इंजेक्ट किया जाता है।

रैपर की पीढ़ी के साथ कंटेनर को कॉन्फ़िगर करने के लिए, आपको एक इंटरसेप्टर बनाने और इसे पंजीकृत करने की आवश्यकता है

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

IInvocation इंटरफ़ेस सजाया गया ऑब्जेक्ट के सदस्य के बारे में जानकारी प्रदान करता है जिसे एक्सेस किया गया था, इंटरफ़ेस का एकमात्र सार्वजनिक सदस्य क्वेरी विधि है, इसलिए हम यह जांच नहीं करेंगे कि एक्सेस इसे पंजीकृत किया गया था, कोई अन्य विकल्प नहीं हैं।

यदि कैश में इस तरह की कुंजी के साथ कोई वस्तु है, तो विधि के रिटर्न मान को भरें (इसे कॉल किए बिना), यदि नहीं, तो प्रोसिड विधि को कॉल करें, जो बदले में, सजाए गए तरीके को कॉल करेगा और रिटर्नवैल्यू में भरें।

Githab पर इंटरसेप्टर पंजीकरण और पूर्ण कोड देखा जा सकता है