Condividi tramite


Creare assembly satellite per applicazioni .NET

I file di risorse svolgono un ruolo centrale nelle applicazioni localizzate. Questi file consentono a un'applicazione di visualizzare stringhe, immagini e altri dati nella lingua dell'utente e con le sue impostazioni cultura, fornendo anche dati alternativi per i casi in cui non siano disponibili risorse per la lingua o le impostazioni cultura dell'utente. .NET usa un modello hub-spoke per individuare e recuperare risorse localizzate. L'hub è l'assembly principale che contiene il codice eseguibile non localizzabile e le risorse per una singola cultura, chiamata cultura neutra o predefinita. La lingua predefinita è quella di fallback per l'applicazione; viene usata quando non sono disponibili risorse localizzate. Per designare la cultura predefinita dell'applicazione, si usa l'attributo NeutralResourcesLanguageAttribute. Ogni spoke si connette a un assembly satellite che contiene le risorse per una singola cultura localizzata ma non contiene codice. Poiché gli assembly satellite non fanno parte dell'assembly principale, è possibile aggiornare o sostituire facilmente le risorse che corrispondono a una cultura specifica senza sostituire l'assembly principale dell'applicazione.

Nota

Le risorse della cultura predefinita di un'applicazione possono anche essere archiviate in un assembly satellite. A tale scopo, si assegna all'attributo NeutralResourcesLanguageAttribute un valore di UltimateResourceFallbackLocation.Satellite.

Posizione e nome dell'assemblaggio satellite

Requisito del modello hub e spoke è che le risorse vengano inserite in posizioni specifiche perché possano essere individuate e usate con facilità. Se le risorse non vengono compilate e denominate come previsto o se non vengono inserite nelle posizioni corrette, il Common Language Runtime non sarà in grado di individuarle e userà le risorse della cultura predefinita. La gestione risorse .NET è rappresentata dal tipo ResourceManager ed è usata per accedere automaticamente alle risorse localizzate. La gestione risorse richiede quanto segue:

  • Un singolo assembly satellite deve includere tutte le risorse per una cultura specifica. In altre parole, è necessario compilare più file .txt o .resx in un singolo file binario .resources.

  • Nella directory dell'applicazione deve esistere una sottodirectory separata per ciascuna cultura localizzata che contenga le risorse per quella cultura. Il nome della sottodirectory deve essere lo stesso del nome della cultura. In alternativa, è possibile archiviare gli assembly satellite nella Global Assembly Cache. In questo caso, il componente delle informazioni di cultura del nome forte dell'assembly deve indicare la sua cultura. Per ulteriori informazioni, consultare Installare assembly satellite nella Global Assembly Cache.

    Nota

    Se l'applicazione include risorse per sottoculture, inserire ciascuna sottocultura in una sottodirectory separata all'interno della directory dell'applicazione. Non inserire sottoculture in sottodirectory della directory della cultura principale.

  • L'assembly satellite deve avere lo stesso nome dell'applicazione e deve usare l'estensione di file ".resources.dll". Ad esempio, se un'applicazione è denominata Example.exe, il nome di ogni assembly satellite deve essere Example.resources.dll. Il nome dell'assembly satellite non indica la cultura dei file delle risorse. L'assembly satellite, tuttavia, si trova in una directory che specifica la cultura.

  • Le informazioni sulla cultura dell'assembly satellite devono essere incluse nei metadati dell'assembly. Per archiviare il nome della cultura nei metadati dell'assembly satellite, specifica l'opzione /culture quando usi Assembly Linker per incorporare le risorse nell'assembly satellite.

La seguente figura illustra una struttura di directory di esempio e i requisiti relativi alla posizione per le applicazioni che non si intende installare nella Global Assembly Cache. Gli elementi con estensione .txt e .resources non verranno forniti con l'applicazione finale. Questi sono file di risorse intermedi usati per creare gli assembly di risorse satellite finali. In questo esempio è possibile sostituire i file con estensione .resx con i file .txt. Per ulteriori informazioni, consultare Creare pacchetti e distribuire risorse.

