Creación de archivos de recursos para aplicaciones .NETCreate resource files for .NET apps

Puede incluir recursos, como cadenas, imágenes o datos de objeto, en los archivos de recursos para hacer que estén disponibles fácilmente en su aplicación.You can include resources, such as strings, images, or object data, in resources files to make them easily available to your application. .NET Framework ofrece cinco mecanismos para crear archivos de recursos:The .NET Framework offers five ways to create resources files:

  • Cree un archivo de texto que contenga recursos de cadena.Create a text file that contains string resources. Puede usar el Generador de archivos de recursos (Resgen.exe) para convertir el archivo de texto en un archivo de recursos binario (.resources).You can use Resource File Generator (Resgen.exe) to convert the text file into a binary resource (.resources) file. Después, puede insertar el archivo de recursos binario en el ejecutable de una aplicación o en una biblioteca de aplicaciones mediante un compilador del lenguaje, o bien puede insertarlo en un ensamblado satélite mediante 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). Para obtener más información, vea la sección Recursos en archivos de texto.For more information, see the Resources in Text Files section.

  • Cree un archivo de recursos XML (.resx) que contenga una cadena, una imagen o datos de objeto.Create an XML resource (.resx) file that contains string, image, or object data. Puede usar el Generador de archivos de recursos (Resgen.exe) para convertir el archivo .resx en un archivo de recursos binario (.resources).You can use Resource File Generator (Resgen.exe) to convert the .resx file into a binary resource (.resources) file. Después, puede insertar el archivo de recursos binario en el ejecutable de una aplicación o en una biblioteca de aplicaciones mediante un compilador del lenguaje, o bien puede insertarlo en un ensamblado satélite mediante 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). Para obtener más información, vea la sección Recursos en archivos .resx.For more information, see the Resources in .resx Files section.

  • Cree un archivo de recursos XML (.resx) mediante programación utilizando los tipos del espacio de nombres System.Resources.Create an XML resource (.resx) file programmatically by using types in the System.Resources namespace. Puede crear un archivo .resx, enumerar sus recursos y recuperar recursos específicos por nombre.You can create a .resx file, enumerate its resources, and retrieve specific resources by name. Para obtener más información, vea el tema Working with .resx Files Programmatically (Trabajar con archivos .resx mediante programación).For more information, see the topic Working with .resx Files Programmatically.

  • Cree un archivo de recursos binario (.resources) mediante programación.Create a binary resource (.resources) file programmatically. Después, puede insertar el archivo en el ejecutable de una aplicación o en una biblioteca de aplicaciones mediante un compilador del lenguaje, o bien puede insertarlo en un ensamblado satélite mediante 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). Para obtener más información, vea la sección Recursos en archivos .resources.For more information, see the Resources in .resources Files section.

  • Use Visual Studio para crear un archivo de recursos e incluirlo en el proyecto.Use Visual Studio to create a resource file and include it in your project. Visual Studio proporciona un editor de recursos que le permite agregar, eliminar y modificar recursos.Visual Studio provides a resource editor that lets you add, delete, and modify resources. En tiempo de compilación, el archivo de recursos se convierte automáticamente en un archivo .resources binario y se incrusta en un ensamblado de la aplicación o un ensamblado satélite.At compile time, the resource file is automatically converted to a binary .resources file and embedded in an application assembly or satellite assembly. Para obtener más información, vea la sección Archivos de recursos en Visual Studio.For more information, see the Resource Files in Visual Studio section.

Recursos en archivos de textoResources in text files

Puede usar archivos de texto (.txt o .restext) únicamente para almacenar recursos de cadena.You can use text (.txt or .restext) files to store string resources only. Para los recursos que no son de cadena, use archivos .resx o créelos mediante programación.For non-string resources, use .resx files or create them programmatically. Los archivos de texto que contienen recursos de cadena tienen el siguiente formato: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

El formato de archivo de recursos de los archivos .txt y .restext es idéntico.The resource file format of .txt and .restext files is identical. La extensión de archivo .restext solo sirve para permitir que los archivos de texto se identifiquen de forma inmediata como archivos de recursos basados ​​en texto.The .restext file extension merely serves to make text files immediately identifiable as text-based resource files.

Los recursos de cadena aparecen como pares name/value, donde name es una cadena que identifica el recurso y value es la cadena de recurso que se devuelve al pasar name a un método de recuperación de recursos como 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 y value deben separarse mediante el signo igual (=).name and value must be separated by an equal sign (=). Por ejemplo:For example:

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

