ResourceManager ResourceManager ResourceManager ResourceManager Class

Definition

Stellt einen Ressourcen-Manager dar, der einfachen Zugriff auf kulturabhängige Ressourcen zur Laufzeit ermöglicht.Represents a resource manager that provides convenient access to culture-specific resources at run time.

public ref class ResourceManager
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class ResourceManager
type ResourceManager = class
Public Class ResourceManager
Vererbung
ResourceManagerResourceManagerResourceManagerResourceManager
Abgeleitet
Attribute

Beispiele

Im folgende Beispiel wird veranschaulicht, wie mit einer expliziten Kultur und die aktuelle Benutzeroberflächenkultur implizite um Zeichenfolgenressourcen aus einer Hauptassembly und eine Satellitenassembly zu erhalten.The following example demonstrates how to use an explicit culture and the implicit current UI culture to obtain string resources from a main assembly and a satellite assembly. Weitere Informationen finden Sie im Abschnitt "Speicherorte für die Satellitenassembly, die nicht im globalen Assemblycache installiert sind" die Erstellen von Satellitenassemblys Thema.For more information, see the "Directory Locations for Satellite Assemblies Not Installed in the Global Assembly Cache" section of the Creating Satellite Assemblies topic.

Um dieses Beispiel auszuführen:To run this example:

  1. Erstellen Sie in das app-Verzeichnis eine Datei namens rmc.txt, die die folgenden Ressourcenzeichenfolgen enthält:In the app directory, create a file named rmc.txt that contains the following resource strings:

    
    day=Friday  
    year=2006  
    holiday="Cinco de Mayo"  
    
  2. Verwenden der Resource File Generator rmc.resources Ressourcendatei wie folgt aus der Eingabedatei rmc.txt generiert:Use the Resource File Generator to generate the rmc.resources resource file from the rmc.txt input file as follows:

    resgen rmc.txt  
    
  3. Erstellen Sie ein Unterverzeichnis des app-Verzeichnis, und nennen Sie es "es-MX".Create a subdirectory of the app directory and name it "es-MX". Dies ist der Name der Kultur der Satellitenassembly, die Sie in den folgenden drei Schritten erstellen.This is the culture name of the satellite assembly that you will create in the next three steps.

  4. Erstellen Sie eine Datei namens rmc.es-MX.txt, in dem Verzeichnis es-MX, das die folgenden Ressourcenzeichenfolgen enthält:Create a file named rmc.es-MX.txt in the es-MX directory that contains the following resource strings:

    
    day=Viernes  
    year=2006  
    holiday="Cinco de Mayo"  
    
  5. Verwenden der Resource File Generator rmc.es-MX.resources Ressourcendatei wie folgt aus der Eingabedatei rmc.es-MX.txt generiert:Use the Resource File Generator to generate the rmc.es-MX.resources resource file from the rmc.es-MX.txt input file as follows:

    resgen rmc.es-MX.txt  
    
  6. Wird davon ausgegangen Sie, dass der Dateiname für dieses Beispiel rmc.vb oder rmc.cs ist.Assume that the filename for this example is rmc.vb or rmc.cs. Kopieren Sie den folgenden Quellcode in eine Datei aus.Copy the following source code into a file. Klicken Sie dann kompiliert, und die Haupt-Assembly-Ressourcendatei, rmc.resources, in die ausführbare Assembly einbetten.Then compile it and embed the main assembly resource file, rmc.resources, in the executable assembly. Wenn Sie Visual Basic-Compiler verwenden, ist die Syntax auf:If you are using the Visual Basic compiler, the syntax is:

    vbc rmc.vb /resource:rmc.resources  
    

    Die entsprechende Syntax für den C#-Compiler lautet:The corresponding syntax for the C# compiler is:

    csc /resource:rmc.resources rmc.cs  
    
  7. Verwenden der Assemblylinker eine Satellitenassembly zu erstellen.Use the Assembly Linker to create a satellite assembly. Wenn der Basisname der app Rmc ist, muss der Name der Satellitenassembly rmc.resources.dll sein.If the base name of the app is rmc, the satellite assembly name must be rmc.resources.dll. Die Satellitenassembly sollte im es-MX-Verzeichnis erstellt werden.The satellite assembly should be created in the es-MX directory. Wenn es-MX im aktuellen Verzeichnis ist, verwenden Sie folgenden Befehl aus:If es-MX is the current directory, use this command:

    al /embed:rmc.es-MX.resources /c:es-MX /out:rmc.resources.dll   
    
  8. Führen Sie rmc.exe zum Abrufen und Anzeigen der eingebetteten Ressource-Zeichenfolgen.Run rmc.exe to obtain and display the embedded resource strings.

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.

Hinweise

Wichtig

Das Aufrufen von Methoden aus dieser Klasse mit nicht vertrauenswürdigen Daten stellt ein Sicherheitsrisiko dar.Calling methods from this class with untrusted data is a security risk. Rufen Sie die Methoden aus dieser Klasse nur mit vertrauenswürdigen Daten auf.Call the methods from this class only with trusted data. Weitere Informationen finden Sie unter Data Validation (Datenüberprüfung).For more information, see Data Validation.

Die ResourceManager Klasse entnimmt Ressourcen eine binäre RESOURCES-Datei, die in einer Assembly eingebettet ist oder eigenständige RESOURCES-Datei.The ResourceManager class retrieves resources from a binary .resources file that is embedded in an assembly or from a standalone .resources file. Wenn eine app lokalisiert wurde und lokalisierte Ressourcen bereitgestellt worden Satellitenassemblys, es kulturabhängige Ressourcen sucht, bietet Sie Ressourcenfallback aus, wenn eine lokalisierte Ressource ist nicht vorhanden, und Resource unterstützt die Serialisierung.If an app has been localized and localized resources have been deployed in satellite assemblies, it looks up culture-specific resources, provides resource fallback when a localized resource does not exist, and supports resource serialization.

Weitere Informationen zum Erstellen und Verwalten von Ressourcen in desktop-apps und Windows 8.x StoreWindows 8.x Store -apps finden Sie unter den folgenden Abschnitten:For more information about creating and managing resources in desktop apps and Windows 8.x StoreWindows 8.x Store apps, see the following sections:

Desktop-AppsDesktop Apps

Für desktop-apps die ResourceManager Klasse ruft Ressourcen aus binäre Ressourcendateien (.resources).For desktop apps, the ResourceManager class retrieves resources from binary resource (.resources) files. In der Regel einen Sprachcompiler oder Assembly Linker (AL.exe) diese Ressourcendateien in einer Assembly eingebettet werden können.Typically, a language compiler or the Assembly Linker (AL.exe) embeds these resource files in an assembly. Sie können auch eine ResourceManager Objekt, das Abrufen von Ressourcen direkt aus einer RESOURCES-Datei, die nicht in einer Assembly, durch den Aufruf eingebettet ist der CreateFileBasedResourceManager Methode.You can also use a ResourceManager object to retrieve resources directly from a .resources file that is not embedded in an assembly, by calling the CreateFileBasedResourceManager method.

Achtung

