Creazione di assembly satellite per applicazioni desktopCreating Satellite Assemblies for Desktop Apps

I file di risorse svolgono un ruolo centrale nelle applicazioni localizzate.Resource files play a central role in localized applications. Questi file consentono a un'applicazione di visualizzare stringhe, immagini e altri dati nella lingua dell'utente e con le impostazioni cultura di questo, fornendo anche dati alternativi per i casi in cui non siano disponibili risorse per la lingua o le impostazioni cultura dell'utente.They enable an application to display strings, images, and other data in the user's own language and culture, and to provide alternate data if resources for the user's own language or culture are unavailable. Per individuare e recuperare risorse localizzate, .NET Framework usa un modello hub e spoke.The .NET Framework uses a hub-and-spoke model to locate and retrieve localized resources. L'hub è l'assembly principale che contiene il codice eseguibile non localizzabile e le risorse di un singolo set di impostazioni cultura, denominate impostazioni cultura neutre o predefinite.The hub is the main assembly that contains the non-localizable executable code and the resources for a single culture, which is called the neutral or default culture. Le impostazioni cultura predefinite sono le impostazioni di fallback per l'applicazione, usate quando non sono disponibili risorse localizzate.The default culture is the fallback culture for the application; it is used when no localized resources are available. Per designare le impostazioni cultura predefinite dell'applicazione, si usa l'attributo NeutralResourcesLanguageAttribute.You use the NeutralResourcesLanguageAttribute attribute to designate the culture of the application's default culture. Ogni spoke si connette a un assembly satellite contenente le risorse relative a impostazioni cultura specifiche, ma non contiene codice.Each spoke connects to a satellite assembly that contains the resources for a single localized culture but does not contain any code. Poiché gli assembly satellite non fanno parte dell'assembly principale, è possibile aggiornare o sostituire facilmente le risorse corrispondenti a impostazioni cultura specifiche senza sostituire l'assembly principale dell'applicazione.Because the satellite assemblies are not part of the main assembly, you can easily update or replace resources that correspond to a specific culture without replacing the main assembly for the application.

Nota

Le risorse delle impostazioni cultura predefinite di un'applicazione possono anche essere archiviate in un assembly satellite.The resources of an application's default culture can also be stored in a satellite assembly. A tale scopo, si assegna all'attributo NeutralResourcesLanguageAttribute un valore di UltimateResourceFallbackLocation.Satellite.To do this, you assign the NeutralResourcesLanguageAttribute attribute a value of UltimateResourceFallbackLocation.Satellite.

Posizione e nome dell'assembly satelliteSatellite Assembly Name and Location

