De vez en cuando, cuando leía sobre Roslyn y sus analizadores, pensaba constantemente: "Pero puedes hacer nuget con esta cosa, que dará la vuelta al código y generará código". Una búsqueda rápida no mostró nada interesante, por lo que se decidió cavar. Qué gratamente me sorprendió cuando descubrí que mi idea no solo era factible, sino que todo esto funcionaría casi sin muletas.

Entonces, ¿quién está interesado en ver cómo puede hacer un "pequeño reflejo" y empaquetarlo en nuget, por favor, debajo de cat.

Introduccion

Creo que lo primero que hay que aclarar es qué se entiende por "poca reflexión". Sugiero implementar para todos los tipos el método Dictionary<string, Type> GetBakedType() , que devolverá los nombres de las propiedades y sus tipos. Como esto debería funcionar con todos los tipos, la opción más fácil sería generar un método de extensión para cada tipo. Su implementación manual tendrá la siguiente forma:

 using System; using System.Collections.Generic; public static class testSimpleReflectionUserExtentions { private static Dictionary<string, Type> properties = new Dictionary<string, Type> { { "Id", typeof(System.Guid)}, { "FirstName", typeof(string)}, { "LastName", typeof(string)}, }; public static Dictionary<string, Type> GetBakedType(this global::testSimpleReflection.User value) { return properties; } } 

Aquí no hay nada sobrenatural, pero realizarlo para todos los tipos es un asunto triste y no interesante que, además, amenaza los errores tipográficos. ¿Por qué no le pedimos ayuda al compilador? Aquí es donde Roslyn y sus analizadores entran en la arena. Brindan la oportunidad de analizar el código y cambiarlo. Entonces, enseñemos al compilador un nuevo truco. Deje que GetBakedType el código y vea dónde usamos, pero aún no hemos implementado nuestro GetBakedType y lo implementa.

Para "habilitar" esta funcionalidad, solo necesitamos instalar un paquete nuget y todo funcionará de inmediato. Luego, solo llame a GetBakedType cuando sea necesario, obtenemos un error de compilación que dice que la reflexión para este tipo aún no está lista, llame a codefix y ya está. Tenemos un método de extensión que nos devolverá todas las propiedades públicas.

Creo que en el movimiento será más fácil entender cómo funciona en general, aquí hay una breve visualización:

Si está interesado en probar esto localmente, puede instalar el paquete nuget bajo el nombre SimpleReflection:

 Install-Package SimpleReflection 

A quién le importa la fuente, están aquí .

Quiero advertir que esta implementación no está diseñada para un uso real. Solo quiero mostrar una forma de organizar la generación de código con Roslyn.

Preparación preliminar

Antes de comenzar a hacer sus analizadores, debe instalar el componente 'Desarrollo de extensión de Visual Studio' en el instalador del estudio. Para VS 2019, debe recordar seleccionar ".NET Compiler Platform SDK" como componente opcional.

Implementación de analizador

No describiré por etapas cómo implementar el analizador, ya que es muy simple, pero solo repase los puntos clave.

Y el primer punto clave será que si tenemos un error de compilación real, entonces los analizadores no comienzan en absoluto. Como resultado, si intentamos llamar a nuestro GetBakedType() en el contexto del tipo para el que no está implementado, obtendremos un error de compilación y todos nuestros esfuerzos no tendrán sentido. Pero aquí seremos ayudados por el conocimiento de la prioridad con la que el compilador llama a los métodos de extensión. El punto es que las implementaciones específicas tienen prioridad sobre los métodos genéricos. Es decir, en el siguiente ejemplo, se llamará al segundo método, no al primero:

 public static class SomeExtentions { public static void Save<T>(this T value) { ... } public static void Save(this User user) { ... } } public class Program { public static void Main(string[] args) { var user = new User(); user.Save(); } } 

Esta característica es muy útil. Simplemente definimos el GetBakedType genérico de la siguiente manera:

 using System; using System.Collections.Generic; public static class StubExtention { public static Dictionary<string, Type> GetBakedType<TValue>(this TValue value) { return new Dictionary<string, Type>(); } } 