Mit eigenständigen Ressourcendateien in einer ASP.NET-Anwendung unterbricht die XCOPY-Bereitstellung, da die Ressourcen gesperrt bleiben, bis sie explizit, indem freigegeben werden die ReleaseAllResources Methode.Using standalone .resources files in an ASP.NET app will break XCOPY deployment, because the resources remain locked until they are explicitly released by the ReleaseAllResources method. Wenn Sie Ressourcen mit ASP.NET-Anwendungen bereitstellen möchten, sollten Sie die RESOURCES-Dateien in Satellitenassemblys kompilieren.If you want to deploy resources with your ASP.NET apps, you should compile your .resources files into satellite assemblies.

In einer app-basierten Ressource enthält eine RESOURCES-Datei die Ressourcen der Standardkultur, deren Ressourcen verwendet werden, wenn keine kulturspezifischen Ressourcen gefunden werden können.In a resource-based app, one .resources file contains the resources of the default culture whose resources are used if no culture-specific resources can be found. Z. B. wenn Standardkultur einer app Englisch (En) ist, werden die Sprachressourcen für Englisch verwendet, wenn lokalisierte Ressourcen für eine bestimmte Kultur, z. B. Englisch (USA) (En-US) oder Französisch (Frankreich) (fr-FR) gefunden werden können.For example, if an app's default culture is English (en), the English language resources are used whenever localized resources cannot be found for a specific culture, such as English (United States) (en-US) or French (France) (fr-FR). Klicken Sie in der Regel die Ressourcen der Standardkultur in die Haupt-app-Assembly eingebettet werden, und Ressourcen für andere lokalisierten Kulturen werden in Satellitenassemblys eingebettet.Typically, the resources for the default culture are embedded in the main app assembly, and resources for other localized cultures are embedded in satellite assemblies. Satellitenassemblys werden nur Ressourcen enthalten.Satellite assemblies contain only resources. Sie haben den gleichen stammdateinamen wie die Haupt-Assembly und der Erweiterung. resources.dll.They have the same root file name as the main assembly and an extension of .resources.dll. Für apps, deren Assemblys nicht im globalen Assemblycache registriert sind, werden Satellitenassemblys in eine app-Unterverzeichnis gespeichert, dessen Name der Assembly Kultur entspricht.For apps whose assemblies are not registered in the global assembly cache, satellite assemblies are stored in an app subdirectory whose name corresponds to the assembly's culture.

Erstellen von RessourcenCreating Resources

Wenn Sie eine Ressource-basierte Anwendung entwickeln, speichern Sie Informationen zu Ressourcen in Textdateien (Dateien, die eine Erweiterung ".txt" oder ".restext") oder XML-Dateien (Dateien, die Erweiterung ".resx").When you develop a resource-based app, you store resource information in text files (files that have a .txt or .restext extension) or XML files (files that have a .resx extension). Kompilieren Sie dann den Text oder XML-Dateien mit der Resource File Generator (Resgen.exe) eine binäre RESOURCES-Datei erstellen.You then compile the text or XML files with the Resource File Generator (Resgen.exe) to create a binary .resources file. Anschließend können Sie die resultierende RESOURCES-Datei in eine ausführbare Datei oder einbetten, wie z. B. mithilfe einer Compileroption /resources für die C#- und Visual Basic-Compiler, oder Sie es in eine Satellitenassembly mit einbetten können die.You can then embed the resulting .resources file in an executable or library by using a compiler option such as /resources for the C# and Visual Basic compilers, or you can embed it in a satellite assembly by using the . Wenn Sie eine RESX-Datei in Visual Studio-Projekts einschließen, wird Visual Studio kümmert sich um die Kompilierung und Einbetten von standardmäßigen und lokalisierte Ressourcen automatisch als Teil des Buildprozesses.If you include a .resx file in your Visual Studio project, Visual Studio handles the compilation and embedding of default and localized resources automatically as part of the build process.

Im Idealfall, erstellen Sie Ressourcen für jede Sprache Ihre app unterstützt, oder zumindest für eine sinnvolle Teilmenge der einzelnen Sprachen.Ideally, you should create resources for every language your app supports, or at least for a meaningful subset of each language. Die binäre RESOURCES-Dateinamen folgen der Namenskonvention Basename. CultureNameResources, wobei Basename ist der Name der app oder den Namen einer Klasse, je nach der gewünschten Detailebene.The binary .resources file names follow the naming convention basename.cultureName.resources, where basename is the name of the app or the name of a class, depending on the level of detail you want. Die CultureInfo.Name Eigenschaft wird verwendet, um zu bestimmen, CultureName.The CultureInfo.Name property is used to determine cultureName. Eine Ressource für die Standardkultur der app heißen BasenameResources.A resource for the app's default culture should be named basename.resources.

Nehmen wir beispielsweise an, dass eine Assembly in einer Ressourcendatei verfügt über mehrere Ressourcen, die den Basisnamen MyResources verfügt.For example, suppose that an assembly has several resources in a resource file that has the base name MyResources. Diese Ressourcendateien müssen die Namen z. B. MyResources.ja-JP.resources für die Kultur Japan (Japanisch) MyResources.de.resources für die deutschen Kultur MyResources.zh-CHS.resources für die Kultur für vereinfachtes Chinesisch, und MyResources.fr-BE.resources für die Kultur Französisch (Belgien).These resource files should have names such as MyResources.ja-JP.resources for the Japan (Japanese) culture, MyResources.de.resources for the German culture, MyResources.zh-CHS.resources for the simplified Chinese culture, and MyResources.fr-BE.resources for the French (Belgium) culture. Die Ressourcendatei sollten MyResources.resources benannt werden.The default resource file should be named MyResources.resources. Die kulturspezifischen Ressourcendateien werden häufig in Satellitenassemblys für jede Kultur gepackt.The culture-specific resource files are commonly packaged in satellite assemblies for each culture. Die Ressourcendatei sollte in die Hauptassembly der Anwendung eingebettet werden.The default resource file should be embedded in the app's main assembly.

Beachten Sie, dass Assemblylinker können Ressourcen als privat gekennzeichnet werden, aber Sie sollten immer kennzeichnen als öffentlich, sodass sie von anderen Assemblys zugegriffen werden kann.Note that Assembly Linker allows resources to be marked as private, but you should always mark them as public so they can be accessed by other assemblies. (Da eine Satellitenassembly keinen Code enthält, sind Ressourcen, die als privat markiert sind für Ihre app auf beliebige Weise nicht verfügbar.)(Because a satellite assembly contains no code, resources that are marked as private are unavailable to your app through any mechanism.)

Weitere Informationen zum Erstellen, Packen und Bereitstellen von Ressourcen, finden Sie in den Artikeln Erstellen von Ressourcendateien, Erstellen von Satellitenassemblys, und Verpacken und Bereitstellen von Ressourcen.For more information about creating, packaging, and deploying resources, see the articles Creating Resource Files, Creating Satellite Assemblies, and Packaging and Deploying Resources.

Instanziieren eines ResourceManager-ObjektsInstantiating a ResourceManager Object

