ResourceManager ResourceManager ResourceManager ResourceManager Class

Definition

Representa un administrador de recursos que proporciona un acceso más cómodo a los recursos específicos de la referencia cultural en tiempo de ejecución. Represents a resource manager that provides convenient access to culture-specific resources at run time.

public ref class ResourceManager
[System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class ResourceManager
type ResourceManager = class
Public Class ResourceManager
Inheritance
ResourceManagerResourceManagerResourceManagerResourceManager
Derived
Attributes
ComVisibleAttribute SerializableAttribute

Examples

El ejemplo siguiente muestra cómo usar una referencia cultural explícita y la referencia cultural implícita de la interfaz de usuario actual para obtener recursos de cadena de un ensamblado principal y un ensamblado satélite.The following example demonstrates how to use an explicit culture and the implicit current UI culture to obtain string resources from a main assembly and a satellite assembly. Para obtener más información, vea la sección "Directorio ubicaciones de satélite ensamblados no instalado en la caché Global de ensamblados" de la crear ensamblados satélite tema.For more information, see the "Directory Locations for Satellite Assemblies Not Installed in the Global Assembly Cache" section of the Creating Satellite Assemblies topic.

Para ejecutar este ejemplo:To run this example:

  1. En el directorio de aplicación, cree un archivo denominado rmc.txt que contiene las cadenas de recursos siguientes:In the app directory, create a file named rmc.txt that contains the following resource strings:

    
    day=Friday  
    year=2006  
    holiday="Cinco de Mayo"  
    
  2. Use la Resource File Generator para generar el archivo de recursos rmc.resources desde el archivo de entrada rmc.txt como sigue:Use the Resource File Generator to generate the rmc.resources resource file from the rmc.txt input file as follows:

    resgen rmc.txt  
    
  3. Cree un subdirectorio del directorio de aplicación y denomínelo "es-MX".Create a subdirectory of the app directory and name it "es-MX". Este es el nombre de referencia cultural del ensamblado satélite que creará en los tres pasos siguientes.This is the culture name of the satellite assembly that you will create in the next three steps.

  4. Cree un archivo denominado rmc.es-MX.txt en el directorio es-MX que contiene las cadenas de recursos siguientes:Create a file named rmc.es-MX.txt in the es-MX directory that contains the following resource strings:

    
    day=Viernes  
    year=2006  
    holiday="Cinco de Mayo"  
    
  5. Use la Resource File Generator para generar el archivo de recursos rmc.es MX.resources desde el archivo de entrada rmc.es MX.txt como sigue:Use the Resource File Generator to generate the rmc.es-MX.resources resource file from the rmc.es-MX.txt input file as follows:

    resgen rmc.es-MX.txt  
    
  6. Suponga que el nombre de archivo para este ejemplo es rmc.vb o rmc.cs.Assume that the filename for this example is rmc.vb or rmc.cs. Copie el siguiente código fuente en un archivo.Copy the following source code into a file. A continuación, compilarlo e incrustar el archivo de recursos del ensamblado principal, rmc.resources, en el ensamblado ejecutable.Then compile it and embed the main assembly resource file, rmc.resources, in the executable assembly. Si usa el compilador de Visual Basic, la sintaxis es:If you are using the Visual Basic compiler, the syntax is:

    vbc rmc.vb /resource:rmc.resources  
    

    La sintaxis para el compilador de C# correspondiente es:The corresponding syntax for the C# compiler is:

    csc /resource:rmc.resources rmc.cs  
    
  7. Use la Assembly Linker para crear un ensamblado satélite.Use the Assembly Linker to create a satellite assembly. Si el nombre de base de la aplicación es rmc, el nombre del ensamblado satélite debe ser rmc.resources.dll.If the base name of the app is rmc, the satellite assembly name must be rmc.resources.dll. El ensamblado satélite debe crearse en el directorio es-MX.The satellite assembly should be created in the es-MX directory. Si es-MX es el directorio actual, use este comando:If es-MX is the current directory, use this command:

    al /embed:rmc.es-MX.resources /c:es-MX /out:rmc.resources.dll   
    
  8. Ejecute rmc.exe para obtener y mostrar las cadenas de recursos incrustado.Run rmc.exe to obtain and display the embedded resource strings.

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

class Example 
{
    public static void Main() 
    {
    string day;
    string year;
    string holiday;
    string celebrate = "{0} will occur on {1} in {2}.\n";

    // Create a resource manager. 
    ResourceManager rm = new ResourceManager("rmc", 
                             typeof(Example).Assembly);

    Console.WriteLine("Obtain resources using the current UI culture.");

    // Get the resource strings for the day, year, and holiday 
    // using the current UI culture. 
    day  = rm.GetString("day");
    year = rm.GetString("year");
    holiday = rm.GetString("holiday");
    Console.WriteLine(celebrate, holiday, day, year);

    // Obtain the es-MX culture.
    CultureInfo ci = new CultureInfo("es-MX");

    Console.WriteLine("Obtain resources using the es-MX culture.");

   // Get the resource strings for the day, year, and holiday 
   // using the specified culture. 
    day  = rm.GetString("day", ci);
    year = rm.GetString("year", ci);
    holiday = rm.GetString("holiday", ci);
// ---------------------------------------------------------------
// Alternatively, comment the preceding 3 code statements and 
// uncomment the following 4 code statements:
// ----------------------------------------------------------------
// Set the current UI culture to "es-MX" (Spanish-Mexico).
//    Thread.CurrentThread.CurrentUICulture = ci;

// Get the resource strings for the day, year, and holiday 
// using the current UI culture. Use those strings to 
// display a message. 
//    day  = rm.GetString("day");
//    year = rm.GetString("year");
//    holiday = rm.GetString("holiday");
// ---------------------------------------------------------------

// Regardless of the alternative that you choose, display a message 
// using the retrieved resource strings.
    Console.WriteLine(celebrate, holiday, day, year);
    }
}
/*
This example displays the following output:

   Obtain resources using the current UI culture.
   "5th of May" will occur on Friday in 2006.
   
   Obtain resources using the es-MX culture.
   "Cinco de Mayo" will occur on Viernes in 2006.
*/
Imports System.Resources
Imports System.Reflection
Imports System.Threading
Imports System.Globalization

Class Example
    Public Shared Sub Main() 
        Dim day As String
        Dim year As String
        Dim holiday As String
        Dim celebrate As String = "{0} will occur on {1} in {2}." & vbCrLf

        ' Create a resource manager. 
        Dim rm As New ResourceManager("rmc", GetType(Example).Assembly)

        Console.WriteLine("Obtain resources using the current UI culture.")

        ' Get the resource strings for the day, year, and holiday 
        ' using the current UI culture. 
        day = rm.GetString("day")
        year = rm.GetString("year")
        holiday = rm.GetString("holiday")
        Console.WriteLine(celebrate, holiday, day, year)

        ' Obtain the es-MX culture.
        Dim ci As New CultureInfo("es-MX")

        Console.WriteLine("Obtain resources using the es-MX culture.")

        ' Get the resource strings for the day, year, and holiday 
        ' using the es-MX culture.  
        day = rm.GetString("day", ci)
        year = rm.GetString("year", ci)
        holiday = rm.GetString("holiday", ci)

        ' ---------------------------------------------------------------
        ' Alternatively, comment the preceding 3 code statements and 
        ' uncomment the following 4 code statements:
        ' ----------------------------------------------------------------
        ' Set the current UI culture to "es-MX" (Spanish-Mexico).
        '    Thread.CurrentThread.CurrentUICulture = ci
        ' Get the resource strings for the day, year, and holiday 
        ' using the current UI culture. 
        '    day  = rm.GetString("day")
        '    year = rm.GetString("year")
        '    holiday = rm.GetString("holiday")
        ' ---------------------------------------------------------------

        ' Regardless of the alternative that you choose, display a message 
        ' using the retrieved resource strings.
        Console.WriteLine(celebrate, holiday, day, year)
    End Sub 
End Class
' This example displays the following output:
'Obtain resources using the current UI culture.
'"5th of May" will occur on Friday in 2006.
'
'Obtain resources using the es-MX culture.
'"Cinco de Mayo" will occur on Viernes in 2006.

Remarks

Importante

Llamar a métodos de esta clase con datos que no son de confianza supone un riesgo de seguridad.Calling methods from this class with untrusted data is a security risk. Llame a los métodos de esta clase solo con datos de confianza.Call the methods from this class only with trusted data. Para obtener más información, vea Data Validation (Validación de datos).For more information, see Data Validation.

La ResourceManager clase recupera los recursos desde un archivo .resources binario que se incrusta en un ensamblado o desde un archivo .resources independiente.The ResourceManager class retrieves resources from a binary .resources file that is embedded in an assembly or from a standalone .resources file. Si se ha localizado una aplicación y se han implementado los recursos localizados en ensamblados satélite, busca recursos específicos de la referencia cultural, que proporciona recursos de reserva cuando no existe un recurso localizado y es compatible con recursos serialización.If an app has been localized and localized resources have been deployed in satellite assemblies, it looks up culture-specific resources, provides resource fallback when a localized resource does not exist, and supports resource serialization.

Para obtener más información sobre cómo crear y administrar recursos en aplicaciones de escritorio y Tienda Windows 8.xWindows 8.x Store las aplicaciones, consulte las secciones siguientes:For more information about creating and managing resources in desktop apps and Tienda Windows 8.xWindows 8.x Store apps, see the following sections:

Aplicaciones de escritorioDesktop Apps

Para aplicaciones de escritorio, la ResourceManager clase recupera los recursos de archivos de recursos binario (.resources).For desktop apps, the ResourceManager class retrieves resources from binary resource (.resources) files. Normalmente, un compilador de lenguaje o la Assembly Linker (AL.exe) inserta estos archivos de recursos en un ensamblado.Typically, a language compiler or the Assembly Linker (AL.exe) embeds these resource files in an assembly. También puede usar un ResourceManager objeto para recuperar recursos directamente desde un archivo .resources que no se incrusta en un ensamblado, mediante una llamada a la CreateFileBasedResourceManager método.You can also use a ResourceManager object to retrieve resources directly from a .resources file that is not embedded in an assembly, by calling the CreateFileBasedResourceManager method.

Precaución

Uso de archivos .resources independientes en una aplicación ASP.NET interrumpirá la implementación de XCOPY, ya que los recursos permanecerán bloqueados hasta que se libere explícitamente el ReleaseAllResources método.Using standalone .resources files in an ASP.NET app will break XCOPY deployment, because the resources remain locked until they are explicitly released by the ReleaseAllResources method. Si desea implementar los recursos con las aplicaciones de ASP.NET, debe compilar los archivos .resources en ensamblados satélite.If you want to deploy resources with your ASP.NET apps, you should compile your .resources files into satellite assemblies.

En una aplicación basada en recursos, un archivo .resources contiene los recursos de la referencia cultural predeterminada cuyos recursos se usan si no se encuentra ningún recurso de la referencia cultural específica.In a resource-based app, one .resources file contains the resources of the default culture whose resources are used if no culture-specific resources can be found. Por ejemplo, si la referencia cultural predeterminada de una aplicación es inglés (en), los recursos de idioma inglés se usan siempre que no se puede encontrar los recursos localizados para una referencia cultural concreta, como inglés (Estados Unidos) (en-US) o francés (Francia) (fr-FR).For example, if an app's default culture is English (en), the English language resources are used whenever localized resources cannot be found for a specific culture, such as English (United States) (en-US) or French (France) (fr-FR). Normalmente, los recursos de la referencia cultural predeterminada se incrustan en el ensamblado de aplicación principal y los recursos para otras referencias culturales incrustados en ensamblados satélite.Typically, the resources for the default culture are embedded in the main app assembly, and resources for other localized cultures are embedded in satellite assemblies. Los ensamblados satélite contienen únicamente los recursos.Satellite assemblies contain only resources. Tienen el mismo nombre de archivo raíz como el ensamblado principal y una extensión de. resources.dll.They have the same root file name as the main assembly and an extension of .resources.dll. Para las aplicaciones cuyos ensamblados no están registrados en la caché global de ensamblados, los ensamblados satélite se almacenan en un subdirectorio de la aplicación cuyo nombre se corresponde con la referencia cultural del ensamblado.For apps whose assemblies are not registered in the global assembly cache, satellite assemblies are stored in an app subdirectory whose name corresponds to the assembly's culture.

Creación de recursosCreating Resources

Al desarrollar una aplicación basada en recursos, almacenar información de recursos en archivos de texto (archivos que tienen una extensión .txt o .restext) o archivos XML (archivos que tienen la extensión .resx).When you develop a resource-based app, you store resource information in text files (files that have a .txt or .restext extension) or XML files (files that have a .resx extension). A continuación, compila el texto o archivos XML con el generador de archivos de recursos (Resgen.exe) para crear un archivo .resources binario.You then compile the text or XML files with the Resource File Generator (Resgen.exe) to create a binary .resources file. A continuación, puede incrustar el archivo .resources resultante en un archivo ejecutable o biblioteca mediante una opción del compilador, como /resources para los compiladores de C# y Visual Basic, o bien puede insertarlo en un ensamblado satélite mediante el.You can then embed the resulting .resources file in an executable or library by using a compiler option such as /resources for the C# and Visual Basic compilers, or you can embed it in a satellite assembly by using the . Si incluye un archivo .resx en el proyecto de Visual Studio, Visual Studio controla la compilación y la incrustación de forma predeterminada y los recursos localizados automáticamente como parte del proceso de compilación.If you include a .resx file in your Visual Studio project, Visual Studio handles the compilation and embedding of default and localized resources automatically as part of the build process.

Idealmente, debe crear los recursos para cada idioma de la aplicación es compatible con, o al menos para un subconjunto significativo de cada idioma.Ideally, you should create resources for every language your app supports, or at least for a meaningful subset of each language. Los nombres de archivo .resources binario siguen la convención de nomenclatura basename.* cultureName*.resources, donde basename es el nombre de la aplicación o el nombre de una clase, según el nivel de detalle que desee.The binary .resources file names follow the naming convention basename.cultureName.resources, where basename is the name of the app or the name of a class, depending on the level of detail you want. El CultureInfo.Name propiedad se utiliza para determinar cultureName.The CultureInfo.Name property is used to determine cultureName. Un recurso para la referencia cultural predeterminada de la aplicación debe denominarse basenameResources.A resource for the app's default culture should be named basename.resources.

Por ejemplo, supongamos que un ensamblado tiene varios recursos en un archivo de recursos que tiene el nombre base MyResources.For example, suppose that an assembly has several resources in a resource file that has the base name MyResources. Estos archivos de recursos deberían tener nombres como MyResources.ja JP.resources la referencia cultural japonés (Japón), MyResources.de.resources para la referencia cultural de alemán, MyResources.zh-CHS.resources la referencia cultural chino simplificado, y MyResources.fr-BE.resources para la referencia cultural de francés (Bélgica).These resource files should have names such as MyResources.ja-JP.resources for the Japan (Japanese) culture, MyResources.de.resources for the German culture, MyResources.zh-CHS.resources for the simplified Chinese culture, and MyResources.fr-BE.resources for the French (Belgium) culture. El archivo de recursos predeterminado debe ser denominado.The default resource file should be named MyResources.resources. Normalmente, los archivos de recursos específicos de referencias culturales se empaquetan en ensamblados satélite para cada referencia cultural.The culture-specific resource files are commonly packaged in satellite assemblies for each culture. El archivo de recursos predeterminado se debe incrustar en el ensamblado principal de la aplicación.The default resource file should be embedded in the app's main assembly.

Tenga en cuenta que permite que los recursos esté marcado como privado, pero siempre debe marcarlas como públicas por lo que se puede acceder a otros ensamblados.Note that allows resources to be marked as private, but you should always mark them as public so they can be accessed by other assemblies. (Dado que un ensamblado satélite no contiene código, los recursos que están marcados como privados no están disponibles a la aplicación mediante cualquier mecanismo.)(Because a satellite assembly contains no code, resources that are marked as private are unavailable to your app through any mechanism.)

Para obtener más información sobre la creación, empaquetado e implementación de recursos, consulte los artículos crear archivos de recursos, crear ensamblados satélite, y empaquetar e implementar Recursos.For more information about creating, packaging, and deploying resources, see the articles Creating Resource Files, Creating Satellite Assemblies, and Packaging and Deploying Resources.

Instancias de un objeto ResourceManagerInstantiating a ResourceManager Object

Crea instancias de un ResourceManager objeto que recupera los recursos de un archivo .resources incrustado llamando a uno de sus sobrecargas del constructor de clase.You instantiate a ResourceManager object that retrieves resources from an embedded .resources file by calling one of its class constructor overloads. Esto se acople estrechamente una ResourceManager objeto con un archivo .resources concreto y con cualquier asociado localizar archivos .resources en ensamblados satélite.This tightly couples a ResourceManager object with a particular .resources file and with any associated localized .resources files in satellite assemblies.

Los dos constructores llamados con más frecuencia son:The two most commonly called constructors are:

  • ResourceManager(String, Assembly) busca recursos en función de los dos fragmentos de información que proporcione: el nombre base del archivo .resources y el ensamblado en el que reside el archivo .resources predeterminado.ResourceManager(String, Assembly) looks up resources based on two pieces of information that you supply: the base name of the .resources file, and the assembly in which the default .resources file resides. El nombre base incluye el nombre raíz y espacio de nombres del archivo .resources, sin su referencia cultural o la extensión.The base name includes the namespace and root name of the .resources file, without its culture or extension. Tenga en cuenta que los archivos .resources que se compilan a partir de la línea de comandos normalmente no incluyen un espacio de nombres, mientras que los archivos .resources que se crean en el entorno de Visual Studio lo hacen.Note that .resources files that are compiled from the command line typically do not include a namespace name, whereas .resources files that are created in the Visual Studio environment do. Por ejemplo, si un archivo de recursos se denomina MyCompany.StringResources.resources y ResourceManager constructor se llama desde un método estático denominado Example.Main, el código siguiente crea una instancia un ResourceManager objeto que puede recuperar recursos desde el. archivo de recursos:For example, if a resource file is named MyCompany.StringResources.resources and the ResourceManager constructor is called from a static method named Example.Main, the following code instantiates a ResourceManager object that can retrieve resources from the .resources file:

    ResourceManager rm = new ResourceManager("MyCompany.StringResources", 
                                             typeof(Example).Assembly);
    
    Dim rm As New ResourceManager("MyCompany.StringResources",
                                  GetType(Example).Assembly)
    
  • ResourceManager(Type) busca recursos en ensamblados satélite según la información de un objeto de tipo.ResourceManager(Type) looks up resources in satellite assemblies based on information from a type object. Nombre completo del tipo corresponde al nombre base del archivo .resources sin la extensión de nombre de archivo.The type's fully qualified name corresponds to the base name of the .resources file without its file name extension. En las aplicaciones de escritorio que se crean mediante el Diseñador de recursos de Visual Studio, Visual Studio crea una clase de contenedor cuyo nombre completo es el mismo que el nombre de la raíz del archivo .resources.In desktop apps that are created by using the Visual Studio Resource Designer, Visual Studio creates a wrapper class whose fully qualified name is the same as the root name of the .resources file. Por ejemplo, si un archivo de recursos se denomina MyCompany.StringResources.resources y hay una clase contenedora denominada MyCompany.StringResources, el código siguiente crea una instancia de un ResourceManager objeto que puede recuperar recursos desde el archivo .resources:For example, if a resource file is named MyCompany.StringResources.resources and there is a wrapper class named MyCompany.StringResources, the following code instantiates a ResourceManager object that can retrieve resources from the .resources file:

    ResourceManager rm = new ResourceManager(typeof(MyCompany.StringResources));
    
    Dim rm As New ResourceManager(GetType(MyCompany.StringResources))
    

Si no se encuentra los recursos adecuados, la llamada al constructor crea un válido ResourceManager objeto.If the appropriate resources cannot be found, the constructor call creates a valid ResourceManager object. Sin embargo, el intento de recuperar un recurso produce un MissingManifestResourceException excepción.However, the attempt to retrieve a resource throws a MissingManifestResourceException exception. Para obtener información sobre cómo tratar con la excepción, vea el control MissingManifestResourceException y excepciones MissingSatelliteAssembly sección más adelante en este artículo.For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssembly Exceptions section later in this article.

El ejemplo siguiente muestra cómo crear una instancia de un ResourceManager objeto.The following example shows how to instantiate a ResourceManager object. Contiene el código fuente para un archivo ejecutable denominado ShowTime.exe.It contains the source code for an executable named ShowTime.exe. También incluye el siguiente archivo de texto denominado Strings.txt que contiene un recurso de cadena único, TimeHeader:It also includes the following text file named Strings.txt that contains a single string resource, TimeHeader:

TimeHeader=The current time is  

Puede usar un archivo por lotes para generar el archivo de recursos e insertarlo en el archivo ejecutable.You can use a batch file to generate the resource file and embed it into the executable. Este es el archivo por lotes para generar un archivo ejecutable con el compilador de C#:Here's the batch file to generate an executable by using the C# compiler:


resgen strings.txt  
csc ShowTime.cs /resource:strings.resources  

Para el compilador de Visual Basic, puede usar el siguiente archivo por lotes:For the Visual Basic compiler, you can use the following batch file:


resgen strings.txt  
vbc ShowTime.vb /resource:strings.resources  
using System;
using System.Resources;

public class Example
{
   public static void Main()
   {
      ResourceManager rm = new ResourceManager("Strings", 
                               typeof(Example).Assembly);
      string timeString = rm.GetString("TimeHeader");
      Console.WriteLine("{0} {1:T}", timeString, DateTime.Now);   
   }
}
// The example displays output like the following:
//        The current time is 2:03:14 PM
Imports System.Resources

Module Example
   Public Sub Main()
      Dim rm As New ResourceManager("Strings", GetType(Example).Assembly)
      Dim timeString As String = rm.GetString("TimeHeader")
      Console.WriteLine("{0} {1:T}", timeString, Date.Now)   
   End Sub
End Module
' The example displays output similar to the following:
'       The current time is 2:03:14 PM

ResourceManager y recursos específicos de la referencia culturalResourceManager and Culture-Specific Resources

Una aplicación localizada requiere recursos para su implementación, como se describe en el artículo empaquetar e implementar recursos.A localized app requires resources to be deployed, as discussed in the article Packaging and Deploying Resources. Si los ensamblados se han configurado correctamente, el Administrador de recursos determina qué recursos recuperar basan en el subproceso actual Thread.CurrentUICulture propiedad.If the assemblies are properly configured, the resource manager determines which resources to retrieve based on the current thread's Thread.CurrentUICulture property. (Esa propiedad también devuelve referencia cultural de interfaz de usuario del subproceso actual). Por ejemplo, si una aplicación se compila con de forma predeterminada los recursos de idioma inglés en el ensamblado principal y con recursos de idioma de francés y ruso en dos ensamblados satélite y el Thread.CurrentUICulture propiedad se establece en fr-FR, el Administrador de recursos recupera el francés recursos.(That property also returns the current thread's UI culture.) For example, if an app is compiled with default English language resources in the main assembly and with French and Russian language resources in two satellite assemblies, and the Thread.CurrentUICulture property is set to fr-FR, the resource manager retrieves the French resources.

