Condividi tramite

Generazione di codice Orleans

Prima della Orleans 7.0, la generazione di origine era più manuale e richiedeva l'intervento esplicito dello sviluppatore. Orleans A partire dalla versione 7.0, la generazione del codice è automatica e in genere non richiede alcun intervento. Tuttavia, esistono casi in cui potrebbe essere necessario influenzare la generazione di codice, ad esempio per generare codice per i tipi non generati automaticamente o per i tipi in un altro assembly.

Abilitare la generazione di codice

Orleans genera il codice sorgente C# per l'app in fase di compilazione. Tutti i progetti, incluso l'host, necessitano dei pacchetti NuGet appropriati installati per abilitare la generazione di codice. Sono disponibili i pacchetti seguenti:

GenerateSerializerAttribute Utilizzare per specificare che il tipo è destinato alla serializzazione e che Orleans deve generare il codice di serializzazione. Per altre informazioni, vedere Usare la serializzazione Orleans.

Il Orleans runtime usa il codice generato per garantire una corretta serializzazione dei tipi usati nel cluster e per generare il codice boilerplate. Questo boilerplate astrae i dettagli di implementazione dell'invio dei metodi, la propagazione delle eccezioni e altri concetti di runtime interno. La generazione di codice può essere eseguita durante la compilazione di progetti o quando l'applicazione viene inizializzata.

Generazione di codice in fase di compilazione

In fase di compilazione, Orleans genera il codice per tutti i tipi contrassegnati con GenerateSerializerAttribute. Se un tipo non è contrassegnato con GenerateSerializer, Orleans non lo serializzerà.

Se si sviluppa con F# o Visual Basic, è anche possibile usare la generazione di codice. Per altre informazioni, vedere questi esempi:

Questi esempi illustrano l'uso di Orleans.GenerateCodeForDeclaringAssemblyAttribute, specificando i tipi nell'assembly per il generatore di origine per esaminare e generare il codice sorgente.

Il metodo preferito per la generazione di codice è in fase di compilazione. Abilitare la generazione di codice in fase di compilazione usando uno dei pacchetti seguenti:

  • Microsoft.Orleans.OrleansCodeGenerator.Build: pacchetto che usa Roslyn per la generazione di codice e la reflection .NET per l'analisi.
  • Microsoft.Orleans.CodeGenerator.MSBuild: pacchetto di generazione di codice più recente che sfrutta Roslyn per la generazione e l'analisi del codice. Non carica i file binari dell'applicazione, evitando problemi causati da conflitti tra versioni delle dipendenze e framework di destinazione diversi. Questo generatore di codice migliora anche il supporto per le compilazioni incrementali, con tempi di compilazione più brevi.

Installare uno di questi pacchetti in tutti i progetti contenenti grani, interfacce di granularità, serializzatori personalizzati o tipi inviati tra grani. L'installazione di un pacchetto inserisce una destinazione nel progetto che genera codice in fase di compilazione.

Entrambi i pacchetti (Microsoft.Orleans.CodeGenerator.MSBuild e Microsoft.Orleans.OrleansCodeGenerator.Build) supportano solo i progetti C#. Supportare altri linguaggi usando il Microsoft.Orleans.OrleansCodeGenerator pacchetto (descritto di seguito) o creando un progetto C# che funge da destinazione per il codice generato dagli assembly scritti in altri linguaggi.

Generare diagnostica aggiuntiva in fase di compilazione specificando un valore per OrleansCodeGenLogLevel nel file csproj del progetto di destinazione. Ad esempio: <OrleansCodeGenLogLevel>Trace</OrleansCodeGenLogLevel>.

Generazione di codice in fase di inizializzazione

In Orleans 7+, non accade nulla durante l'inizializzazione. La generazione del codice viene eseguita solo in fase di compilazione.

La generazione del codice può essere eseguita durante l'inizializzazione nel client e nel silo installando il pacchetto Microsoft.Orleans.OrleansCodeGenerator e usando il metodo di estensione ApplicationPartManagerCodeGenExtensions.WithCodeGeneration:

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

Nell'esempio precedente, builder può essere un'istanza di ISiloHostBuilder o IClientBuilder. Passare un'istanza facoltativa ILoggerFactory a WithCodeGeneration per abilitare la registrazione durante la generazione del codice, ad esempio:

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

Influenzare la generazione di codice

Quando si GenerateSerializerAttribute applica a un tipo, IdAttribute può essere applicato anche per identificare in modo univoco il membro. Analogamente, è possibile applicare un alias usando .AliasAttribute Per altre informazioni sull'influenza della generazione del codice, vedere Usare la serializzazione Orleans.

Durante la generazione del codice, la generazione di codice per un tipo specifico può essere influenzata. Orleans genera automaticamente codice per interfacce granulari, classi granulari, stato di granularità e tipi passati come argomenti nei metodi granulari. Se un tipo non soddisfa questi criteri, usare i metodi seguenti per guidare ulteriormente la generazione del codice.

L'aggiunta SerializableAttribute a un tipo indica al generatore di codice di generare un serializzatore.

L'aggiunta [assembly: GenerateSerializer(Type)] a un progetto indica al generatore di codice di considerare tale tipo come serializzabile. Genera un errore se non è possibile generare un serializzatore per tale tipo, ad esempio perché il tipo non è accessibile. Questo errore interrompe la compilazione se la generazione del codice è abilitata. Questo attributo consente anche di generare codice per tipi specifici da un altro assembly.

[assembly: KnownType(Type)] indica inoltre al generatore di codice di includere un tipo specifico (che potrebbe provenire da un assembly a cui si fa riferimento), ma non causa un'eccezione se il tipo non è accessibile.

Generare serializzatori per tutti i sottotipi

L'aggiunta KnownBaseTypeAttribute a un'interfaccia o a una classe indica al generatore di codice di generare codice di serializzazione per tutti i tipi che ereditano o implementano tale tipo.

Generare codice per tutti i tipi in un altro assembly

In alcuni casi, il codice generato non può essere incluso in un assembly specifico in fase di compilazione. Gli esempi includono le librerie condivise che non fanno riferimento a Orleans, assembly scritti in linguaggi diversi da C# e assembly per i quali il codice sorgente non è disponibile. In questi casi, inserire il codice generato per tali assembly in un assembly separato a cui viene fatto riferimento durante l'inizializzazione.

Per abilitare questa impostazione per un assembly:

  1. Creare un progetto C#.
  2. Installare il pacchetto Microsoft.Orleans.CodeGenerator.MSBuild o Microsoft.Orleans.OrleansCodeGenerator.Build.
  3. Aggiungere un riferimento all'assembly di destinazione.
  4. Aggiungere [assembly: KnownAssembly("OtherAssembly")] al livello superiore di un file C#.

KnownAssemblyAttribute indica al generatore di codice di esaminare l'assembly specificato e generare il codice per i tipi al suo interno. Questo attributo può essere usato più volte all'interno di un progetto.

Aggiungere quindi l'assembly generato al client/silo durante l'inizializzazione:

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

Nell'esempio precedente, builder può essere un'istanza di ISiloHostBuilder o IClientBuilder.

KnownAssemblyAttribute ha una proprietà facoltativa, TreatTypesAsSerializable. Imposta questo su true per indicare al generatore di codice di agire come se tutti i tipi all'interno di tale assembly fossero contrassegnati come serializzabili.