Compartir a través de

Clase System.Resources.ResourceManager

  • Artículo

En este artículo se proporcionan comentarios adicionales a la documentación de referencia de esta API.

Importante

Llamar a métodos de esta clase con datos que no son de confianza supone un riesgo de seguridad. Llame a los métodos de esta clase solo con datos de confianza. Para obtener más información, vea Validar todas las entradas.

La ResourceManager clase recupera los recursos de un archivo .resources binario incrustado en un ensamblado o desde un archivo .resources independiente. Si una aplicación se ha localizado y localizado recursos se han implementado en ensamblados satélite, busca recursos específicos de la referencia cultural, proporciona reserva de recursos cuando no existe un recurso localizado y admite la serialización de recursos.

Aplicaciones de escritorio

En el caso de las aplicaciones de escritorio, la ResourceManager clase recupera los recursos de los archivos de recursos binarios (.resources). Normalmente, un compilador de lenguaje o assembly Linker (AL.exe) inserta estos archivos de recursos en un ensamblado. También puede usar un ResourceManager objeto para recuperar recursos directamente desde un archivo .resources que no está incrustado en un ensamblado mediante una llamada al CreateFileBasedResourceManager método .

Precaución

El uso de archivos .resources independientes en una aplicación de ASP.NET interrumpirá la implementación de XCOPY, ya que los recursos permanecen bloqueados hasta que el ReleaseAllResources método los libere explícitamente. Si desea implementar recursos con las aplicaciones de ASP.NET, debe compilar los archivos .resources en ensamblados satélite.

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 puede encontrar ningún recurso específico de la referencia cultural. 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 encuentren recursos localizados para una referencia cultural específica, como inglés (Estados Unidos) (en-US) o francés (francia) (fr-FR). Normalmente, los recursos de la referencia cultural predeterminada se insertan en el ensamblado de aplicación principal y los recursos de otras referencias culturales localizadas se insertan en ensamblados satélite. Los ensamblados satélite solo contienen recursos. Tienen el mismo nombre de archivo raíz que el ensamblado principal y una extensión de .resources.dll. En el caso de las aplicaciones cuyos ensamblados no están registrados en la caché global de ensamblados, los ensamblados satélite se almacenan en un subdirectorio de aplicación cuyo nombre corresponde a la referencia cultural del ensamblado.

Crear recursos

Al desarrollar una aplicación basada en recursos, se almacena información de recursos en archivos de texto (archivos que tienen una extensión de .txt o .restext) o archivos XML (archivos que tienen una extensión .resx). A continuación, compile el texto o los archivos XML con el Generador de archivos de recursos (Resgen.exe) para crear un archivo .resources binario. A continuación, puede insertar 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 assembly Linker (AI.exe). Si incluye un archivo .resx en el proyecto de Visual Studio, Visual Studio controla la compilación e incrustación de recursos predeterminados y localizados automáticamente como parte del proceso de compilación.

Lo ideal es crear recursos para cada idioma que admita la aplicación o, al menos, para un subconjunto significativo de cada idioma. Los nombres de archivo .resources binarios siguen el nombre base de la convención de nomenclatura.cultureName.resources, donde basename es el nombre de la aplicación o el nombre de una clase, en función del nivel de detalle que desee. La CultureInfo.Name propiedad se usa para determinar cultureName. Un recurso para la referencia cultural predeterminada de la aplicación debe denominarse basename.resources.

Por ejemplo, supongamos que un ensamblado tiene varios recursos en un archivo de recursos que tiene el nombre base MyResources. Estos archivos de recursos deben tener nombres como MyResources.ja-JP.resources para la cultura japonesa (japonesa), MyResources.de.resources para la cultura alemana, MyResources.zh-CHS.resources para la cultura china simplificada y MyResources.fr-BE.resources para la cultura francesa (Bélgica). El archivo de recursos predeterminado debe denominarse MyResources.resources. Los archivos de recursos específicos de la referencia cultural se empaquetan normalmente en ensamblados satélite para cada referencia cultural. El archivo de recursos predeterminado debe incrustarse en el ensamblado principal de la aplicación.

Tenga en cuenta que Assembly Linker permite que los recursos se marquen como privados, pero siempre debe marcarlos como públicos para que otros ensamblados puedan acceder a ellos. (Dado que un ensamblado satélite no contiene código, los recursos marcados como privados no están disponibles para la aplicación a través de cualquier mecanismo).