Instanziieren Sie ein ResourceManager -Objekt, das Ressourcen aus einer eingebetteten .resources-Datei durch Aufrufen einer der zugehörigen Klasse Konstruktorüberladungen abruft.You instantiate a ResourceManager object that retrieves resources from an embedded .resources file by calling one of its class constructor overloads. Diese eng miteinander verbindet eine ResourceManager Objekt mit einer bestimmten RESOURCES-Datei und alle zugehörigen lokalisierte RESOURCES-Dateien in Satellitenassemblys.This tightly couples a ResourceManager object with a particular .resources file and with any associated localized .resources files in satellite assemblies.

Die beiden am häufigsten aufgerufenen Konstruktoren sind:The two most commonly called constructors are:

  • ResourceManager(String, Assembly) Sucht nach Ressourcen basierend auf zwei Arten von Informationen, die Sie angeben: Name der Basisname der RESOURCES-Datei und die Assembly, in dem die Standard-RESOURCES-Datei befindet.ResourceManager(String, Assembly) looks up resources based on two pieces of information that you supply: the base name of the .resources file, and the assembly in which the default .resources file resides. Der Basisname enthält den Namen und das Stammelement der RESOURCES-Datei, ohne die Kultur oder die Erweiterung.The base name includes the namespace and root name of the .resources file, without its culture or extension. Beachten Sie, dass die RESOURCES-Dateien, die über die Befehlszeile, in der Regel kompiliert werden ein Namespacename nicht beinhalten, während führen Sie die RESOURCES-Dateien, die in der Visual Studio-Umgebung erstellt werden.Note that .resources files that are compiled from the command line typically do not include a namespace name, whereas .resources files that are created in the Visual Studio environment do. Angenommen, eine Ressourcendatei MyCompany.StringResources.resources heißt und die ResourceManager Konstruktor wird aufgerufen, eine statische Methode mit dem Namen Example.Main, instanziiert der folgende Code eine ResourceManager -Objekt, das Ressourcen aus abrufen kann die. Ressourcendatei:For example, if a resource file is named MyCompany.StringResources.resources and the ResourceManager constructor is called from a static method named Example.Main, the following code instantiates a ResourceManager object that can retrieve resources from the .resources file:

    ResourceManager rm = new ResourceManager("MyCompany.StringResources", 
                                             typeof(Example).Assembly);
    
    Dim rm As New ResourceManager("MyCompany.StringResources",
                                  GetType(Example).Assembly)
    
  • ResourceManager(Type) Sucht nach Ressourcen in Satellitenassemblys, die basierend auf Informationen von einem Typobjekt.ResourceManager(Type) looks up resources in satellite assemblies based on information from a type object. Den vollqualifizierten Typnamen entspricht den Basisnamen der RESOURCES-Datei ohne Dateierweiterung.The type's fully qualified name corresponds to the base name of the .resources file without its file name extension. In desktop-apps, die mit dem Visual Studio-Ressourcen-Designer erstellt wurden, erstellt Visual Studio eine Wrapperklasse, dessen vollqualifizierter Name den Stammnamen der RESOURCES-Datei übereinstimmt.In desktop apps that are created by using the Visual Studio Resource Designer, Visual Studio creates a wrapper class whose fully qualified name is the same as the root name of the .resources file. Z. B. eine Ressourcendatei MyCompany.StringResources.resources lautet und es ist eine Wrapperklasse, die mit dem Namen MyCompany.StringResources, instanziiert der folgende Code eine ResourceManager -Objekt, das Ressourcen aus der RESOURCES-Datei abgerufen werden kann:For example, if a resource file is named MyCompany.StringResources.resources and there is a wrapper class named MyCompany.StringResources, the following code instantiates a ResourceManager object that can retrieve resources from the .resources file:

    ResourceManager rm = new ResourceManager(typeof(MyCompany.StringResources));
    
    Dim rm As New ResourceManager(GetType(MyCompany.StringResources))
    

Wenn die entsprechenden Ressourcen nicht gefunden wird, erstellt der Konstruktoraufruf eine gültige ResourceManager Objekt.If the appropriate resources cannot be found, the constructor call creates a valid ResourceManager object. Der Versuch, eine Ressource abrufen, löst jedoch eine MissingManifestResourceException Ausnahme.However, the attempt to retrieve a resource throws a MissingManifestResourceException exception. Informationen zum Umgang mit der Ausnahme, finden Sie unter den Behandlung von MissingManifestResourceException- und MissingSatelliteAssembly Ausnahmen weiter unten in diesem Artikel.For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssembly Exceptions section later in this article.

Das folgende Beispiel zeigt, wie Sie instanziieren ein ResourceManager Objekt.The following example shows how to instantiate a ResourceManager object. Es enthält den Quellcode für eine ausführbare Datei namens ShowTime.exe.It contains the source code for an executable named ShowTime.exe. Es enthält auch die folgende Textdatei, die mit dem Namen Strings.txt, die eine einzelne Zeichenfolgenressource enthält TimeHeader:It also includes the following text file named Strings.txt that contains a single string resource, TimeHeader:

TimeHeader=The current time is  

Sie können eine Batchdatei verwenden, um die Ressourcendatei zu generieren und diese in die ausführbare Datei einzubetten.You can use a batch file to generate the resource file and embed it into the executable. Hier wird die Batchdatei eine ausführbare Datei, die mithilfe von c#-Compiler generiert:Here's the batch file to generate an executable by using the C# compiler:


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

Für Visual Basic-Compiler können Sie die folgende Batchdatei verwenden:For the Visual Basic compiler, you can use the following batch file:


resgen strings.txt  
vbc ShowTime.vb /resource:strings.resources  
using System;
using System.Resources;

public class Example
{
   public static void Main()
   {
      ResourceManager rm = new ResourceManager("Strings", 
                               typeof(Example).Assembly);
      string timeString = rm.GetString("TimeHeader");
      Console.WriteLine("{0} {1:T}", timeString, DateTime.Now);   
   }
}
// The example displays output like the following:
//        The current time is 2:03:14 PM
Imports System.Resources

Module Example
   Public Sub Main()
      Dim rm As New ResourceManager("Strings", GetType(Example).Assembly)
      Dim timeString As String = rm.GetString("TimeHeader")
      Console.WriteLine("{0} {1:T}", timeString, Date.Now)   
   End Sub
End Module
' The example displays output similar to the following:
'       The current time is 2:03:14 PM

ResourceManager und kulturspezifische RessourcenResourceManager and Culture-Specific Resources

Eine lokalisierte app benötigt Ressourcen, die bereitgestellt werden, wie im folgenden Artikel beschrieben Packaging and Deploying Resources.A localized app requires resources to be deployed, as discussed in the article Packaging and Deploying Resources. Wenn die Assemblys ordnungsgemäß konfiguriert sind, der Ressourcen-Manager bestimmt des aktuellen Threads abgerufen werden, welche Ressourcen anhand Thread.CurrentUICulture Eigenschaft.If the assemblies are properly configured, the resource manager determines which resources to retrieve based on the current thread's Thread.CurrentUICulture property. (Diese Eigenschaft gibt auch UI-Kultur des aktuellen Threads zurück.) Beispielsweise ist die Kompilierung mit einer app standardmäßig den Sprachressourcen für Englisch und Französisch und Russisch Sprachressourcen in zwei Satellitenassemblys,, in der Hauptassembly und Thread.CurrentUICulture Eigenschaft auf "fr-FR" festgelegt ist, der Ressourcen-Manager Ruft ab, der Französisch Ressourcen zu.(That property also returns the current thread's UI culture.) For example, if an app is compiled with default English language resources in the main assembly and with French and Russian language resources in two satellite assemblies, and the Thread.CurrentUICulture property is set to fr-FR, the resource manager retrieves the French resources.