Esto nos permitirá evitar un error de compilación al principio y generar nuestro propio "error" de compilación.

Considere el analizador en sí. Ofrecerá dos diagnósticos. El primero es responsable del caso en que la generación del código no comenzó en absoluto, y el segundo cuando necesitamos actualizar un código existente. Tendrán los siguientes nombres SimpleReflectionIsNotReady y SimpleReflectionUpdate respectivamente. El primer diagnóstico generará un "error de compilación", y el segundo solo informa que aquí puede volver a ejecutar la generación de código.

La descripción del diagnóstico es la siguiente:

  public const string SimpleReflectionIsNotReady = "SimpleReflectionIsNotReady"; public const string SimpleReflectionUpdate = "SimpleReflectionUpdate"; public static DiagnosticDescriptor SimpleReflectionIsNotReadyDescriptor = new DiagnosticDescriptor( SimpleReflectionIsNotReady, "Simple reflection is not ready.", "Simple reflection is not ready.", "Codegen", DiagnosticSeverity.Error, isEnabledByDefault: true, "Simple reflection is not ready."); public static DiagnosticDescriptor SimpleReflectionUpdateDescriptor = new DiagnosticDescriptor( SimpleReflectionUpdate, "Simple reflection update.", "Simple reflection update.", "Codegen", DiagnosticSeverity.Info, isEnabledByDefault: true, "Simple reflection update."); 

A continuación, es necesario determinar qué buscaremos, en este caso será una llamada al método:

 public override void Initialize(AnalysisContext context) { context.RegisterOperationAction(this.HandelBuilder, OperationKind.Invocation); } 

Entonces ya en HandelBuilder un análisis de árbol de sintaxis. En la entrada, recibiremos todas las llamadas encontradas, por lo que debe eliminar todo excepto nuestro GetBakedType . Esto se puede hacer con lo habitual if en el que verificamos el nombre del método. Luego obtenemos el tipo de variable sobre la cual se llama a nuestro método e informamos al compilador sobre los resultados de nuestro análisis. Esto puede ser un error de compilación si la generación del código aún no se ha iniciado o la capacidad de reiniciarlo.

