Creare i file di risorse per le app .NETCreate resource files for .NET apps

È possibile includere risorse, ad esempio stringhe, immagini o dati di oggetti, all'interno di file di risorse per renderli facilmente disponibili per l'applicazione.You can include resources, such as strings, images, or object data, in resources files to make them easily available to your application. In .NET Framework è possibile creare file di risorse in cinque modi diversi:The .NET Framework offers five ways to create resources files:

  • Creare un file di testo contenente risorse stringa.Create a text file that contains string resources. È possibile usare il generatore di file di risorse (Resgen.exe) per convertire il file di testo in un file di risorse binario con estensione resources.You can use Resource File Generator (Resgen.exe) to convert the text file into a binary resource (.resources) file. È quindi possibile incorporare il file di risorse binario in un file eseguibile o in una libreria dell'applicazione tramite un compilatore del linguaggio. In alternativa, è possibile incorporare il file di risorse in un assembly satellite tramite Assembly Linker (Al.exe).You can then embed the binary resource file in an application executable or an application library by using a language compiler, or you can embed it in a satellite assembly by using Assembly Linker (Al.exe). Per altre informazioni, vedere la sezione Risorse in file di testo.For more information, see the Resources in Text Files section.

  • Creare un file di risorse XML con estensione resx contenente stringhe, immagini o dati di oggetto.Create an XML resource (.resx) file that contains string, image, or object data. È possibile usare il generatore di file di risorse (Resgen.exe) per convertire il file con estensione resx in un file di risorse binario con estensione resources.You can use Resource File Generator (Resgen.exe) to convert the .resx file into a binary resource (.resources) file. È quindi possibile incorporare il file di risorse binario in un file eseguibile o in una libreria dell'applicazione tramite un compilatore del linguaggio. In alternativa, è possibile incorporare il file di risorse in un assembly satellite tramite Assembly Linker (Al.exe).You can then embed the binary resource file in an application executable or an application library by using a language compiler, or you can embed it in a satellite assembly by using Assembly Linker (Al.exe). Per altre informazioni, vedere la sezione Risorse nei file con estensione resx.For more information, see the Resources in .resx Files section.

  • Creare un file di risorse XML con estensione resx a livello di codice usando tipi nello spazio dei nomi System.Resources.Create an XML resource (.resx) file programmatically by using types in the System.Resources namespace. È possibile creare un file con estensione resx, enumerarne le risorse e recuperare risorse specifiche in base al nome.You can create a .resx file, enumerate its resources, and retrieve specific resources by name. Per altre informazioni, vedere l'argomento Uso dei file RESX a livello di codice.For more information, see the topic Working with .resx Files Programmatically.

  • Creare un file di risorse binario con estensione resources a livello di codice.Create a binary resource (.resources) file programmatically. È quindi possibile incorporare il file in un file eseguibile o in una libreria dell'applicazione tramite un compilatore del linguaggio. In alternativa, è possibile incorporare il file di risorse in un assembly satellite tramite Assembly Linker (Al.exe).You can then embed the file in an application executable or an application library by using a language compiler, or you can embed it in a satellite assembly by using Assembly Linker (Al.exe). Per altre informazioni, vedere la sezione Risorse in file con estensione resources.For more information, see the Resources in .resources Files section.

  • Usare Visual Studio per creare un file di risorse e includerlo nel progetto.Use Visual Studio to create a resource file and include it in your project. Visual Studio è dotato di un editor di risorse che consente di aggiungere, eliminare e modificare risorse.Visual Studio provides a resource editor that lets you add, delete, and modify resources. In fase di compilazione il file di risorse viene automaticamente convertito in un file binario con estensione resources e incorporato in un assembly dell'applicazione o in un assembly satellite.At compile time, the resource file is automatically converted to a binary .resources file and embedded in an application assembly or satellite assembly. Per altre informazioni, vedere la sezione File di risorse in Visual Studio.For more information, see the Resource Files in Visual Studio section.

Risorse in file di testoResources in text files