Para obtener más información sobre cómo crear, empaquetar e implementar recursos, consulte los artículos Creación de archivos de recursos, Creación de ensamblados satélite y Empaquetado e Implementación de recursos.

Creación de instancias de un objeto ResourceManager

Cree una instancia de un ResourceManager objeto que recupere los recursos de un archivo .resources incrustado llamando a una de sus sobrecargas de constructor de clase. Esto acopla estrechamente un ResourceManager objeto con un archivo .resources determinado y con los archivos .resources localizados asociados en ensamblados satélite.

Los dos constructores más comunes son:

  • ResourceManager(String, Assembly) busca recursos en función de dos fragmentos de información que proporcione: el nombre base del archivo .resources y el ensamblado en el que reside el archivo .resources predeterminado. El nombre base incluye el espacio de nombres y el nombre raíz del archivo .resources, sin su referencia cultural o extensión. Tenga en cuenta que los archivos .resources que se compilan desde la línea de comandos normalmente no incluyen un nombre de espacio de nombres, mientras que los archivos .resources que se crean en el entorno de Visual Studio sí lo hacen. Por ejemplo, si un archivo de recursos se denomina MyCompany.StringResources.resources y se llama al ResourceManager constructor desde un método estático denominado Example.Main, el código siguiente crea una instancia de un ResourceManager objeto que puede recuperar recursos del archivo .resources:

    ResourceManager rm = new ResourceManager("MyCompany.StringResources",
                                         typeof(Example).Assembly);

    Dim rm As New ResourceManager("MyCompany.StringResources",
                            GetType(Example2).Assembly)

  • ResourceManager(Type) busca recursos en ensamblados satélite en función de la información de un objeto de tipo. El nombre completo del tipo corresponde al nombre base del archivo .resources sin su extensión de nombre de archivo. En las aplicaciones de escritorio creadas mediante el Diseñador de recursos de Visual Studio, Visual Studio crea una clase contenedora cuyo nombre completo es el mismo que el nombre raíz del archivo .resources. 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 del archivo .resources:

    ResourceManager rm = new ResourceManager(typeof(MyCompany.StringResources));

    Dim rm As New ResourceManager(GetType(MyCompany.StringResources))

Si no se encuentran los recursos adecuados, la llamada al constructor crea un objeto válido ResourceManager . Sin embargo, el intento de recuperar un recurso produce una MissingManifestResourceException excepción. Para obtener información sobre cómo tratar con la excepción, vea la sección Handle MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions (Controlar excepciones MissingManifestResourceException y MissingSatelliteAssemblyException) más adelante en este artículo.

En el ejemplo siguiente se muestra cómo crear una instancia de un ResourceManager objeto . Contiene el código fuente de un archivo ejecutable denominado ShowTime.exe. También incluye el siguiente archivo de texto denominado Strings.txt que contiene un único recurso de cadena, TimeHeader:

TimeHeader=The current time is

Puede usar un archivo por lotes para generar el archivo de recursos e insertarlo en el ejecutable. Este es el archivo por lotes para generar un archivo ejecutable mediante el compilador de C#:

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

Para el compilador de Visual Basic, puede usar el siguiente archivo por lotes:

resgen strings.txt
vbc ShowTime.vb /resource:strings.resources

using System;
using System.Resources;

