Recupero di risorse nelle applicazioni desktopRetrieving Resources in Desktop Apps

Quando si utilizzano le risorse localizzate in applicazioni desktop di .NET Framework, è consigliabile comprimere le risorse per le impostazioni cultura predefinite o non associate ad alcun paese con l'assembly principale e creare un assembly satellite separato per ciascuna lingua o impostazione cultura supportata dall'applicazione.When you work with localized resources in .NET Framework desktop apps, you should ideally package the resources for the default or neutral culture with the main assembly and create a separate satellite assembly for each language or culture that your app supports. È quindi possibile utilizzare la classe ResourceManager come descritto nella sezione successiva per accedere alle risorse denominate.You can then use the ResourceManager class as described in the next section to access named resources. Se si sceglie di non includere le risorse nell'assembly principale e negli assembly satellite, è inoltre possibile accedere direttamente ai file binari .resources, come illustrato nella sezione Recupero delle risorse dai file .resources più avanti in questo articolo.If you choose not to embed your resources in the main assembly and satellite assemblies, you can also access binary .resources files directly, as discussed in the section Retrieving Resources from .resources files later in this article. Per recuperare le risorse nelle app di Windows 8.x Store , vedere Creazione e recupero di risorse nelle app di Windows Store nel Windows Dev Center.To retrieve resources in Windows 8.x Store apps, see Creating and retrieving resources in Windows Store apps in the Windows Dev Center.

Recupero delle risorse dagli assemblyRetrieving Resources from Assemblies

La classe ResourceManager fornisce l'accesso alle risorse in fase di esecuzione.The ResourceManager class provides access to resources at run time. Utilizzare il metodo ResourceManager.GetString per recuperare le risorse di tipo stringa e il metodo ResourceManager.GetObject o ResourceManager.GetStream per recuperare le risorse non di tipo stringa.You use the ResourceManager.GetString method to retrieve string resources and the ResourceManager.GetObject or ResourceManager.GetStream method to retrieve non-string resources. Ogni metodo dispone di due overload:Each method has two overloads:

Il gestore di risorse utilizza il processo di fallback delle risorse per controllare come l'applicazione recupera le risorse specifiche delle impostazioni cultura.The resource manager uses the resource fallback process to control how the app retrieves culture-specific resources. Per altre informazioni, vedere la sezione "Il processo di fallback delle risorse" in Packaging and Deploying Resources.For more information, see the "Resource Fallback Process" section in Packaging and Deploying Resources. Per informazioni sulla creazione di un'istanza di un oggetto ResourceManager, vedere la sezione "Creazione di un'istanza di un oggetto ResourceManager" nell'argomento relativo alla classe ResourceManager.For information about instantiating a ResourceManager object, see the "Instantiating a ResourceManager Object" section in the ResourceManager class topic.

Recupero di dati di tipo stringa: un esempioRetrieving String Data: An Example

Nell'esempio seguente viene chiamato il metodo GetString(String) per recuperare le risorse di tipo stringa delle impostazioni cultura correnti dell'interfaccia utente.The following example calls the GetString(String) method to retrieve the string resources of the current UI culture. Include una risorsa di tipo stringa non associata ad alcun paese per le impostazioni cultura inglesi (Stati Uniti) e le risorse localizzate per le impostazioni cultura francesi (Francia) e russe (Russia).It includes a neutral string resource for the English (United States) culture and localized resources for the French (France) and Russian (Russia) cultures. La risorsa inglese (Stati Uniti) seguente si trova in un file denominato Strings.txt:The following English (United States) resource is in a file named Strings.txt:

TimeHeader=The current time is  

La risorsa francese (Francia) si trova in un file denominato Strings.fr-FR.txt:The French (France) resource is in a file named Strings.fr-FR.txt:

TimeHeader=L'heure actuelle est  

La risorsa russa (Russia) si trova in un file denominato Strings.ru-RU-txt:The Russian (Russia) resource is in a file named Strings.ru-RU-txt:

TimeHeader=Текущее время —  

Il codice sorgente per questo esempio, che si trova in un file denominato GetString.cs per la versione C# del codice e GetString.vb per la versione Visual Basic, definisce una matrice di stringhe contenente il nome di quattro impostazioni cultura: le tre impostazioni cultura per le quali sono disponibili le risorse e le impostazioni cultura spagnole (Spagna).The source code for this example, which is in a file named GetString.cs for the C# version of the code and GetString.vb for the Visual Basic version, defines a string array that contains the name of four cultures: the three cultures for which resources are available and the Spanish (Spain) culture. Un ciclo eseguibile cinque volte seleziona casualmente una di queste impostazioni cultura e la assegna alle proprietà Thread.CurrentCulture e CultureInfo.CurrentUICulture.A loop that executes five times randomly selects one of these cultures and assigns it to the Thread.CurrentCulture and CultureInfo.CurrentUICulture properties. Chiama quindi il metodo GetString(String) per recuperare la stringa localizzata, visualizzata con l'ora del giorno.It then calls the GetString(String) method to retrieve the localized string, which it displays along with the time of day.

