System.Resources.ResourceManager-Klasse
Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.
Wichtig
Das Aufrufen von Methoden aus dieser Klasse mit nicht vertrauenswürdigen Daten stellt ein Sicherheitsrisiko dar. Rufen Sie die Methoden aus dieser Klasse nur mit vertrauenswürdigen Daten auf. Weitere Informationen finden Sie unter Überprüfen aller Eingaben.
Die ResourceManager Klasse ruft Ressourcen aus einer binär.resources-Datei ab, die in eine Assembly oder aus einer eigenständigen RESSOURCEN-Datei eingebettet ist. Wenn eine App lokalisiert und lokalisierte Ressourcen in Satellitenassemblys bereitgestellt wurden, sucht sie kulturspezifische Ressourcen, stellt Ressourcenfallback bereit, wenn keine lokalisierte Ressource vorhanden ist, und unterstützt die Ressourcen serialisierung.
Desktop-App
Bei Desktop-Apps ruft die ResourceManager Klasse Ressourcen aus Binärressourcendateien (.resources) ab. In der Regel bettet ein Sprachcompiler oder assembly Linker (AL.exe) diese Ressourcendateien in eine Assembly ein. Sie können auch ein ResourceManager Objekt verwenden, um Ressourcen direkt aus einer RESSOURCENdatei abzurufen, die nicht in eine Assembly eingebettet ist, indem Sie die CreateFileBasedResourceManager Methode aufrufen.
Achtung
Wenn Sie eigenständige RESSOURCEN-Dateien in einer ASP.NET-App verwenden, wird die XCOPY-Bereitstellung aufgehoben, da die Ressourcen wieder Standard gesperrt sind, bis sie explizit von der ReleaseAllResources Methode freigegeben werden. Wenn Sie Ressourcen mit Ihren ASP.NET-Apps bereitstellen möchten, sollten Sie Die RESSOURCEN-Dateien in Satellitenassemblys kompilieren.
In einer ressourcenbasierten App enthält eine RESSOURCENdatei die Ressourcen der Standardkultur, deren Ressourcen verwendet werden, wenn keine kulturspezifischen Ressourcen gefunden werden. Wenn beispielsweise die Standardkultur einer App Englisch (en) ist, werden die Englisch-Sprachressourcen verwendet, wenn lokalisierte Ressourcen für eine bestimmte Kultur nicht gefunden werden können, z. B. Englisch (USA) (en-US) oder Französisch (Frankreich) (fr-FR). In der Regel werden die Ressourcen für die Standardkultur in die Standard App-Assembly eingebettet, und Ressourcen für andere lokalisierte Kulturen werden in Satellitenassemblys eingebettet. Satellitenassemblys enthalten nur Ressourcen. Sie haben denselben Stammdateinamen wie die Standard Assembly und eine Erweiterung von .resources.dll. Für Apps, deren Assemblys nicht im globalen Assemblycache registriert sind, werden Satellitenassemblys in einem App-Unterverzeichnis gespeichert, dessen Name der Assemblykultur entspricht.
Erstellen von Ressourcen
Wenn Sie eine ressourcenbasierte App entwickeln, speichern Sie Ressourceninformationen in Textdateien (Dateien mit .txt- oder RESTEXT-Erweiterung) oder XML-Dateien (Dateien mit einer RESX-Erweiterung). Anschließend kompilieren Sie die Text- oder XML-Dateien mit dem Ressourcendatei-Generator (Resgen.exe), um eine Binärressourcendatei zu erstellen. Anschließend können Sie die resultierende RESSOURCEN-Datei in eine ausführbare Datei oder Bibliothek einbetten, indem Sie eine Compileroption verwenden, z /resources . B. für die Compiler C# und Visual Basic, oder Sie können sie in eine Satellitenassembly einbetten, indem Sie den AssemblyLinker (AI.exe) verwenden. Wenn Sie eine RESX-Datei in Ihr Visual Studio-Projekt einschließen, verarbeitet Visual Studio die Kompilierung und Einbettung von Standard- und lokalisierten Ressourcen automatisch als Teil des Buildprozesses.
Im Idealfall sollten Sie Ressourcen für jede sprache erstellen, die Ihre App unterstützt, oder zumindest für eine sinnvolle Teilmenge jeder Sprache. Die Dateinamen der binären RESSOURCEN folgen dem Basisnamen der Benennungskonvention.cultureName.resources, wobei Basisname der Name der App oder der Name einer Klasse ist, abhängig von der gewünschten Detailebene. Die CultureInfo.Name Eigenschaft wird verwendet, um cultureName zu bestimmen. Eine Ressource für die Standardkultur der App sollte den Namen "basename.resources" haben.
Angenommen, eine Assembly verfügt über mehrere Ressourcen in einer Ressourcendatei mit dem Basisnamen MyResources. Diese Ressourcendateien sollten Namen wie "MyResources.ja-JP.resources" für die japanische (japanische) Kultur, "MyResources.de.resources" für die deutsche Kultur, "MyResources.zh-CHS.resources" für die vereinfachte chinesische Kultur und "MyResources.fr-BE.resources" für die französische Kultur (Belgien) enthalten. Die Standardressourcendatei sollte den Namen "MyResources.resources" haben. Die kulturspezifischen Ressourcendateien werden häufig in Satellitenassemblys für jede Kultur verpackt. Die Standardressourcendatei sollte in die Standard Assembly der App eingebettet werden.
Beachten Sie, dass Der Assemblylinker die Kennzeichnung von Ressourcen als privat zulässt. Sie sollten sie jedoch immer als öffentlich markieren, damit sie von anderen Assemblys aufgerufen werden können. (Da eine Satellitenassembly keinen Code enthält, sind Ressourcen, die als privat gekennzeichnet sind, für Ihre App über einen beliebigen Mechanismus nicht verfügbar.)
Weitere Informationen zum Erstellen, Verpacken und Bereitstellen von Ressourcen finden Sie in den Artikeln "Erstellen von Ressourcendateien", "Erstellen von Satellitenassemblys" und "Packaging" und "Deploying Resources".
Instanziieren eines ResourceManager-Objekts
Sie instanziieren ein ResourceManager Objekt, das Ressourcen aus einer eingebetteten RESSOURCEN-Datei abruft, indem Sie eine seiner Klassenkonstruktorüberladungen aufrufen. Dadurch wird ein ResourceManager Objekt eng mit einer bestimmten RESSOURCEN-Datei und allen zugeordneten lokalisierten RESSOURCEN-Dateien in Satellitenassemblys gekoppelt.
Die beiden am häufigsten genannten Konstruktoren sind:
ResourceManager(String, Assembly) Sucht Ressourcen basierend auf zwei von Ihnen bereitgestellten Informationen: dem Basisnamen der RESSOURCEN-Datei und der Assembly, in der sich die Standardressourcendatei befindet. Der Basisname enthält den Namespace und den Stammnamen der RESSOURCEN-Datei, ohne seine Kultur oder Erweiterung. Beachten Sie, dass RESSOURCEN-Dateien, die aus der Befehlszeile kompiliert werden, in der Regel keinen Namespacenamen enthalten, während ressourcendateien, die in der Visual Studio-Umgebung erstellt werden. Wenn beispielsweise eine Ressourcendatei den Namen "MyCompany.StringResources.resources" hat und der ResourceManager Konstruktor von einer statischen Methode mit dem Namen
Example.Mainaufgerufen wird, instanziiert der folgende Code ein ResourceManager Objekt, das Ressourcen aus der RESSOURCENdatei abrufen kann:ResourceManager rm = new ResourceManager("MyCompany.StringResources", typeof(Example).Assembly);Dim rm As New ResourceManager("MyCompany.StringResources", GetType(Example2).Assembly)ResourceManager(Type) Sucht Ressourcen in Satellitenassemblys basierend auf Informationen aus einem Typobjekt. Der vollqualifizierte Name des Typs entspricht dem Basisnamen der RESSOURCEN-Datei ohne dateinamenerweiterung. In Desktop-Apps, die mit dem Visual Studio-Ressourcen-Designer erstellt werden, erstellt Visual Studio eine Wrapperklasse, deren vollqualifizierter Name dem Stammnamen der RESSOURCEN-Datei entspricht. Wenn beispielsweise eine Ressourcendatei den Namen "MyCompany.StringResources.resources" hat und eine Wrapperklasse namens "Wrapper" vorhanden
MyCompany.StringResourcesist, instanziiert der folgende Code ein ResourceManager Objekt, das Ressourcen aus der RESSOURCENdatei abrufen kann:ResourceManager rm = new ResourceManager(typeof(MyCompany.StringResources));Dim rm As New ResourceManager(GetType(MyCompany.StringResources))
Wenn die entsprechenden Ressourcen nicht gefunden werden können, erstellt der Konstruktoraufruf ein gültiges ResourceManager Objekt. Der Versuch, eine Ressource abzurufen, löst jedoch eine MissingManifestResourceException Ausnahme aus. Informationen zum Umgang mit der Ausnahme finden Sie im Abschnitt "Handle MissingManifestResourceException" und "MissingSatelliteAssemblyException Exceptions" weiter unten in diesem Artikel.
Das folgende Beispiel zeigt, wie ein ResourceManager Objekt instanziieren. Sie enthält den Quellcode für eine ausführbare Datei mit dem Namen ShowTime.exe. Sie enthält auch die folgende Textdatei mit dem Namen Strings.txt, die eine einzelne Zeichenfolgenressource enthält: TimeHeader
TimeHeader=The current time is
Sie können eine Batchdatei verwenden, um die Ressourcendatei zu generieren und in die ausführbare Datei einzubetten. Dies ist die Batchdatei zum Generieren einer ausführbaren Datei mithilfe des C#-Compilers:
resgen strings.txt
csc ShowTime.cs /resource:strings.resources
Für den Visual Basic-Compiler können Sie die folgende Batchdatei verwenden:
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 und kulturspezifische Ressourcen
Eine lokalisierte App erfordert, dass Ressourcen bereitgestellt werden, wie im Artikel "Packen und Bereitstellen von Ressourcen" beschrieben. Wenn die Assemblys ordnungsgemäß konfiguriert sind, bestimmt der Ressourcen-Manager, welche Ressourcen basierend auf der Eigenschaft des Thread.CurrentUICulture aktuellen Threads abgerufen werden sollen. (Diese Eigenschaft gibt auch die UI-Kultur des aktuellen Threads zurück.) Wenn eine App z. B. in der Standard Assembly und in zwei Satellitenassemblys mit französischen und russischen Sprachressourcen kompiliert wird und die Eigenschaft auf "fr-FR" festgelegt ist, ruft der Thread.CurrentUICulture Ressourcenmanager die französischen Ressourcen ab.
Sie können die CurrentUICulture Eigenschaft explizit oder implizit festlegen. Die Art und Weise, wie Sie es festlegen, bestimmt, wie das ResourceManager Objekt Ressourcen basierend auf der Kultur abruft:
Wenn Sie die Thread.CurrentUICulture Eigenschaft explizit auf eine bestimmte Kultur festlegen, ruft der Ressourcenmanager immer die Ressourcen für diese Kultur ab, unabhängig von der Browser- oder Betriebssystemsprache des Benutzers. Betrachten Sie eine App, die mit Standardressourcen für englischen Sprachen und drei Satellitenassemblys kompiliert wird, die Ressourcen für Englisch (USA), Französisch (Frankreich) und Russisch (Russland) enthalten. Wenn die CurrentUICulture Eigenschaft auf fr-FR festgelegt ist, ruft das ResourceManager Objekt immer die Französisch -Ressourcen (Frankreich) ab, auch wenn die Betriebssystemsprache des Benutzers nicht französisch ist. Stellen Sie sicher, dass dies das gewünschte Verhalten ist, bevor Sie die Eigenschaft explizit festlegen.
In ASP.NET Apps müssen Sie die Thread.CurrentUICulture Eigenschaft explizit festlegen, da die Einstellung auf dem Server unwahrscheinlich ist, dass die Einstellung auf dem Server mit eingehenden Clientanforderungen übereinstimmt. Eine ASP.NET-App kann die Thread.CurrentUICulture Eigenschaft explizit auf die Browser-Akzeptiert-Sprache des Benutzers festlegen.
Durch das explizite Festlegen der Thread.CurrentUICulture Eigenschaft wird die aktuelle Benutzeroberflächenkultur für diesen Thread definiert. Sie wirkt sich nicht auf die aktuelle Ui-Kultur anderer Threads in einer App aus.
Sie können die Ui-Kultur aller Threads in einer App festlegen Standard indem Sie ein CultureInfo Objekt zuweisen, das diese Kultur der statischen CultureInfo.DefaultThreadCurrentUICulture Eigenschaft darstellt.
Wenn Sie die aktuelle Benutzeroberflächenkultur nicht explizit festlegen und keine Standardkultur für die aktuelle App definieren Standard wird die CultureInfo.CurrentUICulture Eigenschaft implizit von der Windows-Funktion
GetUserDefaultUILanguagefestgelegt. Diese Funktion wird von der mehrsprachige Benutzeroberfläche (MUI) bereitgestellt, mit der der Benutzer die Standardsprache festlegen kann. Wenn die Benutzeroberflächensprache nicht vom Benutzer festgelegt wird, wird standardmäßig die vom System installierte Sprache verwendet, bei der es sich um die Sprache der Betriebssystemressourcen handelt.
Im folgenden einfachen Beispiel für "Hello world" wird die aktuelle Ui-Kultur explizit festgelegt. Es enthält Ressourcen für drei Kulturen: Englisch (USA) oder en-US, Französisch (Frankreich) oder fr-FR und Russisch (Russland) oder Ru-RU. Die en-US-Ressourcen sind in einer Textdatei namens Greetings.txt enthalten:
HelloString=Hello world!
Die fr-FR-Ressourcen sind in einer Textdatei namens Greetings.fr-FR.txt enthalten:
HelloString=Salut tout le monde!
Die ru-RU-Ressourcen sind in einer Textdatei mit dem Namen Greetings.ru-RU.txt enthalten:
HelloString=Всем привет!
Hier sehen Sie den Quellcode für das Beispiel (Example.vb für die Visual Basic-Version oder Example.cs für die C#-Version):
using System;
using System.Globalization;
using System.Resources;
using System.Threading;
public class Example
{
public static void Main()
{
// Create array of supported cultures
string[] cultures = { "en-CA", "en-US", "fr-FR", "ru-RU" };
Random rnd = new Random();
int cultureNdx = rnd.Next(0, cultures.Length);
CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
ResourceManager rm = new ResourceManager("Greetings", typeof(Example).Assembly);
try
{
CultureInfo newCulture = new CultureInfo(cultures[cultureNdx]);
Thread.CurrentThread.CurrentCulture = newCulture;
Thread.CurrentThread.CurrentUICulture = newCulture;
string greeting = String.Format("The current culture is {0}.\n{1}",
Thread.CurrentThread.CurrentUICulture.Name,
rm.GetString("HelloString"));
Console.WriteLine(greeting);
}
catch (CultureNotFoundException e)
{
Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName);
}
finally
{
Thread.CurrentThread.CurrentCulture = originalCulture;
Thread.CurrentThread.CurrentUICulture = originalCulture;
}
}
}
// The example displays output like the following:
// The current culture is ru-RU.
// Всем привет!
Imports System.Globalization
Imports System.Resources
Imports System.Threading
Module Example
Sub Main()
' Create array of supported cultures
Dim cultures() As String = {"en-CA", "en-US", "fr-FR", "ru-RU" }
Dim rnd As New Random()
Dim cultureNdx As Integer = rnd.Next(0, cultures.Length)
Dim originalCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Dim rm As New ResourceManager("Greetings", GetType(Example).Assembly)
Try
Dim newCulture As New CultureInfo(cultures(cultureNdx))
Thread.CurrentThread.CurrentCulture = newCulture
Thread.CurrentThread.CurrentUICulture = newCulture
Dim greeting As String = String.Format("The current culture is {0}.{1}{2}",
Thread.CurrentThread.CurrentUICulture.Name,
vbCrLf, rm.GetString("HelloString"))
Console.WriteLine(greeting)
Catch e As CultureNotFoundException
Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName)
Finally
Thread.CurrentThread.CurrentCulture = originalCulture
Thread.CurrentThread.CurrentUICulture = originalCulture
End Try
End Sub
End Module
' The example displays output like the following:
' The current culture is ru-RU.
' Всем привет!
Um dieses Beispiel zu kompilieren, erstellen Sie eine Batchdatei (.bat), die die folgenden Befehle enthält, und führen Sie sie über die Eingabeaufforderung aus. Wenn Sie C# verwenden, geben Sie csc anstelle und vbcExample.cs anstelle von 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
Abrufen von Ressourcen
Sie rufen die GetObject(String) Methoden auf GetString(String) , um auf eine bestimmte Ressource zuzugreifen. Sie können die GetStream(String) Methode auch aufrufen, um Ressourcen ohne Zeichenfolge als Bytearray abzurufen. Standardmäßig geben diese Methoden in einer App mit lokalisierten Ressourcen die Ressource für die Kultur zurück, die von der aktuellen Benutzeroberflächenkultur des Threads bestimmt wird, der den Aufruf ausgeführt hat. Weitere Informationen dazu, wie die aktuelle UI-Kultur eines Threads definiert wird, finden Sie im vorherigen Abschnitt, ResourceManager und kulturspezifische Ressourcen. Wenn der Ressourcen-Manager die Ressource für die UI-Kultur des aktuellen Threads nicht finden kann, wird ein Fallbackprozess zum Abrufen der angegebenen Ressource verwendet. Wenn der Ressourcenmanager keine lokalisierten Ressourcen finden kann, verwendet er die Ressourcen der Standardkultur. Weitere Informationen zu Ressourcenfallbackregeln finden Sie im Abschnitt "Ressourcenfallbackprozess" des Artikels "Packen und Bereitstellen von Ressourcen".
Hinweis
Wenn die im ResourceManager Klassenkonstruktor angegebene RESSOURCENdatei nicht gefunden werden kann, löst der Versuch, eine Ressource abzurufen, eine MissingManifestResourceException Ausnahme aus MissingSatelliteAssemblyException . Informationen zum Umgang mit der Ausnahme finden Sie im Abschnitt "Handle MissingManifestResourceException" und "MissingSatelliteAssemblyException Exceptions" weiter unten in diesem Artikel.
Im folgenden Beispiel wird die GetString Methode zum Abrufen kulturspezifischer Ressourcen verwendet. Es besteht aus Ressourcen, die aus .txt Dateien für die Kulturen Englisch (en), Französisch (Frankreich) (fr-FR) und Russisch (Russland) (ru-RU) kompiliert wurden. Im Beispiel wird die aktuelle Kultur und die aktuelle UI-Kultur in Englisch (USA), Französisch (Frankreich), Russisch (Russland) und Schwedisch (Schweden) geändert. Anschließend wird die GetString Methode aufgerufen, um die lokalisierte Zeichenfolge abzurufen, die zusammen mit dem aktuellen Tag und dem aktuellen Monat angezeigt wird. Beachten Sie, dass die Ausgabe die entsprechende lokalisierte Zeichenfolge anzeigt, außer wenn die aktuelle UI-Kultur schwedisch (Schweden) ist. Da schwedische Sprachressourcen nicht verfügbar sind, verwendet die App stattdessen die Ressourcen der Standardkultur, die Englisch ist.
Für das Beispiel sind die textbasierten Ressourcendateien erforderlich, die in der folgenden Tabelle aufgeführt sind. Jede verfügt über eine einzelne Zeichenfolgenressource mit dem Namen DateStart.
| Kultur | Dateiname | Ressourcenname | Ressourcenwert |
|---|---|---|---|
| de-De | DateStrings.txt | DateStart |
Heute ist |
| fr-FR | DateStrings.fr-FR.txt | DateStart |
Aujourd'hui, c'est le |
| ru-RU | DateStrings.ru-RU.txt | DateStart |
Сегодня |
Hier sehen Sie den Quellcode für das Beispiel (ShowDate.vb für die Visual Basic-Version oder ShowDate.cs für die C#-Version des Codes).
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.
Erstellen Sie zum Kompilieren dieses Beispiels eine Batchdatei, die die folgenden Befehle enthält, und führen Sie sie über die Eingabeaufforderung aus. Wenn Sie C# verwenden, geben Sie csc anstelle und vbcshowdate.cs anstelle von 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
Es gibt zwei Möglichkeiten zum Abrufen der Ressourcen einer anderen Kultur als der aktuellen Benutzeroberflächenkultur:
- Sie können die GetString(String, CultureInfo)Oder-Methode GetObject(String, CultureInfo)aufrufen, GetStream(String, CultureInfo) um eine Ressource für eine bestimmte Kultur abzurufen. Wenn eine lokalisierte Ressource nicht gefunden werden kann, verwendet der Ressourcenmanager den Ressourcenfallbackprozess, um eine entsprechende Ressource zu suchen.
- Sie können die GetResourceSet Methode aufrufen, um ein ResourceSet Objekt abzurufen, das die Ressourcen für eine bestimmte Kultur darstellt. Im Methodenaufruf können Sie ermitteln, ob der Ressourcen-Manager-Prüfer für übergeordnete Kulturen überprüft wird, ob lokalisierte Ressourcen nicht gefunden werden können oder ob er einfach auf die Ressourcen der Standardkultur zurückgreift. Anschließend können Sie mithilfe der ResourceSet Methoden auf die Ressourcen (lokalisiert für diese Kultur) anhand des Namens zugreifen oder die Ressourcen im Satz aufzählen.
Behandeln von MissingManifestResourceException- und MissingSatelliteAssemblyException-Ausnahmen
Wenn Sie versuchen, eine bestimmte Ressource abzurufen, aber der Ressourcenmanager diese Ressource nicht finden kann und entweder keine Standardkultur definiert wurde oder die Ressourcen der Standardkultur nicht gefunden werden können, löst der Ressourcenmanager eine MissingManifestResourceException Ausnahme aus, wenn erwartet wird, dass die Ressourcen in der Standard-Assembly gefunden werden, oder eineMissingSatelliteAssemblyException, wenn erwartet wird, dass die Ressourcen in einer Satellitenassembly gefunden werden. Beachten Sie, dass die Ausnahme ausgelöst wird, wenn Sie eine Methode zum Abrufen einer Ressource aufrufen, z GetString . B. oder GetObject, und nicht, wenn Sie ein ResourceManager Objekt instanziieren.
Die Ausnahme wird in der Regel unter den folgenden Bedingungen ausgelöst:
Die entsprechende Ressourcendatei oder Satellitenassembly ist nicht vorhanden. Wenn der Ressourcenmanager erwartet, dass die Standardressourcen der App in die Standard App-Assembly eingebettet werden, fehlen sie. Wenn das NeutralResourcesLanguageAttribute Attribut angibt, dass sich die Standardressourcen der App in einer Satellitenassembly befinden, kann diese Assembly nicht gefunden werden. Stellen Sie beim Kompilieren der App sicher, dass Ressourcen in die Standard-Assembly eingebettet sind oder dass die erforderliche Satellitenassembly generiert und entsprechend benannt wird. Der Name sollte das Format "appName" aufweisen.resources.dll und sollte sich in einem Verzeichnis befinden, das nach der Kultur benannt ist, deren Ressourcen es enthält.
Ihre App verfügt nicht über eine standard- oder neutrale Kultur. Fügen Sie das NeutralResourcesLanguageAttribute Attribut einer Quellcodedatei oder der Projektinformationsdatei (AssemblyInfo.vb für eine Visual Basic-App oder AssemblyInfo.cs für eine C#-App-Datei) hinzu.
Der
baseNameParameter im ResourceManager(String, Assembly) Konstruktor gibt nicht den Namen einer RESSOURCEN-Datei an. Der Name sollte den vollqualifizierten Namespace der Ressourcendatei, aber nicht die Dateinamenerweiterung enthalten. In der Regel enthalten Ressourcendateien, die in Visual Studio erstellt werden, Namespacenamen, aber Ressourcendateien, die an der Eingabeaufforderung erstellt und kompiliert werden, sind nicht zulässig. Sie können die Namen eingebetteter RESSOURCEN-Dateien ermitteln, indem Sie das folgende Hilfsprogramm kompilieren und ausführen. Dies ist eine Konsolen-App, die den Namen einer Standard Assembly oder Satellitenassembly als Befehlszeilenparameter akzeptiert. Es zeigt die Zeichenfolgen an, die alsbaseNameParameter bereitgestellt werden sollen, damit der Ressourcenmanager die Ressource korrekt identifizieren kann.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
Wenn Sie die aktuelle Kultur Ihrer Anwendung explizit ändern, sollten Sie auch daran denken, dass der Ressourcen-Manager basierend auf dem Wert der CultureInfo.CurrentUICulture Eigenschaft und nicht der CultureInfo.CurrentCulture Eigenschaft einen Ressourcensatz abruft. Wenn Sie einen Wert ändern, sollten Sie in der Regel auch den anderen ändern.
Ressourcenversionsverwaltung
Da die Standard-Assembly, die die Standardressourcen einer App enthält, von den Satellitenassemblys der App getrennt ist, können Sie eine neue Version Ihrer Standard-Assembly freigeben, ohne die Satellitenassemblys erneut bereitzustellen. Sie verwenden das SatelliteContractVersionAttribute Attribut, um vorhandene Satellitenassemblys zu verwenden und den Ressourcen-Manager anzuweisen, sie nicht mit einer neuen Version Ihrer Standard-Assembly erneut bereitzustellen,
Weitere Informationen zur Versionsverwaltungsunterstützung für Satellitenassemblys finden Sie im Artikel "Ressourcen abrufen".
<Konfigurationsdateiknoten für Satellitenassemblies>
Hinweis
Dieser Abschnitt ist spezifisch für .NET Framework-Apps.
Bei ausführbaren Dateien, die von einer Website (HREF .exe Dateien) bereitgestellt und ausgeführt werden, kann das ResourceManager Objekt auf Satellitenassemblys im Web untersuchen, was die Leistung Ihrer App beeinträchtigen kann. Um das Leistungsproblem zu beseitigen, können Sie diese Probingung auf die Satellitenassemblys beschränken, die Sie mit Ihrer App bereitgestellt haben. Dazu erstellen Sie einen <satelliteassemblies> Knoten in der Konfigurationsdatei Ihrer App, um anzugeben, dass Sie eine bestimmte Gruppe von Kulturen für Ihre App bereitgestellt haben, und dass das ResourceManager Objekt nicht versuchen sollte, eine Kultur zu untersuchen, die nicht in diesem Knoten aufgeführt ist.
Hinweis
Die bevorzugte Alternative zum Erstellen eines <satelliteassemblies> Knotens ist die Verwendung des ClickOnce-Bereitstellungsmanifestfeatures .
Erstellen Sie in der Konfigurationsdatei Ihrer App einen Abschnitt ähnlich dem folgenden:
<?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>
Bearbeiten Sie diese Konfigurationsinformationen wie folgt:
Geben Sie einen oder
<assembly>mehrere Knoten für jede Standard Assembly an, die Sie bereitstellen, wobei jeder Knoten einen vollqualifizierten Assemblynamen angibt. Geben Sie den Namen der Standard Assembly anstelle von "MainAssemblyName" an, und geben Sie dieVersionWertePublicKeyTokenundCultureAttributwerte an, die Ihrer Standard Assembly entsprechen.Geben Sie für das
VersionAttribut die Versionsnummer der Assembly an. Die erste Version Ihrer Assembly kann beispielsweise version 1.0.0.0.0 sein.Geben Sie für das
PublicKeyTokenAttribut die Schlüsselwort (keyword)nullan, wenn Sie die Assembly nicht mit einem starken Namen signiert haben, oder geben Sie Ihr öffentliches Schlüsseltoken an, wenn Sie die Assembly signiert haben.Geben Sie für das
CultureAttribut die Schlüsselwort (keyword)neutralan, um die Standard-Assembly festzulegen, und führen Sie dazu, dass die ResourceManager Klasse nur für die in den<culture>Knoten aufgeführten Kulturen untersucht wird.Weitere Informationen zu vollqualifizierten Assemblynamen finden Sie im Artikel "Assemblynamen". Weitere Informationen zu assemblys mit starkem Namen finden Sie im Artikel "Erstellen und Verwenden von assemblys mit starkem Namen".
Geben Sie einen oder
<culture>mehrere Knoten mit einem bestimmten Kulturnamen an, z. B. "fr-FR" oder einen neutralen Kulturnamen, z. B. "fr".
Wenn Ressourcen für assemblys erforderlich sind, die nicht unter dem <satelliteassemblies> Knoten aufgeführt sind, verwenden die ResourceManager Klassensonden für Kulturen mit Standard-Probingregeln.
Windows 8.x-Apps
Wichtig
Obwohl die ResourceManager Klasse in Windows 8.x-Apps unterstützt wird, wird die Verwendung nicht empfohlen. Verwenden Sie diese Klasse nur, wenn Sie portable Klassenbibliotheksprojekte entwickeln, die mit Windows 8.x-Apps verwendet werden können. Um Ressourcen aus Windows 8.x-Apps abzurufen, verwenden Sie stattdessen die Windows.ApplicationModel.Resources.ResourceLoader-Klasse .
Bei Windows 8.x-Apps ruft die ResourceManager Klasse Ressourcen aus PRI-Dateien (Package Resource Index) ab. Eine einzelne PRI-Datei (die PRI-Datei des Anwendungspakets) enthält die Ressourcen sowohl für die Standardkultur als auch für alle lokalisierten Kulturen. Sie verwenden das MakePRI-Hilfsprogramm, um eine PRI-Datei aus einer oder mehreren Ressourcendateien zu erstellen, die sich im XML-Ressourcenformat (RESW) befinden. Für Ressourcen, die in einem Visual Studio-Projekt enthalten sind, verarbeitet Visual Studio den Prozess zum automatischen Erstellen und Verpacken der PRI-Datei. Anschließend können Sie mithilfe der .NET-Klasse ResourceManager auf die Ressourcen der App oder Bibliothek zugreifen.
Sie können ein ResourceManager Objekt für eine Windows 8.x-App auf die gleiche Weise instanziieren wie für eine Desktop-App.
Anschließend können Sie auf die Ressourcen für eine bestimmte Kultur zugreifen, indem Sie den Namen der Ressource übergeben, die an die GetString(String) Methode abgerufen werden soll. Standardmäßig gibt diese Methode die Ressource für die Kultur zurück, die von der aktuellen Benutzeroberflächenkultur des Threads bestimmt wird, der den Aufruf ausgeführt hat. Sie können die Ressourcen für eine bestimmte Kultur auch abrufen, indem Sie den Namen der Ressource und ein CultureInfo Objekt übergeben, das die Kultur darstellt, deren Ressource an die GetString(String, CultureInfo) Methode abgerufen werden soll. Wenn die Ressource für die aktuelle Benutzeroberflächenkultur oder die angegebene Kultur nicht gefunden werden kann, verwendet der Ressourcen-Manager eine Fallbackliste für ui-Sprachen, um eine geeignete Ressource zu suchen.
Beispiele
Im folgenden Beispiel wird veranschaulicht, wie Sie eine explizite Kultur und die implizite aktuelle UI-Kultur verwenden, um Zeichenfolgenressourcen aus einer Standard-Assembly und einer Satellitenassembly abzurufen. Weitere Informationen finden Sie im Abschnitt "Verzeichnisspeicherorte für Satellitenassemblys, die nicht im globalen Assemblycache installiert sind" im Thema "Erstellen von Satellitenassemblys" .
So führen Sie dieses Beispiel aus:
Erstellen Sie im App-Verzeichnis eine Datei mit dem Namen rmc.txt, die die folgenden Ressourcenzeichenfolgen enthält:
day=Friday year=2006 holiday="Cinco de Mayo"Verwenden Sie den Ressourcendatei-Generator , um die Ressourcendatei rmc.resources aus der rmc.txt Eingabedatei wie folgt zu generieren:
resgen rmc.txtErstellen Sie ein Unterverzeichnis des App-Verzeichnisses, und nennen Sie es "es-MX". Dies ist der Kulturname der Satellitenassembly, die Sie in den nächsten drei Schritten erstellen werden.
Erstellen Sie eine Datei namens rmc.es-MX.txt im es-MX-Verzeichnis, die die folgenden Ressourcenzeichenfolgen enthält:
day=Viernes year=2006 holiday="Cinco de Mayo"Verwenden Sie den Ressourcendatei-Generator , um die Ressourcendatei rmc.es-MX.resources aus der rmc.es-MX.txt Eingabedatei wie folgt zu generieren:
resgen rmc.es-MX.txtGehen Sie davon aus, dass der Dateiname für dieses Beispiel rmc.vb oder rmc.cs ist. Kopieren Sie den folgenden Quellcode in eine Datei. Kompilieren Sie sie, und betten Sie die Standard Assemblyressourcendatei rmc.resources in die ausführbare Assembly ein. Wenn Sie den Visual Basic-Compiler verwenden, lautet die Syntax:
vbc rmc.vb /resource:rmc.resourcesDie entsprechende Syntax für den C#-Compiler lautet:
csc /resource:rmc.resources rmc.csVerwenden Sie den Assemblylinker , um eine Satellitenassembly zu erstellen. Wenn der Basisname der App rmc ist, muss der Satellitenassemblyname rmc.resources.dll werden. Die Satellitenassembly sollte im es-MX-Verzeichnis erstellt werden. Wenn es-MX das aktuelle Verzeichnis ist, verwenden Sie den folgenden Befehl:
al /embed:rmc.es-MX.resources /c:es-MX /out:rmc.resources.dllFühren Sie rmc.exe aus, um die eingebetteten Ressourcenzeichenfolgen abzurufen und anzuzeigen.
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.