Sie können festlegen, die CurrentUICulture Eigenschaft explizit oder implizit.You can set the CurrentUICulture property explicitly or implicitly. Bestimmt, die Möglichkeit, legen Sie fest, wie die ResourceManager Objekt ruft Ressourcen auf Grundlage der Kultur ab:The way you set it determines how the ResourceManager object retrieves resources based on culture:

  • Wenn Sie explizit festlegen, die Thread.CurrentUICulture Eigenschaft, um eine bestimmte Kultur, immer der Ressourcen-Manager Ruft die Ressourcen für die jeweilige Kultur, unabhängig von der Sprache des Benutzers Browsers oder Betriebssystems ab.If you explicitly set the Thread.CurrentUICulture property to a specific culture, the resource manager always retrieves the resources for that culture, regardless of the user's browser or operating system language. Erwägen Sie eine app, die mit Englisch kompiliert wird und drei Satellitenassemblys, die Ressourcen für Englisch (Vereinigte Staaten), Französisch (Frankreich) und Russisch (Russische Föderation) enthalten.Consider an app that is compiled with default English language resources and three satellite assemblies that contain resources for English (United States), French (France), and Russian (Russia). Wenn die CurrentUICulture -Eigenschaftensatz auf "fr-FR", die ResourceManager Objekt ruft immer die Französisch (Frankreich)-Ressourcen ab, selbst wenn der Benutzer Betriebssystem Systemsprache nicht Französisch.If the CurrentUICulture property is set to fr-FR, the ResourceManager object always retrieves the French (France) resources, even if the user's operating system language is not French. Stellen Sie sicher, dass dies das gewünschte Verhalten ist, bevor Sie die Eigenschaft explizit festlegen.Make sure that this is the desired behavior before you set the property explicitly.

    In ASP.NET-Anwendungen müssen Sie festlegen der Thread.CurrentUICulture Eigenschaft explizit, da es unwahrscheinlich ist, dass die Einstellung auf dem Server eingehende Clientanforderungen übereinstimmt.In ASP.NET apps, you must set the Thread.CurrentUICulture property explicitly, because it is unlikely that the setting on the server will match incoming client requests. Eine ASP.NET-App kann festlegen, die Thread.CurrentUICulture -Eigenschaft explizit auf den Browser des Benutzers, Sprache akzeptieren.An ASP.NET app can set the Thread.CurrentUICulture property explicitly to the user's browser accept language.

    Explizites Festlegen der Thread.CurrentUICulture Eigenschaft definiert, die aktuelle Benutzeroberflächenkultur für diesen Thread.Explicitly setting the Thread.CurrentUICulture property defines the current UI culture for that thread. Es wirkt sich nicht auf die aktuelle Benutzeroberflächenkultur des anderen Threads in einer app aus.It does not affect the current UI culture of any other threads in an app.

  • Sie können die Benutzeroberflächenkultur aller Threads in einer app-Domäne festlegen, durch Zuweisen einer CultureInfo -Objekt, das die Kultur, an die statische darstellt CultureInfo.DefaultThreadCurrentUICulture Eigenschaft.You can set the UI culture of all threads in an app domain by assigning a CultureInfo object that represents that culture to the static CultureInfo.DefaultThreadCurrentUICulture property.

  • Wenn Sie die aktuelle Kultur nicht explizit festlegen, und Sie eine Standardkultur für die aktuelle app-Domäne, nicht definieren die CultureInfo.CurrentUICulture Eigenschaft wird implizit von der Windows festgelegt GetUserDefaultUILanguage Funktion.If you do not explicitly set the current UI culture and you do not define a default culture for the current app domain, the CultureInfo.CurrentUICulture property is set implicitly by the Windows GetUserDefaultUILanguage function. Diese Funktion wird durch das Multilingual User Interface (MUI) bereitgestellt, die dem Benutzer ermöglicht, als Standardsprache festgelegt.This function is provided by the Multilingual User Interface (MUI), which enables the user to set the default language. Wenn die Sprache der Benutzeroberfläche nicht vom Benutzer festgelegt ist, wird standardmäßig die Sprachen-System installiert, die die Sprache der Ressourcen des Betriebssystems ist.If the UI language is not set by the user, it defaults to the system-installed language, which is the language of operating system resources.

Im folgenden einfachen "Hello World"-Beispiel wird die aktuelle Benutzeroberflächenkultur explizit an.The following simple "Hello world" example sets the current UI culture explicitly. Es enthält Ressourcen für die drei Kulturen: Englisch (USA) oder En-US, Französisch (Frankreich) oder "fr-FR", und Russisch (Russische Föderation) oder ru-RU.It contains resources for three cultures: English (United States) or en-US, French (France) or fr-FR, and Russian (Russia) or ru-RU. Die En-US-Ressourcen sind in eine Textdatei namens Greetings.txt enthalten:The en-US resources are contained in a text file named Greetings.txt:

HelloString=Hello world!  

Die "fr-FR" Ressourcen befinden sich in einer Textdatei mit dem Namen Greetings.fr-FR.txt:The fr-FR resources are contained in a text file named Greetings.fr-FR.txt:

HelloString=Salut tout le monde!  

Die ru-RU-Ressourcen befinden sich in einer Textdatei mit dem Namen Greetings.ru-RU.txt:The ru-RU resources are contained in a text file named Greetings.ru-RU.txt:

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

Hier ist der Quellcode für das Beispiel (Example.vb für Visual Basic-Version) oder "example.cs" für die C#-Version:Here's the source code for the example (Example.vb for the Visual Basic version or Example.cs for the 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 enthält die folgenden Befehle aus, und führen Sie es an der Eingabeaufforderung ein.To compile this example, create a batch (.bat) file that contains the following commands and run it from the command prompt. Wenn Sie c# verwenden, geben Sie csc anstelle von vbc und Example.cs anstelle von Example.vb.If you're using C#, specify csc instead of vbc and Example.cs instead of 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 RessourcenRetrieving Resources

