ResourceManager Klasse

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
ResourceManager
Abgeleitet
Attribute

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie eine explizite Kultur und die implizite aktuelle UI-Kultur verwendet werden, um Zeichen folgen Ressourcen aus einer Hauptassembly und einer Satellitenassembly abzurufen.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 "Verzeichnis Speicherorte für Satellitenassemblys, die nicht im globalen Assemblycache installiert sind" im Thema Erstellen von Satellitenassemblys .For more information, see the "Directory Locations for Satellite Assemblies Not Installed in the Global Assembly Cache" section of the Creating Satellite Assemblies topic.

So führen Sie dieses Beispiel aus:To run this example:

  1. Erstellen Sie im App-Verzeichnis eine Datei namens RMC. txt, die die folgenden Ressourcen Zeichenfolgen 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 Sie den Ressourcen Datei-Generator , um die Ressourcen Datei "RMC. Resources" aus der Eingabedatei "RMC. txt" wie folgt zu generieren: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-Verzeichnisses, und nennen Sie es "es-MX".Create a subdirectory of the app directory and name it "es-MX". Dies ist der Kultur Name der Satellitenassembly, die Sie in den nächsten drei Schritten erstellen werden.This is the culture name of the satellite assembly that you will create in the next three steps.

  4. Erstellen Sie im Verzeichnis "es-MX" eine Datei mit dem Namen RMC.es-MX. txt, die die folgenden Ressourcen Zeichenfolgen 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 Sie den Ressourcen Datei-Generator , um die Ressourcen Datei "RMC.es-MX. Resources" aus der Eingabedatei "RMC.es-MX. txt" wie folgt zu generieren: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. Angenommen, der Dateiname für dieses Beispiel lautet RMC. vb oder RMC.cs.Assume that the filename for this example is rmc.vb or rmc.cs. Kopieren Sie den folgenden Quellcode in eine Datei.Copy the following source code into a file. Kompilieren Sie Sie anschließend, und Betten Sie die hauptassemblyressourcendatei RMC. Resources in die ausführbare Assembly ein.Then compile it and embed the main assembly resource file, rmc.resources, in the executable assembly. Wenn Sie den Visual Basic-Compiler verwenden, lautet die Syntax wie folgt: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 Sie den Assembly Linker zum Erstellen einer Satellitenassembly.Use the Assembly Linker to create a satellite assembly. Wenn der Basisname der APP RMC ist, muss der Name der Satellitenassembly RMC. resources. dll lauten.If the base name of the app is rmc, the satellite assembly name must be rmc.resources.dll. Die Satellitenassembly sollte im Verzeichnis "es-MX" erstellt werden.The satellite assembly should be created in the es-MX directory. Wenn es-MX das aktuelle Verzeichnis ist, verwenden Sie den folgenden Befehl: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 aus, um die eingebetteten Ressourcen Zeichenfolgen abzurufen und anzuzeigen.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 ruft Ressourcen aus einer binären resources-Datei ab, die in eine Assembly oder aus einer eigenständigen resources-Datei eingebettet ist.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 in Satellitenassemblysbereitgestellt wurden, sucht Sie nach Kultur abhängigen Ressourcen, bietet einen Ressourcen Fall Back, wenn keine lokalisierte Ressource vorhanden ist, und unterstützt die Ressourcenserialisierung.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 Windows 8.x StoreWindows 8.x Store und-apps finden Sie in 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 ruft ResourceManager die-Klasse Ressourcen aus binären Ressourcen Dateien (. Resources) ab.For desktop apps, the ResourceManager class retrieves resources from binary resource (.resources) files. In der Regel bettet ein sprach Compiler oder der Assembly Linker (Al. exe) diese Ressourcen Dateien in eine Assembly ein.Typically, a language compiler or the Assembly Linker (AL.exe) embeds these resource files in an assembly. Sie können auch ein ResourceManager -Objekt verwenden, um Ressourcen direkt aus einer resources-Datei abzurufen, die nicht in einer Assembly eingebettet ist, indem Sie die CreateFileBasedResourceManager -Methode aufrufen.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

