पिछले लेख में, मैंने रोज़लिन के साथ कोड पीढ़ी को व्यवस्थित करने का एक तरीका बताया। तत्कालीन कार्य एक सामान्य दृष्टिकोण प्रदर्शित करना था। अब मैं कुछ ऐसा महसूस करना चाहता हूं जिसमें वास्तविक अनुप्रयोग होगा।

और इसलिए, कोई भी व्यक्ति यह देखने में रुचि रखता है कि आप ऑटमपैपर जैसी लाइब्रेरी कैसे बना सकते हैं।

परिचय

सबसे पहले, मुझे लगता है कि यह बताने के लायक है कि मेरा समय मैपर (AOTMapper) कैसे काम करेगा। हमारे मैपर का प्रवेश बिंदु जेनेरिक MapTo<> विधि MapTo<> । विश्लेषक इसके लिए खोज करेगा और MapToUser एक्सटेंशन MapToUser को लागू करने की पेशकश करेगा, जहां User वह प्रकार है जो MapTo<> को पारित किया MapTo<> ।

एक उदाहरण के रूप में, निम्नलिखित कक्षाएं लें:

 namespace AOTMapper.Benchmark.Data { public class UserEntity { public UserEntity() { } public UserEntity(Guid id, string firstName, string lastName) { this.Id = id; this.FirstName = firstName; this.LastName = lastName; } public Guid Id { get; set; } public string FirstName { get; set; } public string LastName { get; set; } } public class User { public string FirstName { get; set; } public string LastName { get; set; } public string Name { get; set; } } } 