Puede establecer el CurrentUICulture propiedad explícita o implícitamente.You can set the CurrentUICulture property explicitly or implicitly. Determina la forma en que se establece el modo ResourceManager objeto recupera los recursos basados en la referencia cultural:The way you set it determines how the ResourceManager object retrieves resources based on culture:

  • Si se establece explícitamente el Thread.CurrentUICulture propiedad a una referencia cultural específica, el Administrador de recursos siempre recupera los recursos para esa referencia cultural, independientemente del lenguaje de sistema operativo o explorador del usuario.If you explicitly set the Thread.CurrentUICulture property to a specific culture, the resource manager always retrieves the resources for that culture, regardless of the user's browser or operating system language. Considere la posibilidad de una aplicación que se compila con los recursos del idioma inglés de forma predeterminada y tres ensamblados satélite que contienen los recursos para inglés (Estados Unidos), francés (Francia) y ruso (Rusia).Consider an app that is compiled with default English language resources and three satellite assemblies that contain resources for English (United States), French (France), and Russian (Russia). Si el CurrentUICulture propiedad se establece en fr-FR, el ResourceManager objeto siempre recupera los recursos de francés (Francia), incluso si el usuario operativo del idioma del sistema no es el francés.If the CurrentUICulture property is set to fr-FR, the ResourceManager object always retrieves the French (France) resources, even if the user's operating system language is not French. Asegúrese de que es el comportamiento deseado antes de establecer la propiedad explícitamente.Make sure that this is the desired behavior before you set the property explicitly.

    En las aplicaciones ASP.NET, debe establecer el Thread.CurrentUICulture propiedad explícitamente, porque es improbable que la configuración del servidor coincida con las solicitudes de cliente entrantes.In ASP.NET apps, you must set the Thread.CurrentUICulture property explicitly, because it is unlikely that the setting on the server will match incoming client requests. Una aplicación ASP.NET puede establecer la Thread.CurrentUICulture idioma aceptado por la propiedad explícitamente para el explorador del usuario.An ASP.NET app can set the Thread.CurrentUICulture property explicitly to the user's browser accept language.

    De forma explícita el Thread.CurrentUICulture propiedad define la referencia cultural de interfaz de usuario actual para ese subproceso.Explicitly setting the Thread.CurrentUICulture property defines the current UI culture for that thread. No afecta a la actual referencia cultural de interfaz de usuario de cualquier otro subproceso en una aplicación.It does not affect the current UI culture of any other threads in an app.

  • Puede establecer la referencia cultural de interfaz de usuario de todos los subprocesos en un dominio de aplicación mediante la asignación de un CultureInfo objeto que representa esa referencia cultural estático CultureInfo.DefaultThreadCurrentUICulture propiedad.You can set the UI culture of all threads in an app domain by assigning a CultureInfo object that represents that culture to the static CultureInfo.DefaultThreadCurrentUICulture property.

  • Si no establece explícitamente la referencia cultural de interfaz de usuario actual y no se define una referencia cultural predeterminada para el dominio de aplicación actual, el CultureInfo.CurrentUICulture propiedad se establece implícitamente por el Windows GetUserDefaultUILanguage función.If you do not explicitly set the current UI culture and you do not define a default culture for the current app domain, the CultureInfo.CurrentUICulture property is set implicitly by the Windows GetUserDefaultUILanguage function. Esta función se proporciona por la interfaz de usuario multilingüe (MUI), lo que permite al usuario establecer el idioma predeterminado.This function is provided by the Multilingual User Interface (MUI), which enables the user to set the default language. Si no se establece el idioma de interfaz de usuario por el usuario, el valor predeterminado es el idioma instalado por el sistema, que es el idioma de recursos del sistema operativo.If the UI language is not set by the user, it defaults to the system-installed language, which is the language of operating system resources.

