Freigeben über

System.Resources.ResourceManager-Klasse

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Von Bedeutung

Das Aufrufen von Methoden aus dieser Klasse mit nicht vertrauenswürdigen Daten ist ein Sicherheitsrisiko. 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ären .resources-Datei ab, die in eine Assembly eingebettet ist, oder aus einer eigenständigen .resources-Datei. Wenn eine App lokalisiert wurde und lokalisierte Ressourcen in Satellitenassemblys bereitgestellt wurden, sucht sie nach kulturspezifischen Ressourcen, bietet einen Rückgriff auf Ressourcen, wenn keine lokalisierte Ressource vorhanden ist, und unterstützt die Ressourcenserialisierung.

Desktop-Apps

Bei Desktop-Apps ruft die ResourceManager Klasse Ressourcen aus Binärressourcendateien (.resources) ab. In der Regel bettet ein Sprachcompiler oder der 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.

Vorsicht

Wenn Sie eigenständige RESSOURCEN-Dateien in einer ASP.NET-App verwenden, wird die XCOPY-Bereitstellung aufgehoben, da die Ressourcen gesperrt bleiben, bis sie von der ReleaseAllResources Methode explizit freigegeben werden. Wenn Sie Ressourcen mit Ihren ASP.NET-Apps bereitstellen möchten, sollten Sie Ihre .resources-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 die Standardkultur einer App beispielsweise Englisch (en) ist, werden die Englisch-Sprachressourcen verwendet, wenn lokalisierte Ressourcen für eine bestimmte Kultur nicht gefunden werden können, z. B. Englisch (Vereinigte Staaten) (en-US) oder Französisch (Frankreich) (fr-FR). In der Regel werden die Ressourcen für die Standardkultur in die Hauptassembly der App eingebettet, und Ressourcen für andere lokalisierte Kulturen werden in Satellitenassemblys eingebettet. Satelliten-Assemblies enthalten nur Ressourcen. Sie haben denselben Stammdateinamen wie die Haupt-Assembly und die Erweiterung .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 .resources-Datei in eine ausführbare Datei oder Bibliothek einbetten, indem Sie eine Compileroption wie z.B. /resources für die C#- und Visual Basic-Compiler verwenden, oder Sie können sie in eine Satellitenassembly einbetten, indem Sie den Assembly Linker (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 .resources-Dateien folgen der Benennungskonvention Basisname.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 (Japan) 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 (belgische) Kultur aufweisen. Die Standardressourcendatei sollte den Namen "MyResources.resources" haben. Die gebietsschemaspezifischen Ressourcendateien sind in der Regel in Satelliten-Assemblies für jedes Gebietsschema gepackt. Die Standard-Ressourcendatei sollte in die Main-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 .resources-Datei abruft, indem Sie eine der Konstruktorüberladungen seiner Klasse aufrufen. Dadurch wird ein ResourceManager-Objekt eng mit einer bestimmten .resources-Datei und allen zugeordneten lokalisierten .resources-Dateien in Satellitenassemblys gekoppelt.

Die beiden am häufigsten aufgerufenen 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 .resources-Datei, ohne deren Gebietsschema oder Erweiterung. Beachten Sie, dass Ressourcendateien, die aus der Befehlszeile kompiliert werden, in der Regel keinen Namespace-Namen enthalten, während Ressourcendateien, die in der Visual Studio-Umgebung erstellt werden, dies tun. 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 Satelliten-Assemblies auf der Grundlage von 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 MyCompany.StringResources vorhanden ist, 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 MissingManifestResourceException und MissingSatelliteAssemblyException Ausnahmen verarbeiten weiter unten in diesem Artikel.

Das folgende Beispiel zeigt, wie ein ResourceManager Objekt instanziieren. Er enthält den Quellcode für eine ausführbare Datei mit dem Namen ShowTime.exe. Sie enthält auch die folgende Textdatei namens 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($"{timeString} {DateTime.Now:T}");
    }
}
// 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 beispielsweise mit Den standardressourcen für englischen Sprachen in der Hauptassembly und mit Französisch- und Russisch-Sprachressourcen in zwei Satellitenassemblys kompiliert wird und die Thread.CurrentUICulture Eigenschaft auf fr-FRfestgelegt ist, ruft der Ressourcenmanager die französischen Ressourcen ab.