Durch die Verwendung von eigenständigen resources-Dateien in einer ASP.net-APP wird die XCOPY-Bereitstellung beendet, da die Ressourcen gesperrt ReleaseAllResources bleiben, bis Sie explizit durch die-Methode freigegeben werdenUsing 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 Ihren ASP.net-apps bereitstellen möchten, sollten Sie Ihre 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 ressourcenbasierten app enthält eine resources-Datei die Ressourcen der Standard Kultur, 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. Wenn die Standard Kultur einer App z. b. Englisch (en) ist, werden die englischsprachigen Ressourcen immer dann verwendet, wenn lokalisierte Ressourcen für eine bestimmte Kultur nicht gefunden werden können, z. b. Englisch (USA) (en-US) oder Französisch (Frankreich) (fr-FR).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). In der Regel werden die Ressourcen für die Standard Kultur in die Hauptassembly der APP eingebettet, und Ressourcen für andere lokalisierte 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 enthalten nur Ressourcen.Satellite assemblies contain only resources. Sie haben den gleichen Stamm Dateinamen wie die Hauptassembly und die 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 einem Unterverzeichnis der APP gespeichert, dessen Name der Kultur der Assembly 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 ressourcenbasierte App entwickeln, speichern Sie Ressourcen Informationen in Textdateien (Dateien mit der Erweiterung TXT oder. restext) oder XML-Dateien (Dateien mit der 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). Anschließend kompilieren Sie die Text-oder XML-Dateien mit dem Resource File Generator (Resgen. exe) , um eine binäre RESOURCES-Datei zu 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 Bibliothek einbetten, indem Sie eine /resources -Compileroption wie für den C# -und Visual Basic Compiler verwenden, oder Sie können Sie mithilfe von in eine Satellitenassembly einbetten.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 das Visual Studio-Projekt einschließen, verarbeitet Visual Studio die Kompilierung und Einbettung von standardmäßigen und lokalisierten 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 sollten Sie Ressourcen für jede von ihrer App unterstützte Sprache oder zumindest für eine sinnvolle Teilmenge jeder Sprache erstellen.Ideally, you should create resources for every language your app supports, or at least for a meaningful subset of each language. Die Binärdatei der resources-Datei folgt der Benennungs Konvention baseName. cultureName. Resources, wobei baseName der Name der APP oder der Name einer Klasse ist, abhängig von 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 cultureNamezu bestimmen.The CultureInfo.Name property is used to determine cultureName. Eine Ressource für die Standard Kultur der APP sollte den Namen baseName. Resources haben.A resource for the app's default culture should be named basename.resources.

Angenommen, eine Assembly verfügt über mehrere Ressourcen in einer Ressourcen Datei, die den Basis Namen myResources hat.For example, suppose that an assembly has several resources in a resource file that has the base name MyResources. Diese Ressourcen Dateien sollten Namen wie myResources. ja-JP. Resources für die Kultur Japan (Japanisch), 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 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 Standard Ressourcen Datei sollte den Namen myResources. Resources haben.The default resource file should be named MyResources.resources. Die kulturspezifischen Ressourcen Dateien werden häufig in Satellitenassemblys für jede Kultur verpackt.The culture-specific resource files are commonly packaged in satellite assemblies for each culture. Die Standard Ressourcen Datei sollte in die Hauptassembly der APP eingebettet werden.The default resource file should be embedded in the app's main assembly.