El siguiente ejemplo simple "Hola mundo" establece explícitamente la referencia cultural de interfaz de usuario actual.The following simple "Hello world" example sets the current UI culture explicitly. Contiene recursos para tres referencias culturales: inglés (Estados Unidos) o en-US, francés (Francia) o fr-FR y ruso (Rusia) o ru-RU.It contains resources for three cultures: English (United States) or en-US, French (France) or fr-FR, and Russian (Russia) or ru-RU. Los recursos en-US se incluyen en un archivo de texto denominado Greetings.txt:The en-US resources are contained in a text file named Greetings.txt:

HelloString=Hello world!  

Contenidos en un archivo de texto denominado Greetings.fr los recursos de fr-FR-fr. txt:The fr-FR resources are contained in a text file named Greetings.fr-FR.txt:

HelloString=Salut tout le monde!  

Contenidos en un archivo de texto denominado Greetings.ru los recursos de ru-RU-RU. txt:The ru-RU resources are contained in a text file named Greetings.ru-RU.txt:

HelloString=Всем привет!  

Este es el código fuente para el ejemplo (Example.vb para la versión de Visual Basic) o Example.cs para la versión de C#:Here's the source code for the example (Example.vb for the Visual Basic version or Example.cs for the C# version):

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

public class Example
{
   public static void Main()
   {
      // Create array of supported cultures
      string[] cultures = {"en-CA", "en-US", "fr-FR", "ru-RU" };
      Random rnd = new Random();
      int cultureNdx = rnd.Next(0, cultures.Length);
      CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
      ResourceManager rm = new ResourceManager("Greetings", typeof(Example).Assembly);
      try {
         CultureInfo newCulture = new CultureInfo(cultures[cultureNdx]);
         Thread.CurrentThread.CurrentCulture = newCulture;
         Thread.CurrentThread.CurrentUICulture = newCulture;
         string greeting = String.Format("The current culture is {0}.\n{1}",
                                         Thread.CurrentThread.CurrentUICulture.Name,
                                         rm.GetString("HelloString"));
         Console.WriteLine(greeting);
      }
      catch (CultureNotFoundException e) {
         Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName);
      }
      finally {
         Thread.CurrentThread.CurrentCulture = originalCulture;
         Thread.CurrentThread.CurrentUICulture = originalCulture;
      }
   }
}
// The example displays output like the following:
//       The current culture is ru-RU.
//       Всем привет!
Imports System.Globalization
Imports System.Resources
Imports System.Threading

