ResourceManager Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Rappresenta un gestore delle risorse che offre un comodo accesso a risorse specifiche delle impostazioni cultura in fase di esecuzione.
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- Ereditarietà
-
ResourceManager
- Derivato
- Attributi
Esempio
Nell'esempio seguente viene illustrato come usare impostazioni cultura esplicite e impostazioni cultura dell'interfaccia utente implicita per ottenere risorse stringa da un assembly principale e da un assembly satellite. Per altre informazioni, vedere la sezione "Percorsi directory per assembly satellite non installati nella Global Assembly Cache" dell'argomento Creazione di assembly satellite .
Per eseguire questo esempio:
Nella directory dell'app creare un file denominato rmc.txt contenente le stringhe di risorse seguenti:
day=Friday year=2006 holiday="Cinco de Mayo"Usare il generatore di file di risorse per generare il file di risorse rmc.resources dal file di input rmc.txt come indicato di seguito:
resgen rmc.txtCreare una sottodirectory della directory dell'app e denominarla "es-MX". Si tratta del nome delle impostazioni cultura dell'assembly satellite che verrà creato nei tre passaggi successivi.
Creare un file denominato rmc.es-MX.txt nella directory es-MX che contiene le stringhe di risorse seguenti:
day=Viernes year=2006 holiday="Cinco de Mayo"Usare il generatore di file di risorse per generare il file di risorse rmc.es-MX.resources dal file di input rmc.es-MX.txt come indicato di seguito:
resgen rmc.es-MX.txtSi supponga che il nome del file per questo esempio sia rmc.vb o rmc.cs. Copiare il codice sorgente seguente in un file. Compilare e incorporare quindi il file di risorse dell'assembly principale, rmc.resources, nell'assembly eseguibile. Se si usa il compilatore di Visual Basic, la sintassi è:
vbc rmc.vb /resource:rmc.resourcesLa sintassi corrispondente per il compilatore C# è:
csc /resource:rmc.resources rmc.csUsare il linker assembly per creare un assembly satellite. Se il nome di base dell'app è rmc, il nome dell'assembly satellite deve essere rmc.resources.dll. L'assembly satellite deve essere creato nella directory es-MX. Se es-MX è la directory corrente, usare questo comando:
al /embed:rmc.es-MX.resources /c:es-MX /out:rmc.resources.dllEseguire rmc.exe per ottenere e visualizzare le stringhe di risorse incorporate.
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.
Commenti
Importante
La chiamata a metodi da questa classe con dati non attendibili costituisce un rischio per la sicurezza. Chiamare i metodi da questa classe solo con dati attendibili. Per altre informazioni, vedere Convalidare tutti gli input.
La ResourceManager classe recupera le risorse da un file con estensione resources binario incorporato in un assembly o da un file con estensione resources autonomo. Se un'app è stata localizzata e le risorse localizzate sono state distribuite negli assembly satellite, cerca risorse specifiche delle impostazioni cultura, fornisce il fallback delle risorse quando una risorsa localizzata non esiste e supporta la serializzazione delle risorse.
Per altre informazioni sulla creazione e la gestione delle risorse nelle app desktop e nelle app Windows 8.x, vedere le sezioni seguenti:
App desktop
Per le app desktop, la ResourceManager classe recupera le risorse dai file di risorse binarie (.resources). In genere, un compilatore del linguaggio o il linker assembly (AL.exe) incorpora questi file di risorse in un assembly. È anche possibile usare un ResourceManager oggetto per recuperare le risorse direttamente da un file con estensione resources che non è incorporato in un assembly chiamando il CreateFileBasedResourceManager metodo .
Attenzione
L'uso di file con estensione risorse autonomi in un'app ASP.NET interromperà la distribuzione XCOPY, perché le risorse rimangono bloccate finché non vengono rilasciate in modo esplicito dal ReleaseAllResources metodo. Se si desidera distribuire risorse con le app ASP.NET, è necessario compilare i file con estensione resources in assembly satellite.
In un'app basata su risorse, un file con estensione resources contiene le risorse delle impostazioni cultura predefinite le cui risorse vengono usate se non sono disponibili risorse specifiche delle impostazioni cultura. Ad esempio, se le impostazioni cultura predefinite di un'app sono inglese (en), le risorse della lingua inglese vengono usate ogni volta che le risorse localizzate non possono essere trovate per una cultura specifica, ad esempio inglese (Stati Uniti) (en-US) o francese (francia) (fr-FR). In genere, le risorse per le impostazioni cultura predefinite vengono incorporate nell'assembly dell'app principale e le risorse per altre impostazioni cultura localizzate vengono incorporate negli assembly satellite. Gli assembly satellite contengono solo risorse. Hanno lo stesso nome del file radice dell'assembly principale e un'estensione di .resources.dll. Per le app i cui assembly non sono registrati nella global assembly cache, gli assembly satellite vengono archiviati in una sottodirectory dell'app il cui nome corrisponde alle impostazioni cultura dell'assembly.
Creazione di risorse
Quando si sviluppa un'app basata su risorse, vengono archiviate le informazioni sulle risorse nei file di testo (file con estensione .txt o con estensione restext) o file XML (file con estensione resx). Viene quindi compilato il testo o i file XML con il generatore di file di risorse (Resgen.exe) per creare un file binario con estensione resources. È quindi possibile incorporare il file con estensione resources risultante in un file eseguibile o in una libreria usando un'opzione del compilatore, ad /resources esempio per C# e Visual Basic compilatori oppure è possibile incorporarlo in un assembly satellite usando Assembly Linker (AI.exe). Se si include un file con estensione resx nel progetto Visual Studio, Visual Studio gestisce la compilazione e l'incorporamento delle risorse predefinite e localizzate automaticamente come parte del processo di compilazione.
Idealmente, è consigliabile creare risorse per ogni lingua supportata dall'app o almeno per un subset significativo di ogni lingua. I nomi dei file binari con estensione resources seguono il nome base della convenzione di denominazione. cultureName.resources, dove basename è il nome dell'app o il nome di una classe, a seconda del livello di dettaglio desiderato. La CultureInfo.Name proprietà viene usata per determinare cultureName. Una risorsa per le impostazioni cultura predefinite dell'app deve essere denominata basename.resources.
Si supponga, ad esempio, che un assembly disponga di diverse risorse in un file di risorse con il nome di base MyResources. Questi file di risorse devono avere nomi come MyResources.ja-JP.resources per le impostazioni cultura giapponese (giapponese), MyResources.de.resources per le impostazioni cultura tedesche, MyResources.zh-CHS.resources per le impostazioni cultura cinese semplificate e MyResources.fr-BE.resources per le impostazioni cultura francese (Belgio). Il file di risorse predefinito deve essere denominato MyResources.resources. I file di risorse specifici delle impostazioni cultura vengono comunemente inseriti in assembly satellite per ogni cultura. Il file di risorse predefinito deve essere incorporato nell'assembly principale dell'app.
Si noti che Assembly Linker consente alle risorse di essere contrassegnate come private, ma è consigliabile contrassegnarle sempre come pubbliche in modo che possano essere accessibili da altri assembly. Poiché un assembly satellite non contiene codice, le risorse contrassegnate come private non sono disponibili per l'app tramite qualsiasi meccanismo.
Per altre informazioni sulla creazione, la creazione di pacchetti e la distribuzione di risorse, vedere gli articoli Creazione di file di risorse, creazione di assembly satellite e creazione di pacchetti e distribuzione di risorse.
Creazione di un'istanza di un oggetto ResourceManager
Si crea un'istanza di un ResourceManager oggetto che recupera le risorse da un file con estensione resources incorporato chiamando uno degli overload del costruttore di classe. Ciò associa strettamente un ResourceManager oggetto a un determinato file con estensione resources e a qualsiasi file con estensione risorse localizzato associati negli assembly satellite.
I due costruttori più comunemente chiamati sono:
ResourceManager(String, Assembly) cerca le risorse in base a due informazioni fornite: il nome di base del file .resources e l'assembly in cui risiede il file .resources predefinito. Il nome di base include lo spazio dei nomi e il nome radice del file .resources, senza le impostazioni cultura o l'estensione. Si noti che i file con estensione resources compilati dalla riga di comando in genere non includono un nome dello spazio dei nomi, mentre i file con estensione resources creati nell'ambiente Visual Studio. Ad esempio, se un file di risorse è denominato MyCompany.StringResources.resources e il costruttore viene chiamato da un metodo statico denominato
Example.Main, il ResourceManager codice seguente crea un'istanza di un ResourceManager oggetto che può recuperare risorse dal file .resources:ResourceManager rm = new ResourceManager("MyCompany.StringResources", typeof(Example).Assembly);Dim rm As New ResourceManager("MyCompany.StringResources", GetType(Example).Assembly)ResourceManager(Type) cerca le risorse negli assembly satellite in base alle informazioni di un oggetto type. Il nome completo del tipo corrisponde al nome di base del file .resources senza l'estensione del nome file. Nelle app desktop create usando progettazione risorse Visual Studio, Visual Studio crea una classe wrapper il cui nome completo corrisponde al nome radice del file .resources. Ad esempio, se un file di risorse è denominato MyCompany.StringResources.resources e esiste una classe wrapper denominata
MyCompany.StringResources, il codice seguente crea un'istanza di un ResourceManager oggetto che può recuperare risorse dal file .resources:ResourceManager rm = new ResourceManager(typeof(MyCompany.StringResources));Dim rm As New ResourceManager(GetType(MyCompany.StringResources))
Se non è possibile trovare le risorse appropriate, la chiamata del costruttore crea un oggetto valido ResourceManager . Tuttavia, il tentativo di recuperare una risorsa genera un'eccezione MissingManifestResourceException . Per informazioni sulla gestione dell'eccezione, vedere la sezione Gestione di MissingManifestResourceException e MissingSatelliteAssembly Exceptions più avanti in questo articolo.
Nell'esempio seguente viene illustrato come creare un'istanza di un ResourceManager oggetto. Contiene il codice sorgente per un eseguibile denominato ShowTime.exe. Include anche il file di testo seguente denominato Strings.txt che contiene una singola risorsa stringa, TimeHeader:
TimeHeader=The current time is
È possibile usare un file batch per generare il file di risorse e incorporarlo nel file eseguibile. Ecco il file batch per generare un eseguibile usando il compilatore C#:
resgen strings.txt
csc ShowTime.cs /resource:strings.resources
Per il compilatore Visual Basic, è possibile usare il file batch seguente:
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
Risorse ResourceManager e Culture-Specific
Un'app localizzata richiede la distribuzione delle risorse, come illustrato nell'articolo Creazione di pacchetti e distribuzione di risorse. Se gli assembly sono configurati correttamente, gestione risorse determina quali risorse recuperare in base alla proprietà del Thread.CurrentUICulture thread corrente. Tale proprietà restituisce anche le impostazioni cultura dell'interfaccia utente del thread corrente. Ad esempio, se un'app viene compilata con le risorse di lingua inglese predefinite nell'assembly principale e con le risorse della lingua francese e russa in due assembly satellite e la Thread.CurrentUICulture proprietà è impostata su fr-FR, resource manager recupera le risorse francesi.
È possibile impostare la CurrentUICulture proprietà in modo esplicito o implicito. Il modo in cui viene impostato determina il modo in cui l'oggetto ResourceManager recupera le risorse in base alle impostazioni cultura:
Se la proprietà viene impostata in modo esplicito su impostazioni cultura specifiche, Resource Manager recupera sempre le risorse per tale cultura, indipendentemente Thread.CurrentUICulture dal browser o dalla lingua del sistema operativo dell'utente. Si consideri un'app compilata con le risorse di lingua inglese predefinite e tre assembly satellite che contengono risorse per l'inglese (Stati Uniti), francese (Francia) e russo (Russia). Se la CurrentUICulture proprietà è impostata su fr-FR, l'oggetto ResourceManager recupera sempre le risorse francese (Francia), anche se la lingua del sistema operativo dell'utente non è francese. Assicurarsi che si tratta del comportamento desiderato prima di impostare in modo esplicito la proprietà.
Nelle app ASP.NET è necessario impostare la proprietà in modo esplicito, perché è improbabile che l'impostazione Thread.CurrentUICulture nel server corrisponda alle richieste client in ingresso. Un'app ASP.NET può impostare la Thread.CurrentUICulture proprietà in modo esplicito sulla lingua di accettazione del browser dell'utente.
Impostando in modo esplicito la proprietà definisce le impostazioni cultura dell'interfaccia Thread.CurrentUICulture utente correnti per tale thread. Non influisce sulle impostazioni cultura dell'interfaccia utente correnti di altri thread in un'app.
È possibile impostare le impostazioni cultura dell'interfaccia utente di tutti i thread in un dominio dell'app assegnando un CultureInfo oggetto che rappresenta tale cultura alla proprietà statica CultureInfo.DefaultThreadCurrentUICulture .
Se non si impostano in modo esplicito le impostazioni cultura dell'interfaccia utente correnti e non si definiscono impostazioni cultura predefinite per il dominio dell'app corrente, la CultureInfo.CurrentUICulture proprietà viene impostata in modo implicito dalla funzione Windows
GetUserDefaultUILanguage. Questa funzione viene fornita dalla interfaccia utente multilingue (MUI), che consente all'utente di impostare la lingua predefinita. Se la lingua dell'interfaccia utente non è impostata dall'utente, viene impostata per impostazione predefinita sulla lingua installata dal sistema, ovvero la lingua delle risorse del sistema operativo.
L'esempio semplice "Hello world" seguente imposta in modo esplicito le impostazioni cultura dell'interfaccia utente correnti. Contiene risorse per tre culture: inglese (Stati Uniti) o en-US, francese (Francia) o fr-FR e russo (Russia) o ru-UR. Le risorse en-US sono contenute in un file di testo denominato Greetings.txt:
HelloString=Hello world!
Le risorse fr-FR sono contenute in un file di testo denominato Greetings.fr-FR.txt:
HelloString=Salut tout le monde!
Le risorse ru-UR sono contenute in un file di testo denominato Greetings.ru-RU.txt:
HelloString=Всем привет!
Ecco il codice sorgente dell'esempio (Example.vb per la versione Visual Basic o Example.cs per la versione 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.
' Всем привет!
Per compilare questo esempio, creare un file batch (.bat) contenente i comandi seguenti ed eseguirlo dal prompt dei comandi. Se si usa C#, specificare csc anziché vbc e Example.cs anziché 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
Recupero di risorse
Si chiamano i GetObject(String) metodi e GetString(String) per accedere a una risorsa specifica. È anche possibile chiamare il GetStream(String) metodo per recuperare le risorse non stringa come matrice di byte. Per impostazione predefinita, in un'app con risorse localizzate, questi metodi restituiscono la risorsa per le impostazioni cultura determinate dalle impostazioni cultura dell'interfaccia utente correnti del thread che ha effettuato la chiamata. Per altre informazioni sulla definizione delle impostazioni cultura dell'interfaccia utente correnti di un thread, vedere la sezione precedente, ResourceManager e risorse Culture-Specific. Se gestione risorse non riesce a trovare la risorsa per le impostazioni cultura dell'interfaccia utente del thread corrente, usa un processo di fallback per recuperare la risorsa specificata. Se gestione risorse non riesce a trovare risorse localizzate, usa le risorse delle impostazioni cultura predefinite. Per altre informazioni sulle regole di fallback delle risorse, vedere la sezione "Processo di fallback delle risorse" dell'articolo Creazione di pacchetti e distribuzione di risorse.
Nota
Se non è possibile trovare il file .resources specificato nel ResourceManager costruttore della classe, il tentativo di recuperare una risorsa genera un'eccezione MissingManifestResourceException o MissingSatelliteAssemblyException . Per informazioni sulla gestione dell'eccezione, vedere la sezione Gestione delle eccezioni MissingManifestResourceResourceException e MissingSatelliteAssemblyException più avanti in questo argomento.
Nell'esempio seguente viene usato il GetString metodo per recuperare risorse specifiche delle impostazioni cultura. È costituito da risorse compilate da .txt file per le culture inglese (en), francese (Francia) (fr-FR) e russo (Russia) (ru-UR). Nell'esempio vengono modificate le impostazioni cultura correnti e le impostazioni cultura dell'interfaccia utente correnti in inglese (Stati Uniti), francese (Francia), russo (Russia) e svedese (Svezia). Chiama quindi il GetString metodo per recuperare la stringa localizzata, visualizzata insieme al giorno e al mese corrente. Si noti che l'output visualizza la stringa localizzata appropriata, tranne quando le impostazioni cultura dell'interfaccia utente correnti sono svedesi (Svezia). Poiché le risorse della lingua svedese non sono disponibili, l'app usa invece le risorse delle impostazioni cultura predefinite, ovvero inglese.
L'esempio richiede i file di risorse basati sul testo elencati nella tabella seguente. Ogni oggetto ha una singola risorsa stringa denominata DateStart.
| Impostazioni cultura | Nome file | Nome risorsa | Valore della risorsa |
|---|---|---|---|
| it-IT | DateStrings.txt | DateStart |
Oggi è |
| fr-FR | DateStrings.fr-FR.txt | DateStart |
Aujourd'hui, c'est le |
| ru-RU | DateStrings.ru-RU.txt | DateStart |
Сегодня |
Ecco il codice sorgente dell'esempio (ShowDate.vb per la versione Visual Basic o ShowDate.cs per la versione C# del codice).
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.
Per compilare questo esempio, creare un file batch contenente i comandi seguenti ed eseguirlo dal prompt dei comandi. Se si usa C#, specificare csc anziché vbc e showdate.cs anziché 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
Esistono due modi per recuperare le risorse di impostazioni cultura specifiche diverse dalle impostazioni cultura dell'interfaccia utente correnti:
È possibile chiamare il GetString(String, CultureInfo)metodo , GetObject(String, CultureInfo)o GetStream(String, CultureInfo) per recuperare una risorsa per impostazioni cultura specifiche. Se non è possibile trovare una risorsa localizzata, gestione risorse usa il processo di fallback della risorsa per individuare una risorsa appropriata.
È possibile chiamare il GetResourceSet metodo per ottenere un ResourceSet oggetto che rappresenta le risorse per una determinata cultura. Nella chiamata al metodo è possibile determinare se i probe di Resource Manager per le impostazioni cultura padre se non è in grado di trovare risorse localizzate o se semplicemente tornano alle risorse delle impostazioni cultura predefinite. È quindi possibile usare i ResourceSet metodi per accedere alle risorse (localizzate per tale cultura) in base al nome o per enumerare le risorse nel set.
Gestione delle eccezioni MissingManifestResourceException e MissingSatelliteAssemblyException
Se si tenta di recuperare una risorsa specifica, ma gestione risorse non riesce a trovare tale risorsa e non sono state definite impostazioni cultura predefinite o le risorse delle impostazioni cultura predefinite non possono essere localizzate, gestione risorse genera un'eccezione MissingManifestResourceException se prevede di trovare le risorse nell'assembly principale o un MissingSatelliteAssemblyException se prevede di trovare le risorse in un assembly satellite. Si noti che l'eccezione viene generata quando si chiama un metodo di recupero di risorse, GetString ad esempio o GetObject, e non quando si crea un'istanza di un ResourceManager oggetto.
L'eccezione viene generata in genere nelle condizioni seguenti:
Il file di risorse o l'assembly satellite appropriato non esiste. Se gestione risorse prevede che le risorse predefinite dell'app siano incorporate nell'assembly dell'app principale, sono assenti. Se l'attributo indica che le NeutralResourcesLanguageAttribute risorse predefinite dell'app risiedono in un assembly satellite, tale assembly non può essere trovato. Quando si compila l'app, assicurarsi che le risorse siano incorporate nell'assembly principale o che l'assembly satellite necessario venga generato e sia denominato in modo appropriato. Il nome deve accettare il formato appName.resources.dll e deve trovarsi in una directory denominata dopo le impostazioni cultura le cui risorse contengono.
L'app non ha impostazioni cultura predefinite o neutrali. Aggiungere l'attributo NeutralResourcesLanguageAttribute a un file di codice sorgente o al file di informazioni del progetto (AssemblyInfo.vb per un'app Visual Basic o AssemblyInfo.cs per un file di app C#).
Il
baseNameparametro nel ResourceManager(String, Assembly) costruttore non specifica il nome di un file con estensione resources. Il nome deve includere lo spazio dei nomi completo del file di risorse, ma non l'estensione del nome file. In genere, i file di risorse creati in Visual Studio includono nomi dello spazio dei nomi, ma i file di risorse creati e compilati al prompt dei comandi non sono. È possibile determinare i nomi dei file con estensione risorse incorporati compilando ed eseguendo l'utilità seguente. Si tratta di un'app console che accetta il nome di un assembly principale o di un assembly satellite come parametro della riga di comando. Visualizza le stringhe che devono essere fornite comebaseNameparametro in modo che gestione risorse possa identificare correttamente la risorsa.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
Se si modificano in modo esplicito le impostazioni cultura correnti dell'applicazione, è consigliabile ricordare che gestione risorse recupera un set di risorse in base al valore della CultureInfo.CurrentUICulture proprietà e non alla CultureInfo.CurrentCulture proprietà. In genere, se si modifica un valore, è necessario modificare anche l'altro.
Controllo delle versioni delle risorse
Poiché l'assembly principale che contiene le risorse predefinite di un'app è separato dagli assembly satellite dell'app, è possibile rilasciare una nuova versione dell'assembly principale senza ridistribuire gli assembly satellite. Usare l'attributo SatelliteContractVersionAttribute per usare assembly satellite esistenti e indicare al gestore risorse di non ridistribuirli con una nuova versione dell'assembly principale,
Per altre informazioni sul supporto per il controllo delle versioni per gli assembly satellite, vedere l'articolo Recupero delle risorse.
<satelliteassemblies> Nodo file di configurazione
Nota
Questa sezione è specifica per le app .NET Framework.
Per i file eseguibili distribuiti ed eseguiti da un sito Web (file HREF .exe), l'oggetto ResourceManager può eseguire il probe per gli assembly satellite sul Web, che può danneggiare le prestazioni dell'app. Per eliminare il problema delle prestazioni, è possibile limitare questa verifica agli assembly satellite distribuiti con l'app. A tale scopo, si crea un nodo nel file di configurazione dell'app per specificare che è stato distribuito un <satelliteassemblies> set specifico di impostazioni cultura per l'app e che l'oggetto non deve provare a eseguire il ResourceManager probe per le impostazioni cultura non elencate in tale nodo.
Nota
L'alternativa preferita alla creazione di un <satelliteassemblies> nodo consiste nell'usare la funzionalità manifesto di distribuzione ClickOnce.
Nel file di configurazione dell'app creare una sezione simile alla seguente:
<?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>
Modificare queste informazioni di configurazione come indicato di seguito:
Specificare uno o più
<assembly>nodi per ogni assembly principale distribuito, in cui ogni nodo specifica un nome di assembly completo. Specificare il nome dell'assembly principale al posto di MainAssemblyName e specificare iVersionvalori di attributo ,PublicKeyTokeneCulturecorrispondenti all'assembly principale.Per l'attributo specificare il numero di versione dell'assembly
Version. Ad esempio, la prima versione dell'assembly potrebbe essere il numero di versione 1.0.0.0.Per l'attributo, specificare la parola chiave
nullse l'assemblyPublicKeyTokennon è stato firmato con un nome sicuro o specificare il token di chiave pubblica se l'assembly è stato firmato.Per l'attributo, specificare la parola chiave
neutralper designare l'assemblyCultureprincipale e causare il ResourceManager probe della classe solo per le impostazioni cultura elencate nei<culture>nodi.Per altre informazioni sui nomi di assembly completi, vedere l'articolo Nomi assembly. Per altre informazioni sugli assembly con nome sicuro, vedere l'articolo Creare e usare assembly con nome sicuro.
Specificare uno o più
<culture>nodi con un nome di impostazioni cultura specifico, ad esempio "fr-FR" o un nome cultura neutrale, ad esempio "fr".
Se le risorse sono necessarie per qualsiasi assembly non elencato nel <satelliteassemblies> nodo, i probe di classe per le ResourceManager impostazioni cultura usano regole di test standard.
app Windows 8.x
Importante
Anche se la ResourceManager classe è supportata nelle app Windows 8.x, non è consigliabile usarla. Usare questa classe solo quando si sviluppano progetti di libreria di classi portabili che possono essere usati con app Windows 8.x. Per recuperare le risorse dalle app Windows 8.x, usare la Windows. Classe ApplicationModel.Resources.ResourceLoader.
Per le app Windows 8.x, la ResourceManager classe recupera le risorse dai file PRI (Package Resource Index). Un singolo file PRI (il file PRI del pacchetto dell'applicazione) contiene le risorse per le impostazioni cultura predefinite e le impostazioni cultura localizzate. Usare l'utilità MakePRI per creare un file PRI da uno o più file di risorse in formato xml resource (con estensione resw). Per le risorse incluse in un progetto di Visual Studio, Visual Studio gestisce automaticamente il processo di creazione e creazione del pacchetto del file PRI. È quindi possibile usare la classe .NET Framework ResourceManager per accedere alle risorse dell'app o della libreria.
È possibile creare un'istanza di un oggetto per un'app ResourceManager Windows 8.x nello stesso modo in cui si esegue per un'app desktop.
È quindi possibile accedere alle risorse per una determinata cultura passando il nome della risorsa da recuperare al GetString(String) metodo. Per impostazione predefinita, questo metodo restituisce la risorsa per le impostazioni cultura determinate dalle impostazioni cultura dell'interfaccia utente correnti del thread che ha effettuato la chiamata. È anche possibile recuperare le risorse per una cultura specifica passando il nome della risorsa e un CultureInfo oggetto che rappresenta le impostazioni cultura la cui risorsa deve essere recuperata al GetString(String, CultureInfo) metodo. Se non è possibile trovare la risorsa per le impostazioni cultura dell'interfaccia utente correnti o le impostazioni cultura specificate, gestione risorse usa un elenco di fallback della lingua dell'interfaccia utente per individuare una risorsa appropriata.
Costruttori
| ResourceManager() |
Inizializza una nuova istanza della classe ResourceManager con i valori predefiniti. |
| ResourceManager(String, Assembly) |
Inizializza una nuova istanza della classe ResourceManager che ricerca le risorse contenute nei file con il nome radice specificato nell'assembly fornito. |
| ResourceManager(String, Assembly, Type) |
Inizializza una nuova istanza della classe ResourceManager che usa una classe ResourceSet specificata per cercare le risorse contenute nei file con il nome radice specificato nell'assembly fornito. |
| ResourceManager(Type) |
Inizializza una nuova istanza della classe ResourceManager che ricerca le risorse negli assembly satellite in base alle informazioni derivate dall'oggetto di tipo specificato. |
Campi
| BaseNameField |
Specifica il nome radice dei file di risorse in cui l'oggetto ResourceManager cerca le risorse. |
| HeaderVersionNumber |
Specifica la versione delle intestazioni dei file di risorse interpretabili e producibili dall'implementazione corrente di ResourceManager. |
| MagicNumber |
Contiene il numero usato per identificare i file di risorse. |
| MainAssembly |
Specifica l'assembly principale che contiene le risorse. |
| ResourceSets |
Obsoleta.
Contiene un oggetto Hashtable che restituisce un mapping dalle impostazioni cultura agli oggetti ResourceSet. |
Proprietà
| BaseName |
Ottiene il nome radice dei file di risorse in cui l'oggetto ResourceManager ricerca le risorse. |
| FallbackLocation |
Ottiene o imposta il percorso da cui recuperare le risorse di fallback predefinite. |
| IgnoreCase |
Ottiene o imposta un valore che indica se il gestore delle risorse consente la ricerca delle risorse senza distinzione tra maiuscole e minuscole nei metodi GetString(String) e GetObject(String). |
| ResourceSetType |
Ottiene il tipo di oggetto set di risorse usato dal gestore delle risorse per costruire un oggetto ResourceSet. |
Metodi
| CreateFileBasedResourceManager(String, String, Type) |
Restituisce un oggetto ResourceManager che ricerca le risorse in una directory specifica invece che nel manifesto dell'assembly per le risorse. |
| Equals(Object) |
Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object) |
| GetHashCode() |
Funge da funzione hash predefinita. (Ereditato da Object) |
| GetNeutralResourcesLanguage(Assembly) |
Restituisce le informazioni specifiche delle impostazioni cultura per le risorse predefinite dell'assembly principale mediante il recupero del valore dell'attributo NeutralResourcesLanguageAttribute su un assembly specificato. |
| GetObject(String) |
Restituisce il valore della risorsa non di tipo stringa specificata. |
| GetObject(String, CultureInfo) |
Ottiene il valore della risorsa non di tipo stringa specificata localizzata per le impostazioni cultura specificate. |
| GetResourceFileName(CultureInfo) |
Genera il nome del file di risorse per l'oggetto CultureInfo specificato. |
| GetResourceSet(CultureInfo, Boolean, Boolean) |
Recupera il set di risorse per impostazioni cultura specifiche. |
| GetSatelliteContractVersion(Assembly) |
Restituisce la versione specificata dall'attributo SatelliteContractVersionAttribute nell'assembly specificato. |
| GetStream(String) |
Restituisce un oggetto di flusso di memoria non gestito dalla risorsa specificata. |
| GetStream(String, CultureInfo) |
Restituisce un oggetto flusso di memoria non gestito dalla risorsa specificata usando le impostazioni cultura specificate. |
| GetString(String) |
Restituisce il valore della risorsa di tipo stringa specificata. |
| GetString(String, CultureInfo) |
Restituisce il valore della risorsa di tipo stringa localizzata per le impostazioni cultura specificate. |
| GetType() |
Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object) |
| InternalGetResourceSet(CultureInfo, Boolean, Boolean) |
Fornisce l'implementazione per trovare un set di risorse. |
| MemberwiseClone() |
Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object) |
| ReleaseAllResources() |
Indica al gestore delle risorse di chiamare il metodo Close() su tutti gli oggetti ResourceSet e di rilasciare tutte le risorse. |
| ToString() |
Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object) |
Si applica a
Thread safety
Questo tipo è thread-safe.