Requisito del modello hub e spoke è che le risorse vengano inserite in posizioni specifiche perché possano essere individuate e usate con facilità.The hub-and-spoke model requires that you place resources in specific locations so that they can be easily located and used. Se le risorse non vengono compilate e denominate come previsto oppure se non vengono inserite nelle posizioni corrette, Common Language Runtime non è in grado di individuarle e usa le impostazioni cultura predefinite.If you do not compile and name resources as expected, or if you do not place them in the correct locations, the common language runtime will not be able to locate them and will use the resources of the default culture instead. Lo strumento Gestione risorse di .NET Framework, rappresentato da un oggetto ResourceManager, viene usato per accedere automaticamente alle risorse localizzate.The .NET Framework Resource Manager, represented by a ResourceManager object, is used to automatically access localized resources. Gestione risorse richiede quanto segue:The Resource Manager requires the following:

  • Un assembly satellite singolo deve includere tutte le risorse relative a impostazioni cultura particolari.A single satellite assembly must include all the resources for a particular culture. In altre parole, è necessario compilare più file con estensione txt o resx in un unico file binario con estensione resources.In other words, you should compile multiple .txt or .resx files into a single binary .resources file.

  • Nella directory dell'applicazione deve esistere una sottodirectory separata per ognuna delle impostazioni cultura localizzate. In tali sottodirectory devono essere archiviate le risorse delle rispettive impostazioni cultura.There must be a separate subdirectory in the application directory for each localized culture that stores that culture's resources. Il nome della sottodirectory deve essere lo stesso delle impostazioni cultura.The subdirectory name must be the same as the culture name. In alternativa, è possibile archiviare gli assembly satellite nella Global Assembly Cache.Alternately, you can store your satellite assemblies in the global assembly cache. In questo caso, il componente delle informazioni delle impostazioni cultura del nome sicuro dell'assembly deve indicare le impostazioni cultura corrispondenti.In this case, the culture information component of the assembly's strong name must indicate its culture. Vedere la sezione Installazione di assembly satellite nella Global Assembly Cache più avanti in questo argomento.(See the Installing Satellite Assemblies in the Global Assembly Cache section later in this topic.)

    Nota

    Se l'applicazione include risorse per impostazioni cultura secondarie, inserire le impostazioni cultura secondarie in una sottodirectory separata all'interno della directory dell'applicazione.If your application includes resources for subcultures, place each subculture in a separate subdirectory under the application directory. Non inserire impostazioni cultura secondarie all'interno di sottodirectory della directory delle impostazioni cultura principali.Do not place subcultures in subdirectories under their main culture's directory.

  • L'assembly satellite deve avere lo stesso nome dell'applicazione e deve usare l'estensione di file ".resources.dll".The satellite assembly must have the same name as the application, and must use the file name extension ".resources.dll". Se ad esempio un'applicazione è denominata Example.exe, il nome di ogni assembly satellite deve essere Example.resources.dll.For example, if an application is named Example.exe, the name of each satellite assembly should be Example.resources.dll. Si noti che il nome dell'assembly satellite non indica le impostazioni cultura dei file di risorse corrispondenti.Note that the satellite assembly name does not indicate the culture of its resource files. L'assembly satellite, tuttavia, viene visualizzato in una directory che specifica le impostazioni cultura.However, the satellite assembly appears in a directory that does specify the culture.

  • Le informazioni sulle impostazioni cultura dell'assembly satellite devono essere incluse nei metadati dell'assembly.Information about the culture of the satellite assembly must be included in the assembly's metadata. Per archiviare il nome delle impostazioni cultura nei metadati dell'assembly satellite, specificare l'opzione /culture quando si incorporano le risorse nell'assembly satellite tramite Assembly Linker.To store the culture name in the satellite assembly's metadata, you specify the /culture option when you use Assembly Linker to embed resources in the satellite assembly.

La figura seguente 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.The following illustration shows a sample directory structure and location requirements for applications that you are not installing in the global assembly cache. Gli elementi con estensione txt e resources non verranno forniti con l'applicazione finale.The items with .txt and .resources extensions will not ship with the final application. Questi sono file di risorse intermedi usati per creare gli assembly di risorse satellite finali.These are the intermediate resource files used to create the final satellite resource assemblies. In questo esempio è possibile sostituire il file con estensione resx per i file con estensione txt.In this example, you could substitute .resx files for the .txt files. Per altre informazioni, vedere Creazione del pacchetto e distribuzione delle risorse.For more information, see Packaging and Deploying Resources.

L'immagine seguente mostra la directory degli assembly satellite:The following image shows the satellite assembly directory:

una directory di assembly satellite con sottodirectory di impostazioni cultura localizzate.

compilazione di assembly satelliteCompiling Satellite Assemblies

Per compilare file di testo o il file XML (con estensione resx) contenente risorse per file binari con estensione resources, si usa il generatore di file di risorse (Resgen.exe).You use Resource File Generator (Resgen.exe) to compile text files or XML (.resx) files that contain resources to binary .resources files. Si usa quindi Assembly Linker (Al.exe) per compilare i file con estensione resources in assembly satellite.You then use Assembly Linker (Al.exe) to compile .resources files into satellite assemblies. Al.exe crea un assembly dai file con estensione resources specificati.Al.exe creates an assembly from the .resources files that you specify. Gli assembly satellite possono contenere solo risorse. Non possono contenere codice eseguibile.Satellite assemblies can contain only resources; they cannot contain any executable code.

Il comando Al.exe seguente crea un assembly satellite per l'applicazione Example dal file di risorse strings.de.resources tedesco.The following Al.exe command creates a satellite assembly for the application Example from the German resources file strings.de.resources.

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