Module Example
   Sub Main()
      ' Create array of supported cultures
      Dim cultures() As String = {"en-CA", "en-US", "fr-FR", "ru-RU" }
      Dim rnd As New Random()
      Dim cultureNdx As Integer = rnd.Next(0, cultures.Length)
      Dim originalCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
      Dim rm As New ResourceManager("Greetings", GetType(Example).Assembly)
      Try
         Dim newCulture As New CultureInfo(cultures(cultureNdx))
         Thread.CurrentThread.CurrentCulture = newCulture
         Thread.CurrentThread.CurrentUICulture = newCulture
         Dim greeting As String = String.Format("The current culture is {0}.{1}{2}",
                                                Thread.CurrentThread.CurrentUICulture.Name,
                                                vbCrLf, rm.GetString("HelloString"))

         Console.WriteLine(greeting)
      Catch e As CultureNotFoundException
         Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName)
      Finally
         Thread.CurrentThread.CurrentCulture = originalCulture
         Thread.CurrentThread.CurrentUICulture = originalCulture
      End Try
   End Sub
End Module
' The example displays output like the following:
'       The current culture is ru-RU.
'       Всем привет!

Para compilar este ejemplo, cree un archivo por lotes (.bat) que contiene los siguientes comandos y ejecutarlo desde el símbolo del sistema.To compile this example, create a batch (.bat) file that contains the following commands and run it from the command prompt. Si usa C#, especifique csc en lugar de vbc y Example.cs en lugar de Example.vb.If you're using C#, specify csc instead of vbc and Example.cs instead of Example.vb.

resgen Greetings.txt   
vbc Example.vb /resource:Greetings.resources  

resgen Greetings.fr-FR.txt  
Md fr-FR  
al /embed:Greetings.fr-FR.resources /culture:fr-FR /out:fr-FR\Example.resources.dll  

resgen Greetings.ru-RU.txt  
Md ru-RU  
al /embed:Greetings.ru-RU.resources /culture:ru-RU /out:ru-RU\Example.resources.dll  