Todo se ve así:

 private void HandelBuilder(OperationAnalysisContext context) { if (context.Operation.Syntax is InvocationExpressionSyntax invocation && invocation.Expression is MemberAccessExpressionSyntax memberAccess && memberAccess.Name is IdentifierNameSyntax methodName && methodName.Identifier.ValueText == "GetBakedType") { var semanticModel = context.Compilation .GetSemanticModel(invocation.SyntaxTree); var typeInfo = semanticModel .GetSpeculativeTypeInfo(memberAccess.Expression.SpanStart, memberAccess.Expression, SpeculativeBindingOption.BindAsExpression); var diagnosticProperties = ImmutableDictionary<string, string>.Empty.Add("type", typeInfo.Type.ToDisplayString()); if (context.Compilation.GetTypeByMetadataName(typeInfo.Type.GetSimpleReflectionExtentionTypeName()) is INamedTypeSymbol extention) { var updateDiagnostic = Diagnostic.Create(SimpleReflectionUpdateDescriptor, methodName.GetLocation(), diagnosticProperties); context.ReportDiagnostic(updateDiagnostic); return; } var diagnostic = Diagnostic.Create(SimpleReflectionIsNotReadyDescriptor, methodName.GetLocation(), diagnosticProperties); context.ReportDiagnostic(diagnostic); } } 

  [DiagnosticAnalyzer(LanguageNames.CSharp)] public class SimpleReflectionAnalyzer : DiagnosticAnalyzer { public const string SimpleReflectionIsNotReady = "SimpleReflectionIsNotReady"; public const string SimpleReflectionUpdate = "SimpleReflectionUpdate"; public static DiagnosticDescriptor SimpleReflectionIsNotReadyDescriptor = new DiagnosticDescriptor( SimpleReflectionIsNotReady, "Simple reflection is not ready.", "Simple reflection is not ready.", "Codegen", DiagnosticSeverity.Error, isEnabledByDefault: true, "Simple reflection is not ready."); public static DiagnosticDescriptor SimpleReflectionUpdateDescriptor = new DiagnosticDescriptor( SimpleReflectionUpdate, "Simple reflection update.", "Simple reflection update.", "Codegen", DiagnosticSeverity.Info, isEnabledByDefault: true, "Simple reflection update."); public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(SimpleReflectionIsNotReadyDescriptor, SimpleReflectionUpdateDescriptor); public override void Initialize(AnalysisContext context) { context.RegisterOperationAction(this.HandelBuilder, OperationKind.Invocation); } private void HandelBuilder(OperationAnalysisContext context) { if (context.Operation.Syntax is InvocationExpressionSyntax invocation && invocation.Expression is MemberAccessExpressionSyntax memberAccess && memberAccess.Name is IdentifierNameSyntax methodName && methodName.Identifier.ValueText == "GetBakedType" ) { var semanticModel = context.Compilation .GetSemanticModel(invocation.SyntaxTree); var typeInfo = semanticModel .GetSpeculativeTypeInfo(memberAccess.Expression.SpanStart, memberAccess.Expression, SpeculativeBindingOption.BindAsExpression); var diagnosticProperties = ImmutableDictionary<string, string>.Empty.Add("type", typeInfo.Type.ToDisplayString()); if (context.Compilation.GetTypeByMetadataName(typeInfo.Type.GetSimpleReflectionExtentionTypeName()) is INamedTypeSymbol extention) { var updateDiagnostic = Diagnostic.Create(SimpleReflectionUpdateDescriptor, methodName.GetLocation(), diagnosticProperties); context.ReportDiagnostic(updateDiagnostic); return; } var diagnostic = Diagnostic.Create(SimpleReflectionIsNotReadyDescriptor, methodName.GetLocation(), diagnosticProperties); context.ReportDiagnostic(diagnostic); } } } 

Implementación de generador de código

CodeFixProvider través de CodeFixProvider , que está suscrito a nuestro analizador. En primer lugar, debemos verificar qué sucedió para encontrar nuestro analizador.

Se ve así:

 public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var title = diagnostic.Severity == DiagnosticSeverity.Error ? "Generate simple reflection" : "Recreate simple reflection"; context.RegisterCodeFix( CodeAction.Create( title, createChangedDocument: token => this.CreateFormatterAsync(context, diagnostic, token), equivalenceKey: title), diagnostic); } 

Toda la magia ocurre dentro de CreateFormatterAsync . En él obtenemos una descripción completa del tipo. Luego comenzamos la generación de código y agregamos un nuevo archivo al proyecto.

Obteniendo información y agregando un archivo:

  private async Task<Document> CreateFormatterAsync(CodeFixContext context, Diagnostic diagnostic, CancellationToken token) { var typeName = diagnostic.Properties["type"]; var currentDocument = context.Document; var model = await context.Document.GetSemanticModelAsync(token); var symbol = model.Compilation.GetTypeByMetadataName(typeName); var rawSource = this.BuildSimpleReflection(symbol); var source = Formatter.Format(SyntaxFactory.ParseSyntaxTree(rawSource).GetRoot(), new AdhocWorkspace()).ToFullString(); var fileName = $"{symbol.GetSimpleReflectionExtentionTypeName()}.cs"; if (context.Document.Project.Documents.FirstOrDefault(o => o.Name == fileName) is Document document) { return document.WithText(SourceText.From(source)); } var folders = new[] { "SimpeReflection" }; return currentDocument.Project .AddDocument(fileName, source) .WithFolders(folders); } 