Beachten Sie , dass der Assemblylinker ermöglicht, dass Ressourcen als privat gekennzeichnet werden, Sie sollten Sie jedoch immer als öffentlich markieren, damit andere Assemblys darauf zugreifen können.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 gekennzeichnet sind, über einen beliebigen Mechanismus für Ihre APP 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, Verpacken und Bereitstellen von Ressourcen finden Sie in den Artikeln Erstellen von Ressourcen Dateien, Erstellen von Satellitenassemblysund Verpacken undBereitstellen 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 abruft, indem Sie eine seiner klassenkonstruktorüberladungen aufrufen.You instantiate a ResourceManager object that retrieves resources from an embedded .resources file by calling one of its class constructor overloads. Dadurch wird ein ResourceManager -Objekt eng mit einer bestimmten resources-Datei und mit zugeordneten lokalisierten RESOURCES-Dateien in Satellitenassemblys verknüpft.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, die auf zwei von Ihnen angegebenen Informationen basieren: der Basisname der resources-Datei und die Assembly, in der sich die Datei "default. Resources" 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 Namespace und den Stamm Namen der resources-Datei ohne Kultur oder Erweiterung.The base name includes the namespace and root name of the .resources file, without its culture or extension. Beachten Sie, dass resources-Dateien, die über die Befehlszeile kompiliert werden, in der Regel keinen Namespace Namen enthalten, wohingegen resources-Dateien, die in der Visual Studio-Umgebung erstellt werden, dies tun.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. Wenn eine Ressourcen Datei z. b. den Namen MyCompany. uningresources. Resources hat ResourceManager und der Konstruktor von einer statischen Methode mit Example.Maindem Namen aufgerufen wird, instanziiert ResourceManager der folgende Code ein-Objekt, das Ressourcen aus dem abrufen kann. Ressourcen Datei: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 Ressourcen in Satellitenassemblys auf der Grundlage von Informationen aus einem Typobjekt.ResourceManager(Type) looks up resources in satellite assemblies based on information from a type object. Der voll qualifizierte Name des Typs entspricht dem Basis Namen der resources-Datei ohne die Dateinamenerweiterung.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 werden, erstellt Visual Studio eine Wrapper Klasse, deren voll qualifizierter Name dem Stamm Namen der resources-Datei entspricht.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. Wenn eine Ressourcen Datei z. b. den Namen MyCompany. uningresources. Resources hat und eine Wrapper Klasse mit MyCompany.StringResourcesdem Namen vorhanden ist, instanziiert ResourceManager der folgende Code ein-Objekt, das Ressourcen aus der resources-Datei abrufen 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 werden können, erstellt der konstruktorbefehl ein ResourceManager gültiges-Objekt.If the appropriate resources cannot be found, the constructor call creates a valid ResourceManager object. Der Versuch, eine Ressource abzurufen, löst jedoch eine MissingManifestResourceException -Ausnahme aus.However, the attempt to retrieve a resource throws a MissingManifestResourceException exception. Weitere Informationen zum Umgang mit der Ausnahme finden Sie weiter unten in diesem Artikel im Abschnitt Behandeln von MissingManifestResourceException-und missingsatelliteassembly-Ausnahmen .For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssembly Exceptions section later in this article.

Im folgenden Beispiel wird gezeigt, wie ein ResourceManager -Objekt instanziiert wird.The following example shows how to instantiate a ResourceManager object. Sie enthält den Quellcode für eine ausführbare Datei mit dem Namen "Showtime. exe".It contains the source code for an executable named ShowTime.exe. Außerdem ist TimeHeaderdie folgende Textdatei mit dem Namen Strings. txt enthalten, die eine einzelne Zeichen folgen Ressource enthält: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 Ressourcen Datei zu generieren und in die ausführbare Datei einzubetten.You can use a batch file to generate the resource file and embed it into the executable. Im folgenden finden Sie die Batchdatei zum Generieren einer ausführbaren C# Datei mithilfe des Compilers: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 den 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