Recuperar recursosRetrieving Resources

Se llama a la GetObject(String) y GetString(String) métodos para tener acceso a un recurso específico.You call the GetObject(String) and GetString(String) methods to access a specific resource. También puede llamar a la GetStream(String) método para recuperar los recursos que no son de cadena como una matriz de bytes.You can also call the GetStream(String) method to retrieve non-string resources as a byte array. De forma predeterminada, en una aplicación que ha localizado a los recursos, estos métodos devuelven el recurso para la referencia cultural determinada por la referencia cultural de interfaz de usuario actual del subproceso que realizó la llamada.By default, in an app that has localized resources, these methods return the resource for the culture determined by the current UI culture of the thread that made the call. Consulte la sección anterior, ResourceManager y recursos específicos de la referencia cultural, para obtener más información acerca de cómo se define la referencia cultural de interfaz de usuario actual de un subproceso.See the previous section, ResourceManager and Culture-Specific Resources, for more information about how the current UI culture of a thread is defined. Si el Administrador de recursos no encuentra el recurso para la referencia cultural de interfaz de usuario del subproceso actual, utiliza un proceso de reserva para recuperar el recurso especificado.If the resource manager cannot find the resource for the current thread's UI culture, it uses a fallback process to retrieve the specified resource. Si el Administrador de recursos no puede encontrar los recursos adaptados, usa los recursos de la referencia cultural predeterminada.If the resource manager cannot find any localized resources, it uses the resources of the default culture. Para obtener más información acerca de las reglas de reserva de recursos, consulte la sección "Proceso de reserva de recursos" del artículo empaquetar e implementar recursos.For more information about resource fallback rules, see the "Resource Fallback Process" section of the article Packaging and Deploying Resources.

Nota

Si el archivo .resources especificado en el ResourceManager no se encuentra el constructor de clase, el intento de recuperar un recurso produce una MissingManifestResourceException o MissingSatelliteAssemblyException excepción.If the .resources file specified in the ResourceManager class constructor cannot be found, the attempt to retrieve a resource throws a MissingManifestResourceException or MissingSatelliteAssemblyException exception. Para obtener información sobre cómo tratar con la excepción, vea el control MissingManifestResourceException y MissingSatelliteAssemblyException excepciones sección más adelante en este tema.For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions section later in this topic.

En el ejemplo siguiente se usa el GetString método para recuperar recursos específicos de la referencia cultural.The following example uses the GetString method to retrieve culture-specific resources. Consta de los recursos compilados desde archivos .txt de inglés (en), francés (Francia) (fr-FR) y ruso (Rusia) (ru-RU), las referencias culturales.It consists of resources compiled from .txt files for the English (en), French (France) (fr-FR), and Russian (Russia) (ru-RU) cultures. El ejemplo cambia la referencia cultural actual y la referencia cultural de interfaz de usuario actual para inglés (Estados Unidos), francés (Francia), ruso (Rusia) y sueco (Suecia).The example changes the current culture and current UI culture to English (United States), French (France), Russian (Russia), and Swedish (Sweden). A continuación, llama el GetString método para recuperar la cadena localizada, que muestra junto con el día actual y el mes.It then calls the GetString method to retrieve the localized string, which it displays along with the current day and month. Observe que la salida muestra la cadena localizada adecuada, excepto cuando la referencia cultural de interfaz de usuario actual es Sueco (Suecia).Notice that the output displays the appropriate localized string except when the current UI culture is Swedish (Sweden). Dado que no están disponibles los recursos de idioma sueco, la aplicación en su lugar, usa los recursos de la referencia cultural predeterminada, que es el inglés.Because Swedish language resources are unavailable, the app instead uses the resources of the default culture, which is English.

El ejemplo requiere los archivos de recursos basado en texto aparece en la tabla siguiente.The example requires the text-based resource files listed in following table. Cada uno tiene un recurso de cadena único llamado DateStart.Each has a single string resource named DateStart.

Referencia culturalCulture Nombre del archivoFile name Nombre del recursoResource name Valor del recursoResource value
en-USen-US DateStrings.txtDateStrings.txt DateStart Hoy esToday is
fr-FRfr-FR DateStrings.fr-FR.txtDateStrings.fr-FR.txt DateStart Aujourd'hui, le c'estAujourd'hui, c'est le
ru-RUru-RU DateStrings.ru-RU. txtDateStrings.ru-RU.txt DateStart СЕГОДНЯСегодня

Este es el código fuente para el ejemplo (ShowDate.vb para la versión de Visual Basic) o ShowDate.cs para la versión de C# del código.Here's the source code for the example (ShowDate.vb for the Visual Basic version or ShowDate.cs for the C# version of the code).

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

[assembly:NeutralResourcesLanguage("en")]

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "ru-RU", "sv-SE" };
      ResourceManager rm = new ResourceManager("DateStrings",
                                               typeof(Example).Assembly);
      
      foreach (var cultureName in cultureNames) {
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         Thread.CurrentThread.CurrentCulture = culture; 
         Thread.CurrentThread.CurrentUICulture = culture;

         Console.WriteLine("Current UI Culture: {0}", 
                           CultureInfo.CurrentUICulture.Name);
         string dateString = rm.GetString("DateStart");
         Console.WriteLine("{0} {1:M}.\n", dateString, DateTime.Now);                           
      }                                           
   }
}
// The example displays output similar to the following:
//       Current UI Culture: en-US
//       Today is February 03.
//       
//       Current UI Culture: fr-FR
//       Aujourd'hui, c'est le 3 février
//       
//       Current UI Culture: ru-RU
//       Сегодня февраля 03.
//       
//       Current UI Culture: sv-SE
//       Today is den 3 februari.
Imports System.Globalization
Imports System.Resources
Imports System.Threading

<Assembly:NeutralResourcesLanguage("en")>

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "ru-RU", "sv-SE" }
      Dim rm As New ResourceManager("DateStrings",
                                    GetType(Example).Assembly)
      
      For Each cultureName In cultureNames
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Thread.CurrentThread.CurrentCulture = culture 
         Thread.CurrentThread.CurrentUICulture = culture

         Console.WriteLine("Current UI Culture: {0}", 
                           CultureInfo.CurrentUICulture.Name)
         Dim dateString As String = rm.GetString("DateStart")
         Console.WriteLine("{0} {1:M}.", dateString, Date.Now)                           
         Console.WriteLine()
      Next                                           
   End Sub
End Module
' The example displays output similar to the following:
'       Current UI Culture: en-US
'       Today is February 03.
'       
'       Current UI Culture: fr-FR
'       Aujourd'hui, c'est le 3 février
'       
'       Current UI Culture: ru-RU
'       Сегодня февраля 03.
'       
'       Current UI Culture: sv-SE
'       Today is den 3 februari.

Para compilar este ejemplo, cree un archivo por lotes que contiene los siguientes comandos y ejecutarlo desde el símbolo del sistema.To compile this example, create a batch file that contains the following commands and run it from the command prompt. Si usa C#, especifique csc en lugar de vbc y showdate.cs en lugar de showdate.vb.If you're using C#, specify csc instead of vbc and showdate.cs instead of showdate.vb.


resgen DateStrings.txt  
vbc showdate.vb /resource:DateStrings.resources  

md fr-FR  
resgen DateStrings.fr-FR.txt  
al /out:fr-FR\Showdate.resources.dll /culture:fr-FR /embed:DateStrings.fr-FR.resources   

md ru-RU  
resgen DateStrings.ru-RU.txt  
al /out:ru-RU\Showdate.resources.dll /culture:ru-RU /embed:DateStrings.ru-RU.resources  