L'immagine seguente mostra la directory dell'assembly satellite.

Una directory di assembly satellite con sottodirectory di culture localizzate.

Compilare assembly satelliti

Usare il generatore di file di risorse (resgen.exe) per compilare file di testo o XML (.resx) contenenti risorse in file binari .resources. Quindi, usare Assembly Linker (Al.exe) per compilare file .resources in assembly satellite. al.exe crea un assembly dai file .resources specificati. Gli assembly satellite possono contenere solo risorse. Non possono contenere codice eseguibile.

Il seguente comando al.exe crea un assembly satellite per l'applicazione Example dal file di risorse tedesco strings.de.resources.

al -target:lib -embed:strings.de.resources -culture:de -out:Example.resources.dll

Il seguente comando al.exe crea anche un assembly satellite per l'applicazione Example dal file strings.de.resources. L'opzione /template permette che l'assembly satellite erediti tutti i metadati dell'assembly, tranne le informazioni culturali, dall'assembly padre (Example.dll).

al -target:lib -embed:strings.de.resources -culture:de -out:Example.resources.dll -template:Example.dll

Nella tabella seguente vengono descritte in modo più dettagliato le opzioni di al.exe usate in questi comandi:

Opzione Descrizione
-target:lib Specifica che l'assembly satellite deve essere compilato in un file di libreria con estensione dll. Poiché un assembly satellite non contiene codice eseguibile e non rappresenta l'assembly principale dell'applicazione, è necessario salvare gli assembly satellite come DLL.
-embed:strings.de.resources Specifica il nome del file di risorse da incorporare quando al.exe compila l'assembly. È possibile incorporare più file con estensione .resources in un assembly satellite, ma se si segue il modello hub and spoke, è necessario compilare un assembly satellite per ogni cultura. È tuttavia possibile creare file con estensione resources separati per le stringhe e gli oggetti.
-culture:de Specifica l'impostazione cultura della risorsa che si desidera compilare. Il Common Language Runtime utilizza queste informazioni quando cerca le risorse per una cultura specificata. Se si omette questa opzione, al.exe compilerà comunque la risorsa, ma il runtime non sarà in grado di trovarla quando richiesta da un utente.
-out:Example.resources.dll Specifica il nome del file di output. Il nome deve seguire lo standard di denominazione nomeBase.resources.estensione, dove nomeBase è il nome dell'assembly principale ed estensione è un'estensione di file valida, ad esempio dll. Il runtime non è in grado di determinare la cultura di un assembly satellite in base al nome del file di output; è necessario usare l'opzione /culture per specificarla.
-template:Example.dll Specifica un assembly da cui l'assembly satellite erediterà tutti i metadati tranne il campo cultura. Questa opzione influisce sugli assembly satellite solo se si specifica un assembly con un nome forte.

Per l’elenco completo delle opzioni disponibili con al.exe, consultare Assembly Linker (al.exe).

Nota

In alcuni casi, potrebbe essere necessario utilizzare l'attività MSBuild di .NET Core per compilare assembly satellite, anche se stai puntando a .NET Framework. Ad esempio, è possibile usare l'opzione deterministica del compilatore C# per poter confrontare assembly da compilazioni diverse. In questo caso, impostare GenerateSatelliteAssembliesForCore su true nel file .csproj per generare assembly satellite usando csc.exe anziché Al.exe (Assembly Linker).

<Project>
    <PropertyGroup>
        <GenerateSatelliteAssembliesForCore>true</GenerateSatelliteAssembliesForCore>
    </PropertyGroup>
</Project>

Per impostazione predefinita, l'attività MSBuild di .NET Core usa csc.exe anziché al.exe per generare assembly satellite. Per ulteriori informazioni, vedere Facilitare l'adesione alla generazione di assembly satellite "Core".