using System;
using System.Globalization;
using System.Resources;
using System.Threading;

[assembly: NeutralResourcesLanguageAttribute("en-US")]

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "ru-RU", "es-ES" };
      Random rnd = new Random();
      ResourceManager rm = new ResourceManager("Strings", 
                               typeof(Example).Assembly);

      for (int ctr = 0; ctr <= cultureNames.Length; ctr++) {
         string cultureName = cultureNames[rnd.Next(0, cultureNames.Length)];
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         Thread.CurrentThread.CurrentCulture = culture;
         Thread.CurrentThread.CurrentUICulture = culture;
         
         Console.WriteLine("Current culture: {0}", culture.NativeName);
         string timeString = rm.GetString("TimeHeader");
         Console.WriteLine("{0} {1:T}\n", timeString, DateTime.Now);   
      }   
   }
}
// The example displays output like the following:
//    Current culture: English (United States)
//    The current time is 9:34:18 AM
//    
//    Current culture: Español (España, alfabetización internacional)
//    The current time is 9:34:18
//    
//    Current culture: русский (Россия)
//    Текущее время — 9:34:18
//    
//    Current culture: français (France)
//    L'heure actuelle est 09:34:18
//    
//    Current culture: русский (Россия)
//    Текущее время — 9:34:18
Imports System.Globalization
Imports System.Resources
Imports System.Threading

<Assembly: NeutralResourcesLanguageAttribute("en-US")>

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "ru-RU", "es-ES" }
      Dim rnd As New Random()
      Dim rm As New ResourceManager("Strings", GetType(Example).Assembly)
      
      For ctr As Integer = 0 To cultureNames.Length
         Dim cultureName As String = cultureNames(rnd.Next(0, cultureNames.Length))
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Thread.CurrentThread.CurrentCulture = culture
         Thread.CurrentThread.CurrentUICulture = culture
         
         Console.WriteLine("Current culture: {0}", culture.NativeName)
         Dim timeString As String = rm.GetString("TimeHeader")
         Console.WriteLine("{0} {1:T}", timeString, Date.Now)   
         Console.WriteLine()
      Next   
   End Sub
End Module
' The example displays output similar to the following:
'    Current culture: English (United States)
'    The current time is 9:34:18 AM
'    
'    Current culture: Español (España, alfabetización internacional)
'    The current time is 9:34:18
'    
'    Current culture: русский (Россия)
'    Текущее время — 9:34:18
'    
'    Current culture: français (France)
'    L'heure actuelle est 09:34:18
'    
'    Current culture: русский (Россия)
'    Текущее время — 9:34:18

Il seguente file batch (.bat) consente di compilare l'esempio e genera gli assembly satellite nelle directory appropriate.The following batch (.bat) file compiles the example and generates satellite assemblies in the appropriate directories. I comandi vengono forniti per il linguaggio e il compilatore C#.The commands are provided for the C# language and compiler. Per Visual Basic, modificare csc in vbce modificare GetString.cs in GetString.vb.For Visual Basic, change csc to vbc, and change GetString.cs to GetString.vb.

resgen strings.txt  
csc GetString.cs -resource:strings.resources  
  
resgen strings.fr-FR.txt  
md fr-FR  
al -embed:strings.fr-FR.resources -culture:fr-FR -out:fr-FR\GetString.resources.dll  
  
resgen strings.ru-RU.txt  
md ru-RU  
al -embed:strings.ru-RU.resources -culture:ru-RU -out:ru-RU\GetString.resources.dll  

Quando le impostazioni cultura correnti dell'interfaccia utente sono impostate sullo spagnolo (Spagna), si noti che nell'esempio vengono visualizzate le risorse della lingua inglese, perché le risorse della lingua spagnola non sono disponibili e l'inglese rappresenta le impostazioni cultura predefinite dell'esempio.When the current UI culture is Spanish (Spain), note that the example displays English language resources, because Spanish language resources are unavailable, and English is the example's default culture.

Recupero di dati oggetto: due esempiRetrieving Object Data: Two Examples

È possibile utilizzare i metodi GetObject e GetStream per recuperare i dati oggetto.You can use the GetObject and GetStream methods to retrieve object data. Sono inclusi i tipi di dati primitivi, gli oggetti serializzabili e gli oggetti archiviati in formato binario, ad esempio le immagini.This includes primitive data types, serializable objects, and objects that are stored in binary format (such as images).

