ResourceManager Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
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.
public ref class ResourceManagerpublic class ResourceManager[System.Serializable]
public class ResourceManager[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class ResourceManagertype ResourceManager = class[<System.Serializable>]
type ResourceManager = class[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ResourceManager = classPublic Class ResourceManager- Herencia
-
ResourceManager
- Derivado
- Atributos
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:
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"Use el generador de archivos de recursos para generar el archivo de recursos rmc.resources desde el archivo de entrada rmc.txt de la siguiente manera:
resgen rmc.txtCree 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.
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"Use el generador de archivos de recursos para generar el archivo de recursos rmc.es-MX.resources desde el archivo de entrada rmc.es-MX.txt de la siguiente manera:
resgen rmc.es-MX.txtSupongamos que el nombre de archivo de este ejemplo es rmc.vb o rmc.cs. Copie el código fuente siguiente en un archivo. Después, 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.resourcesLa sintaxis correspondiente para el compilador de C# es:
csc /resource:rmc.resources rmc.csUse 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.dllEjecute rmc.exe para obtener y mostrar las cadenas de recursos incrustadas.
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.
Comentarios
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 se ha localizado una aplicación y se han implementado recursos localizados 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.
Para obtener más información sobre cómo crear y administrar recursos en aplicaciones de escritorio y aplicaciones Windows 8.x, consulte las secciones siguientes:
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 método los ReleaseAllResources libera 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 la 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.
Creación de 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). Después, 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 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 inserción de recursos predeterminados y localizados automáticamente como parte del proceso de compilación.
Lo ideal es crear recursos para cada lenguaje 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, según el 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 insertarse 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 basados en 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 creados 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(Example).Assembly)ResourceManager(Type) busca recursos en ensamblados satélite basados en 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 que se crean 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, consulte la sección Control de las excepciones MissingManifestResourceException y MissingSatelliteAssembly 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 archivo 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 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 de Culture-Specific
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 se van a 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 en francés.
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 o del idioma del sistema operativo del usuario. 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.
Para establecer la referencia cultural de la interfaz de usuario de todos los subprocesos de un dominio de aplicación, asigne un CultureInfo objeto que represente 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 CultureInfo.CurrentUICulture propiedad se establece implícitamente mediante la función Windows
GetUserDefaultUILanguage. 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.
El siguiente ejemplo sencillo de "Hola mundo" 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 de interfaz de usuario actual del subproceso que realizó la llamada. Consulte la sección anterior ResourceManager y los recursos de Culture-Specific para obtener más información sobre cómo se define la referencia cultural de interfaz de usuario actual 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 constructor de clase ResourceManager , 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 Control de MissingManifestResourceException y MissingSatelliteAssemblyException Exceptions más adelante en este tema.
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.
El ejemplo requiere los archivos de recursos basados en texto enumerados en la tabla siguiente. Cada tiene un único recurso de cadena denominado DateStart.
| culture | 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 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 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 recurre 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.
Control de 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 .
La excepción se produce normalmente en las siguientes condiciones:
El archivo de recursos o ensamblado satélite adecuado no existe. Si el administrador de recursos espera que los recursos predeterminados de la aplicación se inserten en el ensamblado de la aplicación principal, no están presentes. 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 neutra. 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 una aplicación de C#).
El
baseNamepará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. Para determinar los nombres de los archivos .resources incrustados, compile y ejecute 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ámetrobaseNamepara que el administrador de recursos pueda identificar correctamente el recurso.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 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.
<satelliteassemblies> Nodo de archivo de configuración
Nota
Esta sección es específica de las aplicaciones de .NET Framework.
En el caso de los 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, cree 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 de manifiesto de implementación de 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 losVersionvalores de atributo ,PublicKeyTokenyCultureque corresponden al ensamblado principal.Para el
Versionatributo , 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
PublicKeyTokenatributo , especifique la palabra clavenullsi no ha firmado el ensamblado con un nombre seguro o especifique el token de clave pública si ha firmado el ensamblado.Para el
Cultureatributo , especifique la palabra claveneutralpara 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 Windows 8.x, no se recomienda su uso. Use esta clase solo cuando desarrolle proyectos de biblioteca de clases portables que se puedan usar con aplicaciones Windows 8.x. Para recuperar recursos de aplicaciones Windows 8.x, use el Windows. Clase ApplicationModel.Resources.ResourceLoader en su lugar.
Para las aplicaciones Windows 8.x, la ResourceManager clase recupera los recursos de los archivos de índice de recursos de paquete (PRI). Un único archivo PRI (el archivo PRI del paquete de aplicación) contiene los recursos para la referencia cultural predeterminada y las referencias culturales localizadas. La utilidad MakePRI se usa 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 automático del archivo PRI. A continuación, puede usar la clase .NET Framework ResourceManager para acceder a los recursos de la aplicación o de la biblioteca.
Puede crear una instancia de un ResourceManager objeto para una aplicación Windows 8.x de la misma manera que 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 de la referencia cultural determinada por la referencia cultural de la interfaz de usuario actual 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 de 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.
Constructores
| ResourceManager() |
Inicializa una nueva instancia de la clase ResourceManager con valores predeterminados. |
| 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. |
| 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. |
| 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. |
Campos
| BaseNameField |
Especifica el nombre raíz de los archivos de recursos donde ResourceManager busca recursos. |
| HeaderVersionNumber |
Especifica la versión de los encabezados de archivos de recursos que la implementación actual de ResourceManager puede interpretar y producir. |
| MagicNumber |
Conserva el número usado para identificar los archivos de recursos. |
| MainAssembly |
Especifica el ensamblado principal que contiene los recursos. |
| ResourceSets |
Obsoleto.
Contiene un objeto Hashtable que devuelve una asignación de referencias culturales a objetos ResourceSet. |
Propiedades
| BaseName |
Obtiene el nombre raíz de los archivos de recursos donde ResourceManager busca recursos. |
| FallbackLocation |
Obtiene o establece la ubicación de la que se recuperan los recursos de reserva predeterminados. |
| 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). |
| ResourceSetType |
Obtiene el tipo de objeto de conjunto de recursos que el administrador de recursos usa para construir un objeto ResourceSet. |
Métodos
| CreateFileBasedResourceManager(String, String, Type) |
Devuelve un objeto ResourceManager que busca un directorio específico en lugar de en el manifiesto del ensamblado para recursos. |
| Equals(Object) |
Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object) |
| GetHashCode() |
Sirve como la función hash predeterminada. (Heredado de Object) |
| 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. |
| GetObject(String) |
Devuelve el valor del recurso que no sea de cadena especificado. |
| GetObject(String, CultureInfo) |
Obtiene el valor del recurso especificado de cadena no adaptado a la referencia cultural especificada. |
| GetResourceFileName(CultureInfo) |
Genera el nombre del archivo de recursos para el objeto CultureInfo especificado. |
| GetResourceSet(CultureInfo, Boolean, Boolean) |
Recupera el conjunto de recursos para una referencia cultural determinada. |
| GetSatelliteContractVersion(Assembly) |
Devuelve la versión especificada por el atributo SatelliteContractVersionAttribute en el ensamblado especificado. |
| GetStream(String) |
Devuelve un objeto de secuencia de memoria no administrada del recurso especificado. |
| GetStream(String, CultureInfo) |
Devuelve un objeto de secuencia de memoria no administrada a partir del recurso especificado, usando la referencia cultural especificada. |
| GetString(String) |
Devuelve el valor del recurso de cadena especificado. |
| GetString(String, CultureInfo) |
Devuelve el valor del recurso de cadena adaptado a la referencia cultural especificada. |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| InternalGetResourceSet(CultureInfo, Boolean, Boolean) |
Proporciona la implementación para buscar un conjunto de recursos. |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| ReleaseAllResources() |
Indica al administrador de recursos que llame al método Close() en todos los objetos ResourceSet y libere todos los recursos. |
| ToString() |
Devuelve una cadena que representa el objeto actual. (Heredado de Object) |
Se aplica a
Seguridad para subprocesos
Este tipo es seguro para la ejecución de subprocesos.