हम स्वयं के लिए ऑटोमैपर को अनुकूलित करते हैं

AutoMapper एंटरप्राइज़ एप्लिकेशन को विकसित करने में उपयोग किए जाने वाले मुख्य उपकरणों में से एक है, इसलिए मैं यूनिट मैपिंग को परिभाषित करते हुए यथासंभव कम कोड लिखना चाहता हूं।

मुझे विस्तृत अनुमानों के साथ MapFrom में दोहराव पसंद नहीं है।

CreateMap<Pupil, PupilDto>() .ForMember(x => x.Name, s => s.MapFrom(x => x.Identity.Passport.Name)) .ForMember(x => x.Surname, s => s.MapFrom(x => x.Identity.Passport.Surname)) .ForMember(x => x.Age, s => s.MapFrom(x => x.Identity.Passport.Age)) .ForMember(x => x.Number, s => s.MapFrom(x => x.Identity.Passport.Number)) 

मैं इसे इस तरह से फिर से लिखना चाहूंगा:

 CreateMap<Pupil, PupilDto>() .From(x=>x.IdentityCard.Passport).To() 

ProjectTo

AutoMapper दोनों मेमोरी में मैपिंग का निर्माण कर सकता है और इसे SQL में ट्रांसलेट कर सकता है, यह एक्सप्रेशन को पूरा करता है, जो आप प्रोफाइल में वर्णित नियमों के अनुसार DTO में पेश करते हैं।

 EntityQueryable.Select(dtoPupil => new PupilDto() { Name = dtoPupil.Identity.Passport, Surname = dtoPupil.Identity.Passport.Surname}) 

मेरे द्वारा लिखी गई मैपिंग का 80% मानचित्रण है जो IQueryble से अभिव्यक्ति को पूरा करता है।

यह बहुत सुविधाजनक है:

 public ActionResult<IEnumerable<PupilDto>> GetAdultPupils(){ var result = _context.Pupils .Where(x=>x.Identity.Passport.Age >= 18 && ...) .ProjectTo<PupilDto>().ToList(); return result; } 

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

सच है, गंभीर अनुप्रयोगों में ऐसे कार्यों से ग्राहकों को संतुष्ट करने की संभावना नहीं है।

विपक्ष AutoMapper'a

1) यह बहुत व्यापक है, "वाइड" मैपिंग के साथ आपको ऐसे नियम लिखने होंगे जो कोड की एक पंक्ति पर फिट नहीं होते हैं।

प्रोफाइल बढ़ते हैं और कोड के अभिलेखागार में बदल जाते हैं जो एक बार लिखा जाता है और केवल नाम बदलने पर ही बदल जाता है।

2) यदि आप कन्वेंशन के अनुसार मैपिंग का उपयोग करते हैं, तो नाम खो गया है
DTO में गुण:

 public class PupilDto { //  Pupil       IdentityCard // IdentityCard     Passport public string IdentityCardPassportName { get; set; } public string IdentityCardPassportSurname { get; set; } } 

3) प्रकार की सुरक्षा का अभाव

1 और 2 अप्रिय क्षण हैं, लेकिन आप उनके साथ रख सकते हैं, लेकिन पंजीकरण करते समय टाइप सुरक्षा की कमी के साथ, यह पहले से ही अधिक मुश्किल है, इसे संकलित नहीं किया जाना चाहिए:

 // Name - string // Age - int ForMember(x => x.Age, s => s.MapFrom(x => x.Identity.Passport.Name) 

हम संकलन चरण में ऐसी त्रुटियों के बारे में जानकारी प्राप्त करना चाहते हैं, न कि रन-टाइम पर।

इन बिंदुओं को खत्म करने के लिए एक्सट्रेशन रैपर का उपयोग करना।

एक आवरण लिखना

पंजीकरण इस तरह क्यों लिखा जाना चाहिए?

 CreateMap<Pupil, PupilDto>() .ForMember(x => x.Name, s => s.MapFrom(x => x.Identity.Passport.Name)) .ForMember(x => x.Surname, s => s.MapFrom(x => x.Identity.Passport.Surname)) .ForMember(x => x.Age, s => s.MapFrom(x => x.Identity.Passport.Age)) .ForMember(x => x.House, s => s.MapFrom(x => x.Address.House)) .ForMember(x => x.Street, s => s.MapFrom(x => x.Address.Street)) .ForMember(x => x.Country, s => s.MapFrom(x => x.Address.Country)) .ForMember(x => x.Surname, s => s.MapFrom(x => x.Identity.Passport.Age)) .ForMember(x => x.Group, s => s.MapFrom(x=>x.EducationCard.StudyGroup.Number)) 