Precaución

No utilice archivos de recursos para almacenar contraseñas, información relativa a la seguridad o datos privados.Do not use resource files to store passwords, security-sensitive information, or private data.

Las cadenas vacías (es decir, un recurso cuyo valor es String.Empty) se permiten en los archivos de texto.Empty strings (that is, a resource whose value is String.Empty) are permitted in text files. Por ejemplo:For example:

EmptyString=

A partir de .NET Framework 4.5 y en todas las versiones de .NET Core, los archivos de texto admiten compilación condicional con las construcciones #ifdefsymbol... #endif y #if !symbol... #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. Se puede usar el modificador /define con el Generador de archivos de recursos (Resgen.exe) para definir símbolos.You can then use the /define switch with Resource File Generator (Resgen.exe) to define symbols. Cada recurso requiere su propia construcción #ifdefsymbol... #endif o #if !symbol... #endif.Each resource requires its own #ifdefsymbol... #endif or #if !symbol... #endif construct. Si se usa una instrucción #ifdef y se ha definido symbol, el recurso asociado se incluye en el archivo .resources. En caso contrario, no se incluye.If you use an #ifdef statement and symbol is defined, the associated resource is included in the .resources file; otherwise, it is not included. Si se usa una instrucción #if ! y no se ha definido symbol, el recurso asociado se incluye en el archivo .resources. En caso contrario, no se incluye.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.

En los archivos de texto, los comentarios son opcionales y se incluyen al principio de la línea precedidos por un símbolo de punto y coma (;) o un signo de número (#).Comments are optional in text files and are preceded either by a semicolon (;) or by a pound sign (#) at the beginning of a line. Las líneas que contienen los comentarios se pueden colocar en cualquier parte del archivo.Lines that contain comments can be placed anywhere in the file. Los comentarios no se incluirán en un archivo .resources compilado que se crea mediante el Generador de archivos de recursos (Resgen.exe).Comments are not included in a compiled .resources file that is created by using Resource File Generator (Resgen.exe).

Las líneas en blanco de los archivos de texto se consideran espacios en blanco y no se tienen en cuenta.Any blank lines in the text files are considered to be white space and are ignored.

En el ejemplo siguiente se definen dos recursos de cadena denominados OKButton y CancelButton.The following example defines two string resources named OKButton and CancelButton.

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

Si el archivo de texto contiene instancias duplicadas de name, el Generador de archivos de recursos (Resgen.exe) muestra una advertencia y omite el segundo nombre.If the text file contains duplicate occurrences of name, Resource File Generator (Resgen.exe) displays a warning and ignores the second name.

value no puede contener caracteres de nueva línea, pero se pueden usar caracteres de escape del estilo del lenguaje C, como \n para representar una línea nueva y \t para representar una tabulación. También se puede incluir un carácter de barra diagonal inversa si se añade el carácter de escape (por ejemplo, "\\").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, "\\"). Además, se admite el uso de una cadena vacía.In addition, an empty string is permitted.

Debe guardar los recursos en formato de archivo de texto utilizando la codificación UTF-8 o UTF-16 con el orden de bytes 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. Pero el Generador de archivos de recursos (Resgen.exe), que convierte un archivo .txt en un archivo .resources, trata los archivos como UTF-8 de forma predeterminada.However, Resource File Generator (Resgen.exe), which converts a .txt file to a .resources file, treats files as UTF-8 by default. Si desea que Resgen.exe reconozca un archivo codificado con UTF-16, es preciso incluir una marca de orden de bytes Unicode (U+FEFF) al principio del archivo.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.

Para insertar un archivo de recursos en formato de texto en un ensamblado .NET, debe convertirlo en un archivo de recursos binario (.resources) mediante el Generador de archivos de recursos (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). Después, puede insertar el archivo .resources en un ensamblado .NET mediante un compilador del lenguaje o insertarlo en un ensamblado satélite mediante 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).

En el siguiente ejemplo se utiliza un archivo de recursos en formato de texto denominado GreetingResources.txt para una sencilla aplicación de consola "Hello World".The following example uses a resource file in text format named GreetingResources.txt for a simple "Hello World" console application. El archivo de texto define dos cadenas, prompt y greeting, que solicitan al usuario que escriba su nombre y muestran un saludo.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}!

El archivo de texto se convierte en un archivo .resources a través del siguiente comando:The text file is converted to a .resources file by using the following command:

resgen GreetingResources.txt