Il comando Al.exe seguente crea anche un assembly satellite per l'applicazione Example dal file strings.de.resources.The following Al.exe command also creates a satellite assembly for the application Example from the file strings.de.resources. L'opzione /template fa sì che l'assembly satellite erediti tutti i metadati dell'assembly tranne le informazioni relative alle impostazioni cultura dell'assembly padre (Example. dll).The /template option causes the satellite assembly to inherit all assembly metadata except for its culture information from the parent assembly (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.The following table describes the Al.exe options used in these commands in more detail.

OpzioneOption DescriptionDescription
-target: lib-target: lib Specifica che l'assembly satellite deve essere compilato in un file di libreria con estensione dll.Specifies that your satellite assembly is compiled to a library (.dll) file. Poiché un assembly satellite non contiene codice eseguibile e non rappresenta l'assembly principale dell'applicazione, è necessario salvare gli assembly satellite come DLL.Because a satellite assembly does not contain executable code and is not an application's main assembly, you must save satellite assemblies as DLLs.
-embed: strings.de.resources-embed: strings.de.resources Specifica il nome del file di risorse da incorporare quando Al.exe compila l'assembly.Specifies the name of the resource file to embed when Al.exe compiles the assembly. È possibile incorporare più file con estensione resources in un assembly satellite. Se si segue il modello hub e spoke, però, è necessario compilare un assembly satellite per ognuna delle impostazioni cultura.You can embed multiple .resources files in a satellite assembly, but if you are following the hub-and-spoke model, you must compile one satellite assembly for each culture. È tuttavia possibile creare file con estensione resources separati per le stringhe e gli oggetti.However, you can create separate .resources files for strings and objects.
-culture: de-culture: de Specifica le impostazioni cultura della risorsa da compilare.Specifies the culture of the resource to compile. Common Language Runtime usa queste informazioni durante la ricerca delle risorse per impostazioni cultura specifiche.The common language runtime uses this information when it searches for the resources for a specified culture. Se si omette questa opzione, Al.exe compila comunque la risorsa, ma il runtime non sarà in grado di trovarla quando un utente la richiederà.If you omit this option, Al.exe will still compile the resource, but the runtime will not be able to find it when a user requests it.
-out: Example.resources.dll-out: Example.resources.dll Specifica il nome del file di output.Specifies the name of the output file. 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.The name must follow the naming standard baseName.resources.extension, where baseName is the name of the main assembly and extension is a valid file name extension (such as .dll). Si noti che il runtime non è in grado di determinare le impostazioni cultura di un assembly satellite in base al nome del file di output. Per specificare tali impostazioni è necessario usare l'opzione /culture.Note that the runtime is not able to determine the culture of a satellite assembly based on its output file name; you must use the /culture option to specify it.
-template: Example.dll-template: Example.dll Specifica l'assembly dal quale l'assembly satellite deve ereditare tutti i metadati, ad eccezione del campo relativo alle impostazioni cultura.Specifies an assembly from which the satellite assembly will inherit all assembly metadata except the culture field. Questa opzione influisce sugli assembly satellite solo se si specifica un assembly con un nome sicuro.This option affects satellite assemblies only if you specify an assembly that has a strong name.

Per l'elenco completo delle opzioni disponibili con Al.exe, vedere Assembly Linker (Al.exe).For a complete list of options available with Al.exe, see Assembly Linker (Al.exe).

Assembly satellite: EsempioSatellite Assemblies: An Example