Esempio di assembly satellite

Di seguito è riportato un semplice esempio di tipo "Hello world" che visualizza una finestra di messaggio contenente un saluto localizzato. L'esempio include risorse per le culture inglese (Stati Uniti), francese (Francia) e russo (Russia), e la sua cultura di fallback è l'inglese. Per creare l'esempio, eseguire le operazioni seguenti:

  1. Creare un file di risorse denominato Greeting.resx o Greeting.txt per contenere la risorsa per le impostazioni cultura predefinite. Archiviare in questo file una singola stringa denominata HelloString il cui valore è "Hello world!".

  2. Per indicare che la cultura predefinita dell'applicazione è inglese (en), aggiungere il seguente attributo System.Resources.NeutralResourcesLanguageAttribute al file AssemblyInfo dell'applicazione o al file di codice sorgente principale da compilare nell'assembly principale dell'applicazione.

    [assembly: NeutralResourcesLanguage("en")]
    
    <Assembly: NeutralResourcesLanguage("en")>
    
  3. Aggiungere il supporto per culture aggiuntive (en-US, fr-FR, e ru-RU) all'applicazione nel modo seguente:

    • Per supportare la cultura en-US o inglese (Stati Uniti), creare un file di risorse denominato Greeting.en-US.resx o Greeting.en-US.txt e in esso archiviare una singola stringa denominata HelloString il cui valore è "Hi world!".

    • Per supportare la cultura fr-FR o francese (Francia), creare un file di risorse denominato Greeting.fr-FR.resx o Greeting.fr-FR.txt e inserirvi una stringa chiamata HelloString, il cui valore è "Salut tout le monde!".

    • Per supportare l'impostazione culturale ru-RU o la cultura russa (Russia), creare un file di risorse denominato Greeting.ru-RU.resx o Greeting.ru-RU.txt e inserire in esso una singola stringa denominata HelloString il cui valore è "Всем привет!".

  4. Usare resgen.exe per compilare ogni file di risorse XML o di testo in un file binario .resources. L'output è un set di file con lo stesso nome di file radice del file .resx o .txt, ma con estensione .resources. Se si crea l'esempio con Visual Studio, il processo di compilazione viene gestito automaticamente. Se non si usa Visual Studio, eseguire i seguenti comandi per compilare i file .resx in file .resources:

    resgen Greeting.resx
    resgen Greeting.en-us.resx
    resgen Greeting.fr-FR.resx
    resgen Greeting.ru-RU.resx
    

    Se le risorse sono contenute in file di testo anziché in file XML, sostituire l'estensione .resx con .txt.

  5. Compilare il seguente codice sorgente insieme alle risorse per la cultura predefinita nell'assembly principale dell'applicazione:

    Importante

    Se per creare l'esempio si usa la riga di comando anziché Visual Studio, è necessario modificare la chiamata al costruttore della classe ResourceManager come segue: ResourceManager rm = new ResourceManager("Greeting", typeof(Example).Assembly);

    using System;
    using System.Globalization;
    using System.Reflection;
    using System.Resources;
    using System.Threading;
    using System.Windows.Forms;
    
    class Example
    {
       static void Main()
       {
          // Create array of supported cultures
          string[] cultures = {"en-CA", "en-US", "fr-FR", "ru-RU"};
          Random rnd = new Random();
          int cultureNdx = rnd.Next(0, cultures.Length);
          CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
    
          try {
             CultureInfo newCulture = new CultureInfo(cultures[cultureNdx]);
             Thread.CurrentThread.CurrentCulture = newCulture;
             Thread.CurrentThread.CurrentUICulture = newCulture;
             ResourceManager rm = new ResourceManager("Example.Greeting",
                                                      typeof(Example).Assembly);
             string greeting = String.Format("The current culture is {0}.\n{1}",
                                             Thread.CurrentThread.CurrentUICulture.Name,
                                             rm.GetString("HelloString"));
    
             MessageBox.Show(greeting);
          }
          catch (CultureNotFoundException e) {
             Console.WriteLine($"Unable to instantiate culture {e.InvalidCultureName}");
          }
          finally {
             Thread.CurrentThread.CurrentCulture = originalCulture;
             Thread.CurrentThread.CurrentUICulture = originalCulture;
          }
       }
    }
    
    Imports System.Globalization
    Imports System.Resources
    Imports System.Threading
    
    Module Module1
    
        Sub Main()
            ' Create array of supported cultures
            Dim cultures() As String = {"en-CA", "en-US", "fr-FR", "ru-RU"}
            Dim rnd As New Random()
            Dim cultureNdx As Integer = rnd.Next(0, cultures.Length)
            Dim originalCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
    
            Try
                Dim newCulture As New CultureInfo(cultures(cultureNdx))
                Thread.CurrentThread.CurrentCulture = newCulture
                Thread.CurrentThread.CurrentUICulture = newCulture
                Dim greeting As String = String.Format("The current culture is {0}.{1}{2}",
                                                       Thread.CurrentThread.CurrentUICulture.Name,
                                                       vbCrLf, My.Resources.Greetings.HelloString)
    
                MsgBox(greeting)
            Catch e As CultureNotFoundException
                Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName)
            Finally
                Thread.CurrentThread.CurrentCulture = originalCulture
                Thread.CurrentThread.CurrentUICulture = originalCulture
            End Try
        End Sub
    End Module
    

    Se l'applicazione è denominata Example e si esegue la compilazione dalla riga di comando, il comando per il compilatore C# è:

    csc Example.cs -res:Greeting.resources
    

    Per il compilatore Visual Basic il comando corrispondente è:

    vbc Example.vb -res:Greeting.resources
    
  6. Creare una sottodirectory nella directory principale dell'applicazione per ciascuna cultura localizzata supportata dall'applicazione. È necessario creare un en-US, un fr-FRe una sottodirectory ru-UR. Visual Studio crea queste sottodirectory automaticamente nell'ambito del processo di compilazione.

  7. Incorporare i singoli file .resources specifici alla cultura negli assembly satellite e salvarli nella directory appropriata. Il comando per eseguire questa operazione per ogni file .resources è:

    al -target:lib -embed:Greeting.culture.resources -culture:culture -out:culture\Example.resources.dll
    

    dove culture è il nome della cultura le cui risorse sono contenute nell'assembly satellite. Visual Studio gestisce questo processo automaticamente.