Generación de código propio (sospecho que el hub romperá toda la subred):

 private string BuildSimpleReflection(INamedTypeSymbol symbol) => $@" using System; using System.Collections.Generic; // Simple reflection for {symbol.ToDisplayString()} public static class {symbol.GetSimpleReflectionExtentionTypeName()} {{ private static Dictionary<string, Type> properties = new Dictionary<string, Type> {{ { symbol .GetAllMembers() .OfType<IPropertySymbol>() .Where(o => (o.DeclaredAccessibility & Accessibility.Public) > 0) .Select(o => $@" {{ ""{o.Name}"", typeof({o.Type.ToDisplayString()})}},") .JoinWithNewLine() } }}; public static Dictionary<string, Type> GetBakedType(this global::{symbol.ToDisplayString()} value) {{ return properties; }} }} "; } 

 using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CodeActions; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Formatting; using Microsoft.CodeAnalysis.Text; using SimpleReflection.Utils; using System; using System.Collections.Generic; using System.Collections.Immutable; using System.Composition; using System.IO; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; namespace SimpleReflection { [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(SimpleReflectionCodeFixProvider)), Shared] public class SimpleReflectionCodeFixProvider : CodeFixProvider { public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(SimpleReflectionAnalyzer.SimpleReflectionIsNotReady, SimpleReflectionAnalyzer.SimpleReflectionUpdate); public sealed override FixAllProvider GetFixAllProvider() { return WellKnownFixAllProviders.BatchFixer; } public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var title = diagnostic.Severity == DiagnosticSeverity.Error ? "Generate simple reflection" : "Recreate simple reflection"; context.RegisterCodeFix( CodeAction.Create( title, createChangedDocument: token => this.CreateFormatterAsync(context, diagnostic, token), equivalenceKey: title), diagnostic); } private async Task<Document> CreateFormatterAsync(CodeFixContext context, Diagnostic diagnostic, CancellationToken token) { var typeName = diagnostic.Properties["type"]; var currentDocument = context.Document; var model = await context.Document.GetSemanticModelAsync(token); var symbol = model.Compilation.GetTypeByMetadataName(typeName); var symbolName = symbol.ToDisplayString(); var rawSource = this.BuildSimpleReflection(symbol); var source = Formatter.Format(SyntaxFactory.ParseSyntaxTree(rawSource).GetRoot(), new AdhocWorkspace()).ToFullString(); var fileName = $"{symbol.GetSimpleReflectionExtentionTypeName()}.cs"; if (context.Document.Project.Documents.FirstOrDefault(o => o.Name == fileName) is Document document) { return document.WithText(SourceText.From(source)); } var folders = new[] { "SimpeReflection" }; return currentDocument.Project .AddDocument(fileName, source) .WithFolders(folders); } private string BuildSimpleReflection(INamedTypeSymbol symbol) => $@" using System; using System.Collections.Generic; // Simple reflection for {symbol.ToDisplayString()} public static class {symbol.GetSimpleReflectionExtentionTypeName()} {{ private static Dictionary<string, Type> properties = new Dictionary<string, Type> {{ { symbol .GetAllMembers() .OfType<IPropertySymbol>() .Where(o => (o.DeclaredAccessibility & Accessibility.Public) > 0) .Select(o => $@" {{ ""{o.Name}"", typeof({o.Type.ToDisplayString()})}},") .JoinWithNewLine() } }}; public static Dictionary<string, Type> GetBakedType(this global::{symbol.ToDisplayString()} value) {{ return properties; }} }} "; } } 

Resumen

Como resultado, tenemos un generador de código de analizador Roslyn con la ayuda del cual se implementa una reflexión "pequeña" mediante la generación de código. Será difícil encontrar una aplicación real para la biblioteca actual, pero será un gran ejemplo para implementar generadores de código fácilmente accesibles. Este enfoque puede ser, como cualquier generación de código, útil para escribir serializadores. Mi implementación de prueba de MessagePack funcionó ~ 20% más rápido que neuecc / MessagePack-CSharp , y todavía no he visto un serializador más rápido. Además, este enfoque no requiere Roslyn.Emit , que es perfecto para los escenarios Unity y AOT.