Hay dos maneras de recuperar los recursos de una referencia cultural que no sea la actual referencia cultural de interfaz de usuario:There are two ways to retrieve the resources of a specific culture other than the current UI culture:

  • Puede llamar a la GetString(String, CultureInfo), GetObject(String, CultureInfo), o GetStream(String, CultureInfo) método para recuperar un recurso para una referencia cultural concreta.You can call the GetString(String, CultureInfo), GetObject(String, CultureInfo), or GetStream(String, CultureInfo) method to retrieve a resource for a specific culture. Si no se encuentra un recurso localizado, el Administrador de recursos usa el proceso de reserva de recursos para buscar un recurso adecuado.If a localized resource cannot be found, the resource manager uses the resource fallback process to locate an appropriate resource.

  • Puede llamar a la GetResourceSet método para obtener un ResourceSet objeto que representa los recursos para una referencia cultural determinada.You can call the GetResourceSet method to obtain a ResourceSet object that represents the resources for a particular culture. En la llamada al método, puede determinar si el Administrador de recursos busca las referencias culturales del elemento primario si no puede encontrar los recursos localizados, o si simplemente recurre a los recursos de la referencia cultural predeterminada.In the method call, you can determine whether the resource manager probes for parent cultures if it is unable to find localized resources, or whether it simply falls back to the resources of the default culture. A continuación, puede usar el ResourceSet métodos para tener acceso a los recursos (adaptados para esa referencia cultural) por su nombre, o para enumerar los recursos en el conjunto.You can then use the ResourceSet methods to access the resources (localized for that culture) by name, or to enumerate the resources in the set.

Control MissingManifestResourceException y MissingSatelliteAssemblyException excepcionesHandling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions

Si se intenta recuperar un recurso específico, pero no se encuentra el Administrador de recursos que se ha definido ninguna referencia cultural de forma predeterminada y de recursos o los recursos de la referencia cultural predeterminada no se encuentra, se inicia el Administrador de recursos un MissingManifestResourceException excepción si se espera encontrar los recursos en el ensamblado principal o un MissingSatelliteAssemblyException si espera encontrar los recursos en un ensamblado satélite.If you try to retrieve a specific resource, but the resource manager cannot find that resource and either no default culture has been defined or the resources of the default culture cannot be located, the resource manager throws a MissingManifestResourceException exception if it expects to find the resources in the main assembly or a MissingSatelliteAssemblyException if it expects to find the resources in a satellite assembly. Tenga en cuenta que la excepción se produce cuando se llama a un método de recuperación de recursos, como GetString o GetObject, y no cuando cree una instancia un ResourceManager objeto.Note that the exception is thrown when you call a resource retrieval method such as GetString or GetObject, and not when you instantiate a ResourceManager object.

La excepción se produce normalmente en las siguientes condiciones:The exception is typically thrown under the following conditions:

  • No existe el ensamblado de archivo o satélite de recursos apropiado.The appropriate resource file or satellite assembly does not exist. Si el Administrador de recursos espera recursos de la aplicación predeterminada para incrustar en el ensamblado de aplicación principal, no aparecen.If the resource manager expects the app's default resources to be embedded in the main app assembly, they are absent. Si el NeutralResourcesLanguageAttribute atributo indica que los recursos predeterminados de la aplicación se encuentran en un ensamblado satélite, que no se encuentra el ensamblado.If the NeutralResourcesLanguageAttribute attribute indicates that the app's default resources reside in a satellite assembly, that assembly cannot be found. Cuando se compila la aplicación, asegúrese de que los recursos se incrustan en el ensamblado principal o que el ensamblado satélite necesario se genera y se denomina apropiadamente.When you compile your app, make sure that resources are embedded in the main assembly or that the necessary satellite assembly is generated and is named appropriately. Su nombre debe tener la forma appName. resources.dll y deben encontrarse en un directorio con el nombre de la referencia cultural cuyos recursos que contiene.Its name should take the form appName.resources.dll, and it should be located in a directory named after the culture whose resources it contains.

  • La aplicación no tiene un valor predeterminado o la referencia cultural neutra definido.Your app doesn't have a default or neutral culture defined. Agregar el NeutralResourcesLanguageAttribute atributo a un archivo de código fuente o al archivo de archivo (AssemblyInfo.vb para una aplicación de Visual Basic) o AssemblyInfo.cs para una aplicación de C# de información del proyecto.Add the NeutralResourcesLanguageAttribute attribute to a source code file or to the project information file (AssemblyInfo.vb for a Visual Basic app or AssemblyInfo.cs for a C# app) file.

  • El baseName parámetro en el ResourceManager(String, Assembly) constructor no especifica el nombre de un archivo .resources.The baseName parameter in the ResourceManager(String, Assembly) constructor does not specify the name of a .resources file. El nombre debe incluir el espacio de nombres completo del archivo de recursos, pero no su extensión de nombre de archivo.The name should include the resource file's fully qualified namespace but not its file name extension. Normalmente, los archivos de recursos que se crean en Visual Studio incluyen espacios de nombres, pero no los archivos de recursos que se crean y se compilan en el símbolo del sistema.Typically, resource files that are created in Visual Studio include namespace names, but resource files that are created and compiled at the command prompt do not. Puede determinar los nombres de archivos .resources insertados, compile y ejecute la siguiente utilidad.You can determine the names of embedded .resources files by compiling and running the following utility. Se trata de una aplicación de consola que acepta el nombre de un ensamblado principal o un ensamblado satélite como un parámetro de línea de comandos.This is a console app that accepts the name of a main assembly or satellite assembly as a command-line parameter. Muestra las cadenas que se deben proporcionar como el baseName parámetro para que el Administrador de recursos pueda identificar correctamente el recurso.It displays the strings that should be provided as the baseName parameter so that the resource manager can correctly identify the resource.

    using System;
    using System.IO;
    using System.Reflection;
    using System.Resources;
    
    public class Example
    {
       public static void Main()
       {
          if (Environment.GetCommandLineArgs().Length == 1) { 
             Console.WriteLine("No filename.");
             return;
          }
          
          string filename = Environment.GetCommandLineArgs()[1].Trim();
          // Check whether the file exists.
          if (! File.Exists(filename)) {
             Console.WriteLine("{0} does not exist.", filename);
             return;
          }   
          
          // Try to load the assembly.
          Assembly assem = Assembly.LoadFrom(filename);
          Console.WriteLine("File: {0}", filename);
             
          // Enumerate the resource files.
          string[] resNames = assem.GetManifestResourceNames();
          if (resNames.Length == 0)
             Console.WriteLine("   No resources found.");
    
          foreach (var resName in resNames)
             Console.WriteLine("   Resource: {0}", resName.Replace(".resources", ""));
    
          Console.WriteLine();
       }
    }
    
    Imports System.IO
    Imports System.Reflection
    Imports System.Resources
     
    Module Example
       Public Sub Main()
          If Environment.GetCommandLineArgs.Length = 1 Then 
             Console.WriteLine("No filename.")
             Exit Sub
          End If
          Dim filename As String = Environment.GetCommandLineArgs(1).Trim()
          ' Check whether the file exists.
          If Not File.Exists(filename) Then
             Console.WriteLine("{0} does not exist.", filename)
             Exit Sub
          End If   
          
          ' Try to load the assembly.
          Dim assem As Assembly = Assembly.LoadFrom(filename)
          Console.WriteLine("File: {0}", filename)
             
          ' Enumerate the resource files.
          Dim resNames() As String = assem.GetManifestResourceNames()
          If resNames.Length = 0 Then
             Console.WriteLine("   No resources found.")
          End If
          For Each resName In resNames
             Console.WriteLine("   Resource: {0}", resName.Replace(".resources", ""))
          Next
          Console.WriteLine()
       End Sub
    End Module
    

Si va a cambiar explícitamente la referencia cultural actual de la aplicación, también debe recordar que el Administrador de recursos recupera un conjunto de recursos en función del valor de la CultureInfo.CurrentUICulture propiedad y no el CultureInfo.CurrentCulture propiedad.If you are changing the current culture of your application explicitly, you should also remember that the resource manager retrieves a resource set based on the value of the CultureInfo.CurrentUICulture property, and not the CultureInfo.CurrentCulture property. Normalmente, si cambia un valor, también debe cambiar el otro.Typically, if you change one value, you should also change the other.