È quindi possibile eseguire l'esempio. Questo selezionerà casualmente una delle culture supportate, la imposterà come corrente e mostrerà un saluto localizzato.

Installazione di assembly satellite nella Global Assembly Cache

Invece di installare gli assembly in una sottodirectory locale dell'applicazione, è possibile installarli nella Global Assembly Cache. Ciò è particolarmente utile se alcuni assembly di librerie di classi e di risorse di librerie di classi vengono usati da più applicazioni.

L'installazione di assembly nella Global Assembly Cache richiede che gli assembly abbiano nomi sicuri. Gli assembly con nome forte sono firmati con una coppia di chiavi pubblica/privata valida. Contengono informazioni sulla versione che il runtime utilizza per determinare quale assembly usare per soddisfare una richiesta di associazione. Per ulteriori informazioni su nomi sicuri e sul controllo delle versioni, consultare Controllo delle versioni degli assembly. Per ulteriori informazioni su nomi sicuri, consultare Assembly con nomi sicuri.

Quando si sviluppa un'applicazione, è improbabile che si possa accedere alla coppia di chiavi pubblica/privata finale. Per installare un assembly satellite nella Global Assembly Cache e assicurarsi che funzioni come previsto, è possibile usare la cosiddetta tecnica della firma ritardata. Quando si rinvia la firma di un assembly, durante la compilazione viene riservato spazio nel file per la firma con nome sicuro. La firma effettiva viene posticipata al momento in cui la coppia di chiavi pubblica/privata finale è disponibile. Per ulteriori informazioni sul ritardo della firma, consultare Ritardo della firma di un assembly.