public class ShowTimeEx
{
    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 Example6
    Public Sub Main()
        Dim rm As New ResourceManager("Strings", GetType(Example6).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 cultural

Una aplicación localizada requiere que se implementen recursos, como se describe en el artículo Empaquetado e implementación de recursos. Si los ensamblados están configurados correctamente, el administrador de recursos determina qué recursos recuperar en función de la propiedad del Thread.CurrentUICulture subproceso actual. (Esa propiedad también devuelve la referencia cultural de la interfaz de usuario del subproceso actual). Por ejemplo, si una aplicación se compila con recursos de idioma inglés predeterminados en el ensamblado principal y con recursos de idioma francés y ruso en dos ensamblados satélite, y la Thread.CurrentUICulture propiedad se establece en fr-FR, el administrador de recursos recupera los recursos franceses.

Puede establecer la CurrentUICulture propiedad explícita o implícitamente. La forma en que se establece determina cómo el ResourceManager objeto recupera los recursos en función de la referencia cultural:

  • Si establece explícitamente la Thread.CurrentUICulture propiedad en una referencia cultural específica, el administrador de recursos siempre recupera los recursos de esa referencia cultural, independientemente del explorador del usuario o del idioma del sistema operativo. Considere una aplicación compilada con recursos de idioma inglés predeterminados y tres ensamblados satélite que contienen recursos para inglés (Estados Unidos), francés (Francia) y ruso (Rusia). Si la CurrentUICulture propiedad se establece en fr-FR, el ResourceManager objeto siempre recupera los recursos francés (Francia), aunque el idioma del sistema operativo del usuario no sea francés. Asegúrese de que este es el comportamiento deseado antes de establecer la propiedad explícitamente.

    En ASP.NET aplicaciones, debe establecer la Thread.CurrentUICulture propiedad explícitamente, ya que es poco probable que la configuración del servidor coincida con las solicitudes de cliente entrantes. Una aplicación ASP.NET puede establecer la Thread.CurrentUICulture propiedad explícitamente en el idioma de aceptación del explorador del usuario.

    Al establecer explícitamente la Thread.CurrentUICulture propiedad , se define la referencia cultural de la interfaz de usuario actual para ese subproceso. No afecta a la referencia cultural actual de la interfaz de usuario de ningún otro subproceso de una aplicación.

  • Puede establecer la referencia cultural de la interfaz de usuario de todos los subprocesos de un dominio de aplicación asignando un CultureInfo objeto que representa esa referencia cultural a la propiedad estática CultureInfo.DefaultThreadCurrentUICulture .

  • Si no establece explícitamente la referencia cultural de la interfaz de usuario actual y no define una referencia cultural predeterminada para el dominio de aplicación actual, la función de Windows GetUserDefaultUILanguage establece implícitamente la CultureInfo.CurrentUICulture propiedad . Esta función la proporciona el Interfaz de usuario multilingüe (MUI), que permite al usuario establecer el idioma predeterminado. Si el usuario no establece el idioma de la interfaz de usuario, el valor predeterminado es el idioma instalado por el sistema, que es el idioma de los recursos del sistema operativo.

En el siguiente ejemplo sencillo de "Hola mundo" se establece explícitamente la referencia cultural de la interfaz de usuario actual. 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. Los recursos en-US se encuentran en un archivo de texto denominado Greetings.txt:

HelloString=Hello world!

Los recursos fr-FR se encuentran en un archivo de texto denominado Greetings.fr-FR.txt:

HelloString=Salut tout le monde!

Los recursos ru-RU se encuentran en un archivo de texto denominado Greetings.ru-RU.txt:

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

Este es el código fuente del ejemplo (Example.vb para la versión de Visual Basic o Example.cs para la versión de C#):

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 contenga los siguientes comandos y ejecútelo desde el símbolo del sistema. Si usa C#, especifique csc en lugar de vbc y Example.cs en lugar de 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 recursos

Llame a los GetObject(String) métodos y GetString(String) para acceder a un recurso específico. También puede llamar al GetStream(String) método para recuperar recursos que no son de cadena como una matriz de bytes. De forma predeterminada, en una aplicación que tiene recursos localizados, estos métodos devuelven el recurso para la referencia cultural determinada por la referencia cultural actual de la interfaz de usuario del subproceso que realizó la llamada. Consulte la sección anterior, ResourceManager y recursos específicos de la referencia cultural, para obtener más información sobre cómo se define la referencia cultural actual de la interfaz de usuario de un subproceso. Si el administrador de recursos no encuentra el recurso para la referencia cultural de la interfaz de usuario del subproceso actual, usa un proceso de reserva para recuperar el recurso especificado. Si el administrador de recursos no encuentra ningún recurso localizado, usa los recursos de la referencia cultural predeterminada. Para obtener más información sobre las reglas de reserva de recursos, consulte la sección "Proceso de reserva de recursos" del artículo Empaquetado e implementación de recursos.

Nota:

Si no se encuentra el archivo .resources especificado en el ResourceManager constructor de clase, el intento de recuperar un recurso produce una MissingManifestResourceException excepción o MissingSatelliteAssemblyException . Para obtener información sobre cómo tratar con la excepción, vea la sección Handle MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions (Controlar excepciones MissingManifestResourceException y MissingSatelliteAssemblyException) más adelante en este artículo.

En el ejemplo siguiente se usa el GetString método para recuperar recursos específicos de la referencia cultural. Consta de recursos compilados a partir de archivos de .txt para las referencias culturales inglés (en), francés (Francia) (fr-FR) y ruso (Rusia) (ru-RU). En el ejemplo se cambia la referencia cultural actual y la referencia cultural actual de la interfaz de usuario a inglés (Estados Unidos), francés (Francia), ruso (Rusia) y sueco (Suecia). A continuación, llama al GetString método para recuperar la cadena localizada, que se muestra junto con el día y el mes actuales. Observe que la salida muestra la cadena localizada adecuada, excepto cuando la referencia cultural actual de la interfaz de usuario es sueca (Suecia). Dado que los recursos de idioma sueco no están disponibles, la aplicación usa en su lugar los recursos de la referencia cultural predeterminada, que es inglés.

En el ejemplo se requieren los archivos de recursos basados en texto enumerados en la tabla siguiente. Cada tiene un único recurso de cadena denominado DateStart.

Referencia cultural Nombre de archivo Nombre del recurso Valor del recurso
en-US DateStrings.txt DateStart Hoy es
fr-FR DateStrings.fr-FR.txt DateStart Aujourd'hui, c'est le
ru-RU DateStrings.ru-RU.txt DateStart Сегодня

Este es el código fuente del ejemplo (ShowDate.vb para la versión de Visual Basic o ShowDate.cs para la versión de C# del código).

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

[assembly: NeutralResourcesLanguage("en")]

public class ShowDateEx
{
    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 Example5
    Public Sub Main()
        Dim cultureNames() As String = {"en-US", "fr-FR", "ru-RU", "sv-SE"}
        Dim rm As New ResourceManager("DateStrings",
                                    GetType(Example5).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 contenga los siguientes comandos y ejecútelo desde el símbolo del sistema. Si usa C#, especifique csc en lugar de vbc y showdate.cs en lugar de 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 específica distinta de la referencia cultural actual de la interfaz de usuario:

  • Puede llamar al GetString(String, CultureInfo)método , GetObject(String, CultureInfo)o GetStream(String, CultureInfo) para recuperar un recurso para una referencia cultural específica. Si no se encuentra un recurso localizado, el administrador de recursos usa el proceso de reserva de recursos para buscar un recurso adecuado.
  • Puede llamar al GetResourceSet método para obtener un ResourceSet objeto que represente los recursos de una referencia cultural determinada. En la llamada al método, puede determinar si el administrador de recursos sondea las referencias culturales primarias si no puede encontrar recursos localizados o si simplemente vuelve a los recursos de la referencia cultural predeterminada. A continuación, puede usar los ResourceSet métodos para acceder a los recursos (localizados para esa referencia cultural) por nombre o para enumerar los recursos del conjunto.

Controlar las excepciones MissingManifestResourceException y MissingSatelliteAssemblyException

Si intenta recuperar un recurso específico, pero el administrador de recursos no puede encontrar ese recurso y no se ha definido ninguna referencia cultural predeterminada o no se pueden encontrar los recursos de la referencia cultural predeterminada, el administrador de recursos produce una MissingManifestResourceException excepción si espera encontrar los recursos en el ensamblado principal o si MissingSatelliteAssemblyException espera encontrar los recursos en un ensamblado satélite. 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 se crea una instancia de un ResourceManager objeto.

Normalmente, la excepción se produce en las condiciones siguientes:

  • El archivo de recursos o el ensamblado satélite adecuados no existen. Si el administrador de recursos espera que los recursos predeterminados de la aplicación se inserten en el ensamblado de la aplicación principal, están ausentes. Si el NeutralResourcesLanguageAttribute atributo indica que los recursos predeterminados de la aplicación residen en un ensamblado satélite, no se encuentra ese ensamblado. Al compilar la aplicación, asegúrese de que los recursos están incrustados en el ensamblado principal o de que se genera el ensamblado satélite necesario y se denomina correctamente. Su nombre debe tener el formato appName.resources.dll y debe encontrarse en un directorio denominado después de la referencia cultural cuyos recursos contiene.

  • La aplicación no tiene definida una referencia cultural predeterminada o neutral. Agregue el NeutralResourcesLanguageAttribute atributo a un archivo de código fuente o al archivo de información del proyecto (AssemblyInfo.vb para una aplicación de Visual Basic o AssemblyInfo.cs para un archivo de aplicación de C#).

  • El baseName parámetro del ResourceManager(String, Assembly) constructor no especifica el nombre de un archivo .resources. El nombre debe incluir el espacio de nombres completo del archivo de recursos, pero no su extensión de nombre de archivo. Normalmente, los archivos de recursos que se crean en Visual Studio incluyen nombres de espacio de nombres, pero los archivos de recursos que se crean y compilan en el símbolo del sistema no lo hacen. Puede determinar los nombres de los archivos .resources incrustados mediante la compilación y ejecución de la siguiente utilidad. Se trata de una aplicación de consola que acepta el nombre de un ensamblado principal o ensamblado satélite como parámetro de línea de comandos. Muestra las cadenas que se deben proporcionar como parámetro baseName para que el administrador de recursos pueda identificar correctamente el recurso.

    using System;
using System.IO;
using System.Reflection;

public class Example0
{
   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 la referencia cultural actual de la aplicación explícitamente, también debe recordar que el administrador de recursos recupera un conjunto de recursos basado en el valor de la CultureInfo.CurrentUICulture propiedad y no en la CultureInfo.CurrentCulture propiedad . Normalmente, si cambia un valor, también debe cambiar el otro.

Control de versiones de recursos

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 publicar una nueva versión del ensamblado principal sin volver a implementar los ensamblados satélite. Use el SatelliteContractVersionAttribute atributo para usar ensamblados satélite existentes e indique al administrador de recursos que no vuelva a implementarlos con una nueva versión del ensamblado principal,

Para obtener más información sobre la compatibilidad de control de versiones con ensamblados satélite, consulte el artículo Recuperación de recursos.

<nodo de archivo de configuración de ensamblados> satélite

Nota:

Esta sección es específica de las aplicaciones de .NET Framework.

En el caso de los archivos ejecutables que se implementan y ejecutan desde un sitio web (archivos .exe HREF), el ResourceManager objeto puede sondear los ensamblados satélite en la web, lo que puede afectar al rendimiento de la aplicación. Para eliminar el problema de rendimiento, puede limitar este sondeo a los ensamblados satélite que ha implementado con la aplicación. Para ello, crea un <satelliteassemblies> nodo en el archivo de configuración de la aplicación para especificar que ha implementado un conjunto específico de referencias culturales para la aplicación y que el ResourceManager objeto no debe intentar sondear ninguna referencia cultural que no aparezca en ese nodo.

Nota:

La alternativa preferida a la creación de un <satelliteassemblies> nodo es usar la característica Manifiesto de implementación clickOnce.

En el archivo de configuración de la aplicación, cree una sección similar a la siguiente:

<?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 siguiente manera:

  • Especifique uno o varios <assembly> nodos para cada ensamblado principal que implemente, donde cada nodo especifica un nombre de ensamblado completo. Especifique el nombre del ensamblado principal en lugar de MainAssemblyName y especifique los Versionvalores de atributo , PublicKeyTokeny Culture que corresponden al ensamblado principal.

    Para el Version atributo , especifique el número de versión del ensamblado. Por ejemplo, la primera versión del ensamblado podría ser el número de versión 1.0.0.0.

    Para el PublicKeyToken atributo , especifique la palabra clave null si no ha firmado el ensamblado con un nombre seguro o especifique el token de clave pública si ha firmado el ensamblado.

    Para el Culture atributo , especifique la palabra clave neutral para designar el ensamblado principal y haga que la ResourceManager clase sondee solo para las referencias culturales enumeradas en los <culture> nodos.

    Para obtener más información sobre los nombres de ensamblado completos, consulte el artículo Nombres de ensamblado. Para obtener más información sobre los ensamblados con nombre seguro, consulte el artículo Creación y uso de ensamblados con nombre seguro.

  • Especifique uno o varios <culture> nodos con un nombre de referencia cultural específico, como "fr-FR" o un nombre de referencia cultural neutral, como "fr".

Si se necesitan recursos para cualquier ensamblado que no aparezca en el <satelliteassemblies> nodo, la ResourceManager clase sondea las referencias culturales mediante reglas de sondeo estándar.

Aplicaciones de Windows 8.x

Importante

Aunque la ResourceManager clase se admite en aplicaciones de Windows 8.x, no se recomienda su uso. Use esta clase solo cuando desarrolle proyectos de biblioteca de clases portables que se pueden usar con aplicaciones de Windows 8.x. Para recuperar recursos de aplicaciones de Windows 8.x, use la clase Windows.ApplicationModel.Resources.ResourceLoader en su lugar.

En el caso de las aplicaciones de Windows 8.x, la ResourceManager clase recupera los recursos de los archivos del índice de recursos del paquete (PRI). Un único archivo PRI (el archivo PRI del paquete de aplicación) contiene los recursos de la referencia cultural predeterminada y de las referencias culturales localizadas. Use la utilidad MakePRI para crear un archivo PRI a partir de uno o varios archivos de recursos que estén en formato de recurso XML (.resw). En el caso de los recursos que se incluyen en un proyecto de Visual Studio, Visual Studio controla el proceso de creación y empaquetado del archivo PRI automáticamente. A continuación, puede usar la clase .NET ResourceManager para acceder a los recursos de la aplicación o de la biblioteca.

Puedes crear instancias de un ResourceManager objeto para una aplicación de Windows 8.x de la misma manera que haces para una aplicación de escritorio.

A continuación, puede acceder a los recursos de una referencia cultural determinada pasando el nombre del recurso que se va a recuperar al GetString(String) método . De forma predeterminada, este método devuelve el recurso para la referencia cultural determinada por la referencia cultural actual de la interfaz de usuario del subproceso que realizó la llamada. También puede recuperar los recursos de una referencia cultural específica pasando el nombre del recurso y un CultureInfo objeto que representa la referencia cultural cuyo recurso se va a recuperar al GetString(String, CultureInfo) método . Si no se encuentra el recurso para la referencia cultural de la interfaz de usuario actual o la referencia cultural especificada, el administrador de recursos usa una lista de reserva de idioma de la interfaz de usuario para buscar un recurso adecuado.

Ejemplos

En el ejemplo siguiente se muestra cómo usar una referencia cultural explícita y la referencia cultural de interfaz de usuario actual implícita para obtener recursos de cadena de un ensamblado principal y un ensamblado satélite. Para obtener más información, vea la sección "Ubicaciones de directorio para ensamblados satélite no instalados en la caché global de ensamblados" del tema Creación de ensamblados satélite.

Para ejecutar este ejemplo:

  1. En el directorio de la aplicación, cree un archivo denominado rmc.txt que contenga las siguientes cadenas de recursos:

    day=Friday
year=2006
holiday="Cinco de Mayo"

  2. Use el generador de archivos de recursos para generar el archivo de recursos rmc.resources desde el archivo de entrada de rmc.txt de la siguiente manera:

    resgen rmc.txt

  3. Cree un subdirectorio del directorio de la aplicación y asígnelo el nombre "es-MX". Este es el nombre de referencia cultural del ensamblado satélite que creará en los tres pasos siguientes.

  4. Cree un archivo denominado rmc.es-MX.txt en el directorio es-MX que contenga las siguientes cadenas de recursos:

    day=Viernes
year=2006
holiday="Cinco de Mayo"

  5. Use el generador de archivos de recursos para generar el archivo de recursos rmc.es-MX.resources desde el archivo de entrada de rmc.es-MX.txt como se indica a continuación:

    resgen rmc.es-MX.txt

  6. Supongamos que el nombre de archivo de este ejemplo es rmc.vb o rmc.cs. Copie el código fuente siguiente en un archivo. A continuación, compile e inserte el archivo de recursos de ensamblado principal, rmc.resources, en el ensamblado ejecutable. Si usa el compilador de Visual Basic, la sintaxis es:

    vbc rmc.vb /resource:rmc.resources

    La sintaxis correspondiente para el compilador de C# es:

    csc /resource:rmc.resources rmc.cs

  7. Use assembly Linker para crear un ensamblado satélite. Si el nombre base de la aplicación es rmc, el nombre del ensamblado satélite debe ser rmc.resources.dll. El ensamblado satélite debe crearse en el directorio es-MX. Si es-MX es el directorio actual, use este comando:

    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 incrustadas.

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

class Example2
{
    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 Example4
    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(Example4).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.