Control de versiones de recursosResource Versioning

Dado que el ensamblado principal que contiene los recursos predeterminados de una aplicación es independiente de los ensamblados satélite de la aplicación, puede liberar una nueva versión del ensamblado principal sin volver a implementar los ensamblados satélite.Because the main assembly that contains an app's default resources is separate from the app's satellite assemblies, you can release a new version of your main assembly without redeploying the satellite assemblies. Usa el SatelliteContractVersionAttribute atributo usar ensamblados satélite existentes e indicarle el Administrador de recursos no volver a implementarlos con una nueva versión del ensamblado principal,You use the SatelliteContractVersionAttribute attribute to use existing satellite assemblies and instruct the resource manager not to redeploy them with a new version of your main assembly,

Para obtener más información sobre la compatibilidad con control de versiones de los ensamblados satélite, vea el artículo recuperar recursos.For more information about versioning support for satellite assemblies, see the article Retrieving Resources.

<satelliteassemblies > nodo del archivo de configuración<satelliteassemblies> Configuration File Node

Para los archivos ejecutables que se implementan y ejecutan desde un sitio Web (archivos .exe HREF), el ResourceManager objeto puede sondear los ensamblados satélite a través de la web, que puede afectar negativamente al rendimiento de la aplicación.For executables that are deployed and run from a website (HREF .exe files), the ResourceManager object may probe for satellite assemblies over the web, which can hurt your app's performance. Para eliminar el problema de rendimiento, puede limitar este sondeo de los ensamblados satélite que haya implementado con la aplicación.To eliminate the performance problem, you can limit this probing to the satellite assemblies that you have deployed with your app. Para ello, se crea un <satelliteassemblies> nodo en el archivo de configuración de la aplicación para especificar que ha implementado un conjunto de referencias culturales específicas para la aplicación y que la ResourceManager no debe intentar que el objeto de sondeo para cualquier referencia cultural que no aparece en ese nodo.To do this, you create a <satelliteassemblies> node in your app's configuration file to specify that you have deployed a specific set of cultures for your app, and that the ResourceManager object should not try to probe for any culture that is not listed in that node.

Nota

La alternativa preferida a la creación de un <satelliteassemblies> nodo consiste en usar el del manifiesto de implementación ClickOnce característica.The preferred alternative to creating a <satelliteassemblies> node is to use the ClickOnce Deployment Manifest feature.

En el archivo de configuración de la aplicación, cree una sección similar al siguiente:In your app's configuration file, create a section similar to the following:

<?xml version ="1.0"?>  
<configuration>  
    <satelliteassemblies>  
        <assembly name="MainAssemblyName, Version=versionNumber, Culture=neutral, PublicKeyToken=null|yourPublicKeyToken">  
            <culture>cultureName1</culture>  
            <culture>cultureName2</culture>  
            <culture>cultureName3</culture>  
        </assembly>  
    </satelliteassemblies>  
</configuration>  

Edite esta información de configuración de la manera siguiente:Edit this configuration information as follows:

  • Especifique uno o más <assembly> nodos para cada ensamblado principal que implemente, donde cada nodo especifica un nombre completo del ensamblado.Specify one or more <assembly> nodes for each main assembly that you deploy, where each node specifies a fully qualified assembly name. Especifique el nombre del ensamblado principal en lugar de nombre de ensamblado principaly especifique el Version, PublicKeyToken, y Culture valores de atributo que corresponden al ensamblado principal.Specify the name of your main assembly in place of MainAssemblyName, and specify the Version, PublicKeyToken, and Culture attribute values that correspond to your main assembly.

    Para el Version atributo, especifique el número de versión del ensamblado.For the Version attribute, specify the version number of your assembly. Por ejemplo, la primera versión del ensamblado podría ser un número de versión 1.0.0.0.For example, the first release of your assembly might be version number 1.0.0.0.

    Para el PublicKeyToken atributo, especifique la palabra clave null si no se ha firmado el ensamblado con un nombre seguro, o especifique su token de clave pública si ha firmado el ensamblado.For the PublicKeyToken attribute, specify the keyword null if you have not signed your assembly with a strong name, or specify your public key token if you have signed your assembly.

    Para el Culture atributo, especifique la palabra clave neutral para designar el ensamblado principal y hacer que el ResourceManager clase sondee solo para las referencias culturales que se muestran en el <culture> nodos.For the Culture attribute, specify the keyword neutral to designate the main assembly and cause the ResourceManager class to probe only for the cultures listed in the <culture> nodes.

    Para obtener más información acerca de los nombres de ensamblado completo, vea el artículo nombres de ensamblado.For more information about fully qualified assembly names, see the article Assembly Names. Para obtener más información acerca de los ensamblados con nombre seguro, vea el artículo crear y utilizar ensamblados.For more information about strong-named assemblies, see the article Creating and Using Strong-Named Assemblies.

  • Especifique uno o más <culture> nodos con un nombre de referencia cultural específica, como "fr-FR", o un nombre de referencia cultural neutra, por ejemplo, "fr".Specify one or more <culture> nodes with a specific culture name, such as "fr-FR", or a neutral culture name, such as "fr".

Si se necesitan recursos de cualquier ensamblado no aparece en el <satelliteassemblies> nodo, el ResourceManager clase sondeos para referencias culturales con reglas de búsqueda estándares.If resources are needed for any assembly not listed under the <satelliteassemblies> node, the ResourceManager class probes for cultures using standard probing rules.

Aplicaciones de Tienda Windows 8.xWindows 8.x StoreTienda Windows 8.xWindows 8.x Store Apps

Importante

Aunque el ResourceManager clase es compatible en Tienda Windows 8.xWindows 8.x Store las aplicaciones, no se recomienda su uso.Although the ResourceManager class is supported in Tienda Windows 8.xWindows 8.x Store apps, we do not recommend its use. Utilice esta clase solo cuando se desarrollan Biblioteca de clases portablePortable Class Library proyectos que se pueden usar con Tienda Windows 8.xWindows 8.x Store aplicaciones.Use this class only when you develop Biblioteca de clases portablePortable Class Library projects that can be used with Tienda Windows 8.xWindows 8.x Store apps. Para recuperar recursos desde Tienda Windows 8.xWindows 8.x Store aplicaciones, use el Windows.ApplicationModel.Resources.ResourceLoader clase en su lugar.To retrieve resources from Tienda Windows 8.xWindows 8.x Store apps, use the Windows.ApplicationModel.Resources.ResourceLoader class instead.

Para Tienda Windows 8.xWindows 8.x Store aplicaciones, la ResourceManager clase recupera los recursos de paquete (PRI) de índice archivos de recursos.For Tienda Windows 8.xWindows 8.x Store apps, the ResourceManager class retrieves resources from package resource index (PRI) files. Un único archivo PRI (el archivo PRI del paquete de aplicación) contiene los recursos de la referencia cultural predeterminada y cualquier localizados de las referencias culturales.A single PRI file (the application package PRI file) contains the resources for both the default culture and any localized cultures. Use la utilidad MakePRI para crear un archivo PRI desde uno o varios archivos de recursos que están en formato de recursos (.resw) XML.You use the MakePRI utility to create a PRI file from one or more resource files that are in XML resource (.resw) format. Para obtener recursos que se incluyen en un proyecto de Visual Studio, Visual Studio controla el proceso de crear y empaquetar el archivo PRI automáticamente.For resources that are included in a Visual Studio project, Visual Studio handles the process of creating and packaging the PRI file automatically. A continuación, puede usar .NET Framework ResourceManager clase para tener acceso a los recursos de la biblioteca o de la aplicación.You can then use the .NET Framework ResourceManager class to access the app's or library's resources.

Puede crear instancias de un ResourceManager de objeto para un Tienda Windows 8.xWindows 8.x Store aplicación de la misma manera que lo hace para una aplicación de escritorio.You can instantiate a ResourceManager object for a Tienda Windows 8.xWindows 8.x Store app in the same way that you do for a desktop app.