È possibile usare file di testo (con estensione txt o restext) per archiviare solo risorse stringa.You can use text (.txt or .restext) files to store string resources only. Per le risorse non di tipo stringa, usare file con estensione resx o crearle a livello di codice.For non-string resources, use .resx files or create them programmatically. I file di testo che contengono risorse stringa hanno il formato seguente:Text files that contain string resources have the following format:

# This is an optional comment.
name = value

; This is another optional comment.
name = value

; The following supports conditional compilation if X is defined.
#ifdef X
name1=value1
name2=value2
#endif

# The following supports conditional compilation if Y is undefined.
#if !Y
name1=value1
name2=value2
#endif

Il formato dei file di risorse con estensione txt e restext è identico.The resource file format of .txt and .restext files is identical. L'estensione restext serve semplicemente a rendere immediatamente identificabili i file di testo come file di risorse basati su testo.The .restext file extension merely serves to make text files immediately identifiable as text-based resource files.

Le risorse stringa sono visualizzate come coppie name/value, dove name è una stringa che identifica la risorsa e value è la stringa di risorsa che viene restituita quando si passa name a un metodo di recupero quale ResourceManager.GetString.String resources appear as name/value pairs, where name is a string that identifies the resource, and value is the resource string that is returned when you pass name to a resource retrieval method such as ResourceManager.GetString. name e value devono essere separati da un segno di uguale (=).name and value must be separated by an equal sign (=). Ad esempio:For example:

FileMenuName=File
EditMenuName=Edit
ViewMenuName=View
HelpMenuName=Help

Attenzione

Non usare file di risorse per archiviare password, informazioni sensibili per la sicurezza o dati personali.Do not use resource files to store passwords, security-sensitive information, or private data.

Stringhe vuote, ovvero risorse il cui valore è String.Empty, sono consentite nei file di testo.Empty strings (that is, a resource whose value is String.Empty) are permitted in text files. Ad esempio:For example:

EmptyString=

A partire da .NET Framework 4.5 e in tutte le versioni di .NET Core, i file di testo supportano la compilazione condizionale con i costrutti #ifdefsimbolo... #endif e #if !simbolo... #endif.Starting with .NET Framework 4.5 and in all versions of .NET Core, text files support conditional compilation with the #ifdefsymbol... #endif and #if !symbol... #endif constructs. È quindi possibile usare l'opzione /define con il generatore di file di risorse (Resgen.exe) per definire i simboli.You can then use the /define switch with Resource File Generator (Resgen.exe) to define symbols. Ogni risorsa richiede un costrutto #ifdef simbolo... #endif o #if !simbolo... #endif specifico.Each resource requires its own #ifdefsymbol... #endif or #if !symbol... #endif construct. Se si usa un'istruzione #ifdef e simbolo è definito, la risorsa associata è inclusa nel file con estensione resources. In caso contrario, non è inclusa.If you use an #ifdef statement and symbol is defined, the associated resource is included in the .resources file; otherwise, it is not included. Se si usa un'istruzione #if ! e simbolo non è definito, la risorsa associata è inclusa nel file con estensione resources. In caso contrario, non è inclusa.If you use an #if ! statement and symbol is not defined, the associated resource is included in the .resources file; otherwise, it is not included.