Für eine lokalisierte App müssen Ressourcen bereitgestellt werden, wie im Artikel Verpacken undBereitstellen von Ressourcen erläutert.A localized app requires resources to be deployed, as discussed in the article Packaging and Deploying Resources. Wenn die Assemblys ordnungsgemäß konfiguriert sind, bestimmt der Ressourcen-Manager, welche Ressourcen basierend auf der Thread.CurrentUICulture -Eigenschaft des aktuellen Threads abgerufen werden sollen.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 die Benutzeroberflächen Kultur des aktuellen Threads zurück.) Wenn eine APP beispielsweise mit den englischen Standardsprachen Ressourcen in der Hauptassembly und mit französischen und russischen Sprachressourcen in zwei Satellitenassemblys kompiliert wird Thread.CurrentUICulture und die-Eigenschaft auf "fr-FR" festgelegt ist, ruft der Ressourcen-Manager die französische verfügt.(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 die CurrentUICulture Eigenschaft explizit oder implizit festlegen.You can set the CurrentUICulture property explicitly or implicitly. Die festgelegte Methode bestimmt, wie das ResourceManager Objektressourcen basierend auf der Kultur abruft:The way you set it determines how the ResourceManager object retrieves resources based on culture:

  • Wenn Sie die Thread.CurrentUICulture Eigenschaft explizit auf eine bestimmte Kultur festlegen, ruft der Ressourcen-Manager die Ressourcen für diese Kultur unabhängig von der Browser-oder Betriebssystem Sprache des Benutzers 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. Angenommen, eine APP wird mit den englischen Standardsprachen Ressourcen und drei Satellitenassemblys mit Ressourcen für Englisch (USA), Französisch (Frankreich) und Russisch (Russische Föderation) zusammengefasst.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 Eigenschaft auf "fr-FR" festgelegt ResourceManager ist, ruft das Objekt immer die französischen Ressourcen (Frankreich) ab, selbst wenn die Betriebssystem Sprache des Benutzers nicht Französisch ist.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-apps muss die Thread.CurrentUICulture -Eigenschaft explizit festgelegt werden, da es unwahrscheinlich ist, dass die Einstellung auf dem Server eingehenden Client Anforderungen entspricht.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 die Thread.CurrentUICulture -Eigenschaft explizit auf die Browser Accept-Sprache des Benutzers festlegen.An ASP.NET app can set the Thread.CurrentUICulture property explicitly to the user's browser accept language.

    Durch das explizite Thread.CurrentUICulture Festlegen der-Eigenschaft wird die aktuelle Benutzeroberflächen Kultur für diesen Thread definiert.Explicitly setting the Thread.CurrentUICulture property defines the current UI culture for that thread. Dies hat keine Auswirkung auf die aktuelle Benutzeroberflächen Kultur anderer Threads in einer App.It does not affect the current UI culture of any other threads in an app.

  • Sie können die Benutzeroberflächen Kultur für alle Threads in einer APP-Domäne festlegen, CultureInfo indem Sie ein-Objekt, das diese CultureInfo.DefaultThreadCurrentUICulture Kultur darstellt, der statischen-Eigenschaft zuweisen.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 Benutzeroberflächen Kultur nicht explizit festlegen und keine Standard Kultur für die aktuelle App-Domäne definieren, wird die CultureInfo.CurrentUICulture -Eigenschaft implizit von der Windows GetUserDefaultUILanguage -Funktion festgelegt.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 von der Mi (mehrsprachige Benutzeroberfläche) bereitgestellt, die es dem Benutzer ermöglicht, die Standardsprache festzulegen.This function is provided by the Multilingual User Interface (MUI), which enables the user to set the default language. Wenn die Benutzeroberflächen Sprache nicht vom Benutzer festgelegt wird, wird standardmäßig die System installierte Sprache verwendet. Dies ist die Sprache der Betriebssystemressourcen.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ächen Kultur explizit festgelegt.The following simple "Hello world" example sets the current UI culture explicitly. Sie enthält Ressourcen für drei Kulturen: Englisch (USA) oder en-US, Französisch (Frankreich), 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 einer Textdatei mit dem Namen "Greetings. txt" enthalten:The en-US resources are contained in a text file named Greetings.txt:

HelloString=Hello world!  

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

HelloString=Salut tout le monde!  

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

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

Hier ist der Quellcode für das Beispiel (z. b. vb für die Visual Basic Version oder example.cs für C# die 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-Datei), die die folgenden Befehle enthält, und führen Sie Sie von der Eingabeaufforderung aus.To compile this example, create a batch (.bat) file that contains the following commands and run it from the command prompt. Wenn Sie verwenden C#, geben csc Sie anstelle von vbc und Example.cs anstelle von Example.vban.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

Sie können die GetObject(String) Methoden GetString(String) und aufrufen, um auf eine bestimmte Ressource zuzugreifen.You call the GetObject(String) and GetString(String) methods to access a specific resource. Sie können auch die GetStream(String) -Methode aufrufen, um nicht-Zeichen folgen Ressourcen als Bytearray abzurufen.You can also call the GetStream(String) method to retrieve non-string resources as a byte array. Standardmäßig geben diese Methoden in einer APP, die über lokalisierte Ressourcen verfügt, die Ressource für die Kultur zurück, die durch die aktuelle Benutzeroberflächen Kultur des Threads bestimmt wird, der den-Befehl durchgeführt hat.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. Weitere Informationen zur Definition der aktuellen Benutzeroberflächen Kultur eines Threads finden Sie im vorherigen Abschnitt ResourceManager und kulturspezifische Ressourcen.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 die Benutzeroberflächen Kultur des aktuellen Threads nicht finden kann, verwendet er einen Fall Backprozess zum Abrufen der angegebenen Ressource.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 keine lokalisierten Ressourcen finden kann, verwendet er die Ressourcen der Standard Kultur.If the resource manager cannot find any localized resources, it uses the resources of the default culture. Weitere Informationen zu Ressourcen Fall Back Regeln finden Sie im Abschnitt "Ressourcen Fall Back-Prozess" im Artikel Verpacken undBereitstellen von Ressourcen.For more information about resource fallback rules, see the "Resource Fallback Process" section of the article Packaging and Deploying Resources.

Hinweis

Wenn die im ResourceManager Klassenkonstruktor angegebene resources-Datei nicht gefunden werden kann, löst der Versuch, eine Ressource abzurufen, MissingSatelliteAssemblyException eine MissingManifestResourceException -oder-Ausnahme aus.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. Weitere Informationen zum Umgang mit der Ausnahme finden Sie im Abschnitt Behandlung von MissingManifestResourceException und MissingSatelliteAssemblyException 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 verwendet, um kulturspezifische Ressourcen abzurufen.The following example uses the GetString method to retrieve culture-specific resources. 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.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 Benutzeroberflächen Kultur in Englisch (USA), 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). Anschließend wird die GetString -Methode aufgerufen, um die lokalisierte Zeichenfolge abzurufen, die zusammen mit dem aktuellen Tag und Monat angezeigt wird.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 anzeigt, es sei denn, die aktuelle Benutzeroberflächen Kultur ist Schwedisch (Sweden).Notice that the output displays the appropriate localized string except when the current UI culture is Swedish (Sweden). Da die schwedischen Sprachressourcen nicht verfügbar sind, verwendet die APP stattdessen die Ressourcen der Standard Kultur (Englisch).Because Swedish language resources are unavailable, the app instead uses the resources of the default culture, which is English.

Das Beispiel erfordert die textbasierten Ressourcen Dateien, die in der folgenden Tabelle aufgeführt sind.The example requires the text-based resource files listed in following table. Jede verfügt über eine einzelne Zeichen folgen DateStartRessource mit dem Namen.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/cAujourd'hui, c'est le
ru-RUru-RU DateStrings.ru-RU.txtDateStrings.ru-RU.txt DateStart In derСегодня

Im folgenden finden Sie den Quellcode für das Beispiel (showdate. vb für die Visual Basic Version oder ShowDate.cs für C# die 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 die folgenden Befehle enthält, und führen Sie Sie von der Eingabeaufforderung aus.To compile this example, create a batch file that contains the following commands and run it from the command prompt. Wenn Sie verwenden C#, geben csc Sie anstelle von vbc und showdate.cs anstelle von showdate.vban.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, die Ressourcen einer bestimmten Kultur als der aktuellen Benutzeroberflächen Kultur abzurufen:There are two ways to retrieve the resources of a specific culture other than the current UI culture:

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

  • Sie können die GetResourceSet -Methode zum Abrufen eines ResourceSet -Objekts, das die Ressourcen für eine bestimmte Kultur darstellt, abrufen.You can call the GetResourceSet method to obtain a ResourceSet object that represents the resources for a particular culture. Im Methoden Befehl können Sie bestimmen, ob der Ressourcen-Manager für übergeordnete Kulturen prüft, wenn keine lokalisierten Ressourcen gefunden werden können, oder ob er einfach auf die Ressourcen der Standard Kultur zurückgreift.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 verwenden, um über den Namen auf die Ressourcen (lokalisiert für diese Kultur) zuzugreifen oder um die Ressourcen im Satz aufzulisten.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.

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

Wenn Sie versuchen, eine bestimmte Ressource abzurufen, aber der Ressourcen-Manager diese Ressource nicht findet und entweder keine Standard Kultur definiert wurde oder die Ressourcen der Standard Kultur nicht gefunden werden können, löst der Ressourcen-Manager MissingManifestResourceException eine-Ausnahme aus, wenn er erwartet, dass die Ressourcen in der Hauptassembly oder eine MissingSatelliteAssemblyException gefunden werden, wenn die Ressourcen in einer Satellitenassembly gefunden werden sollen.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 Ressourcen Abruf Methode GetString wie GetObjectoder aufgerufen haben und nicht, wenn Sie ein ResourceManager -Objekt instanziieren.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 unter den folgenden Bedingungen ausgelöst:The exception is typically thrown under the following conditions:

  • Die entsprechende Ressourcen Datei oder Satellitenassembly ist nicht vorhanden.The appropriate resource file or satellite assembly does not exist. Wenn der Ressourcen-Manager erwartet, dass die Standard Ressourcen der app in die 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 das NeutralResourcesLanguageAttribute Attribut angibt, dass sich die Standard Ressourcen der app in einer Satellitenassembly befinden, kann diese Assembly nicht gefunden werden.If the NeutralResourcesLanguageAttribute attribute indicates that the app's default resources reside in a satellite assembly, that assembly cannot be found. Wenn Sie die APP kompilieren, stellen Sie sicher, dass die Ressourcen in die Hauptassembly eingebettet sind oder dass die erforderliche Satellitenassembly generiert wird und entsprechend benannt wird.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 Format " appname. resources. dll" aufweisen, und es sollte sich in einem Verzeichnis befinden, das nach der Kultur, in der es enthalten ist, benannt wird.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.

  • Für Ihre APP ist keine standardmäßige oder neutrale Kultur definiert.Your app doesn't have a default or neutral culture defined. Fügen Sie NeutralResourcesLanguageAttribute das-Attribut einer Quell Code Datei oder der Projekt Informationsdatei (AssemblyInfo. vb für eine Visual Basic-APP oder AssemblyInfo.cs für C# eine-APP-Datei) hinzu.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.

  • Der baseName -Parameter ResourceManager(String, Assembly) im-Konstruktor gibt nicht den Namen einer 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 voll qualifizierten Namespace der Ressourcen Datei, 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 enthalten Ressourcen Dateien, die in Visual Studio erstellt werden, Namespace Namen, Ressourcen Dateien, die an der Eingabeaufforderung erstellt und kompiliert werden, 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 eingebetteter resources-Dateien ermitteln, indem Sie das folgende Hilfsprogramm kompilieren und ausführen.You can determine the names of embedded .resources files by compiling and running the following utility. Dabei handelt es sich um 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. Sie zeigt die Zeichen folgen an, die als baseName Parameter bereitgestellt werden sollen, 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 daran denken, dass der Ressourcen-Manager einen Ressourcen Satz basierend auf dem Wert der CultureInfo.CurrentUICulture -Eigenschaft und nicht der CultureInfo.CurrentCulture -Eigenschaft abruft.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. Wenn Sie einen Wert ändern, sollten Sie in der Regel auch den anderen ändern.Typically, if you change one value, you should also change the other.

Ressourcen VersionsverwaltungResource Versioning

Da die Hauptassembly, die die Standard Ressourcen einer app enthält, von den Satellitenassemblys der APP getrennt ist, können Sie eine neue Version Ihrer Hauptassembly freigeben, ohne die Satellitenassemblys erneut bereitstellen zu müssen.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. Verwenden Sie das SatelliteContractVersionAttribute -Attribut, um vorhandene Satellitenassemblys zu verwenden, und weisen Sie den Ressourcen-Manager an, Sie nicht erneut mit einer neuen Version Ihrer Hauptassembly bereitzustellen.You 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 zur Versions Unterstützung für Satellitenassemblys finden Sie im Artikel Abrufen von Ressourcen.For more information about versioning support for satellite assemblies, see the article Retrieving Resources.

<satelliteassemblys > Konfigurationsdatei Knoten<satelliteassemblies> Configuration File Node

Für ausführbare Dateien, die von einer Website (href. exe-Dateien) bereitgestellt und ausgeführt ResourceManager werden, kann das Objekt im Internet nach Satellitenassemblys suchen, was die Leistung Ihrer APP beeinträchtigen 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 beseitigen, können Sie diese Überprüfung auf die Satellitenassemblys beschränken, die Sie mit Ihrer 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 einen <satelliteassemblies> Knoten in der Konfigurationsdatei Ihrer APP, um anzugeben, dass Sie einen bestimmten Satz von Kulturen für Ihre APP bereitgestellt haben, und dass das ResourceManager Objekt nicht versuchen soll, eine andere Kultur zu suchen, 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 eines <satelliteassemblies> Knotens ist die Verwendung des ClickOnce-Bereitstellungs Manifest -Features.The preferred alternative to creating a <satelliteassemblies> node is to use the ClickOnce Deployment Manifest feature.

Erstellen Sie in der Konfigurationsdatei Ihrer APP einen Abschnitt ähnlich dem folgenden: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 einen oder <assembly> mehrere Knoten für jede Hauptassembly an, die Sie bereitstellen, wobei jeder Knoten einen voll qualifizierten 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 anstelle von MainAssemblyNameden Namen der Hauptassembly an, und geben Sie Versiondie PublicKeyTokenAttributwerte Culture , und an, die der Hauptassembly entsprechen.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.

    Geben Sie Version für das-Attribut die Versionsnummer der Assembly an.For the Version attribute, specify the version number of your assembly. Beispielsweise kann die erste Version der Assembly die Versionsnummer 1.0.0.0 sein.For example, the first release of your assembly might be version number 1.0.0.0.

    Geben Sie PublicKeyToken für das-Attribut das null -Schlüsselwort an, wenn Sie die Assembly nicht mit einem starken Namen signiert haben, oder geben Sie das Token des öffentlichen Schlüssels an, wenn Sie die Assembly signiert haben.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.

    Geben Sie das-Schlüsselwort neutral für das- ResourceManager <culture> Attributan,umdieHauptassemblyfestzulegen,undbewirkenSie,dassdieKlassenurdieindenKnotenCulture aufgelisteten Kulturen testet.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 voll qualifizierten Assemblynamen 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 Verwenden von Assemblys mit starkem Namen.For more information about strong-named assemblies, see the article Creating and Using Strong-Named Assemblies.

  • Geben Sie einen oder <culture> mehrere Knoten mit einem bestimmten Kultur Namen an, z. b. "fr-FR", oder einen neutralen Kultur Namen, 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 für eine Assembly, die nicht unter dem <satelliteassemblies> Knoten aufgeführt ist, Ressourcen benötigt werden, wird die ResourceManager Klasse mithilfe von Standard Prüfregeln für Kulturen überprüft.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 in Windows 8.x StoreWindows 8.x Store -Apps unterstützt wird, wird die Verwendung nicht empfohlen.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, wenn Portable KlassenbibliothekPortable Class Library Sie Projekte entwickeln, die mit Windows 8.x StoreWindows 8.x Store -Apps verwendet werden können.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 Windows 8.x StoreWindows 8.x Store aus Apps verwenden Sie stattdessen die Windows. applicationmodel. resources. resourceloader -Klasse.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 ruft ResourceManager die-Klasse Ressourcen von PRI-Dateien (Package Resource Index) ab.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 PRI-Datei des Anwendungspakets) enthält die Ressourcen für die Standard Kultur und alle lokalisierten Kulturen.A single PRI file (the application package PRI file) contains the resources for both the default culture and any localized cultures. Verwenden Sie das makepri-Hilfsprogramm, um eine PRI-Datei aus einer oder mehreren Ressourcen Dateien im XML-Ressourcen Format (. resw) zu erstellen.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 einem Visual Studio-Projekt enthalten sind, behandelt Visual Studio den Prozess, bei dem die PRI-Datei automatisch erstellt und verpackt wird.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 verwenden, um auf die Ressourcen der APP oder der Bibliothek zuzugreifen.You can then use the .NET Framework ResourceManager class to access the app's or library's resources.

Sie können ein ResourceManager -Objekt für eine Windows 8.x StoreWindows 8.x Store -App auf die gleiche Weise instanziieren wie für eine Desktop-App.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.

Sie können dann auf die Ressourcen für eine bestimmte Kultur zugreifen, indem Sie den Namen der abzurufenden Ressource GetString(String) an die-Methode übergeben.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 zurück, die durch die aktuelle Benutzeroberflächen Kultur des Threads bestimmt wird, der den-Befehl durchgeführt hat.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 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.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ächen Kultur oder die angegebene Kultur nicht gefunden werden kann, verwendet der Ressourcen-Manager eine Fall Back Liste für die Benutzeroberflächen Sprache, um eine geeignete Ressource zu suchen.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()

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

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)

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)

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

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

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

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

MainAssembly

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

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

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

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

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

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)

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)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
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)

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

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)

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)

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

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)

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)

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)

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

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()

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

(Geerbt von Object)
InternalGetResourceSet(CultureInfo, Boolean, Boolean)

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

MemberwiseClone()

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

(Geerbt von Object)
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()

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

(Geerbt von Object)

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.This type is thread safe.

Siehe auch