A continuación, puede tener acceso a los recursos para una referencia cultural determinada pasando el nombre del recurso que se va a recuperar para el GetString(String) método.You can then access the resources for a particular culture by passing the name of the resource to be retrieved to the GetString(String) method. De forma predeterminada, este método devuelve el recurso para la referencia cultural determinada por la referencia cultural de interfaz de usuario actual del subproceso que realizó la llamada.By default, this method returns the resource for the culture determined by the current UI culture of the thread that made the call. También puede recuperar los recursos para una referencia cultural concreta, pasando el nombre del recurso y un CultureInfo objeto que representa la referencia cultural cuyo recurso se va a recuperar para el GetString(String, CultureInfo) método.You can also retrieve the resources for a specific culture by passing the name of the resource and a CultureInfo object that represents the culture whose resource is to be retrieved to the GetString(String, CultureInfo) method. Si no se encuentra el recurso para la referencia cultural de interfaz de usuario actual o la referencia cultural especificada, el Administrador de recursos usa una lista de reserva de idioma de interfaz de usuario para buscar un recurso adecuado.If the resource for the current UI culture or the specified culture cannot be found, the resource manager uses a UI language fallback list to locate a suitable resource.

Constructors

ResourceManager() ResourceManager() ResourceManager() ResourceManager()

Inicializa una nueva instancia de la clase ResourceManager con valores predeterminados. Initializes a new instance of the ResourceManager class with default values.

ResourceManager(String, Assembly) ResourceManager(String, Assembly) ResourceManager(String, Assembly) ResourceManager(String, Assembly)

Inicializa una nueva instancia de la clase ResourceManager que busca los recursos que contienen los archivos con el nombre raíz especificado, en el objeto dado. Initializes a new instance of the ResourceManager class that looks up resources contained in files with the specified root name in the given assembly.

ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type)

Inicializa una nueva instancia de la clase ResourceManager que usa un ResourceSet especificado para buscar recursos que contenga archivos con el nombre de raíz especificado en el ensamblado determinado. Initializes a new instance of the ResourceManager class that uses a specified ResourceSet class to look up resources contained in files with the specified root name in the given assembly.

ResourceManager(Type) ResourceManager(Type) ResourceManager(Type) ResourceManager(Type)

Inicializa una nueva instancia de la clase ResourceManager que busca recursos en los ensamblados satélite a partir de la información del objeto de tipo especificado. Initializes a new instance of the ResourceManager class that looks up resources in satellite assemblies based on information from the specified type object.

Fields

BaseNameField BaseNameField BaseNameField BaseNameField

Especifica el nombre raíz de los archivos de recursos donde ResourceManager busca recursos. Specifies the root name of the resource files that the ResourceManager searches for resources.

HeaderVersionNumber HeaderVersionNumber HeaderVersionNumber HeaderVersionNumber

Especifica la versión de los encabezados de archivos de recursos que la implementación actual de ResourceManager puede interpretar y producir. Specifies the version of resource file headers that the current implementation of ResourceManager can interpret and produce.

MagicNumber MagicNumber MagicNumber MagicNumber

Conserva el número utilizado para identificar los archivos de recursos. Holds the number used to identify resource files.

MainAssembly MainAssembly MainAssembly MainAssembly

Especifica el ensamblado principal que contiene los recursos. Specifies the main assembly that contains the resources.

ResourceSets ResourceSets ResourceSets ResourceSets

Contiene un objeto Hashtable que devuelve una asignación de referencias culturales a objetos ResourceSet. Contains a Hashtable that returns a mapping from cultures to ResourceSet objects.

Properties

BaseName BaseName BaseName BaseName

Obtiene el nombre raíz de los archivos de recursos donde ResourceManager busca recursos. Gets the root name of the resource files that the ResourceManager searches for resources.

FallbackLocation FallbackLocation FallbackLocation FallbackLocation

Obtiene o establece la ubicación de la que se recuperan los recursos de reserva predeterminados. Gets or sets the location from which to retrieve default fallback resources.

IgnoreCase IgnoreCase IgnoreCase IgnoreCase

Obtiene o establece un valor que indica si el administrador de recursos permite realizar búsquedas de recursos sin distinción entre mayúsculas y minúsculas en los métodos GetString(String) y GetObject(String). Gets or sets a value that indicates whether the resource manager allows case-insensitive resource lookups in the GetString(String) and GetObject(String) methods.

ResourceSetType ResourceSetType ResourceSetType ResourceSetType

Obtiene el tipo de objeto de conjunto de recursos que el administrador de recursos usa para construir un objeto ResourceSet. Gets the type of the resource set object that the resource manager uses to construct a ResourceSet object.

Methods

CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type)

Devuelve un objeto ResourceManager que busca un directorio específico en lugar de en el manifiesto del ensamblado para recursos. Returns a ResourceManager object that searches a specific directory instead of an assembly manifest for resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual. Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada. Serves as the default hash function.

(Inherited from Object)
GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly)

Devuelve información específica de la referencia cultural para los recursos predeterminados del ensamblado recuperando el valor del atributo NeutralResourcesLanguageAttribute en un ensamblado específico. Returns culture-specific information for the main assembly's default resources by retrieving the value of the NeutralResourcesLanguageAttribute attribute on a specified assembly.

GetObject(String) GetObject(String) GetObject(String) GetObject(String)

Devuelve el valor del recurso que no sea de cadena especificado. Returns the value of the specified non-string resource.

GetObject(String, CultureInfo) GetObject(String, CultureInfo) GetObject(String, CultureInfo) GetObject(String, CultureInfo)

Obtiene el valor del recurso especificado de cadena no adaptado a la referencia cultural especificada. Gets the value of the specified non-string resource localized for the specified culture.

GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo)

Genera el nombre del archivo de recursos para el objeto CultureInfo especificado. Generates the name of the resource file for the given CultureInfo object.

GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean)

Recupera el conjunto de recursos para una referencia cultural determinada. Retrieves the resource set for a particular culture.

GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly)

Devuelve la versión especificada por el atributo SatelliteContractVersionAttribute en el ensamblado especificado. Returns the version specified by the SatelliteContractVersionAttribute attribute in the given assembly.

GetStream(String) GetStream(String) GetStream(String) GetStream(String)

Devuelve un objeto de secuencia de memoria no administrada del recurso especificado. Returns an unmanaged memory stream object from the specified resource.

GetStream(String, CultureInfo) GetStream(String, CultureInfo) GetStream(String, CultureInfo) GetStream(String, CultureInfo)

Devuelve un objeto de secuencia de memoria no administrada a partir del recurso especificado, utilizando la referencia cultural especificada. Returns an unmanaged memory stream object from the specified resource, using the specified culture.

GetString(String) GetString(String) GetString(String) GetString(String)

Devuelve el valor del recurso de cadena especificado. Returns the value of the specified string resource.

GetString(String, CultureInfo) GetString(String, CultureInfo) GetString(String, CultureInfo) GetString(String, CultureInfo)

Devuelve el valor del recurso de cadena adaptado a la referencia cultural especificada. Returns the value of the string resource localized for the specified culture.

GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual. Gets the Type of the current instance.

(Inherited from Object)
InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean)

Proporciona la implementación para buscar un conjunto de recursos. Provides the implementation for finding a resource set.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del Object actual. Creates a shallow copy of the current Object.

(Inherited from Object)
ReleaseAllResources() ReleaseAllResources() ReleaseAllResources() ReleaseAllResources()

Indica al administrador de recursos que llame al método Close() en todos los objetos ResourceSet y libere todos los recursos. Tells the resource manager to call the Close() method on all ResourceSet objects and release all resources.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual. Returns a string that represents the current object.

(Inherited from Object)

Applies to

Thread Safety

Este tipo es seguro para la ejecución de subprocesos. This type is thread safe.

See Also