Ottenere la chiave pubblica

Per posticipare la firma di un assembly, è necessario avere accesso alla chiave pubblica. È possibile ottenere la chiave pubblica reale dall'organizzazione della società che eseguirà la firma finale oppure creare una chiave pubblica usando lo strumento Nome sicuro (sn.exe).

Il seguente comando Sn.exe crea una coppia di chiavi pubblica/privata di test. L'opzione –k specifica che Sn.exe deve creare una nuova coppia di chiavi e salvarla in un file denominato TestKeyPair.snk.

sn –k TestKeyPair.snk

È possibile estrarre la chiave pubblica dal file che contiene la coppia di chiavi di test. Il seguente comando estrae la chiave pubblica da TestKeyPair.snk e la salva in PublicKey.snk:

sn –p TestKeyPair.snk PublicKey.snk

Ritardo della firma di un assembly

Dopo aver ottenuto o creato la chiave pubblica, usare Assembly Linker (al.exe) per compilare l'assembly e specificare il ritardo della firma.

Il seguente comando al.exe crea un assembly satellite con nome sicuro per l'applicazione StringLibrary dal file strings.ja.resources:

al -target:lib -embed:strings.ja.resources -culture:ja -out:StringLibrary.resources.dll -delay+ -keyfile:PublicKey.snk

L'opzione -delay+ specifica che l'Assembly Linker deve applicare una firma ritardata all'assembly. L'opzione -keyfile specifica il nome del file di chiave che contiene la chiave pubblica da usare per ritardare la firma dell'assembly.

Ri-firma di un assembly

Prima di distribuire l'applicazione, è necessario firmare nuovamente l'assembly satellite firmato con ritardo con la coppia di chiavi reale. A tale scopo, è possibile usare Sn.exe.

Il seguente comando Sn.exe firma StringLibrary.resources.dll con la coppia di chiavi archiviata nel file RealKeyPair.snk. L'opzione -R specifica che un assembly firmato in precedenza deve essere firmato nuovamente o che un assembly firmato con ritardo deve essere firmato.

sn –R StringLibrary.resources.dll RealKeyPair.snk

Installazione di un assembly satellite nella Global Assembly Cache

Durante la ricerca di risorse nell'ambito del processo di fallback delle risorse, il runtime prima cerca nella Global Assembly Cache. (Per ulteriori informazioni, consultare la sezione "Processo di fallback delle risorse" in Creare pacchetti e distribuire risorse.) Non appena un assembly satellite viene firmato con un nome sicuro, può essere installato nella Global Assembly Cache usando lo strumento global Assembly Cache (gacutil.exe).

Il seguente comando Gacutil.exe installa StringLibrary.resources.dll* nella Global Assembly Cache:

gacutil -i:StringLibrary.resources.dll

L'opzione /i specifica che Gacutil.exe deve installare l'assembly specificato nella Global Assembly Cache. Dopo l'installazione dell'assembly satellite nella cache, le risorse in esso contenute diventano disponibili per tutte le applicazioni progettate per l'uso dell'assembly satellite.

Risorse nella Global Assembly Cache: un esempio

