Compartir a través de

Generación de código de Orleans

Antes de Orleans la versión 7.0, la generación de código era más manual y requería la intervención explícita por parte del desarrollador. Orleans A partir de la versión 7.0, la generación de código es automática y normalmente no requiere ninguna intervención. Sin embargo, todavía existen casos en los que se podría desear influir en la generación de código, por ejemplo, para generar código para tipos no generados automáticamente o para tipos de otro ensamblaje.

Generación de código fuente

Orleans genera código fuente de C# para la aplicación en tiempo de compilación. Todos los proyectos, incluido el host, necesitan los paquetes NuGet adecuados instalados para habilitar la generación de código. Están disponibles los siguientes paquetes:

Usar GenerateSerializerAttribute para especificar que el tipo está destinado a la serialización y que Orleans debe generar el código de serialización para ello. Para obtener más información, consulte Uso de serialización Orleans.

El Orleans tiempo de ejecución utiliza código generado para garantizar la serialización adecuada de los tipos utilizados en el clúster y para generar código estándar. Este código base abstrae los detalles de implementación del despacho de métodos, la propagación de excepciones y otros conceptos internos del entorno de ejecución. La generación de código se puede realizar al compilar proyectos o cuando se inicializa la aplicación.

Generación de código en tiempo de compilación

En tiempo de compilación, Orleans genera código para todos los tipos marcados con GenerateSerializerAttribute. Si un tipo no está marcado con GenerateSerializer, Orleans no lo serializará.

Si desarrolla con F# o Visual Basic, también se puede usar la generación de código. Para obtener más información, consulte estos ejemplos:

Estos ejemplos muestran el uso de Orleans.GenerateCodeForDeclaringAssemblyAttribute, especificando tipos en el ensamblado para que el generador de origen inspeccione y genere código fuente.

El método preferido para la generación de código es en tiempo de compilación. Habilite la generación de código en tiempo de compilación mediante uno de los siguientes paquetes:

  • Microsoft.Orleans.OrleansCodeGenerator.Build: un paquete que usa Roslyn para la generación de código y la reflexión de .NET para el análisis.
  • Microsoft.Orleans.CodeGenerator.MSBuild: un paquete de generación de código más reciente que aprovecha Roslyn tanto para la generación de código como para el análisis. No carga archivos binarios de aplicación, evitando problemas causados por conflictos con versiones de dependencia y marcos de destino diferentes. Este generador de código también mejora la compatibilidad con compilaciones incrementales, lo que da lugar a tiempos de compilación más cortos.

Instale uno de estos paquetes en todos los proyectos que contengan granos, interfaces de granos, serializadores personalizados o tipos que se envíen entre granos. La instalación de un paquete inserta un destino en el proyecto que genera código en tiempo de compilación.

Ambos paquetes (Microsoft.Orleans.CodeGenerator.MSBuild y Microsoft.Orleans.OrleansCodeGenerator.Build) solo admiten proyectos de C#. Admita otros lenguajes mediante el Microsoft.Orleans.OrleansCodeGenerator paquete (descrito a continuación) o mediante la creación de un proyecto de C# que actúe como destino para el código generado a partir de ensamblados escritos en otros lenguajes.

Emita diagnósticos adicionales en tiempo de compilación especificando un valor para OrleansCodeGenLogLevel en el archivo .csproj del proyecto de destino. Por ejemplo: <OrleansCodeGenLogLevel>Trace</OrleansCodeGenLogLevel>.

Generación de código en tiempo de inicialización

En 7+ Orleans, no ocurre nada durante la inicialización. La generación de código solo se produce en tiempo de compilación.

La generación de código se puede realizar durante la inicialización en el cliente y el silo mediante la instalación del paquete Microsoft.Orleans.OrleansCodeGenerator y el uso del método de extensión ApplicationPartManagerCodeGenExtensions.WithCodeGeneration:

builder.ConfigureApplicationParts(
    parts => parts
        .AddApplicationPart(typeof(IRuntimeCodeGenGrain).Assembly)
        .WithCodeGeneration());

En el ejemplo anterior, builder puede ser una instancia de ISiloHostBuilder o IClientBuilder. Pase una instancia opcional ILoggerFactory a WithCodeGeneration para habilitar el registro durante la generación de código, por ejemplo:

ILoggerFactory codeGenLoggerFactory = new LoggerFactory();
codeGenLoggerFactory.AddProvider(new ConsoleLoggerProvider());
    builder.ConfigureApplicationParts(
        parts => parts
            .AddApplicationPart(typeof(IRuntimeCodeGenGrain).Assembly)
            .WithCodeGeneration(codeGenLoggerFactory));

Influir en la generación de código

Al aplicar GenerateSerializerAttribute a un tipo, IdAttribute también se puede aplicar para identificar de forma única el miembro. Del mismo modo, se puede aplicar un alias mediante .AliasAttribute Para obtener más información sobre cómo influir en la generación de código, consulte Usode la serialización Orleans.

Durante la generación de código, se puede influir en la generación de código para un tipo específico. Orleans genera automáticamente código para interfaces de grano, clases de grano, estado de grano y tipos pasados como argumentos en métodos de grano. Si un tipo no se ajusta a estos criterios, use los métodos siguientes para guiar aún más la generación de código.

Agregar SerializableAttribute a un tipo indica al generador de código que genere un serializador para él.

Agregar [assembly: GenerateSerializer(Type)] a un proyecto indica al generador de código que trate ese tipo como serializable. Produce un error si no se puede generar un serializador para ese tipo (por ejemplo, porque el tipo no es accesible). Este error detiene la compilación si la generación de código está habilitada. Este atributo también permite generar código para tipos específicos de otro ensamblado.

[assembly: KnownType(Type)] también indica al generador de código que incluya un tipo específico (que podría ser de un ensamblado al que se hace referencia), pero no produce una excepción si el tipo no es accesible.

Generación de serializadores para todos los subtipos

Agregar KnownBaseTypeAttribute a una interfaz o clase indica al generador de código que genere código de serialización para todos los tipos que heredan de ese tipo o implemente ese tipo.

Generación de código para todos los tipos de otro ensamblado

A veces, el código generado no se puede incluir en un ensamblado determinado en tiempo de compilación. Entre los ejemplos se incluyen bibliotecas compartidas que no hacen referencia a Orleans, ensamblados escritos en lenguajes distintos de C#y ensamblados para los que el código fuente no está disponible. En estos casos, coloque el código generado para esos ensamblados en un ensamblado independiente al que se hace referencia durante la inicialización.

Para habilitar esto para un ensamblado:

  1. Crear un proyecto de C#.
  2. Instale el paquete Microsoft.Orleans.CodeGenerator.MSBuild o el paquete Microsoft.Orleans.OrleansCodeGenerator.Build.
  3. Agregue una referencia al ensamblado de destino.
  4. Agregue [assembly: KnownAssembly("OtherAssembly")] en el nivel superior de un archivo de C#.

KnownAssemblyAttribute indica al generador de código que inspeccione el ensamblado especificado y genere código para los tipos que contiene. Este atributo se puede usar varias veces dentro de un proyecto.

A continuación, agregue el ensamblado generado al cliente o silo durante la inicialización:

builder.ConfigureApplicationParts(
    parts => parts.AddApplicationPart("CodeGenAssembly"));

En el ejemplo anterior, builder puede ser una instancia de ISiloHostBuilder o IClientBuilder.

KnownAssemblyAttribute tiene una propiedad opcional, TreatTypesAsSerializable. Establézcalo a true para indicar al generador de código que actúe como si todos los tipos de ese ensamblado se marquen como serializables.