En el ejemplo siguiente se muestra el código fuente de una aplicación de consola que utiliza el archivo .resources para mostrar mensajes al usuario.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!

Si está utilizando Visual Basic y el archivo de código fuente se denomina Greeting.vb, el siguiente comando crea un archivo ejecutable que incluye el archivo .resources incrustado: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

Si está utilizando C# y el archivo de código fuente se denomina Greeting.cs, el comando siguiente crea un archivo ejecutable que incluye el archivo .resources incrustado: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

Recursos en archivos .resxResources in .resx files

A diferencia de los archivos de texto, que solo pueden almacenar recursos de cadena, los archivos de recursos XML (.resx) pueden almacenar cadenas, datos binarios (como imágenes, iconos y clips de sonido) y objetos de programación.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. Los archivos .resx contienen un encabezado estándar, en el que se describe el formato de las entradas de los recursos y se especifica la información sobre el control de versiones correspondiente al código XML que se usa para analizar los datos.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. Los datos del archivo de recursos siguen lo establecido en el encabezado XML.The resource file data follows the XML header. Cada elemento de datos se compone de un par nombre/valor incluido en una etiqueta data.Each data item consists of a name/value pair that is contained in a data tag. Su atributo name define el nombre del recurso y la etiqueta value anidada contiene el valor del recurso.Its name attribute defines the resource name, and the nested value tag contains the resource value. En el caso de los datos de cadena, la etiqueta value contiene la cadena.For string data, the value tag contains the string.

Por ejemplo, la etiqueta data siguiente define un recurso de cadena denominado prompt cuyo valor es "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>

Advertencia

No utilice archivos de recursos para almacenar contraseñas, información relativa a la seguridad o datos privados.Do not use resource files to store passwords, security-sensitive information, or private data.

En el caso de los objetos de recursos, la etiqueta data contiene un atributo type que indica el tipo de datos del recurso.For resource objects, the data tag includes a type attribute that indicates the data type of the resource. En el caso de los objetos que se componen de datos binarios, la etiqueta data contiene también un atributo mimetype, que indica el tipo base64 de los datos binarios.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

Todos los archivos .resx utilizan un formateador de serialización binaria para generar y analizar los datos binarios de un tipo especificado.All .resx files use a binary serialization formatter to generate and parse the binary data for a specified type. Como resultado, un archivo .resx puede convertirse en un archivo no válido si el formato de serialización binaria de un objeto cambia de manera que sea incompatible.As a result, a .resx file can become invalid if the binary serialization format for an object changes in an incompatible way.

En el siguiente ejemplo se muestra una parte de un archivo .resx que contiene un recurso Int32 y una imagen de mapa de bits.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

Como los archivos .resx deben componerse de código XML con formato correcto y tener un formato predefinido, no resulta recomendable trabajar manualmente con este tipo de archivos, sobre todo cuando contienen recursos que no son cadenas.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. En cambio, Visual Studio proporciona una interfaz transparente para crear y manipular archivos. resx.Instead, Visual Studio provides a transparent interface for creating and manipulating .resx files. Para obtener más información, vea la sección Archivos de recursos en Visual Studio.For more information, see the Resource Files in Visual Studio section. También puede crear y manipular archivos .resx mediante programación.You can also create and manipulate .resx files programmatically. Para obtener más información, vea Working with .resx Files Programmatically (Trabajar con archivos .resx mediante programación).For more information, see Working with .resx Files Programmatically.

Recursos en archivos .resourcesResources in .resources files

Puede usar la clase System.Resources.ResourceWriter para crear mediante programación un archivo de recursos binario (.resources) directamente desde el código.You can use the System.Resources.ResourceWriter class to programmatically create a binary resource (.resources) file directly from code. También puede usar el Generador de archivos de recursos (Resgen.exe) para crear un archivo .resources a partir de un archivo de texto o un archivo .resx.You can also use Resource File Generator (Resgen.exe) to create a .resources file from a text file or a .resx file. El archivo .resources puede contener datos binarios (matrices de bytes) y datos de objeto además de datos de cadena.The .resources file can contain binary data (byte arrays) and object data in addition to string data. Al crear un archivo .resources mediante programación, se requieren los siguientes pasos:Programmatically creating a .resources file requires the following steps:

  1. Cree un objeto ResourceWriter con un nombre de archivo único.Create a ResourceWriter object with a unique file name. Puede hacerlo especificando el nombre de archivo o una secuencia de archivos en un constructor de clase ResourceWriter.You can do this by specifying either a file name or a file stream to a ResourceWriter class constructor.

  2. Llame a una de las sobrecargas del método ResourceWriter.AddResource para que cada recurso con nombre se agregue al archivo.Call one of the overloads of the ResourceWriter.AddResource method for each named resource to add to the file. El recurso puede ser una cadena, un objeto o una colección de datos binarios (una matriz de bytes).The resource can be a string, an object, or a collection of binary data (a byte array).

  3. Llame al método ResourceWriter.Close para que escriba los recursos en el archivo y cierre el objeto ResourceWriter.Call the ResourceWriter.Close method to write the resources to the file and to close the ResourceWriter object.