Il seguente esempio usa un metodo di una libreria di classi .NET per estrarre e restituire un messaggio di saluto localizzato contenuto in un file di risorse. La libreria e le relative risorse sono registrate nella Global Assembly Cache. L'esempio include risorse per le impostazioni cultura inglesi (Stati Uniti), francesi (Francia), russe (Russia) e inglese. La cultura predefinita è quella inglese; le sue risorse sono archiviate nell'assembly principale. Nell’esempio, inizialmente si firma con ritardo la libreria e i relativi assembly satelliti utilizzando una chiave pubblica, e successivamente vengono firmati nuovamente con una coppia di chiavi pubblica/privata. Per creare l'esempio, eseguire le operazioni seguenti:

  1. Se non si usa Visual Studio, usare il comando Strong Name Tool (Sn.exe) per creare una coppia di chiavi pubblica/privata denominata ResKey.snk:

    sn –k ResKey.snk
    

    Se si usa Visual Studio, generare il file di chiave tramite la scheda Firma della finestra di dialogo Proprietà del progetto.

  2. Usare il seguente comando Strong Name Tool (Sn.exe) per creare un file di chiave pubblica denominato PublicKey.snk:

    sn –p ResKey.snk PublicKey.snk
    
  3. Creare un file di risorse denominato Strings.resx che contenga le risorse per le impostazioni cultura predefinite. Archivia una singola stringa denominata Greeting con valore "How do you do?" in quel file.

  4. Per impostare "en" come impostazioni cultura predefinite dell'applicazione, aggiungere l'attributo System.Resources.NeutralResourcesLanguageAttribute seguente al file AssemblyInfo dell'applicazione o al file di codice sorgente principale che verrà compilato nell'assembly principale dell'applicazione:

    [assembly:NeutralResourcesLanguageAttribute("en")]
    
    <Assembly: NeutralResourcesLanguageAttribute("en")>
    
  5. Aggiungere all'applicazione il supporto per le impostazioni culturali aggiuntive (en-US, fr-FR e ru-RU) come segue:

    • Per supportare la cultura "en-US" o Inglese (Stati Uniti), crea un file di risorse chiamato Strings.en-US.resx o Strings.en-US.txt e memorizza in esso una singola stringa denominata Greeting il cui valore è "Hello!".

    • Per supportare la cultura "fr-FR" o francese (Francia), creare un file di risorse denominato Strings.fr-FR.resx o Strings.fr-FR.txt e memorizzare in esso una singola stringa denominata Greeting il cui valore è "Bon jour!".

    • Per supportare la cultura "ru-RU" o russo (Russia), crea un file di risorse denominato Strings.ru-RU.resx o Strings.ru-RU.txt e inserisci al suo interno una singola stringa chiamata Greeting, il cui valore è "Привет!".

  6. Usare resgen.exe per compilare ogni file di risorse XML o di testo in un file binario .resources. L'output è un set di file con lo stesso nome di file radice del file .resx o .txt, ma con estensione .resources. Se si crea l'esempio con Visual Studio, il processo di compilazione viene gestito automaticamente. Se non si usa Visual Studio, eseguire il seguente comando per compilare i file .resx in file .resources:

    resgen filename
    

    Quando filename è il percorso facoltativo, il nome file e l'estensione del file .resx o di testo.

  7. Compilare il seguente codice sorgente per StringLibrary.vb o StringLibrary.cs insieme alle risorse per la cultura predefinita in un assembly di libreria con firma ritardata denominato StringLibrary.dll.

    Importante

    Se per creare l'esempio si usa la riga di comando anziché Visual Studio, è necessario modificare la chiamata al costruttore della classe ResourceManager in ResourceManager rm = new ResourceManager("Strings",typeof(Example).Assembly);.

    using System;
    using System.Globalization;
    using System.Reflection;
    using System.Resources;
    using System.Threading;
    
    [assembly:NeutralResourcesLanguageAttribute("en")]
    
    public class StringLibrary
    {
       public string GetGreeting()
       {
          ResourceManager rm = new ResourceManager("Strings",
                               Assembly.GetAssembly(typeof(StringLibrary)));
          string greeting = rm.GetString("Greeting");
          return greeting;
       }
    }
    
    Imports System.Globalization
    Imports System.Reflection
    Imports System.Resources
    Imports System.Threading
    
    <Assembly: NeutralResourcesLanguageAttribute("en")>
    
    Public Class StringLibrary
        Public Function GetGreeting() As String
            Dim rm As New ResourceManager("Strings", _
                                          Assembly.GetAssembly(GetType(StringLibrary)))
            Dim greeting As String = rm.GetString("Greeting")
            Return greeting
        End Function
    End Class
    

    La riga di comando per il compilatore C# è:

    csc -t:library -resource:Strings.resources -delaysign+ -keyfile:publickey.snk StringLibrary.cs
    

    Per il compilatore Visual Basic il comando corrispondente è:

    vbc -t:library -resource:Strings.resources -delaysign+ -keyfile:publickey.snk StringLibrary.vb
    
  8. Creare una sottodirectory nella directory principale dell'applicazione per ciascuna cultura localizzata supportata dall'applicazione. È necessario creare un en-US, un fr-FRe una sottodirectory ru-UR. Visual Studio crea queste sottodirectory automaticamente nell'ambito del processo di compilazione. Poiché tutti gli assembly satellite hanno lo stesso nome del file, le sottodirectory sono usate per archiviare gli assembly satellite specifici della cultura fino a quando non sono firmati con una coppia di chiavi pubblica/privata.

  9. Incorporare i singoli file .resources specifici della cultura negli assembly satellite firmati con ritardo e salvarli nella directory appropriata. Il comando per eseguire questa operazione per ogni file .resources è:

    al -target:lib -embed:Strings.culture.resources -culture:culture -out:culture\StringLibrary.resources.dll -delay+ -keyfile:publickey.snk
    

    dove culture è il nome di una cultura. In questo esempio, le etichette culturali sono en-US, fr-FR e ru-RU.

  10. Rifirmare StringLibrary.dll usando lo strumento Strong Name (sn.exe) come indicato di seguito:

    sn –R StringLibrary.dll RealKeyPair.snk
    
  11. Firmare nuovamente i singoli assembly satellite. A tale scopo, usare il strumento Strong Name (sn.exe) come segue per ciascun assembly satellite:

    sn –R StringLibrary.resources.dll RealKeyPair.snk
    
  12. Registrare StringLibrary.dll e ognuno dei relativi assembly satellite nella Global Assembly Cache usando il comando seguente:

    gacutil -i filename
    

    dove filename rappresenta il nome del file da registrare.

  13. Se si usa Visual Studio, creare un nuovo progetto di applicazione console denominato Example, aggiungere un riferimento a StringLibrary.dll e al codice sorgente seguente e quindi eseguire la compilazione.

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       public static void Main()
       {
          string[] cultureNames = { "en-GB", "en-US", "fr-FR", "ru-RU" };
          Random rnd = new Random();
          string cultureName = cultureNames[rnd.Next(0, cultureNames.Length)];
          Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(cultureName);
          Console.WriteLine($"The current UI culture is {Thread.CurrentThread.CurrentUICulture.Name}");
          StringLibrary strLib = new StringLibrary();
          string greeting = strLib.GetGreeting();
          Console.WriteLine(greeting);
       }
    }
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
        Public Sub Main()
            Dim cultureNames() As String = {"en-GB", "en-US", "fr-FR", "ru-RU"}
            Dim rnd As New Random()
            Dim cultureName As String = cultureNames(rnd.Next(0, cultureNames.Length))
            Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(cultureName)
            Console.WriteLine("The current UI culture is {0}",
                              Thread.CurrentThread.CurrentUICulture.Name)
            Dim strLib As New StringLibrary()
            Dim greeting As String = strLib.GetGreeting()
            Console.WriteLine(greeting)
        End Sub
    End Module
    

    Per eseguire la compilazione dalla riga di comando, per il compilatore C# usare il comando seguente:

    csc Example.cs -r:StringLibrary.dll
    

    La riga di comando per il compilatore Visual Basic è:

    vbc Example.vb -r:StringLibrary.dll
    
  14. Eseguire Example.exe.

Vedi anche