इतना अधिक संक्षिप्त:

 CreateMap<Pupil,PupilDto>() //    // PassportName = Passport.Name, PassportSurname = Passport.Surname .From(x => x.IdentityCard.Passport).To() // House,Street,Country -   .From(x => x.Address).To() //    -  DTO,  -  .From(x => x.EducationCard.Group).To((x => x.Group,x => x.Number)); 

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

IMapping <TSource, TDest> ऑटोमेपर का इंटरफ़ेस है जिसमें ForMember, ForAll () विधियों को परिभाषित किया गया है ... ये सभी विधियाँ इसे (धाराप्रवाह) लौटाती हैं।

हम अभिव्यक्ति को विधि से याद करने के लिए रैपर को वापस करेंगे

 public static MapperExpressionWrapper<TSource, TDest, TProjection> From<TSource, TDest, TProjection> (this IMappingExpression<TSource, TDest> mapping, Expression<Func<TSource, TProjection>> expression) => new MapperExpressionWrapper<TSource, TDest, TProjection>(mapping, expression); 

अब प्रोग्रामर, फ्रॉम मेथड, लिखा हुआ, तुरंत टू- मेथड के अधिभार को देखेगा, जिससे हम उसे एपीआई बताएंगे, ऐसे मामलों में हम सभी विस्तार विधियों के आकर्षण का एहसास कर सकते हैं, हमने ऑटोमोटिव स्रोतों के लिए लिखने के बिना व्यवहार का विस्तार किया

हम टाइप करते हैं

टाइप की गई विधि को लागू करना अधिक जटिल है।

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

जब मेरे अभ्यास में एक समान कार्य का सामना होता है, तो मैं तुरंत रोजलिन की दिशा में देखता हूं, मुझे एक ही तरह के कई तरीके लिखने और कॉपी पेस्ट करने का मन नहीं करता है, उन्हें उत्पन्न करना आसान है।

इसमें जेनेरिक हमारी मदद करेंगे। जेनरिक और मापदंडों की एक अलग संख्या के साथ 10 विधियां उत्पन्न करना आवश्यक है

प्रक्षेप्य के लिए पहला दृष्टिकोण थोड़ा अलग था, मैं लैम्ब्डा के रिटर्न प्रकार (इंट, स्ट्रिंग, बूलियन, डेटाइम) को सीमित करना चाहता था और सार्वभौमिक प्रकार का उपयोग नहीं करना चाहता था।

कठिनाई यह है कि 3 मापदंडों के लिए भी हमें 64 अलग-अलग ओवरलोड उत्पन्न करने होंगे, और केवल सामान्य का उपयोग करते समय 1:

 IMappingExpression<TSource, TDest> To<TSource, TDest, TProjection,T,T1, T2, T3>( this MapperExpressionWrapper<TSource,TDest,TProjection> mapperExpressionWrapper, (Expression<Func<TDest, T>>, Expression<Func<TProjection, T>>) arg0, (Expression<Func<TDest, T1>>, Expression<Func<TProjection, T1>>) arg1, (Expression<Func<TDest, T2>>, Expression<Func<TProjection, T2>>) arg2, (Expression<Func<TDest, T3>>, Expression<Func<TProjection, T3>>) arg3) { ... } 

लेकिन यह मुख्य समस्या नहीं है, हम कोड उत्पन्न करते हैं, इसमें कुछ समय लगेगा और हमें आवश्यक तरीकों का पूरा सेट मिलेगा।

समस्या अलग है, ReSharper इतने सारे अधिभार नहीं उठाएंगे और बस काम करने से इनकार कर देंगे, आप Intellisience खो देंगे और IDE लोड करेंगे।