Sie können die CurrentUICulture Eigenschaft explizit oder implizit festlegen. Die Art und Weise, wie Sie das Set festlegen, bestimmt, wie das ResourceManager-Objekt Ressourcen auf der Grundlage des Gebietsschemas 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-FRfestgelegt 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 es unwahrscheinlich ist, dass die Einstellung auf dem Server mit den 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-Domäne festlegen, 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-Domäne definieren, wird die CultureInfo.CurrentUICulture Eigenschaft implizit von der Windows-Funktion GetUserDefaultUILanguage festgelegt. Diese Funktion wird von der Mehrsprachigen Benutzeroberfläche (Multilingual User Interface, 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 (Vereinigte Staaten) 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.txtenthalten:

HelloString=Hello world!

Die fr-FR Ressourcen sind in einer Textdatei namens Greetings.fr-FR.txtenthalten:

HelloString=Salut tout le monde!

Die ru-RU Ressourcen sind in einer Textdatei namens Greetings.ru-RU.txtenthalten:

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 {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.
'       Всем привет!

Erstellen Sie zum Kompilieren dieses Beispiels 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 von vbc und Example.cs anstelle von Example.vb an.

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 Methoden GetObject(String) und GetString(String) auf, um auf eine bestimmte Ressource zuzugreifen. Sie können die GetStream(String) Methode auch aufrufen, um Ressourcen ohne Zeichenfolge als Bytearray abzurufen. In einer App, die über lokalisierte Ressourcen verfügt, geben diese Methoden standardmäßig die Ressource für das Gebietsschema zurück, die durch die aktuelle UI-Kultur des aufrufenden Threads bestimmt wird. 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, führt der Versuch, eine Ressource abzurufen, zu einer Ausnahme der Typen MissingManifestResourceException oder MissingSatelliteAssemblyException. Informationen zum Umgang mit der Ausnahme finden Sie im Abschnitt MissingManifestResourceException und MissingSatelliteAssemblyException Ausnahmen verarbeiten 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. Das Beispiel ändert die aktuelle Kultur und die aktuelle Kultur der Benutzeroberfläche in Englisch (Vereinigte Staaten), Französisch (Frankreich), Russisch (Russland) und Schwedisch (Schweden). 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
en-US 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: {CultureInfo.CurrentUICulture.Name}");
            string dateString = rm.GetString("DateStart");
            Console.WriteLine($"{dateString} {DateTime.Now:M}.\n");
        }
    }
}
// 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 von vbc und showdate.cs anstelle von showdate.vb an.

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 Methoden GetString(String, CultureInfo), GetObject(String, CultureInfo) oder GetStream(String, CultureInfo) aufrufen, um eine Ressource für eine spezifische 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 nach übergeordneten Kulturen sucht, wenn er keine lokalisierten Ressourcen findet, oder ob einfach auf die Ressourcen der Standardkultur zurückgegriffen wird. 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.

Umgang mit MissingManifestResourceException und MissingSatelliteAssemblyException-Ausnahmen