Nei file di testo i commenti sono facoltativi e sono preceduti da un punto e virgola (;) o da un segno di cancelletto (#) all'inizio della riga.Comments are optional in text files and are preceded either by a semicolon (;) or by a pound sign (#) at the beginning of a line. Le righe che contengono i commenti possono trovarsi in qualsiasi punto del file.Lines that contain comments can be placed anywhere in the file. I commenti non sono inclusi in un file con estensione resources compilato creato tramite il generatore di file di risorse (Resgen.exe).Comments are not included in a compiled .resources file that is created by using Resource File Generator (Resgen.exe).

Eventuali righe vuote nel file di testo sono considerate spazi e vengono ignorate.Any blank lines in the text files are considered to be white space and are ignored.

Nell'esempio seguente sono definite due risorse stringa denominate OKButton e CancelButton.The following example defines two string resources named OKButton and CancelButton.

#Define resources for buttons in the user interface.
OKButton=OK
CancelButton=Cancel

Se il file di testo contiene occorrenze duplicate di name, il generatore di file di risorse (Resgen.exe) visualizza un avviso e ignora il secondo nome.If the text file contains duplicate occurrences of name, Resource File Generator (Resgen.exe) displays a warning and ignores the second name.

value non può contenere caratteri di nuova riga, ma è possibile usare caratteri di escape nello stile del linguaggio C, come \n per rappresentare una nuova riga e \t per rappresentare un carattere di tabulazione. È anche possibile includere un carattere barra rovesciata se è preceduto da un carattere di escape, ad esempio "\\".value cannot contain new line characters, but you can use C language-style escape characters such as \n to represent a new line and \t to represent a tab. You can also include a backslash character if it is escaped (for example, "\\"). Sono anche consentite le stringhe vuote.In addition, an empty string is permitted.

È consigliabile salvare le risorse nel formato di file di testo con la codifica UTF-8 UTF-16 in ordine dei byte little-endian o big-endian.You should save resources in text file format by using UTF-8 encoding or UTF-16 encoding in either little-endian or big-endian byte order. Il generatore di file di risorse (Resgen.exe), tuttavia, che consente di convertire un file con estensione txt in un file con estensione resources, per impostazione predefinita considera i file come salvati con la codifica UTF-8.However, Resource File Generator (Resgen.exe), which converts a .txt file to a .resources file, treats files as UTF-8 by default. Se si vuole che Resgen.exe riconosca un file come salvato con la codifica UTF-16, è necessario includere un byte order mark Unicode (U + FEFF) all'inizio del file.If you want Resgen.exe to recognize a file that was encoded using UTF-16, you must include a Unicode byte order mark (U+FEFF) at the beginning of the file.

Per incorporare un file di risorse in formato testo in un assembly .NET, è necessario convertire il file in un file di risorse binario (con estensione resources) tramite il generatore di file di risorse (Resgen.exe).To embed a resource file in text format into a .NET assembly, you must convert the file to a binary resource (.resources) file by using Resource File Generator (Resgen.exe). È quindi possibile incorporare il file con estensione resources in un assembly .NET tramite un compilatore del linguaggio. In alternativa, è possibile incorporare il file in un assembly satellite tramite Assembly Linker (Al.exe).You can then embed the .resources file in a .NET assembly by using a language compiler or embed it in a satellite assembly by using Assembly Linker (Al.exe).

Nell'esempio seguente viene usato un file di risorse in formato testo denominato GreetingResources.txt per un'applicazione console "Hello World" semplice.The following example uses a resource file in text format named GreetingResources.txt for a simple "Hello World" console application. Il file di testo definisce due stringhe, prompt e greeting, che richiedono all'utente di immettere il proprio nome e visualizzano un saluto.The text file defines two strings, prompt and greeting, that prompt the user to enter his or her name and display a greeting.

# GreetingResources.txt
# A resource file in text format for a "Hello World" application.
#
# Initial prompt to the user.
prompt=Enter your name:
# Format string to display the result.
greeting=Hello, {0}!

Il file di testo viene convertito in un file con estensione resources tramite il comando seguente:The text file is converted to a .resources file by using the following command:

resgen GreetingResources.txt

Nell'esempio seguente viene illustrato il codice sorgente per un'applicazione console che usa il file con estensione resources per visualizzare messaggi per l'utente.The following example shows the source code for a console application that uses the .resources file to display messages to the user.

using System;
using System.Reflection;
using System.Resources;

public class Example
{
   public static void Main()
   {
      ResourceManager rm = new ResourceManager("GreetingResources", 
                               typeof(Example).Assembly);
      Console.Write(rm.GetString("prompt"));
      string name = Console.ReadLine();
      Console.WriteLine(rm.GetString("greeting"), name);                                                                          
   }
}
// The example displays output like the following:
//       Enter your name: Wilberforce
//       Hello, Wilberforce!
Imports System.Reflection
Imports System.Resources

Module Example
   Public Sub Main()
      Dim rm As New ResourceManager("GreetingResources", 
                                    GetType(Example).Assembly())
      Console.Write(rm.GetString("prompt"))
      Dim name As String = Console.ReadLine()
      Console.WriteLine(rm.GetString("greeting"), name)                                                                          
   End Sub
End Module
' The example displays output like the following:
'       Enter your name: Wilberforce
'       Hello, Wilberforce!

Se si usa Visual Basic e il file di codice sorgente è denominato Greeting.vb, il comando seguente crea un file eseguibile che include il file con estensione resources incorporato:If you are using Visual Basic, and the source code file is named Greeting.vb, the following command creates an executable file that includes the embedded .resources file:

vbc greeting.vb -resource:GreetingResources.resources

Se si usa C# e il file di codice sorgente è denominato Greeting.cs, il comando seguente crea un file eseguibile che include il file con estensione resources incorporato:If you are using C#, and the source code file is named Greeting.cs, the following command creates an executable file that includes the embedded .resources file:

csc greeting.cs -resource:GreetingResources.resources

Risorse nei file con estensione resxResources in .resx files

A differenza dei file di testo, che possono archiviare solo risorse stringa, i file di risorse XML con estensione resx possono archiviare stringhe, dati binari quali immagini, icone e clip audio e oggetti a livello di codice.Unlike text files, which can only store string resources, XML resource (.resx) files can store strings, binary data such as images, icons, and audio clips, and programmatic objects. Un file con estensione resx contiene un'intestazione standard che descrive il formato delle voci di risorsa e specifica le informazioni del controllo delle versioni per l'XML usato per l'analisi dei dati.A .resx file contains a standard header, which describes the format of the resource entries and specifies the versioning information for the XML that is used to parse the data. I dati del file di risorse seguono l'intestazione XML.The resource file data follows the XML header. Ogni elemento di dati è costituito da una coppia nome/valore contenuta in un tag data.Each data item consists of a name/value pair that is contained in a data tag. Il relativo attributo name definisce il nome della risorsa e il tag value annidato contiene il valore della risorsa stessa.Its name attribute defines the resource name, and the nested value tag contains the resource value. Per i dati di tipo stringa, il tag value contiene la stringa.For string data, the value tag contains the string.

Il tag data seguente, ad esempio, definisce una risorsa stringa denominata prompt il cui valore è "Enter your name:".For example, the following data tag defines a string resource named prompt whose value is "Enter your name:".

<data name="prompt" xml:space="preserve">
  <value>Enter your name:</value>
</data>

Avviso

Non usare file di risorse per archiviare password, informazioni sensibili per la sicurezza o dati personali.Do not use resource files to store passwords, security-sensitive information, or private data.

Per gli oggetti risorsa, il tag dati include un attributo type che indica il tipo di dati della risorsa.For resource objects, the data tag includes a type attribute that indicates the data type of the resource. Per gli oggetti costituiti da dati binari, il tag data include anche un attributo mimetype, che indica il tipo base64 dei dati binari.For objects that consist of binary data, the data tag also includes a mimetype attribute, which indicates the base64 type of the binary data.

Nota

Tutti i file con estensione resx usano un formattatore di serializzazione binario per generare e analizzare i dati binari relativi a un tipo specifico.All .resx files use a binary serialization formatter to generate and parse the binary data for a specified type. Di conseguenza, un file con estensione resx può perdere di validità se il formato di serializzazione binario di un oggetto diventa incompatibile.As a result, a .resx file can become invalid if the binary serialization format for an object changes in an incompatible way.

Nell'esempio seguente viene illustrata una parte di un file con estensione resx che include una risorsa Int32 e un'immagine bitmap.The following example shows a portion of a .resx file that includes an Int32 resource and a bitmap image.

<data name="i1" type="System.Int32, mscorlib">
  <value>20</value>
</data>

<data name="flag" type="System.Drawing.Bitmap, System.Drawing,
    Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
    mimetype="application/x-microsoft.net.object.bytearray.base64">
  <value>
    AAEAAAD/////AQAAAAAAAAAMAgAAADtTeX…
  </value>
</data>

Importante

Poiché i file con estensione resx devono essere costituiti da codice XML ben formato in un formato predefinito, non è consigliabile usare i file con estensione resx manualmente, specialmente se tali file contengono risorse diverse da stringhe.Because .resx files must consist of well-formed XML in a predefined format, we do not recommend working with .resx files manually, particularly when the .resx files contain resources other than strings. Visual Studio offre invece un'interfaccia trasparente per la creazione e la modifica di file con estensione resx.Instead, Visual Studio provides a transparent interface for creating and manipulating .resx files. Per altre informazioni, vedere la sezione File di risorse in Visual Studio.For more information, see the Resource Files in Visual Studio section. È anche possibile creare e modificare i file con estensione resx a livello di codice.You can also create and manipulate .resx files programmatically. Per altre informazioni, vedere Uso dei file RESX a livello di codice.For more information, see Working with .resx Files Programmatically.

Risorse nei file con estensione resourcesResources in .resources files

È possibile usare la classe System.Resources.ResourceWriter per creare a livello di codice un file di risorse binario con estensione resources direttamente dal codice.You can use the System.Resources.ResourceWriter class to programmatically create a binary resource (.resources) file directly from code. È anche possibile usare il generatore di file di risorse (Resgen.exe) per creare un file con estensione resources da un file di testo o da un file con estensione resx.You can also use Resource File Generator (Resgen.exe) to create a .resources file from a text file or a .resx file. Oltre a dati di tipo stringa, il file con estensione resources può contenere dati binari (matrici di byte) e dati di oggetto.The .resources file can contain binary data (byte arrays) and object data in addition to string data. Per creare un file con estensione resources a livello di codice è necessaria la procedura seguente:Programmatically creating a .resources file requires the following steps:

  1. Creare un oggetto ResourceWriter con un nome file univoco.Create a ResourceWriter object with a unique file name. A tale scopo, specificare un nome file o un flusso di file per un costruttore della classe ResourceWriter.You can do this by specifying either a file name or a file stream to a ResourceWriter class constructor.

  2. Chiamare uno degli overload del metodo ResourceWriter.AddResource per ogni risorsa denominata da aggiungere al file.Call one of the overloads of the ResourceWriter.AddResource method for each named resource to add to the file. La risorsa può essere una stringa, un oggetto o una raccolta di dati binari (una matrice di byte).The resource can be a string, an object, or a collection of binary data (a byte array).

  3. Chiamare il metodo ResourceWriter.Close per scrivere le risorse nel file e chiudere l'oggetto ResourceWriter.Call the ResourceWriter.Close method to write the resources to the file and to close the ResourceWriter object.

Nota

Non usare file di risorse per archiviare password, informazioni sensibili per la sicurezza o dati personali.Do not use resource files to store passwords, security-sensitive information, or private data.

Nell'esempio seguente viene creato a livello di codice un file con estensione resources denominato CarResources.resources contenente sei stringhe, un'icona e due oggetti definiti dall'applicazione, ovvero due oggetti Automobile.The following example programmatically creates a .resources file named CarResources.resources that stores six strings, an icon, and two application-defined objects (two Automobile objects). Si noti che la classe Automobile definita e di cui è stata creata un'istanza nell'esempio viene contrassegnata con l'attributo SerializableAttribute, che consente di renderla persistente al formattatore della serializzazione binaria.Note that the Automobile class, which is defined and instantiated in the example, is tagged with the SerializableAttribute attribute, which allows it to be persisted by the binary serialization formatter.

using System;
using System.Drawing;
using System.Resources;

[Serializable()] public class Automobile
{
   private string carMake;
   private string carModel;
   private int carYear;
   private int carDoors;
   private int carCylinders;
   
   public Automobile(string make, string model, int year) :
                     this(make, model, year, 0, 0)
   { }
   
   public Automobile(string make, string model, int year, 
                     int doors, int cylinders)
   {                     
      this.carMake = make;
      this.carModel = model;
      this.carYear = year;
      this.carDoors = doors;
      this.carCylinders = cylinders;
   }

   public string Make {
      get { return this.carMake; }
   }       
   
   public string Model {
      get { return this.carModel; } 
   }       
   
   public int Year {
      get { return this.carYear; }
   }       
   
   public int Doors {
      get { 
         return this.carDoors; }
   }       
   
   public int Cylinders {
      get { 
         return this.carCylinders; }
   }        
}

public class Example
{
   public static void Main()
   {
      // Instantiate an Automobile object.
      Automobile car1 = new Automobile("Ford", "Model N", 1906, 0, 4);
      Automobile car2 = new Automobile("Ford", "Model T", 1909, 2, 4);
      // Define a resource file named CarResources.resx.
      using (ResourceWriter rw = new ResourceWriter(@".\CarResources.resources"))
      {
         rw.AddResource("Title", "Classic American Cars");
         rw.AddResource("HeaderString1", "Make");
         rw.AddResource("HeaderString2", "Model");
         rw.AddResource("HeaderString3", "Year");
         rw.AddResource("HeaderString4", "Doors");
         rw.AddResource("HeaderString5", "Cylinders");
         rw.AddResource("Information", SystemIcons.Information); 
         rw.AddResource("EarlyAuto1", car1);
         rw.AddResource("EarlyAuto2", car2);  
      }
   }
}
Imports System.Drawing
Imports System.Resources

<Serializable()> Public Class Automobile
   Private carMake As String
   Private carModel As String
   Private carYear As Integer
   Private carDoors AS Integer
   Private carCylinders As Integer
   
   Public Sub New(make As String, model As String, year As Integer) 
      Me.New(make, model, year, 0, 0)   
   End Sub
   
   Public Sub New(make As String, model As String, year As Integer, 
                  doors As Integer, cylinders As Integer)
      Me.carMake = make
      Me.carModel = model
      Me.carYear = year
      Me.carDoors = doors
      Me.carCylinders = cylinders
   End Sub

   Public ReadOnly Property Make As String
      Get
         Return Me.carMake
      End Get   
   End Property       
   
   Public ReadOnly Property Model As String
      Get
         Return Me.carModel
      End Get   
   End Property       
   
   Public ReadOnly Property Year As Integer
      Get
         Return Me.carYear
      End Get   
   End Property       
   
   Public ReadOnly Property Doors As Integer
      Get
         Return Me.carDoors
      End Get   
   End Property       
   
   Public ReadOnly Property Cylinders As Integer
      Get
         Return Me.carCylinders
      End Get   
   End Property       
End Class

Module Example
   Public Sub Main()
      ' Instantiate an Automobile object.
      Dim car1 As New Automobile("Ford", "Model N", 1906, 0, 4)
      Dim car2 As New Automobile("Ford", "Model T", 1909, 2, 4)
      ' Define a resource file named CarResources.resx.
      Using rw As New ResourceWriter(".\CarResources.resources")
         rw.AddResource("Title", "Classic American Cars")
         rw.AddResource("HeaderString1", "Make")
         rw.AddResource("HeaderString2", "Model")
         rw.AddResource("HeaderString3", "Year")
         rw.AddResource("HeaderString4", "Doors")
         rw.AddResource("HeaderString5", "Cylinders")
         rw.AddResource("Information", SystemIcons.Information) 
         rw.AddResource("EarlyAuto1", car1)
         rw.AddResource("EarlyAuto2", car2)  
      End Using
   End Sub
End Module

Dopo aver creato il file con estensione resources, è possibile incorporarlo in un eseguibile di runtime o in una libreria, includendo l'opzione /resource del compilatore del linguaggio, oppure in un assembly satellite tramite Assembly Linker (Al.exe).After you create the .resources file, you can embed it in a run-time executable or library by including the language compiler's /resource switch, or embed it in a satellite assembly by using Assembly Linker (Al.exe).

File di risorse in Visual StudioResource files in Visual Studio

Quando si aggiunge un file di risorse a un progetto di Visual Studio, Visual Studio crea un file con estensione resx nella directory del progetto.When you add a resource file to your Visual Studio project, Visual Studio creates a .resx file in the project directory. In Visual Studio sono disponibili editor di risorse che consentono di aggiungere stringhe, immagini e oggetti binari.Visual Studio provides resource editors that enable you to add strings, images, and binary objects. Poiché gli editor vengono progettati per gestire solo dati statici, non possono essere usati per archiviare oggetti a livello di codice, ma è necessario scrivere i dati degli oggetti in un file con estensione resx o resources a livello di codice.Because the editors are designed to handle static data only, they cannot be used to store programmatic objects; you must write object data to either a .resx file or to a .resources file programmatically. Per altre informazioni, vedere Uso dei file RESX a livello di codice e la sezione Risorse in file con estensione resources.For more information, see Working with .resx Files Programmatically and the Resources in .resources Files section.

Se si aggiungono risorse localizzate, assegnarvi lo stesso nome di file radice del file di risorse principale.If you're adding localized resources, give them the same root file name as the main resource file. È necessario designare anche le impostazioni cultura nel nome del file.You should also designate their culture in the file name. Se ad esempio si aggiunge un file di risorse denominato Resources.resx, è possibile creare anche file di risorse denominati Resources.en-US.resx e Resources.fr-FR.resx per le risorse localizzate rispettivamente per le impostazioni cultura inglesi (Stati Uniti) e francesi (Francia).For example, if you add a resource file named Resources.resx, you might also create resource files named Resources.en-US.resx and Resources.fr-FR.resx to hold localized resources for the English (United States) and French (France) cultures, respectively. È necessario designare anche le impostazioni cultura predefinite dell'applicazione.You should also designate your application's default culture. Si tratta delle impostazioni cultura di cui si usano le risorse se non è possibile trovare le risorse localizzate per impostazioni cultura particolari.This is the culture whose resources are used if no localized resources for a particular culture can be found. Per specificare le impostazioni cultura predefinite, in Esplora soluzioni in Visual Studio fare clic con il pulsante destro del mouse sul nome del progetto, scegliere Applicazione, fare clic su Informazioni assemblye selezionare la lingua e le impostazioni cultura appropriate nell'elenco Lingua neutra.To specify the default culture, in Solution Explorer in Visual Studio, right-click the project name, point to Application, click Assembly Information, and select the appropriate language/culture in the Neutral language list.

In fase di compilazione, Visual Studio prima converte i file con estensione resx di un progetto in file di risorse binari con estensione resources e li archivia in una sottodirectory della directory obj del progetto.At compile time, Visual Studio first converts the .resx files in a project to binary resource (.resources) files and stores them in a subdirectory of the project's obj directory. Visual Studio incorpora ogni file di risorse che non contiene risorse localizzate nell'assembly principale generato dal progetto.Visual Studio embeds any resource files that do not contain localized resources in the main assembly that is generated by the project. Se tutti i file di risorse contengono risorse localizzate, Visual Studio li incorpora in assembly satellite separati per ognuna delle impostazioni cultura localizzateIf any resource files contain localized resources, Visual Studio embeds them in separate satellite assemblies for each localized culture. e archivia quindi ogni assembly satellite in una directory il cui nome corrisponde alle impostazioni cultura localizzate.It then stores each satellite assembly in a directory whose name corresponds to the localized culture. Ad esempio, le risorse localizzate per l'inglese (Stati Uniti) vengono archiviate in un assembly satellite nella sottodirectory en-US.For example, localized English (United States) resources are stored in a satellite assembly in the en-US subdirectory.

Vedere ancheSee also