हम एक ऐसी विधि लागू करते हैं जो एक टपल लेती है:

 public static IMappingExpression<TSource, TDest> To <TSource, TDest, TProjection, T>(this MapperExpressionWrapper<TSource,TDest,TProjection> mapperExpressionWrapper, (Expression<Func<TDest, T>>, Expression<Func<TProjection, T>>) arg0) { //    RegisterByConvention(mapperExpressionWrapper); //    expreession RegisterRule(mapperExpressionWrapper, arg0); //  IMappingExpression,     //   extension  return mapperExpressionWrapper.MappingExpression; } 

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

प्रकार के लैंबडा को दर्ज करना असंभव है अभिव्यक्ति <फंक <TSource, object >>, फिर AutoMapper ऑब्जेक्ट टाइप करने के लिए सभी DTO गुणों को मैप करेगा

 private static void RegisterByConvention<TSource, TDest, TProjection>( MapperExpressionWrapper<TSource, TDest, TProjection> mapperExpressionWrapper) { var properties = typeof(TDest).GetProperties().ToList(); properties.ForEach(prop => { // mapperExpressionWrapper.FromExpression = x=>x.Identity.Passport // prop.Name = Name // ruleByConvention Expression<Func<Pupil,string>> x=>x.Identity.Passport.Name var ruleByConvention = _cachedMethodInfo .GetMethod(nameof(HelpersMethod.GetRuleByConvention)) .MakeGenericMethod(typeof(TSource), typeof(TProjection), prop.PropertyType) .Invoke(null, new object[] {prop, mapperExpressionWrapper.FromExpression}); if (ruleByConvention == null) return; // mapperExpressionWrapper.MappingExpression.ForMember(prop.Name, s => s.MapFrom((dynamic) ruleByConvention)); }); } 

रजिस्टररुले एक टपल प्राप्त करता है जो मानचित्रण नियमों को परिभाषित करता है, इसे इसमें "कनेक्ट" होने की आवश्यकता है
FromExpression और अभिव्यक्ति tuple को पारित कर दिया।

यह हमें अभिव्यक्ति में मदद करेगा। इंवोक, ईएफ कोर 2.0 ने इसका समर्थन नहीं किया, बाद में संस्करणों ने समर्थन करना शुरू कर दिया। यह आपको "लैम्ब्ड रचना" बनाने की अनुमति देगा:

 Expression<Func<Pupil,StudyGroup>> from = x=>x.EducationCard.StudyGroup; Expression<Func<StudyGroup,int>> @for = x=>x.Number; //invoke = x=>x.EducationCard.StudyGroup.Number; var composition = Expression.Lambda<Func<Pupil, string>>( Expression.Invoke(@for,from.Body),from.Parameters.First()) 

रजिस्टर विधि:

 private static void RegisterRule<TSource, TDest, TProjection, T (MapperExpressionWrapper<TSource,TDest,TProjection> mapperExpressionWrapper, (Expression<Func<TDest, T>>, Expression<Func<TProjection, T>>) rule) { //rule = (x=>x.Group,x=>x.Number) var (from, @for) = rule; //      @for = (Expression<Func<TProjection, T>>) _interpolationReplacer.Visit(@for); //mapperExpressionWrapper.FromExpression = (x=>x.EducationCard.StudyGroup) var result = Expression.Lambda<Func<TSource, T>>( Expression.Invoke(@for, mapperExpressionWrapper.FromExpression.Body), mapperExpressionWrapper.FromExpression.Parameters.First()); var destPropertyName = from.PropertiesStr().First(); // result = x => Invoke(x => x.Number, x.EducationCard.StudyGroup) //  ,  result = x=>x.EducationCard.StudyCard.Number mapperExpressionWrapper.MappingExpression .ForMember(destPropertyName, s => s.MapFrom(result)); } 

टपल मापदंडों को जोड़ते समय विधि को विस्तारित करना आसान बनाने के लिए डिज़ाइन किया गया है। मापदंडों में एक और टपल जोड़ते समय, आपको एक और जेनेरिक, पैरामीटर जोड़ना होगा, और नए पैरामीटर के लिए RegisterRule विधि को कॉल करना होगा।

दो मापदंडों के लिए एक उदाहरण:

 IMappingExpression<TSource, TDest> To<TSource, TDest, TProjection, T, T1> (this MapperExpressionWrapper<TSource,TDest,TProjection>mapperExpressionWrapper, (Expression<Func<TDest, T>>, Expression<Func<TProjection, T>>) arg0, (Expression<Func<TDest, T1>>, Expression<Func<TProjection, T1>>) arg1) { RegisterByConvention(mapperExpressionWrapper); RegisterRule(mapperExpressionWrapper, arg0); RegisterRule(mapperExpressionWrapper, arg1); return mapperExpressionWrapper.MappingExpression; } 

हम CSharpSyntaxRewriter का उपयोग करते हैं , यह एक आगंतुक है जो वाक्यविन्यास के नोड्स के माध्यम से चलता है। हम एक तर्क के साथ To को आधार बनाते हैं और एक जेनेरिक पैरामीटर जोड़ते हैं और RegisterRule को कॉल करते हैं;

 public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { //     To if (node.Identifier.Value.ToString() != "To") return base.VisitMethodDeclaration(node); // returnStatement = return mapperExpressionWrapper.MappingExpression; var returnStatement = node.Body.Statements.Last(); //beforeReturnStatements: //[RegisterByConvention(mapperExpressionWrapper), // RegisterRule(mapperExpressionWrapper, arg0)] var beforeReturnStatements = node.Body.Statements.SkipLast(1); //   RegisterRule  returStatement var newBody = SyntaxFactory.Block( beforeReturnStatements.Concat(ReWriteMethodInfo.Block.Statements) .Concat(new[] {returnStatement})); //     return node.Update( node.AttributeLists, node.Modifiers, node.ReturnType, node.ExplicitInterfaceSpecifier, node.Identifier, node.TypeParameterList.AddParameters (ReWriteMethodInfo.Generics.Parameters.ToArray()), node.ParameterList.AddParameters (ReWriteMethodInfo.AddedParameters.Parameters.ToArray()), node.ConstraintClauses, newBody, node.SemicolonToken); } 

ReWriteMethodInfo में उत्पन्न सिंटैक्स ट्री नोड्स होते हैं जिन्हें आपको जोड़ना होगा। उसके बाद, हमें MethodDeclarationSyntax (एक विधि का प्रतिनिधित्व करने वाला एक सिंटैक्स ट्री) प्रकार की 10 वस्तुओं की सूची मिलती है।

अगले चरण में, हम उस क्लास को लेते हैं जिसमें टेम्प्लेट मेथड निहित है और अन्य विज़िटर का उपयोग करके इसमें सभी नए तरीके लिखते हैं, जिसमें हम VisitClassDeclatation को फिर से परिभाषित करते हैं।

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

 public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) { //todo refactoring it return node.Update( node.AttributeLists, node.Modifiers, node.Keyword, node.Identifier, node.TypeParameterList, node.BaseList, node.ConstraintClauses, node.OpenBraceToken, new SyntaxList<MemberDeclarationSyntax>(ReWriteMethods), node.CloseBraceToken, node.SemicolonToken); } 

अंत में, हमें एक SyntaxNode मिलता है - एक क्लास जिसमें जोड़े गए तरीके हैं, नोड को एक नई फ़ाइल में लिखें। अब हमने 1 से 10 ट्यूपल और बहुत अधिक संक्षिप्त मानचित्रण करने के लिए Too विधि को ओवरलोड कर दिया है।

विस्तार बिंदु

आइए AutoMapper को कुछ और के रूप में देखें। क्वेरी करने योग्य प्रदाता बहुत अधिक प्रश्नों को पार्स नहीं कर सकता है, और इन प्रश्नों का एक निश्चित भाग अलग से फिर से लिखा जा सकता है। यह वह जगह है जहां AutoMapper खेल में आता है, विस्तार एक विस्तार बिंदु है जहां हम अपने स्वयं के नियमों को जोड़ सकते हैं।

हम पिछले लेख से विज़िटर का उपयोग करेंगे जो कि रेगस्टर विधि में संगति के साथ स्ट्रिंग प्रक्षेप की जगह लेता है। परिणामस्वरूप, सभी अभिव्यक्ति जो इकाई से मानचित्रण को परिभाषित करते हैं, इस आगंतुक के माध्यम से जाएंगे, जिससे हर बार कॉल करने की आवश्यकता समाप्त हो जाएगी । यह एक रामबाण नहीं है, एकमात्र तरीका है कि हम क्या कर सकते हैं। प्रबंधन एक प्रक्षेपण है, लेकिन यह अभी भी जीवन को आसान बनाता है।

हम कुछ सुविधाजनक extention'y भी जोड़ सकते हैं, उदाहरण के लिए, शर्त द्वारा मानचित्रण के लिए:

 CreateMap<Passport,PassportDto>() .ToIf(x => x.Age, x => x < 18, x => $"{x.Age}", x => "Adult") 

मुख्य बात यह है कि इसके साथ खेलना नहीं है और प्रदर्शन स्तर पर जटिल तर्क को स्थानांतरित करना शुरू नहीं करना है
Github