Wenn Sie versuchen, eine bestimmte Ressource abzurufen, aber der Ressourcen-Manager 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 Hauptassembly gefunden werden, oder wenn MissingSatelliteAssemblyException 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 Haupt-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 Hauptassembly eingebettet sind oder dass die erforderliche Satellitenassembly generiert und entsprechend benannt wird. Der Name sollte das Format "appName ".resources.dllhaben, und er 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 baseName Parameter 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. Ressourcendateien, die an der Eingabeaufforderung erstellt und kompiliert werden, enthalten diese jedoch nicht. Sie können die Namen eingebetteter RESSOURCEN-Dateien ermitteln, indem Sie das folgende Hilfsprogramm kompilieren und ausführen. Dies ist eine App für die Konsole, die den Namen einer Main Assembly oder einer Satellite Assembly als Kommandozeilenparameter akzeptiert. Es zeigt die Zeichenfolgen an, die als baseName Parameter 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($"{filename} does not exist.");
         return;
      }   
      
      // Try to load the assembly.
      Assembly assem = Assembly.LoadFrom(filename);
      Console.WriteLine($"File: {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: {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 Hauptassembly, die die Standardressourcen einer App enthält, von den Satellitenassemblys der App getrennt ist, können Sie eine neue Version der Hauptassembly freigeben, ohne die Satellitenassemblys erneut bereitzustellen. Sie verwenden das SatelliteContractVersionAttribute Attribut, um die vorhandenen Satellitenassemblys zu nutzen und den Ressourcen-Manager anzuweisen, sie nicht mit einer neuen Version der Hauptassembly erneut einzusetzen,

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 über eine Website bereitgestellt und ausgeführt werden (HREF .exe-Dateien), kann das ResourceManager-Objekt über das Web nach Satellite-Assemblies abfragen, was die Leistung Ihrer App beeinträchtigen kann. Um das Leistungsproblem zu beseitigen, können Sie dieses Probes auf die Satelliten-Assemblies 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 der ClickOnce-Bereitstellungsmanifest-Funktion.

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 für jede Hauptassembly, die Sie bereitstellen, einen oder mehrere <assembly> Knoten an, wobei jeder Knoten einen vollqualifizierten Assemblynamen angibt. Geben Sie den Namen Ihrer Hauptassembly anstelle von MainAssemblyName an und spezifizieren Sie die Attributwerte Version, PublicKeyToken und Culture, die Ihrer Hauptassembly entsprechen.

    Geben Sie für das Version Attribut die Versionsnummer der Assembly an. Die erste Version Ihrer Assembly könnte beispielsweise die Versionsnummer 1.0.0.0 haben.

    Geben Sie für das PublicKeyToken Attribut das Schlüsselwort null an, 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 Culture Attribut das Schlüsselwort neutral an, mit dem die Hauptassembly festgelegt werden soll, und führen Sie dazu, dass die ResourceManager Klasse nur für die in den <culture> Knoten aufgeführten Kulturen untersucht wird.

    Weitere Informationen über vollständig qualifizierte Assembly-Namen finden Sie im Artikel Assembly-Namen. 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 für eine Assembly, die nicht unter dem Knoten <satelliteassemblies> aufgeführt ist, Ressourcen benötigt werden, wird mit der Klasse ResourceManager anhand der Standardregeln für die Suche nach Gebietsschemata nachgefragt.

Windows 8.x-Apps

Von Bedeutung

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 das Gebietsschema zurück, die durch das aktuelle UI- Gebietsschema des aufrufenden Threads bestimmt wird. 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 Hauptassembly 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:

  1. 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"

  2. Verwenden Sie den Ressourcendatei-Generator , um die Ressourcendatei rmc.resources aus der rmc.txt Eingabedatei wie folgt zu generieren:

    resgen rmc.txt

  3. Erstellen Sie ein Unterverzeichnis des App-Verzeichnisses, und nennen Sie es "es-MX". Dies ist der Gebietsschemaname der Satelliten Assembly, die Sie in den nächsten drei Schritten erstellen werden.

  4. Erstellen Sie eine Datei namens rmc.es-MX.txt im verzeichnis es-MX, die die folgenden Ressourcenzeichenfolgen enthält:

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

  5. Verwenden Sie den Ressourcendateigenerator, um die rmc.es-MX.resources-Ressourcendatei aus der rmc.es-MX.txt Eingabedatei wie folgt zu generieren:

    resgen rmc.es-MX.txt

  6. Gehen 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 das Ganze und betten Sie die Haupt-Assembly-Ressourcendatei, rmc.resources, in die ausführbare Assembly ein. Wenn Sie den Visual Basic-Compiler verwenden, lautet die Syntax:

    vbc rmc.vb /resource:rmc.resources

    Die entsprechende Syntax für den C#-Compiler lautet:

    csc /resource:rmc.resources rmc.cs

  7. Verwenden Sie den Assemblylinker , um eine Satellitenassembly zu erstellen. Wenn der Basisname der App rmc ist, muss der Name der Satelliten Assembly rmc.resources.dll lauten. Die Satellitenassembly sollte im verzeichnis es-MX erstellt werden. Wenn es-MX das aktuelle Verzeichnis ist, verwenden Sie folgenden Befehl:

    al /embed:rmc.es-MX.resources /c:es-MX /out:rmc.resources.dll

  8. Fü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.