Nell'esempio seguente viene usato il metodo GetStream(String) per recuperare una bitmap visualizzata nella finestra iniziale di apertura di un'app.The following example uses the GetStream(String) method to retrieve a bitmap that is used in an app's opening splash window. Il seguente codice sorgente in un file denominato CreateResources.cs (per C#) o CreateResources.vb (per Visual Basic) genera un file .resx che contiene l'immagine serializzata.The following source code in a file named CreateResources.cs (for C#) or CreateResources.vb (for Visual Basic) generates a .resx file that contains the serialized image. In questo caso, l'immagine viene caricata da un file denominato SplashScreen.jpg. È possibile modificare il nome per sostituire il file con un'immagine personalizzata.In this case, the image is loaded from a file named SplashScreen.jpg; you can modify the file name to substitute your own image.

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Resources;

public class Example
{
   public static void Main()
   {
      Bitmap bmp = new Bitmap(@".\SplashScreen.jpg");
      MemoryStream imageStream = new MemoryStream();
      bmp.Save(imageStream, ImageFormat.Jpeg);
      
      ResXResourceWriter writer = new ResXResourceWriter("AppResources.resx");
      writer.AddResource("SplashScreen", imageStream);
      writer.Generate();
      writer.Close();      
   }
}
Imports System.Drawing
Imports System.Drawing.Imaging
Imports System.IO
Imports System.Resources

Module Example
   Public Sub Main()
      Dim bmp As New Bitmap(".\SplashScreen.jpg")
      Dim imageStream As New MemoryStream()
      bmp.Save(imageStream, ImageFormat.Jpeg)
      
      Dim writer As New ResXResourceWriter("AppResources.resx")
      writer.AddResource("SplashScreen", imageStream)
      writer.Generate()
      writer.Close()      
   End Sub
End Module

Il seguente codice recupera la risorsa e visualizza l'immagine in un controllo PictureBox.The following code retrieves the resource and displays the image in a PictureBox control.

using System;
using System.Drawing;
using System.IO;
using System.Resources;
using System.Windows.Forms;

public class Example
{
   public static void Main()
   {
      ResourceManager rm = new ResourceManager("AppResources", typeof(Example).Assembly);
      Bitmap screen = (Bitmap) Image.FromStream(rm.GetStream("SplashScreen"));
      
      Form frm = new Form();
      frm.Size = new Size(300, 300);

      PictureBox pic = new PictureBox();
      pic.Bounds = frm.RestoreBounds;
      pic.BorderStyle = BorderStyle.Fixed3D; 
      pic.Image = screen;
      pic.SizeMode = PictureBoxSizeMode.StretchImage;

      frm.Controls.Add(pic);
      pic.Anchor = AnchorStyles.Top | AnchorStyles.Bottom |
                   AnchorStyles.Left | AnchorStyles.Right;

      frm.ShowDialog();
   }
}
Imports System.Drawing
Imports System.IO
Imports System.Resources
Imports System.Windows.Forms

Module Example
   Public Sub Main()
      Dim rm As New ResourceManager("AppResources", GetType(Example).Assembly)
      Dim screen As Bitmap = CType(Image.FromStream(rm.GetStream("SplashScreen")), Bitmap)
      
      Dim frm As New Form()
      frm.Size = new Size(300, 300)

      Dim pic As New PictureBox()
      pic.Bounds = frm.RestoreBounds
      pic.BorderStyle = BorderStyle.Fixed3D 
      pic.Image = screen
      pic.SizeMode = PictureBoxSizeMode.StretchImage

      frm.Controls.Add(pic)
      pic.Anchor = AnchorStyles.Top Or AnchorStyles.Bottom Or
                   AnchorStyles.Left Or AnchorStyles.Right

      frm.ShowDialog()
   End Sub
End Module

È possibile usare il file batch seguente per compilare l'esempio in C#.You can use the following batch file to build the C# example. Per Visual Basic, sostituire csc con vbce modificare l'estensione del file del codice sorgente da .cs a .vb.For Visual Basic, change csc to vbc, and change the extension of the source code file from .cs to .vb.

csc CreateResources.cs  
CreateResources  
  
resgen AppResources.resx  
  
csc GetStream.cs -resource:AppResources.resources  

Nell'esempio seguente viene usato il metodo ResourceManager.GetObject(String) per deserializzare un oggetto personalizzato.The following example uses the ResourceManager.GetObject(String) method to deserialize a custom object. L'esempio include un file di codice sorgente denominato UIElements.cs (UIElements.vb per Visual Basic) che definisce la seguente struttura denominata PersonTable.The example includes a source code file named UIElements.cs (UIElements.vb for Visual Basic) that defines the following structure named PersonTable. Questa struttura deve essere usata da una procedura generale di visualizzazione della tabella che mostra i nomi localizzati delle colonne della tabella.This structure is intended to be used by a general table display routine that displays the localized names of table columns. Si noti che la struttura PersonTable è contrassegnata con l'attributo SerializableAttribute.Note that the PersonTable structure is marked with the SerializableAttribute attribute.

using System;

[Serializable] public struct PersonTable
{
   public readonly int nColumns;
   public readonly string column1; 
   public readonly string column2;
   public readonly string column3; 
   public readonly int width1;
   public readonly int width2;
   public readonly int width3;
   
   public PersonTable(string column1, string column2, string column3,
                  int width1, int width2, int width3)
   {
      this.column1 = column1;
      this.column2 = column2;
      this.column3 = column3;
      this.width1 = width1;
      this.width2 = width2;
      this.width3 = width3;
      this.nColumns = typeof(PersonTable).GetFields().Length / 2; 
   }
}
<Serializable> Public Structure PersonTable
   Public ReadOnly nColumns As Integer
   Public Readonly column1 As String
   Public ReadOnly column2 As String
   Public ReadOnly column3 As String
   Public ReadOnly width1 As Integer
   Public ReadOnly width2 As Integer
   Public ReadOnly width3 As Integer
   
   Public Sub New(column1 As String, column2 As String, column3 As String,
                  width1 As Integer, width2 As Integer, width3 As Integer)
      Me.column1 = column1
      Me.column2 = column2
      Me.column3 = column3
      Me.width1 = width1
      Me.width2 = width2
      Me.width3 = width3
      Me.nColumns = Me.GetType().GetFields().Count \ 2 
   End Sub
End Structure

Il codice seguente, proveniente da un file denominato CreateResources.cs (CreateResources.vb per Visual Basic), crea un file di risorse XML denominato UIResources.resx che memorizza un titolo di tabella e un oggetto PersonTable contenente le informazioni per un'app che viene localizzata per la lingua inglese.The following code from a file named CreateResources.cs (CreateResources.vb for Visual Basic) creates an XML resource file named UIResources.resx that stores a table title and a PersonTable object that contains information for an app that is localized for the English language.

using System;
using System.Resources;

public class CreateResource
{
   public static void Main()
   {
      PersonTable table = new PersonTable("Name", "Employee Number", 
                                          "Age", 30, 18, 5);
      ResXResourceWriter rr = new ResXResourceWriter(@".\UIResources.resx");
      rr.AddResource("TableName", "Employees of Acme Corporation");
      rr.AddResource("Employees", table);
      rr.Generate();
      rr.Close();
   }
}
Imports System.Resources

Module CreateResource
   Public Sub Main()
      Dim table As New PersonTable("Name", "Employee Number", "Age", 30, 18, 5)
      Dim rr As New ResXResourceWriter(".\UIResources.resx")
      rr.AddResource("TableName", "Employees of Acme Corporation")
      rr.AddResource("Employees", table)
      rr.Generate()
      rr.Close()
   End Sub
End Module

Il codice seguente, contenuto in un file di codice sorgente denominato GetObject.cs (GetObject.vb), recupera quindi le risorse e le visualizza nella console.The following code in a source code file named GetObject.cs (GetObject.vb) then retrieves the resources and displays them to the console.

using System;
using System.Resources;

[assembly: NeutralResourcesLanguageAttribute("en")]

public class Example
{
   public static void Main()
   {
      string fmtString = String.Empty;
      ResourceManager rm = new ResourceManager("UIResources", typeof(Example).Assembly);       
      string title = rm.GetString("TableName");
      PersonTable tableInfo = (PersonTable) rm.GetObject("Employees");

      if (! String.IsNullOrEmpty(title)) {
         fmtString = "{0," + ((Console.WindowWidth + title.Length) / 2).ToString() + "}"; 
         Console.WriteLine(fmtString, title);      
         Console.WriteLine();
      }

      for (int ctr = 1; ctr <= tableInfo.nColumns; ctr++) {
         string columnName = "column"  + ctr.ToString();
         string widthName = "width" + ctr.ToString();
         string value = tableInfo.GetType().GetField(columnName).GetValue(tableInfo).ToString();
         int width = (int) tableInfo.GetType().GetField(widthName).GetValue(tableInfo);
         fmtString = "{0,-" + width.ToString() + "}";
         Console.Write(fmtString, value);
      }      
      Console.WriteLine();
   }
}
Imports System.Resources

<Assembly: NeutralResourcesLanguageAttribute("en")>

Module Example
   Public Sub Main()
      Dim fmtString As String = String.Empty
      Dim rm As New ResourceManager("UIResources", GetType(Example).Assembly)       
      Dim title As String = rm.GetString("TableName")
      Dim tableInfo As PersonTable = DirectCast(rm.GetObject("Employees"), PersonTable)

      If Not String.IsNullOrEmpty(title) Then
         fmtString = "{0," + ((Console.WindowWidth + title.Length) \ 2).ToString() + "}" 
         Console.WriteLine(fmtString, title)      
         Console.WriteLine()
      End If

      For ctr As Integer = 1 To tableInfo.nColumns
         Dim columnName As String = "column"  + ctr.ToString()
         Dim widthName As String = "width" + ctr.ToString()
         Dim value As String = CStr(tableInfo.GetType().GetField(columnName).GetValue(tableInfo))
         Dim width As Integer = CInt(tableInfo.GetType().GetField(widthName).GetValue(tableInfo))
         fmtString = "{0,-" + width.ToString() + "}"
         Console.Write(fmtString, value)
      Next      
      Console.WriteLine()
   End Sub
End Module

È possibile creare il file di risorse e gli assembly necessari ed eseguire l'app mediante il file batch seguente.You can build the necessary resource file and assemblies and run the app by executing the following batch file. È necessario usare l'opzione /r per fornire a Resgen.exe un riferimento a UIElements.dll in modo che possa accedere alle informazioni sulla struttura PersonTable .You must use the /r option to supply Resgen.exe with a reference to UIElements.dll so that it can access information about the PersonTable structure. Se si usa C#, sostituire il nome del compilatore vbc con csce l'estensione .vb con .cs.If you're using C#, replace the vbc compiler name with csc, and replace the .vb extension with .cs.

vbc -t:library UIElements.vb  
vbc CreateResources.vb -r:UIElements.dll  
CreateResources  
  
resgen UIResources.resx  -r:UIElements.dll  
vbc GetObject.vb -r:UIElements.dll -resource:UIResources.resources  
  
GetObject.exe  

Supporto per il controllo delle versioni per gli assembly satelliteVersioning Support for Satellite Assemblies

Per impostazione predefinita, quando l'oggetto ResourceManager recupera le risorse richieste, cerca gli assembly satellite con numeri di versione che corrispondono a quello dell'assembly principale.By default, when the ResourceManager object retrieves requested resources, it looks for satellite assemblies that have version numbers that match the version number of the main assembly. Una volta distribuita un'applicazione, è possibile che si desideri aggiornare l'assembly principale o gli assembly satellite di risorse specifiche.After you have deployed an app, you might want to update the main assembly or specific resource satellite assemblies. .NET Framework offre supporto per il controllo delle versioni dell'assembly principale e degli assembly satellite.The .NET Framework provides support for versioning the main assembly and satellite assemblies.

L'attributo SatelliteContractVersionAttribute fornisce supporto per il controllo delle versioni di un assembly principale.The SatelliteContractVersionAttribute attribute provides versioning support for a main assembly. Specificare questo attributo per l'assembly principale di un'applicazione consente di aggiornare e ridistribuire un assembly principale senza aggiornare i relativi assembly satellite.Specifying this attribute on an app's main assembly enables you to update and redeploy a main assembly without updating its satellite assemblies. Una volta aggiornato l'assembly principale, incrementare il numero di versione dell'assembly principale, ma lasciare inalterato il numero di versione del contratto con i satelliti.After you update the main assembly, increment the main assembly's version number but leave the satellite contract version number unchanged. Per recuperare le risorse richieste, il gestore di risorse carica la versione di assembly satellite specificata da questo attributo.When the resource manager retrieves requested resources, it loads the satellite assembly version specified by this attribute.

Gli assembly di criteri dell'editore forniscono il supporto per il controllo delle versioni degli assembly satellite.Publisher policy assemblies provide support for versioning satellite assemblies. È possibile aggiornare e ridistribuire un assembly satellite senza aggiornare l'assembly principale.You can update and redeploy a satellite assembly without updating the main assembly. Una volta aggiornato un assembly satellite, incrementarne il numero di versione e fornirlo con un assembly di criteri dell'editore.After you update a satellite assembly, increment its version number and ship it with a publisher policy assembly. Nell'assembly di criteri dell'editore specificare che il nuovo assembly satellite è compatibile con le versioni precedenti.In the publisher policy assembly, specify that your new satellite assembly is backward-compatible with its previous version. Il gestore di risorse utilizzerà l'attributo SatelliteContractVersionAttribute per determinare la versione di assembly satellite, ma il caricatore di assembly verrà associato alla versione di assembly satellite specificata dai criteri editore.The resource manager will use the SatelliteContractVersionAttribute attribute to determine the version of the satellite assembly, but the assembly loader will bind to the satellite assembly version specified by the publisher policy. Per ulteriori informazioni sugli assembly di criteri dell'editore, vedere Creazione di un file dei criteri editore.For more information about publisher policy assemblies, see Creating a Publisher Policy File.

Per abilitare il supporto completo del controllo delle versioni, si consiglia di distribuire gli assembly con nome sicuro nella Global Assembly Cache e gli assembly che non hanno nome sicuro nella directory dell'applicazione.To enable full assembly versioning support, we recommend that you deploy strong-named assemblies in the global assembly cache and deploy assemblies that don't have strong names in the application directory. Se si vuole distribuire assembly con nome sicuro nella directory dell'applicazione, non sarà possibile incrementare il numero di versione di un assembly satellite quando si aggiorna l'assembly.If you want to deploy strong-named assemblies in the application directory, you will not be able to increment a satellite assembly's version number when you update the assembly. Sarà invece necessario eseguire un aggiornamento sul posto in base al quale il codice esistente verrà sostituito dal codice aggiornato e verrà mantenuto lo stesso numero di versione.Instead, you must perform an in-place update where you replace the existing code with the updated code and maintain the same version number. Se, ad esempio, si desidera aggiornare la versione 1.0.0.0 di un assembly satellite con il nome assembly completo "myApp.resources, Version=1.0.0.0, Culture=de, PublicKeyToken=b03f5f11d50a3a", sovrascriverlo con il file myApp.resources.dll aggiornato compilato con lo stesso nome assembly completo "myApp.resources, Version=1.0.0.0, Culture=de, PublicKeyToken=b03f5f11d50a3a".For example, if you want to update version 1.0.0.0 of a satellite assembly with the fully specified assembly name "myApp.resources, Version=1.0.0.0, Culture=de, PublicKeyToken=b03f5f11d50a3a", overwrite it with the updated myApp.resources.dll that has been compiled with the same, fully specified assembly name "myApp.resources, Version=1.0.0.0, Culture=de, PublicKeyToken=b03f5f11d50a3a". Si noti che l'utilizzo degli aggiornamenti sul posto dei file di assembly satellite rende difficile la determinazione accurata da parte dell'applicazione della versione di un assembly satellite.Note that using in-place updates on satellite assembly files makes it difficult for an app to accurately determine the version of a satellite assembly.

Per ulteriori informazioni sul controllo delle versioni degli assembly, vedere Controllo delle versioni degli assembly e Come il runtime individua gli assembly.For more information about assembly versioning, see Assembly Versioning and How the Runtime Locates Assemblies.

Recupero delle risorse dai file .resourcesRetrieving Resources from .resources Files

Se si sceglie di non distribuire le risorse in assembly satellite, è comunque possibile utilizzare direttamente un oggetto ResourceManager per accedere alle risorse dai file .resources.If you choose not to deploy resources in satellite assemblies, you can still use a ResourceManager object to access resources from .resources files directly. A tale scopo, è necessario distribuire i file .resources correttamente.To do this, you must deploy the .resources files correctly. Utilizzare quindi il metodo ResourceManager.CreateFileBasedResourceManager per creare un'istanza di un oggetto ResourceManager e specificare la directory contenente i file .resources autonomi.Then you use the ResourceManager.CreateFileBasedResourceManager method to instantiate a ResourceManager object and specify the directory that contains the standalone .resources files.

Distribuzione di file .resourcesDeploying .resources Files

Quando si incorporano i file .resources in un assembly dell'applicazione e in assembly satellite, ogni assembly satellite ha lo stesso nome file, ma viene collocato in una sottodirectory che corrisponde alle impostazioni cultura dell'assembly satellite.When you embed .resources files in an application assembly and satellite assemblies, each satellite assembly has the same file name, but is placed in a subdirectory that reflects the satellite assembly's culture. Al contrario, quando si accede direttamente alle risorse dai file .resources, è possibile inserire tutti i file .resources in una singola directory, in genere una sottodirectory della directory dell'applicazione.In contrast, when you access resources from .resources files directly, you can place all the .resources files in a single directory, usually a subdirectory of the application directory. Il nome del file .resources predefinito dell'applicazione è costituito solo da un nome radice, senza indicare le impostazioni cultura, ad esempio strings.resources.The name of the app's default .resources file consists of a root name only, with no indication of its culture (for example, strings.resources). Le risorse per ogni impostazione cultura localizzata vengono archiviate in un file il cui nome è costituito dal nome radice seguito dalle impostazioni cultura, ad esempio strings.ja.resources o strings.de-DE.resources.The resources for each localized culture are stored in a file whose name consists of the root name followed by the culture (for example, strings.ja.resources or strings.de-DE.resources).

La figura seguente mostra dove collocare i file di risorse nella struttura di directory.The following illustration shows where resource files should be located in the directory structure. Illustra anche le convenzioni di denominazione per i file di risorse.It also gives the naming conventions for .resource files.

Figura che illustra la directory principale per l'applicazione.

Utilizzo del gestore di risorseUsing the Resource Manager

Dopo aver creato e inserito le risorse nella directory appropriata, creare un oggetto ResourceManager per utilizzare le risorse chiamando il metodo CreateFileBasedResourceManager(String, String, Type).After you have created your resources and placed them in the appropriate directory, you create a ResourceManager object to use the resources by calling the CreateFileBasedResourceManager(String, String, Type) method. Il primo parametro specifica il nome radice del file .resources predefinito dell'applicazione, ovvero "stringa" per l'esempio nella sezione precedente.The first parameter specifies the root name of the app's default .resources file (this would be "strings" for the example in the previous section). Il secondo parametro specifica il percorso delle risorse, ovvero "Resources" per l'esempio precedente.The second parameter specifies the location of the resources ("Resources" for the previous example). Il terzo parametro specifica l'implementazione di ResourceSet da usare.The third parameter specifies the ResourceSet implementation to use. Se il terzo parametro è null, viene utilizzato il runtime predefinito ResourceSet.If the third parameter is null, the default runtime ResourceSet is used.

Nota

Non distribuire applicazioni ASP.NET utilizzando file .resources autonomi.Do not deploy ASP.NET apps using standalone .resources files. Questo può causare problemi di blocco e interrompere la distribuzione XCOPY.This can cause locking issues and breaks XCOPY deployment. Si consiglia di distribuire le risorse ASP.NET in assembly satellite.We recommend that you deploy ASP.NET resources in satellite assemblies. Per altre informazioni, vedere ASP.NET Web Page Resources Overview.For more information, see ASP.NET Web Page Resources Overview.

Dopo avere creato un'istanza dell'oggetto ResourceManager, utilizzare i metodi GetString, GetObject e GetStream come illustrato in precedenza per recuperare le risorse.After you instantiate the ResourceManager object, you use the GetString, GetObject, and GetStream methods as discussed earlier to retrieve the resources. Tuttavia, il recupero delle risorse direttamente dai file .resources differisce dal recupero delle risorse incorporate dagli assembly.However, the retrieval of resources directly from .resources files differs from the retrieval of embedded resources from assemblies. Quando si recuperano le risorse dai file .resources, i metodi GetString(String), GetObject(String) e GetStream(String) recuperano sempre le risorse delle impostazioni cultura predefinite indipendentemente dalle impostazioni cultura correnti.When you retrieve resources from .resources files, the GetString(String), GetObject(String), and GetStream(String) methods always retrieve the default culture's resources regardless of the current culture. Per recuperare le risorse delle impostazioni cultura correnti dell'applicazione o delle impostazioni cultura specifiche, è necessario chiamare il metodo GetString(String, CultureInfo), GetObject(String, CultureInfo) o GetStream(String, CultureInfo) e specificare le impostazioni cultura di cui devono essere recuperate le risorse.To retrieve the resources of the either the app's current culture or a specific culture, you must call the GetString(String, CultureInfo), GetObject(String, CultureInfo), or GetStream(String, CultureInfo) method and specify the culture whose resources are to be retrieved. Per recuperare le risorse delle impostazioni cultura correnti, specificare il valore della proprietà CultureInfo.CurrentCulture come argomento culture.To retrieve the resources of the current culture, specify the value of the CultureInfo.CurrentCulture property as the culture argument. Se il gestore di risorse non può recuperare le risorse di culture, utilizza le regole standard di fallback delle risorse per recuperare le risorse appropriate.If the resource manager cannot retrieve the resources of culture, it uses the standard resource fallback rules to retrieve the appropriate resources.

EsempioAn Example

Nell'esempio seguente viene illustrato come il gestore di risorse recupera le risorse direttamente dai file .resources.The following example illustrates how the resource manager retrieves resources directly from .resources files. L'esempio è costituito da tre file di risorse basati su testo per le impostazioni cultura inglesi (Stati Uniti), francesi (Francia) e russe (Russia).The example consists of three text-based resource files for the English (United States), French (France), and Russian (Russia) cultures. L'inglese (Stati Uniti) rappresenta le impostazioni cultura predefinite dell'esempio.English (United States) is the example's default culture. Le risorse vengono archiviate nel seguente file denominato Strings.txt:Its resources are stored in the following file named Strings.txt:

Greeting=Hello  
Prompt=What is your name?  

Le risorse per le impostazioni cultura francesi (Francia) vengono archiviate nel seguente file, denominato Strings.fr-FR.txt:Resources for the French (France) culture are stored in the following file, which is named Strings.fr-FR.txt:

Greeting=Bon jour  
Prompt=Comment vous appelez-vous?  

Le risorse per le impostazioni cultura russe (Russia) vengono archiviate nel seguente file, denominato Strings.ru-RU.txt:Resources for the Russian (Russia) culture are stored in the following file, which is named Strings.ru-RU.txt:

Greeting=Здравствуйте  
Prompt=Как вас зовут?  

Di seguito viene riportato il codice sorgente per l'esempio.The following is the source code for the example. L'esempio crea un'istanza degli oggetti CultureInfo per le impostazioni cultura inglesi (Stati Uniti), inglesi (Canada), francesi (Francia) e russe (Russia) e imposta ognuna come le impostazioni cultura correnti.The example instantiates CultureInfo objects for the English (United States), English (Canada), French (France), and Russian (Russia) cultures, and makes each the current culture. Il metodo ResourceManager.GetString(String, CultureInfo) fornisce quindi il valore della proprietà CultureInfo.CurrentCulture come argomento culture per recuperare le risorse specifiche delle impostazioni cultura appropriate.The ResourceManager.GetString(String, CultureInfo) method then supplies the value of the CultureInfo.CurrentCulture property as the culture argument to retrieve the appropriate culture-specific resources.

using System;
using System.Globalization;
using System.Resources;
using System.Threading;

[assembly: NeutralResourcesLanguage("en-US")]

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "en-CA", "ru-RU", "fr-FR" };
      ResourceManager rm = ResourceManager.CreateFileBasedResourceManager("Strings", "Resources", null);
      
      foreach (var cultureName in cultureNames) {
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         string greeting = rm.GetString("Greeting", CultureInfo.CurrentCulture);
         Console.WriteLine("\n{0}!", greeting);
         Console.Write(rm.GetString("Prompt", CultureInfo.CurrentCulture));
         string name = Console.ReadLine();
         if (! String.IsNullOrEmpty(name))
            Console.WriteLine("{0}, {1}!", greeting, name);
      }
      Console.WriteLine();
   }
}
// The example displays output like the following:
//       Hello!
//       What is your name? Dakota
//       Hello, Dakota!
//       
//       Hello!
//       What is your name? Koani
//       Hello, Koani!
//       
//       Здравствуйте!
//       Как вас зовут?Samuel
//       Здравствуйте, Samuel!
//       
//       Bon jour!
//       Comment vous appelez-vous?Yiska
//       Bon jour, Yiska!
Imports System.Globalization
Imports System.Resources
Imports System.Threading