Nota

No utilice archivos de recursos para almacenar contraseñas, información relativa a la seguridad o datos privados.Do not use resource files to store passwords, security-sensitive information, or private data.

En el ejemplo siguiente se crea mediante programación un archivo .resources denominado CarResources.resources que almacena seis cadenas, un icono y dos objetos definidos por la aplicación (dos objetos 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). Tenga en cuenta la clase Automobile, que se define y de la que se crean instancias en el ejemplo, está etiquetada con el atributo SerializableAttribute, lo que permite que el formateador de serialización binaria la mantenga.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

Después de crear el archivo .resources, puede insertarlo en un ejecutable o una biblioteca en tiempo de ejecución si incluye el modificador /resource del compilador del lenguaje o insertarlo en un ensamblado satélite mediante 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).

Archivos de recursos en Visual StudioResource files in Visual Studio

Cuando agrega un archivo de recursos a su proyecto de Visual Studio, Visual Studio crea un archivo .resx en el directorio del proyecto.When you add a resource file to your Visual Studio project, Visual Studio creates a .resx file in the project directory. Visual Studio proporciona editores de recursos que permiten agregar cadenas, imágenes y objetos binarios.Visual Studio provides resource editors that enable you to add strings, images, and binary objects. Dado que los editores están diseñados para administrar únicamente datos estáticos, no se pueden utilizar para almacenar objetos de programación; debe escribir mediante programación los datos de objeto en un archivo .resx o un archivo .resources.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. Para más información, consulte el tema Trabajar con archivos .resx mediante programación y la sección Recursos en archivos .resources.For more information, see Working with .resx Files Programmatically and the Resources in .resources Files section.

Si va a agregar recursos localizados, asígneles el mismo nombre de archivo raíz que el archivo de recursos principal.If you're adding localized resources, give them the same root file name as the main resource file. También deberá designar su referencia cultural en el nombre de archivo.You should also designate their culture in the file name. Por ejemplo, si agrega un archivo de recursos denominado Resources.resx, también podrá crear los archivos de recursos denominados Resources.en-US.resx y Resources.fr-FR.resx para incluir los recursos localizados en las referencias culturales inglés (Estados Unidos) y francés (Francia), respectivamente.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. También deberá designar la referencia cultural predeterminada de la aplicación.You should also designate your application's default culture. Esta es la referencia cultural cuyos recursos van a usarse si no se encuentran recursos localizados en una determinada referencia cultural.This is the culture whose resources are used if no localized resources for a particular culture can be found. Para especificar la referencia cultural predeterminada, en el Explorador de soluciones de Visual Studio, haga clic con el botón derecho en el nombre del proyecto, elija Aplicación, haga clic en Información de ensamblado y seleccione el idioma o la referencia cultural apropiada en la lista Idioma neutro.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.

En tiempo de compilación, Visual Studio convierte primero los archivos .resx de un proyecto en archivos de recursos binarios (.resources) y los almacena en un subdirectorio del directorio obj del proyecto.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 incrusta los archivos de recursos que no contienen recursos localizados en el ensamblado principal que el proyecto genera.Visual Studio embeds any resource files that do not contain localized resources in the main assembly that is generated by the project. Si los archivos de recursos contienen recursos localizados, Visual Studio los incrusta en un ensamblado satélite distinto para cada referencia cultural localizada.If any resource files contain localized resources, Visual Studio embeds them in separate satellite assemblies for each localized culture. Después, almacena cada ensamblado satélite en un directorio cuyo nombre se corresponde con la referencia cultural localizada.It then stores each satellite assembly in a directory whose name corresponds to the localized culture. Por ejemplo, los recursos localizados en inglés (Estados Unidos) se almacenan en un ensamblado satélite del subdirectorio en-US.For example, localized English (United States) resources are stored in a satellite assembly in the en-US subdirectory.

Vea tambiénSee also