उत्पन्न MapToUser इस तरह दिखेगा:

 public static AOTMapper.Benchmark.Data.User MapToUser(this AOTMapper.Benchmark.Data.UserEntity input) { var output = new AOTMapper.Benchmark.Data.User(); output.FirstName = input.FirstName; output.LastName = input.LastName; output.Name = ; // missing property return output; } 

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

उदाहरण के लिए, इस तरह:

 public static AOTMapper.Benchmark.Data.User MapToUser(this AOTMapper.Benchmark.Data.UserEntity input) { var output = new AOTMapper.Benchmark.Data.User(); output.FirstName = input.FirstName; output.LastName = input.LastName; output.Name = $"{input.FirstName} {input.LastName}"; return output; } 

MapToUser पीढ़ी के दौरान, MapTo<User> कॉल MapTo<User> को MapToUser द्वारा प्रतिस्थापित किया MapToUser ।

यह गति में कैसे काम करता है यहाँ देखा जा सकता है:

AOTMapper को नुगेट के माध्यम से भी स्थापित किया जा सकता है:

 Install-Package AOTMapper 

पूर्ण परियोजना कोड यहां पाया जा सकता है ।

कार्यान्वयन

मैंने लंबे समय तक सोचा कि यह कैसे अलग तरीके से किया जा सकता है और अंत में मैं इस नतीजे पर पहुंचा कि यह इतना बुरा नहीं है, क्योंकि यह कुछ असुविधा को हल करता है जिसने मुझे AutoMapper का उपयोग करते समय पीड़ा दी।

सबसे पहले, हमें विभिन्न प्रकारों के लिए अलग-अलग एक्सटेंशन विधियां मिलती हैं, जिसके परिणामस्वरूप, कुछ अमूर्त User प्रकारों के लिए, हम बहुत आसानी से इंटेलीजेंस का उपयोग कर सकते हैं यह पता लगाने के लिए कि कौन से नक्शे पहले से ही उसी फ़ाइल की तलाश किए बिना कार्यान्वित किए जाते हैं जहां हमारे नक्शे पंजीकृत हैं। जरा देखें कि आपके पास पहले से कौन सी एक्सटेंशन विधियां हैं।

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

इसके अलावा, इस मैपर के फायदों में यह तथ्य शामिल है कि आमतौर पर आवेदन शुरू होने पर इसे शुरू करने के लिए समय की आवश्यकता नहीं होती है, जो बड़े अनुप्रयोगों में उपयोगी हो सकता है।

विश्लेषक के पास स्वयं निम्नलिखित रूप हैं (बाध्यकारी कोड को याद रखना):

 private void Handle(OperationAnalysisContext context) { var syntax = context.Operation.Syntax; if (syntax is InvocationExpressionSyntax invocationSytax && invocationSytax.Expression is MemberAccessExpressionSyntax memberAccessSyntax && syntax.DescendantNodes().OfType<GenericNameSyntax>().FirstOrDefault() is GenericNameSyntax genericNameSyntax && genericNameSyntax.Identifier.ValueText == "MapTo") { var semanticModel = context.Compilation.GetSemanticModel(syntax.SyntaxTree); var methodInformation = semanticModel.GetSymbolInfo(genericNameSyntax); if (methodInformation.Symbol.ContainingAssembly.Name != CoreAssemblyName) { return; } var fromTypeInfo = semanticModel.GetTypeInfo(memberAccessSyntax.Expression); var fromTypeName = fromTypeInfo.Type.ToDisplayString(); var typeSyntax = genericNameSyntax.TypeArgumentList.Arguments.First(); var toTypeInfo = semanticModel.GetTypeInfo(typeSyntax); var toTypeName = toTypeInfo.Type.ToDisplayString(); var properties = ImmutableDictionary<string, string>.Empty .Add("fromType", fromTypeName) .Add("toType", toTypeName); context.ReportDiagnostic(Diagnostic.Create(AOTMapperIsNotReadyDescriptor, genericNameSyntax.GetLocation(), properties)); } } 

वह जो कुछ भी करता है वह MapTo<> कि क्या यह वह विधि है जिसकी हमें आवश्यकता है, उस इकाई से प्रकार निकालता है जिस पर MapTo<> को सामान्यीकृत विधि के पहले पैरामीटर से एक साथ कहा जाता है, और एक नैदानिक ​​संदेश उत्पन्न करता है।

यह बदले में AOTMapperCodeFixProvider अंदर संसाधित किया AOTMapperCodeFixProvider । यहां हमें उन प्रकारों के बारे में जानकारी मिलती है जिन पर हम कोड जनरेशन चलाएंगे। फिर हम एक विशिष्ट कार्यान्वयन के साथ कॉल को MapTo<> बदल देते हैं। फिर हम AOTMapperGenerator कॉल AOTMapperGenerator जो एक्सटेंशन विधि के साथ एक फ़ाइल उत्पन्न करेगा।

कोड में, यह इस तरह दिखता है:

 private async Task<Document> Handle(Diagnostic diagnostic, CodeFixContext context) { var fromTypeName = diagnostic.Properties["fromType"]; var toTypeName = diagnostic.Properties["toType"]; var document = context.Document; var semanticModel = await document.GetSemanticModelAsync(); var root = await diagnostic.Location.SourceTree.GetRootAsync(); var call = root.FindNode(diagnostic.Location.SourceSpan); root = root.ReplaceNode(call, SyntaxFactory.IdentifierName($"MapTo{toTypeName.Split('.').Last()}")); var pairs = ImmutableDictionary<string, string>.Empty .Add(fromTypeName, toTypeName); var generator = new AOTMapperGenerator(document.Project, semanticModel.Compilation); generator.GenerateMappers(pairs, new[] { "AOTMapper", "Mappers" }); var newProject = generator.Project; var documentInNewProject = newProject.GetDocument(document.Id); return documentInNewProject.WithSyntaxRoot(root); } 

AOTMapperGenerator स्वयं प्रकारों के बीच मैपिंग के साथ फ़ाइलें बनाकर आने वाली परियोजना को संशोधित करता है।
यह निम्नानुसार किया जाता है:

 public void GenerateMappers(ImmutableDictionary<string, string> values, string[] outputNamespace) { foreach (var value in values) { var fromSymbol = this.Compilation.GetTypeByMetadataName(value.Key); var toSymbol = this.Compilation.GetTypeByMetadataName(value.Value); var fromSymbolName = fromSymbol.ToDisplayString().Replace(".", ""); var toSymbolName = toSymbol.ToDisplayString().Replace(".", ""); var fileName = $"{fromSymbolName}_To_{toSymbolName}"; var source = this.GenerateMapper(fromSymbol, toSymbol, fileName); this.Project = this.Project .AddDocument($"{fileName}.cs", source) .WithFolders(outputNamespace) .Project; } } private string GenerateMapper(INamedTypeSymbol fromSymbol, INamedTypeSymbol toSymbol, string fileName) { var fromProperties = fromSymbol.GetAllMembers() .OfType<IPropertySymbol>() .Where(o => (o.DeclaredAccessibility & Accessibility.Public) > 0) .ToDictionary(o => o.Name, o => o.Type); var toProperties = toSymbol.GetAllMembers() .OfType<IPropertySymbol>() .Where(o => (o.DeclaredAccessibility & Accessibility.Public) > 0) .ToDictionary(o => o.Name, o => o.Type); return $@" public static class {fileName}Extentions {{ public static {toSymbol.ToDisplayString()} MapTo{toSymbol.ToDisplayString().Split('.').Last()}(this {fromSymbol.ToDisplayString()} input) {{ var output = new {toSymbol.ToDisplayString()}(); { toProperties .Where(o => fromProperties.TryGetValue(o.Key, out var type) && type == o.Value) .Select(o => $" output.{o.Key} = input.{o.Key};" ) .JoinWithNewLine() } { toProperties .Where(o => !fromProperties.TryGetValue(o.Key, out var type) || type != o.Value) .Select(o => $" output.{o.Key} = ; // missing property") .JoinWithNewLine() } return output; }} }} "; } 

निष्कर्ष

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