<Assembly: NeutralResourcesLanguageAttribute("en-US")>

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "en-CA", "ru-RU", "fr-FR" }
      Dim rm As ResourceManager = ResourceManager.CreateFileBasedResourceManager("Strings", "Resources", Nothing)
      
      For Each cultureName In cultureNames
         Console.WriteLine()
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Dim greeting As String = rm.GetString("Greeting", CultureInfo.CurrentCulture)
         Console.WriteLine("{0}!", greeting)
         Console.Write(rm.GetString("Prompt", CultureInfo.CurrentCulture))
         Dim name As String = Console.ReadLine()
         If Not String.IsNullOrEmpty(name) Then
            Console.WriteLine("{0}, {1}!", greeting, name)
         End If         
      Next
      Console.WriteLine()
   End Sub
End Module
' The example displays output like the following:
'       Hello!
'       What is your name? Dakota
'       Hello, Dakota!
'       
'       Hello!
'       What is your name? Koani
'       Hello, Koani!
'       
'       Здравствуйте!
'       Как вас зовут?Samuel
'       Здравствуйте, Samuel!
'       
'       Bon jour!
'       Comment vous appelez-vous?Yiska
'       Bon jour, Yiska!

È possibile compilare la versione C# dell'esempio eseguendo il file batch riportato di seguito.You can compile the C# version of the example by running the following batch file. Se si usa Visual Basic, sostituire csc con vbc e l'estensione .cs con .vb.If you're using Visual Basic, replace csc with vbc, and replace the .cs extension with .vb.

Md Resources  
Resgen Strings.txt Resources\Strings.resources  
Resgen Strings.fr-FR.txt Resources\Strings.fr-FR.resources  
Resgen Strings.ru-RU.txt Resources\Strings.ru-RU.resources  
  
csc Example.cs  

Vedere ancheSee also