Di seguito è riportato un semplice esempio di tipo "Hello world" che visualizza una finestra di messaggio contenente un saluto localizzato.The following is a simple "Hello world" example that displays a message box containing a localized greeting. L'esempio include le risorse per le impostazioni cultura inglesi (Stati Uniti), francesi (Francia) e russe (Russia). Le impostazioni cultura inglesi sono le impostazioni cultura di fallback.The example includes resources for the English (United States), French (France), and Russian (Russia) cultures, and its fallback culture is English. Per creare l'esempio, eseguire le operazioni seguenti:To create the example, do the following:

  1. Creare un file di risorse denominato Greeting.resx o Greeting.txt che deve contenere le risorse per le impostazioni cultura predefinite.Create a resource file named Greeting.resx or Greeting.txt to contain the resource for the default culture. Salvare in questo file un'unica stringa denominata HelloString il cui valore sia "Hello world!"Store a single string named HelloString whose value is "Hello world!" .in this file.

  2. Per impostare le impostazioni cultura inglesi (en) come predefinite per l'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.To indicate that English (en) is the application's default culture, add the following System.Resources.NeutralResourcesLanguageAttribute attribute to the application's AssemblyInfo file or to the main source code file that will be compiled into the application's main assembly.

    [assembly: NeutralResourcesLanguageAttribute("en")]
    
    <Assembly: NeutralResourcesLanguageAttribute("en")>
    
  3. Aggiungere all'applicazione il supporto per le impostazioni cultura aggiuntive (en-US, fr-FR e ru-RU) come segue:Add support for additional cultures (en-US, fr-FR, and ru-RU) to the application as follows:

    • Per supportare le impostazioni cultura en-US, cioè Inglese (Stati Uniti), creare un file di risorse denominato Greeting.en-US.resx o Greeting.en-US.txt e salvare al suo interno una sola stringa denominata HelloString il cui valore sia "Hi world!".To support the en-US or English (United States) culture, create a resource file named Greeting.en-US.resx or Greeting.en-US.txt, and store in it a single string named HelloString whose value is "Hi world!"

    • Per supportare le impostazioni cultura fr-FR, cioè Francese (Francia), creare un file di risorse denominato Greeting.fr-FR.resx o Greeting.fr-FR.txt e salvare al suo interno una sola stringa denominata HelloString il cui valore sia "Salut tout le monde!".To support the fr-FR or French (France) culture, create a resource file named Greeting.fr-FR.resx or Greeting.fr-FR.txt, and store in it a single string named HelloString whose value is "Salut tout le monde!"

    • Per supportare le impostazioni cultura ru-RU, cioè Russo (Russia), creare un file di risorse denominato Greeting.ru-RU.resx o Greeting.ru-RU.txt e salvare al suo interno una sola stringa denominata HelloString il cui valore sia "Всем привет!".To support the ru-RU or Russian (Russia) culture, create a resource file named Greeting.ru-RU.resx or Greeting.ru-RU.txt, and store in it a single string named HelloString whose value is "Всем привет!"

  4. Usare Resgen.exe per compilare ogni file di risorse testo o XML in un file con estensione resources binario.Use Resgen.exe to compile each text or XML resource file to a binary .resources file. L'output è un set di file con lo stesso nome file radice dei file con estensione resx o txt, ma con estensione resources.The output is a set of files that have the same root file name as the .resx or .txt files, but a .resources extension. Se si crea l'esempio con Visual Studio, il processo di compilazione viene gestito automaticamente.If you create the example with Visual Studio, the compilation process is handled automatically. Se non si usa Visual Studio, eseguire i comandi seguenti per compilare i file con estensione resx in file con estensione resources:If you aren't using Visual Studio, run the following commands to compile the .resx files into .resources files:

    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 l'estensione txt.If your resources are in text files instead of XML files, replace the .resx extension with .txt.

  5. Compilare il codice sorgente seguente con le risorse per le impostazioni cultura predefinite nell'assembly principale dell'applicazione:Compile the following source code along with the resources for the default culture into the application's main assembly:

    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("Greetings", typeof(Example).Assembly);If you are using the command line rather than Visual Studio to create the example, you should modify the call to the ResourceManager class constructor to the following: ResourceManager rm = new ResourceManager("Greetings", 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.Greetings", 
                                                      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 {0}", 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# è:If the application is named Example and you are compiling from the command line, the command for the C# compiler is:

    csc Example.cs -res:Greeting.resources  
    

    Per il compilatore Visual Basic il comando corrispondente è:The corresponding Visual Basic compiler command is:

    vbc Example.vb -res:Greeting.resources  
    
  6. Creare una sottodirectory nella directory principale dell'applicazione per ognuna delle impostazioni cultura localizzate supportate dall'applicazione.Create a subdirectory in the main application directory for each localized culture supported by the application. È necessario creare le sottodirectory en-US, fr-FR e ru-RU.You should create an en-US, an fr-FR, and an ru-RU subdirectory. Visual Studio crea queste sottodirectory automaticamente nell'ambito del processo di compilazione.Visual Studio creates these subdirectories automatically as part of the compilation process.

  7. Incorporare i singoli file con estensione resources specifici di ognuna delle impostazioni cultura in assembly satellite e salvarli nella directory appropriata.Embed the individual culture-specific .resources files into satellite assemblies and save them to the appropriate directory. Il comando per eseguire questa operazione per ogni file con estensione resources è:The command to do this for each .resources file is:

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

    dove culture è il nome delle impostazioni cultura le cui risorse sono contenute dall'assembly satellite.where culture is the name of the culture whose resources the satellite assembly contains. Visual Studio gestisce questo processo automaticamente.Visual Studio handles this process automatically.

È quindi possibile eseguire l'esempio.You can then run the example. Questo effettua una selezione casuale tra le impostazioni cultura supportate, definisce le impostazioni cultura selezionate come correnti e visualizza il saluto localizzato.It will randomly make one of the supported cultures the current culture and display a localized greeting.

Installazione di assembly satellite nella Global Assembly CacheInstalling Satellite Assemblies in the Global Assembly Cache

Invece di installare gli assembly in una sottodirectory locale dell'applicazione, è possibile installarli nella Global Assembly Cache.Instead of installing assemblies in a local application subdirectory, you can install them in the 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.This is particularly useful if you have class libraries and class library resource assemblies that are used by multiple applications.

L'installazione di assembly nella Global Assembly Cache richiede che gli assembly abbiano nomi sicuri.Installing assemblies in the global assembly cache requires that they have strong names. Gli assembly con nomi sicuri, firmati con una coppia di chiavi pubblica/privata valida,Strong-named assemblies are signed with a valid public/private key pair. contengono informazioni sulla versione usate dal runtime allo scopo di determinare l'assembly da usare per soddisfare una richiesta di associazione.They contain version information that the runtime uses to determine which assembly to use to satisfy a binding request. Per altre informazioni sui nomi sicuri e sul controllo delle versioni, vedere Controllo delle versioni degli assembly.For more information about strong names and versioning, see Assembly Versioning. Per altre informazioni sui nomi sicuri, vedere Assembly con nomi sicuri.For more information about strong names, see Strong-Named Assemblies.

Quando si sviluppa un'applicazione, è improbabile che si possa accedere alla coppia di chiavi pubblica/privata finale.When you are developing an application, it is unlikely that you will have access to the final public/private key pair. Per installare un assembly satellite nella Global Assembly Cache e assicurarsi che funzioni come previsto, è possibile usare la cosiddetta tecnica del ritardo della firma.In order to install a satellite assembly in the global assembly cache and ensure that it works as expected, you can use a technique called delayed signing. Quando si ritarda la firma di un assembly, al momento della compilazione viene riservato spazio nel file per la firma con nome sicuro.When you delay sign an assembly, at build time you reserve space in the file for the strong name signature. La firma effettiva viene posticipata al momento in cui la coppia di chiavi pubblica/privata finale è disponibile.The actual signing is delayed until later, when the final public/private key pair is available. Per altre informazioni sul ritardo della firma, vedere Ritardo della firma di un assembly.For more information about delayed signing, see Delay Signing an Assembly.

Ottenere la chiave pubblicaObtaining the Public Key

Per ritardare la firma di un assembly, è necessario avere accesso alla chiave pubblica.To delay sign an assembly, you must have access to the public key. È possibile ottenere la chiave pubblica reale dall'organizzazione della società che eventualmente effettuerà la firma oppure creare una chiave pubblica con lo strumento Nome sicuro (Sn.exe).You can either obtain the real public key from the organization in your company that will do the eventual signing, or create a public key by using the Strong Name Tool (Sn.exe).

Il comando Sn.exe seguente crea una coppia di chiavi pubblica/privata di test.The following Sn.exe command creates a test public/private key pair. L'opzione -k specifica che Sn.exe deve creare una nuova coppia di chiavi e salvarla in un file denominato TestKeyPair.snk.The –k option specifies that Sn.exe should create a new key pair and save it in a file named TestKeyPair.snk.

sn –k TestKeyPair.snk   

È possibile estrarre la chiave pubblica dal file che contiene la coppia di chiavi di test.You can extract the public key from the file that contains the test key pair. Il comando seguente estrae la chiave pubblica da TestKeyPair.snk e lo salva in PublicKey.snk:The following command extracts the public key from TestKeyPair.snk and saves it in PublicKey.snk:

sn –p TestKeyPair.snk PublicKey.snk  

Ritardo della firma di un assemblyDelay Signing an Assembly

Dopo aver ottenuto o creato la chiave pubblica, si usa Assembly Linker (Al.exe) per compilare l'assembly e specificare il ritardo della firma.After you obtain or create the public key, you use the Assembly Linker (Al.exe) to compile the assembly and specify delayed signing.

Il comando Al.exe seguente crea un assembly satellite con nome sicuro per la DLL StringLibrary dell'applicazione dal file di risorse strings.ja.resources:The following Al.exe command creates a strong-named satellite assembly for the application StringLibrary from the strings.ja.resources file:

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

L'opzione -delay+ specifica che Assembly Linker deve ritardare la firma dell'assembly.The -delay+ option specifies that the Assembly Linker should delay sign the assembly. L'opzione -keyfile specifica il nome del file di chiave che contiene la chiave pubblica da usare per ritardare la firma dell'assembly.The -keyfile option specifies the name of the key file that contains the public key to use to delay sign the assembly.

Nuova firma di un assemblyRe-signing an Assembly

Prima di distribuire l'applicazione, è necessario firmare nuovamente l'assembly satellite con ritardo della firma con la coppia di chiavi reale.Before you deploy your application, you must re-sign the delay signed satellite assembly with the real key pair. A tale scopo, è possibile usare Sn.exe.You can do this by using Sn.exe.

Il comando Sn.exe seguente firma StringLibrary.resources.dll con la coppia di chiavi archiviata nel file RealKeyPair.snk.The following Sn.exe command signs StringLibrary.resources.dll with the key pair stored in the file RealKeyPair.snk. L'opzione -R specifica che un assembly firmato in precedenza deve essere firmato nuovamente o che un assembly con ritardo della firma deve essere firmato.The –R option specifies that a previously signed or delay signed assembly is to be re-signed.

sn –R StringLibrary.resources.dll RealKeyPair.snk   

Installazione di un assembly satellite nella Global Assembly CacheInstalling a Satellite Assembly in the Global Assembly Cache

Durante la ricerca di risorse nell'ambito del processo di fallback delle risorse, il runtime prima cerca nella Global Assembly Cache.When the runtime searches for resources in the resource fallback process, it looks in the global assembly cache first. Per altre informazioni, vedere la sezione "Processo di fallback delle risorse" dell'argomento Creazione del pacchetto e distribuzione delle risorse. Non appena un assembly satellite viene firmato con un nome sicuro, può essere installato nella Global Assembly Cache tramite lo strumento Global Assembly Cache (Gacutil.exe).(For more information, see the "Resource Fallback Process" section of the Packaging and Deploying Resources topic.) As soon as a satellite assembly is signed with a strong name, it can be installed in the global assembly cache by using the Global Assembly Cache Tool (Gacutil.exe).

Il comando Gacutil.exe seguente installa StringLibrary.resources.dll nella Global Assembly Cache:The following Gacutil.exe command installs StringLibrary.resources.dll in the global assembly cache:

gacutil -i:StringLibrary.resources.dll  

L'opzione /i specifica che Gacutil.exe deve installare l'assembly specificato nella Global Assembly Cache.The /i option specifies that Gacutil.exe should install the specified assembly into the 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.After the satellite assembly is installed in the cache, the resources it contains become available to all applications that are designed to use the satellite assembly.

Risorse nella Global Assembly Cache: EsempioResources in the Global Assembly Cache: An Example

L'esempio seguente usa un metodo di una libreria di classi .NET Framework per estrarre e restituire un messaggio di saluto localizzato contenuto in un file di risorse.The following example uses a method in a .NET Framework class library to extract and return a localized greeting from a resource file. La libreria e le relative risorse sono registrate nella Global Assembly Cache.The library and its resources are registered in the global assembly cache. L'esempio include risorse per le impostazioni cultura inglesi (Stati Uniti), francesi (Francia), russe (Russia) e inglesi.The example includes resources for the English (United States), French (France), Russian (Russia), and English cultures. Le impostazioni cultura predefinite corrispondono a quelle inglesi e le risorse corrispondenti sono archiviate nell'assembly principale.English is the default culture; its resources are stored in the main assembly. All'inizio dell'esempio viene impostato il ritardo della firma della libreria e dei relativi assembly con una chiave pubblica. Questi vengono quindi firmati di nuovo con una coppia di chiavi pubblica/privata.The example initially delay signs the library and its satellite assemblies with a public key, then re-signs them with a public/private key pair. Per creare l'esempio, eseguire le operazioni seguenti:To create the example, do the following:

  1. Se non si usa Visual Studio, creare una coppia di chiavi pubblica/privata denominata ResKey.snk tramite il comando dello strumento Nome sicuro (Sn.exe) seguente:If you are not using Visual Studio, use the following Strong Name Tool (Sn.exe) command to create a public/private key pair named 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.If you are using Visual Studio, use the Signing tab of the project Properties dialog box to generate the key file.

  2. Usare il comando dello strumento Nome sicuro (Sn.exe) seguente per creare un file di chiave pubblica denominato PublicKey.snk:Use the following Strong Name Tool (Sn.exe) command to create a public key file named PublicKey.snk:

    sn –p ResKey.snk PublicKey.snk  
    
  3. Creare un file di risorse denominato Strings.resx o Greeting.txt che contenga le risorse per le impostazioni cultura predefinite.Create a resource file named Strings.resx to contain the resource for the default culture. Archiviare in questo file un'unica stringa denominata Greeting il cui valore sia "How do you do?"Store a single string named Greeting whose value is "How do you do?" .in that 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:To indicate that "en" is the application's default culture, add the following System.Resources.NeutralResourcesLanguageAttribute attribute to the application's AssemblyInfo file or to the main source code file that will be compiled into the application's main assembly:

    [assembly:NeutralResourcesLanguageAttribute("en")]
    
    <Assembly:NeutralResourcesLanguageAttribute("en")>
    
  5. Aggiungere all'applicazione il supporto per le impostazioni cultura aggiuntive (en-US, fr-FR e ru-RU) come segue:Add support for additional cultures (the en-US, fr-FR, and ru-RU cultures) to the application as follows:

    • Per supportare le impostazioni cultura "en-US", cioè Inglese (Stati Uniti), creare un file di risorse denominato Strings.en-US.resx o Strings.en-US.txt e salvare al suo interno una sola stringa denominata Greeting il cui valore sia "Hello!".To support the "en-US" or English (United States) culture, create a resource file named Strings.en-US.resx or Strings.en-US.txt, and store in it a single string named Greeting whose value is "Hello!".

    • Per supportare le impostazioni cultura "fr-FR", cioè Francese (Francia), creare un file di risorse denominato Strings.fr-FR.resx o Strings.fr-FR.txt e salvare al suo interno una sola stringa denominata Greeting il cui valore sia "Bonjour!".To support the "fr-FR" or French (France) culture, create a resource file named Strings.fr-FR.resx or Strings.fr-FR.txt and store in it a single string named Greeting whose value is "Bon jour!"

    • Per supportare le impostazioni cultura "ru-RU", cioè Russo (Russia), creare un file di risorse denominato Strings.ru-RU.resx o Strings.ru-RU.txt e salvare al suo interno una sola stringa denominata Greeting il cui valore sia "Привет!".To support the "ru-RU" or Russian (Russia) culture, create a resource file named Strings.ru-RU.resx or Strings.ru-RU.txt and store in it a single string named Greeting whose value is "Привет!"

  6. Usare Resgen.exe per compilare ogni file di risorse testo o XML in un file con estensione resources binario.Use Resgen.exe to compile each text or XML resource file to a binary .resources file. L'output è un set di file con lo stesso nome file radice dei file con estensione resx o txt, ma con estensione resources.The output is a set of files that have the same root file name as the .resx or .txt files, but a .resources extension. Se si crea l'esempio con Visual Studio, il processo di compilazione viene gestito automaticamente.If you create the example with Visual Studio, the compilation process is handled automatically. Se non si usa Visual Studio, eseguire il comando seguente per compilare i file con estensione resx in file con estensione resources:If you aren't using Visual Studio, run the following command to compile the .resx files into .resources files:

    resgen filename  
    

    dove filename rappresenta il percorso facoltativo, il nome file e l'estensione del file resx o di testo.where filename is the optional path, file name, and extension of the .resx or text file.

  7. Compilare il codice sorgente seguente per StringLibrary.vb o StringLibrary.cs con le risorse per le impostazioni cultura predefinite in un assembly con ritardo della firma denominato StringLibrary.dll:Compile the following source code for StringLibrary.vb or StringLibrary.cs along with the resources for the default culture into a delay signed library assembly named 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);.If you are using the command line rather than Visual Studio to create the example, you should modify the call to the ResourceManager class constructor to 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# è:The command for the C# compiler is:

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

    Per il compilatore Visual Basic il comando corrispondente è:The corresponding Visual Basic compiler command is:

    vbc -t:library -resource:Strings.resources -delaysign+ -keyfile:publickey.snk StringLibrary.vb  
    
  8. Creare una sottodirectory nella directory principale dell'applicazione per ognuna delle impostazioni cultura localizzate supportate dall'applicazione.Create a subdirectory in the main application directory for each localized culture supported by the application. È necessario creare le sottodirectory en-US, fr-FR e ru-RU.You should create an en-US, an fr-FR, and an ru-RU subdirectory. Visual Studio crea queste sottodirectory automaticamente nell'ambito del processo di compilazione.Visual Studio creates these subdirectories automatically as part of the compilation process. Poiché tutti gli assembly satellite hanno lo stesso nome file, le sottodirectory vengono usate per archiviare gli assembly satellite specifici delle impostazioni cultura fino a quando non sono firmati con una coppia di chiavi pubblica/privata.Because all satellite assemblies have the same file name, the subdirectories are used to store individual culture-specific satellite assemblies until they are signed with a public/private key pair.

  9. Incorporare i singoli file con estensione resources specifici di ognuna delle impostazioni cultura in assembly satellite con ritardo della firma e salvarli nella directory appropriata.Embed the individual culture-specific .resources files into delay signed satellite assemblies and save them to the appropriate directory. Il comando per eseguire questa operazione per ogni file con estensione resources è:The command to do this for each .resources file is:

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

    dove culture è il nome delle impostazioni cultura.where culture is the name of a culture. In questo esempio i nomi delle impostazioni cultura sono en-US, fr-FR e ru-RU.In this example, the culture names are en-US, fr-FR, and ru-RU.

  10. Firmare nuovamente StringLibrary.dll tramite lo strumento Nome sicuro (Sn.exe) come indicato di seguito:Re-sign StringLibrary.dll by using the Strong Name Tool (Sn.exe) as follows:

    sn –R StringLibrary.dll RealKeyPair.snk  
    
  11. Firmare nuovamente i singoli assembly satellite.Re-sign the individual satellite assemblies. A tale scopo, usare lo strumento Nome sicuro (Sn.exe) come indicato di seguito per ogni assembly satellite:To do this, use the Strong Name Tool (Sn.exe) as follows for each satellite assembly:

    sn –R StringLibrary.resources.dll RealKeyPair.snk  
    
  12. Registrare StringLibrary.dll e ognuno dei relativi assembly satellite nella Global Assembly Cache tramite il comando seguente:Register StringLibrary.dll and each of its satellite assemblies in the global assembly cache by using the following command:

    gacutil -i filename  
    

    dove filename rappresenta il nome del file da registrare.where filename is the name of the file to register.

  13. Se si usa Visual Studio, creare un nuovo progetto di applicazione console denominato Example, aggiungervi un riferimento a StringLibrary.dll e il codice sorgente seguente e quindi eseguire la compilazione.If you are using Visual Studio, create a new Console Application project named Example, add a reference to StringLibrary.dll and the following source code to it, and compile.

    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 {0}", 
                            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:To compile from the command line, use the following command for the C# compiler:

    csc Example.cs -r:StringLibrary.dll   
    

    La riga di comando per il compilatore Visual Basic è:The command line for the Visual Basic compiler is:

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

Vedere ancheSee also