Rufen Sie die GetObject(String) und GetString(String) Methoden, um eine bestimmte Ressource zugreifen darf.You call the GetObject(String) and GetString(String) methods to access a specific resource. Sie können auch aufrufen, die GetStream(String) Methode zum Abrufen von nicht-Zeichenfolgenressourcen als Bytearray.You can also call the GetStream(String) method to retrieve non-string resources as a byte array. Standardmäßig zurück diese Methoden in einer app, die die lokalisierte Ressourcen, hat die Ressource für die Kultur, die durch die aktuelle Benutzeroberflächenkultur des Threads, der der Aufruf bestimmt.By default, in an app that has localized resources, these methods return the resource for the culture determined by the current UI culture of the thread that made the call. Finden Sie im vorherigen Abschnitt ResourceManager und kulturspezifische Ressourcen, Weitere Informationen dazu, wie die aktuelle Benutzeroberflächenkultur eines Threads definiert wird.See the previous section, ResourceManager and Culture-Specific Resources, for more information about how the current UI culture of a thread is defined. Wenn der Ressourcen-Manager die Ressource für UI-Kultur des aktuellen Threads nicht gefunden, verwendet es einen Ressourcenfallback-Prozess, um die angegebene Ressource abzurufen.If the resource manager cannot find the resource for the current thread's UI culture, it uses a fallback process to retrieve the specified resource. Wenn der Ressourcen-Manager nicht lokalisierten Ressourcen finden kann, verwendet er die Ressourcen der Standardkultur.If the resource manager cannot find any localized resources, it uses the resources of the default culture. Weitere Informationen zum Ressourcen-fallback-Regeln finden Sie im Abschnitt "Ressourcenfallback-Prozess" des Artikels Packaging and Deploying Resources.For more information about resource fallback rules, see the "Resource Fallback Process" section of the article Packaging and Deploying Resources.

Hinweis

Wenn die RESOURCES-Datei im angegebenen der ResourceManager Klassenkonstruktor kann nicht gefunden werden kann, löst des Versuch, eine Ressource abrufen eine MissingManifestResourceException oder MissingSatelliteAssemblyException Ausnahme.If the .resources file specified in the ResourceManager class constructor cannot be found, the attempt to retrieve a resource throws a MissingManifestResourceException or MissingSatelliteAssemblyException exception. Informationen zum Umgang mit der Ausnahme, finden Sie unter den Behandlung von MissingManifestResourceException- und MissingSatelliteAssemblyException-Ausnahmen weiter unten in diesem Thema.For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions section later in this topic.

Im folgenden Beispiel wird die GetString Methode zum Abrufen von kulturspezifischen Ressourcen.The following example uses the GetString method to retrieve culture-specific resources. Es besteht aus Ressourcen, die von TXT-Dateien für den Englisch (En), Französisch (Frankreich) (fr-FR) und Russisch (Russische Föderation) (ru-RU) kompiliert Kulturen.It consists of resources compiled from .txt files for the English (en), French (France) (fr-FR), and Russian (Russia) (ru-RU) cultures. Im Beispiel wird die aktuelle Kultur und die aktuelle UI-Kultur Englisch (Vereinigte Staaten), Französisch (Frankreich), Russisch (Russische Föderation) und Schwedisch (Schweden) geändert.The example changes the current culture and current UI culture to English (United States), French (France), Russian (Russia), and Swedish (Sweden). Es ruft dann die GetString Methode, um die lokalisierte Zeichenfolge abzurufen, die zusammen mit den aktuellen Tag und Monat angezeigt.It then calls the GetString method to retrieve the localized string, which it displays along with the current day and month. Beachten Sie, dass die Ausgabe die entsprechende lokalisierte Zeichenfolge zeigt, es sei denn, die aktuelle Benutzeroberflächenkultur Schwedisch (Schweden).Notice that the output displays the appropriate localized string except when the current UI culture is Swedish (Sweden). Da die Ressourcen der Schwedischen Sprache nicht verfügbar sind, verwendet die app stattdessen die Ressourcen der Standardkultur-Englisch.Because Swedish language resources are unavailable, the app instead uses the resources of the default culture, which is English.

Das Beispiel erfordert die textbasierte Ressourcendateien, die in der folgenden Tabelle aufgeführt.The example requires the text-based resource files listed in following table. Jede hat eine einzelne Zeichenfolgenressource mit dem Namen DateStart.Each has a single string resource named DateStart.

cultureCulture DateinameFile name RessourcennameResource name RessourcenwertResource value
en-USen-US DateStrings.txtDateStrings.txt DateStart Heute istToday is
fr-FRfr-FR DateStrings.fr-FR.txtDateStrings.fr-FR.txt DateStart Aujourd'hui, c'est leAujourd'hui, c'est le
ru-RUru-RU DateStrings.ru-RU.txtDateStrings.ru-RU.txt DateStart СЕГОДНЯСегодня

Hier ist der Quellcode für das Beispiel (ShowDate.vb für Visual Basic-Version) oder ShowDate.cs für die C#-Version des Codes.Here's the source code for the example (ShowDate.vb for the Visual Basic version or ShowDate.cs for the C# version of the code).

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.

Um dieses Beispiel zu kompilieren, erstellen Sie eine Batchdatei, die enthält die folgenden Befehle aus, und führen Sie es von der Befehlszeile aus.To compile this example, create a batch file that contains the following commands and run it from the command prompt. Wenn Sie c# verwenden, geben Sie csc anstelle von vbc und showdate.cs anstelle von showdate.vb.If you're using C#, specify csc instead of vbc and showdate.cs instead of 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, um die Ressourcen einer bestimmten Kultur als die aktuelle Benutzeroberflächenkultur abzurufen:There are two ways to retrieve the resources of a specific culture other than the current UI culture:

  • Rufen Sie die GetString(String, CultureInfo), GetObject(String, CultureInfo), oder GetStream(String, CultureInfo) Methode, um eine Ressource für eine bestimmte Kultur abrufen.You can call the GetString(String, CultureInfo), GetObject(String, CultureInfo), or GetStream(String, CultureInfo) method to retrieve a resource for a specific culture. Wenn Sie eine lokalisierte Ressource nicht gefunden werden kann, verwendet der Ressourcen-Manager den Ressourcenfallback-Prozess zu einer geeigneten Ressource.If a localized resource cannot be found, the resource manager uses the resource fallback process to locate an appropriate resource.

  • Rufen Sie die GetResourceSet Methode zum Abrufen einer ResourceSet -Objekt, das die Ressourcen für eine bestimmte Kultur darstellt.You can call the GetResourceSet method to obtain a ResourceSet object that represents the resources for a particular culture. Im Aufruf Methode können Sie bestimmen, ob der Ressourcen-Manager für übergeordneten Kulturen Tests, wenn keine lokalisierte Ressourcen gefunden werden kann, oder gibt an, ob sie einfach auf die Ressourcen der Standardkultur zurückgegriffen.In the method call, you can determine whether the resource manager probes for parent cultures if it is unable to find localized resources, or whether it simply falls back to the resources of the default culture. Anschließend können Sie die ResourceSet Methoden Zugriff auf die Ressourcen (für die jeweilige Kultur lokalisierte) anhand des Namens oder die Ressourcen in der Gruppe aufgelistet werden.You can then use the ResourceSet methods to access the resources (localized for that culture) by name, or to enumerate the resources in the set.

Behandlung von MissingManifestResourceException- und MissingSatelliteAssemblyException-AusnahmenHandling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions

Wenn Sie versuchen, eine bestimmte Ressource abzurufen, aber der Ressourcen-Manager wurde nicht gefunden, dass die Ressource und entweder keine Standardkultur definiert wurde oder die Ressourcen der Standardkultur nicht gefunden werden kann, löst des Ressourcen-Managers eine MissingManifestResourceException Ausnahme wenn es davon ausgeht, die Ressourcen in der Hauptassembly oder MissingSatelliteAssemblyException , wenn er davon ausgeht, die Ressourcen in eine Satellitenassembly.If you try to retrieve a specific resource, but the resource manager cannot find that resource and either no default culture has been defined or the resources of the default culture cannot be located, the resource manager throws a MissingManifestResourceException exception if it expects to find the resources in the main assembly or a MissingSatelliteAssemblyException if it expects to find the resources in a satellite assembly. Beachten Sie, dass die Ausnahme ausgelöst wird, wenn Sie eine Ressourcenabrufmethode, z. B. Aufrufen GetString oder GetObject, und nicht beim Instanziieren einer ResourceManager Objekt.Note that the exception is thrown when you call a resource retrieval method such as GetString or GetObject, and not when you instantiate a ResourceManager object.

Die Ausnahme wird in der Regel in den folgenden Situationen ausgelöst:The exception is typically thrown under the following conditions:

  • Die entsprechende Ressource Datei- oder Satelliten-Assembly ist nicht vorhanden.The appropriate resource file or satellite assembly does not exist. Wenn der RM erwartet, der app-Standardressourcen dass, die in der Haupt-app-Assembly eingebettet werden, sind sie nicht vorhanden.If the resource manager expects the app's default resources to be embedded in the main app assembly, they are absent. Wenn die NeutralResourcesLanguageAttribute -Attribut gibt an, dass es sich bei der app-Standardressourcen in einer Satellitenassembly befinden sich, dass die Assembly nicht gefunden werden kann.If the NeutralResourcesLanguageAttribute attribute indicates that the app's default resources reside in a satellite assembly, that assembly cannot be found. Beim Kompilieren Ihrer app stellen Sie sicher, dass Ressourcen in die Hauptassembly eingebettet sind oder die erforderlichen Satellitenassembly generiert wird und entsprechend benannt ist.When you compile your app, make sure that resources are embedded in the main assembly or that the necessary satellite assembly is generated and is named appropriately. Der Name sollte das Formular dauern AppName. "Resources.dll"-Datei enthält, und es in ein Verzeichnis namens nach der die Kultur, deren darin enthaltenen Ressourcen gefunden werden.Its name should take the form appName.resources.dll, and it should be located in a directory named after the culture whose resources it contains.

  • Ihre app keine Standardinstanz oder eine neutrale Kultur definiert.Your app doesn't have a default or neutral culture defined. Hinzufügen der NeutralResourcesLanguageAttribute -Attribut in einer Quellcodedatei oder in der Projektdatei von Informationen (AssemblyInfo.vb-Datei für eine Visual Basic-app) oder die Datei "AssemblyInfo.cs" für eine c#-app-Datei.Add the NeutralResourcesLanguageAttribute attribute to a source code file or to the project information file (AssemblyInfo.vb for a Visual Basic app or AssemblyInfo.cs for a C# app) file.

  • Die baseName Parameter in der ResourceManager(String, Assembly) Konstruktor gibt nicht den Namen des eine RESOURCES-Datei an.The baseName parameter in the ResourceManager(String, Assembly) constructor does not specify the name of a .resources file. Der Name muss den vollqualifizierten Namespace der Ressourcendatei, aber nicht die Dateinamenerweiterung enthalten.The name should include the resource file's fully qualified namespace but not its file name extension. In der Regel Ressourcendateien, die in Visual Studio erstellt werden, umfassen Namespacenamen, Ressourcendateien, die erstellt und kompiliert werden, an der Eingabeaufforderung jedoch nicht.Typically, resource files that are created in Visual Studio include namespace names, but resource files that are created and compiled at the command prompt do not. Sie können die Namen der eingebettete RESOURCES-Dateien durch Kompilieren und Ausführen von das folgende Dienstprogramm bestimmen.You can determine the names of embedded .resources files by compiling and running the following utility. Dies ist eine Konsolen-app, die den Namen einer Hauptassembly oder Satellitenassembly als Befehlszeilenparameter akzeptiert.This is a console app that accepts the name of a main assembly or satellite assembly as a command-line parameter. Zeigt die Zeichenfolgen, die als bereitgestellt werden, müssen die baseName Parameter, damit der Ressourcen-Manager die Ressource ordnungsgemäß identifizieren kann.It displays the strings that should be provided as the baseName parameter so that the resource manager can correctly identify the resource.

    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
    

Wenn Sie die aktuelle Kultur der Anwendung explizit ändern, sollten Sie auch bedenken, dass der Ressourcen-Manager Ruft ab, ein Ressourcensatz, der anhand des Werts von der CultureInfo.CurrentUICulture -Eigenschaft, und nicht die CultureInfo.CurrentCulture Eigenschaft.If you are changing the current culture of your application explicitly, you should also remember that the resource manager retrieves a resource set based on the value of the CultureInfo.CurrentUICulture property, and not the CultureInfo.CurrentCulture property. In der Regel, wenn Sie einen Wert ändern, sollten Sie auch den anderen ändern.Typically, if you change one value, you should also change the other.

RessourcenversionsverwaltungResource Versioning

Da die Haupt-Assembly, die der app-Standardressourcen enthält von der app-Satellitenassemblys ist, können Sie eine neue Version der Hauptassembly freigeben, ohne erneute Bereitstellung der Satellitenassemblys.Because the main assembly that contains an app's default resources is separate from the app's satellite assemblies, you can release a new version of your main assembly without redeploying the satellite assemblies. Sie verwenden die SatelliteContractVersionAttribute Attribut, um die vorhandenen Satellitenassemblys verwenden, und weisen des Ressourcen-Managers nicht, dass diese mit einer neuen Version der Hauptassembly, erneut bereitgestelltYou use the SatelliteContractVersionAttribute attribute to use existing satellite assemblies and instruct the resource manager not to redeploy them with a new version of your main assembly,

Weitere Informationen zu Unterstützung der Versionskontrolle bei Satellitenassemblys, finden Sie im Artikel Abrufen von Ressourcen.For more information about versioning support for satellite assemblies, see the article Retrieving Resources.

<Satelliteassemblies > Knoten "Datei"<satelliteassemblies> Configuration File Node

Für ausführbare Dateien, die bereitgestellt und von einer Website (HREF .exe-Dateien), führen Sie die ResourceManager Objekt kann eine Überprüfung auf Satellitenassemblys über das Web, wodurch die Leistung Ihrer Anwendung beeinträchtigt werden kann.For executables that are deployed and run from a website (HREF .exe files), the ResourceManager object may probe for satellite assemblies over the web, which can hurt your app's performance. Um das Leistungsproblem zu vermeiden, können Sie einschränken, diese Überprüfung auf Satellitenassemblys, die Sie mit der app bereitgestellt haben.To eliminate the performance problem, you can limit this probing to the satellite assemblies that you have deployed with your app. Zu diesem Zweck erstellen Sie eine <satelliteassemblies> Knoten in Ihrer app-Konfigurationsdatei, um anzugeben, dass Sie einen bestimmten Satz von Kulturen, für Ihre app, und bereitgestellt haben die ResourceManager Objekt sollten nicht versuchen, nach einer Kultur gesucht werden soll, die in diesem Knoten nicht aufgeführt ist.To do this, you create a <satelliteassemblies> node in your app's configuration file to specify that you have deployed a specific set of cultures for your app, and that the ResourceManager object should not try to probe for any culture that is not listed in that node.

