En un artículo anterior , describí una forma de organizar la generación de código con Roslyn. La tarea de entonces era demostrar un enfoque común. Ahora quiero darme cuenta de algo que tendrá una aplicación real.

Entonces, cualquier persona interesada en ver cómo puede hacer que una biblioteca como AutoMapper pida un gato.

Introduccion

En primer lugar, creo que vale la pena describir cómo funcionará mi Ahead of Time Mapper (AOTMapper). El punto de entrada de nuestro mapeador será el método de extensión genérico MapTo<> . El analizador lo buscará y ofrecerá implementar el MapToUser extensión MapToUser , donde User es el tipo que se pasa a MapTo<> .

Como ejemplo, tome las siguientes clases:

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

El MapToUser generado se verá así:

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

Como puede ver en este ejemplo, todas las propiedades con los mismos nombres y tipos se asignan automáticamente. A su vez, aquellos para los que no se encontraron coincidencias continúan "colgándose" creando un error de compilación y el desarrollador de alguna manera debe manejarlos.

Por ejemplo, así:

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

Durante la generación de MapToUser , la MapTo<User> llamada MapTo<User> será reemplazada por MapToUser .

Cómo funciona en movimiento se puede ver aquí:

AOTMapper también se puede instalar a través de nuget:

 Install-Package AOTMapper 

El código completo del proyecto se puede encontrar aquí .

Implementación

Pensé durante mucho tiempo cómo se puede hacer esto de manera diferente y al final llegué a la conclusión de que esto no es tan malo, ya que esto resuelve algunos de los inconvenientes que me atormentaban al usar AutoMapper .

En primer lugar, obtenemos diferentes métodos de extensión para diferentes tipos, como resultado de lo cual, para algunos tipos de User abstractos, podemos usar IntelliSense muy fácilmente para averiguar qué mapas ya están implementados sin tener que buscar el mismo archivo donde están registrados nuestros mapas. Solo mira qué métodos de extensión ya tienes.

En segundo lugar, en tiempo de ejecución es solo un método de extensión y, por lo tanto, evitamos cualquier sobrecarga asociada con la llamada a nuestro mapeador. Entiendo que los desarrolladores de AutoMapper dedicaron mucho esfuerzo a optimizar la llamada, pero todavía hay algunos costos adicionales. Mi pequeño punto de referencia mostró que, en promedio, es de 140-150ns por llamada, excluyendo el tiempo de inicialización. El punto de referencia en sí se puede ver en el repositorio, y los resultados de la medición son más bajos.

Además, las ventajas de este mapeador incluyen el hecho de que generalmente no requiere tiempo para inicializarse cuando se inicia la aplicación, lo que puede ser útil en aplicaciones grandes.

El analizador tiene la siguiente forma (falta el código de enlace):

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

Todo lo que hace es verificar si es el método que necesitamos, extrae el tipo de la entidad en la que se llama MapTo<> desde el primer parámetro del método generalizado y genera un mensaje de diagnóstico.

A su vez, se procesará dentro del AOTMapperCodeFixProvider . Aquí obtenemos información sobre los tipos sobre los que ejecutaremos la generación de código. Luego reemplazamos la llamada a MapTo<> con una implementación específica. Luego llamamos a AOTMapperGenerator que generará un archivo con el método de extensión.

En el código, se ve así:

 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 modifica el proyecto entrante creando archivos con mapeos entre los tipos.
Esto se hace de la siguiente manera:

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

Conclusiones

En total, tenemos un mapeador que funciona justo al momento de escribir el código, y luego no queda nada de su tiempo de ejecución. Los planes presentan una forma de agregar capacidades de configuración. Por ejemplo, configure las plantillas para los nombres de los métodos generados y especifique el directorio donde guardar. También agregue la capacidad de rastrear cambios en los tipos. Tengo una idea de cómo se puede organizar esto, pero sospecho que esto puede ser notable en términos de consumo de recursos, y hasta ahora se ha decidido retrasar esto.