Hinweis

Die bevorzugte Alternative zum Erstellen einer <satelliteassemblies> Knoten ist die Verwendung der ClickOnce-Bereitstellungsmanifest Feature.The preferred alternative to creating a <satelliteassemblies> node is to use the ClickOnce Deployment Manifest feature.

Erstellen Sie einen Abschnitt in Ihrer app-Konfigurationsdatei etwa wie folgt:In your app's configuration file, create a section similar to the following:

<?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:Edit this configuration information as follows:

  • Geben Sie eine oder mehrere <assembly> Knoten für jede Hauptassembly, die Sie bereitstellen, wobei jeder Knoten einen vollqualifizierten Assemblynamen angibt.Specify one or more <assembly> nodes for each main assembly that you deploy, where each node specifies a fully qualified assembly name. Geben Sie den Namen der Hauptassembly anstelle von MainAssemblyName, und geben Sie die Version, PublicKeyToken, und Culture Attributwerte entsprechen, die auf Ihre Hauptassembly.Specify the name of your main assembly in place of MainAssemblyName, and specify the Version, PublicKeyToken, and Culture attribute values that correspond to your main assembly.

    Für die Version Attribut verwenden, geben Sie die Versionsnummer der Assembly.For the Version attribute, specify the version number of your assembly. Beispielsweise kann die erste Version der Assembly Versionsnummer 1.0.0.0 sein.For example, the first release of your assembly might be version number 1.0.0.0.

    Für die PublicKeyToken -Attributs festzulegen, geben Sie das Schlüsselwort null , wenn Sie Ihre Assembly mit einem starken Namen noch nicht registriert, oder geben Sie das öffentliche Schlüsseltoken aus, wenn Sie die Assembly signiert ist.For the PublicKeyToken attribute, specify the keyword null if you have not signed your assembly with a strong name, or specify your public key token if you have signed your assembly.

    Für die Culture -Attributs festzulegen, geben Sie das Schlüsselwort neutral zum Festlegen der Hauptassembly und dazu führen, dass die ResourceManager Klasse, um nur die Kulturen, die in aufgeführten sucht die <culture> Knoten.For the Culture attribute, specify the keyword neutral to designate the main assembly and cause the ResourceManager class to probe only for the cultures listed in the <culture> nodes.

    Weitere Informationen zu den vollqualifizierten Assemblynamen verwenden zu müssen, finden Sie im Artikel Assemblynamen.For more information about fully qualified assembly names, see the article Assembly Names. Weitere Informationen zu Assemblys mit starkem Namen finden Sie im Artikel erstellen und Assemblys mit starkem Namen.For more information about strong-named assemblies, see the article Creating and Using Strong-Named Assemblies.

  • Geben Sie eine oder mehrere <culture> Knoten mit einem bestimmten Kulturnamen wie z. B. "fr-FR", oder eine neutrale Kultur-ein, z. B. "fr".Specify one or more <culture> nodes with a specific culture name, such as "fr-FR", or a neutral culture name, such as "fr".

Wenn Ressourcen, für jede Assembly, die nicht aufgeführt benötigt werden, unter der <satelliteassemblies> Knoten die ResourceManager Prüfpunkte für die Kulturen, die mit standardmäßigen Überprüfungsregeln Klasse.If resources are needed for any assembly not listed under the <satelliteassemblies> node, the ResourceManager class probes for cultures using standard probing rules.

Windows 8.x StoreWindows 8.x Store-AppsApps

Wichtig

Obwohl die ResourceManager Klasse wird von unterstützt Windows 8.x StoreWindows 8.x Store apps sollten nicht die Verwendung.Although the ResourceManager class is supported in Windows 8.x StoreWindows 8.x Store apps, we do not recommend its use. Verwenden Sie diese Klasse nur beim Entwickeln von Portable KlassenbibliothekPortable Class Library Projekte, die mit verwendet werden können Windows 8.x StoreWindows 8.x Store apps.Use this class only when you develop Portable KlassenbibliothekPortable Class Library projects that can be used with Windows 8.x StoreWindows 8.x Store apps. Zum Abrufen von Ressourcen aus Windows 8.x StoreWindows 8.x Store apps verwenden die Windows.ApplicationModel.Resources.ResourceLoader stattdessen.To retrieve resources from Windows 8.x StoreWindows 8.x Store apps, use the Windows.ApplicationModel.Resources.ResourceLoader class instead.

Für Windows 8.x StoreWindows 8.x Store -apps, die ResourceManager Klasse ruft Ressourcen aus dem Paket ressourcenindexdateien (PRI).For Windows 8.x StoreWindows 8.x Store apps, the ResourceManager class retrieves resources from package resource index (PRI) files. Eine einzelne PRI-Datei (die Anwendung Paket PRI-Datei) enthält die Ressourcen für die Standardkultur und alle Kulturen lokalisiert.A single PRI file (the application package PRI file) contains the resources for both the default culture and any localized cultures. Sie verwenden das MakePRI-Hilfsprogramm, um eine PRI-Datei aus einem oder mehreren Ressourcendateien zu erstellen, die im XML-Ressource (.resw) Format vorliegen.You use the MakePRI utility to create a PRI file from one or more resource files that are in XML resource (.resw) format. Für Ressourcen, die in Visual Studio-Projekt enthalten sind, wird Visual Studio erstellen und Packen die PRI-Datei automatisch.For resources that are included in a Visual Studio project, Visual Studio handles the process of creating and packaging the PRI file automatically. Anschließend können Sie die .NET Framework ResourceManager Klasse, um die app oder Bibliothek zugreifen.You can then use the .NET Framework ResourceManager class to access the app's or library's resources.

Instanziieren Sie ein ResourceManager Objekt für eine Windows 8.x StoreWindows 8.x Store app auf die gleiche Weise, die Sie für eine desktop-app ausführen.You can instantiate a ResourceManager object for a Windows 8.x StoreWindows 8.x Store app in the same way that you do for a desktop app.

Anschließend können Sie die Ressourcen für eine bestimmte Kultur zugreifen, durch Übergeben des Namens der Ressource, die abgerufen werden die GetString(String) Methode.You can then access the resources for a particular culture by passing the name of the resource to be retrieved to the GetString(String) method. Standardmäßig gibt diese Methode die Ressource für die Kultur, die bestimmt, indem die aktuelle Benutzeroberflächenkultur des Threads, der der Aufruf ausgeführt wird.By default, this method returns the resource for the culture determined by the current UI culture of the thread that made the call. Sie können auch die Ressourcen für eine bestimmte Kultur abrufen, indem der Name der Ressource übergeben und ein CultureInfo -Objekt, das die Kultur darstellt, deren Ressourcen abgerufen werden die GetString(String, CultureInfo) Methode.You can also retrieve the resources for a specific culture by passing the name of the resource and a CultureInfo object that represents the culture whose resource is to be retrieved to the GetString(String, CultureInfo) method. Wenn die Ressource für die aktuelle Benutzeroberflächenkultur oder die angegebene Kultur nicht gefunden werden kann, verwendet der Ressourcen-Manager eine alternative Benutzeroberfläche Sprachenliste nach einer geeigneten Ressource.If the resource for the current UI culture or the specified culture cannot be found, the resource manager uses a UI language fallback list to locate a suitable resource.

Konstruktoren

ResourceManager() ResourceManager() ResourceManager() ResourceManager()

Initialisiert eine neue Instanz der ResourceManager-Klasse mit Standardwerten.Initializes a new instance of the ResourceManager class with default values.

ResourceManager(String, Assembly) ResourceManager(String, Assembly) ResourceManager(String, Assembly) ResourceManager(String, Assembly)

Initialisiert eine neue Instanz der ResourceManager-Klasse zum Suchen von Ressourcen in Dateien mit dem angegebenen Stammnamen in der angegebenen Assembly.Initializes a new instance of the ResourceManager class that looks up resources contained in files with the specified root name in the given assembly.

ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type)

Initialisiert eine neue Instanz der ResourceManager-Klasse, die eine angegebene ResourceSet-Klasse verwendet, um Ressourcen in Dateien mit dem angegebenen Stammnamen in der angegebenen Assembly zu suchen.Initializes a new instance of the ResourceManager class that uses a specified ResourceSet class to look up resources contained in files with the specified root name in the given assembly.

ResourceManager(Type) ResourceManager(Type) ResourceManager(Type) ResourceManager(Type)

Initialisiert eine neue Instanz der ResourceManager-Klasse, die Ressourcen in Satellitenassemblys auf der Grundlage der Informationen aus dem angegebenen Typobjekt sucht.Initializes a new instance of the ResourceManager class that looks up resources in satellite assemblies based on information from the specified type object.

Felder

BaseNameField BaseNameField BaseNameField BaseNameField

Gibt den Stammnamen der Ressourcendateien an, die der ResourceManager nach Ressourcen durchsucht.Specifies the root name of the resource files that the ResourceManager searches for resources.

HeaderVersionNumber HeaderVersionNumber HeaderVersionNumber HeaderVersionNumber

Gibt die Version der Ressourcendateiheader an, die die aktuelle Implementierung von ResourceManager interpretieren und erstellen kann.Specifies the version of resource file headers that the current implementation of ResourceManager can interpret and produce.

MagicNumber MagicNumber MagicNumber MagicNumber

Enthält die für die Identifizierung von Ressourcendateien verwendete Nummer.Holds the number used to identify resource files.

MainAssembly MainAssembly MainAssembly MainAssembly

Gibt die Hauptassembly an, die die Ressourcen enthält.Specifies the main assembly that contains the resources.

ResourceSets ResourceSets ResourceSets ResourceSets

Enthält eine Hashtable die eine Zuordnung von Kulturen zu ResourceSet-Objekten zurückgibt.Contains a Hashtable that returns a mapping from cultures to ResourceSet objects.

Eigenschaften

BaseName BaseName BaseName BaseName

Ruft den Stammnamen der Ressourcendateien ab, die der ResourceManager nach Ressourcen durchsucht.Gets the root name of the resource files that the ResourceManager searches for resources.

FallbackLocation FallbackLocation FallbackLocation FallbackLocation

Ruft den Speicherort für das Abrufen von Standard-Fallbackressourcen ab oder legt diesen fest.Gets or sets the location from which to retrieve default fallback resources.

IgnoreCase IgnoreCase IgnoreCase IgnoreCase

Ruft einen booleschen Wert ab, der angibt, ob der Ressourcen-Manager eine Ressourcensuche ohne Berücksichtigung der Groß- und Kleinschreibung in der GetString(String)-Methode und der GetObject(String)-Methode zulässt, oder legt diesen fest.Gets or sets a value that indicates whether the resource manager allows case-insensitive resource lookups in the GetString(String) and GetObject(String) methods.

ResourceSetType ResourceSetType ResourceSetType ResourceSetType

Ruft den Typ des Ressourcensatzobjekts ab, das der Ressourcen-Manager verwendet, um ein ResourceSet-Objekt zu erstellen.Gets the type of the resource set object that the resource manager uses to construct a ResourceSet object.

Methoden

CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type)

Gibt ein ResourceManager-Objekt zurück, der anstelle eines Assemblymanifests ein bestimmtes Verzeichnis nach Ressourcen durchsucht.Returns a ResourceManager object that searches a specific directory instead of an assembly manifest for resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly)

Gibt kulturspezifische Informationen für die Standardressourcen der Hauptassembly zurück, indem der Wert des NeutralResourcesLanguageAttribute-Attributs in einer angegebenen Assembly gelesen wird.Returns culture-specific information for the main assembly's default resources by retrieving the value of the NeutralResourcesLanguageAttribute attribute on a specified assembly.

GetObject(String) GetObject(String) GetObject(String) GetObject(String)

Gibt den Wert der angegebenen Ressource, die keine Zeichenfolge ist, zurück.Returns the value of the specified non-string resource.

GetObject(String, CultureInfo) GetObject(String, CultureInfo) GetObject(String, CultureInfo) GetObject(String, CultureInfo)

Ruft den Wert der angegebenen Ressource ab, die keine Zeichenfolge ist und für die angegebene Kultur lokalisiert wurde.Gets the value of the specified non-string resource localized for the specified culture.

GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo)

Generiert den Ressourcendateinamen für das angegebene CultureInfo-Objekt.Generates the name of the resource file for the given CultureInfo object.

GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean)

Ruft die Ressource ab, die für eine bestimmte Kultur festgelegt wird.Retrieves the resource set for a particular culture.

GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly)

Gibt die vom SatelliteContractVersionAttribute-Attribut in der gegebenen Assembly angegebene Version zurück.Returns the version specified by the SatelliteContractVersionAttribute attribute in the given assembly.

GetStream(String) GetStream(String) GetStream(String) GetStream(String)

Gibt ein nicht verwaltetes Arbeitsspeicher-Datenstromobjekt aus der angegebenen Ressource zurück.Returns an unmanaged memory stream object from the specified resource.

GetStream(String, CultureInfo) GetStream(String, CultureInfo) GetStream(String, CultureInfo) GetStream(String, CultureInfo)

Gibt mithilfe der angegebenen Kultur ein nicht verwaltetes Arbeitsspeicherstreamobjekt aus der angegebenen Ressource zurück.Returns an unmanaged memory stream object from the specified resource, using the specified culture.

GetString(String) GetString(String) GetString(String) GetString(String)

Gibt den Wert der angegebenen Zeichenkette zurück.Returns the value of the specified string resource.

GetString(String, CultureInfo) GetString(String, CultureInfo) GetString(String, CultureInfo) GetString(String, CultureInfo)

Gibt den Wert der Zeichenfolgenressource zurück, die für die angegebene Kultur lokalisiert wurde.Returns the value of the string resource localized for the specified culture.

GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean)

Stellt die Implementierung zum Suchen eines Ressourcensatzes bereit.Provides the implementation for finding a resource set.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ReleaseAllResources() ReleaseAllResources() ReleaseAllResources() ReleaseAllResources()

Teilt dem Ressourcen-Manager mit, die Close()-Methode bei allen ResourceSet-Objekten aufzurufen und alle Ressourcen freizugeben.Tells the resource manager to call the Close() method on all ResourceSet objects and release all resources.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.This type is thread safe.

Siehe auch