Erstellen von Ressourcendateien für .NET-AppsCreate resource files for .NET apps

Sie können Ressourcen (z. B. Zeichenfolgen, Bilder oder Objektdaten) in Ressourcendateien einschließen, um sie für die Anwendung leicht verfügbar zu machen.You can include resources, such as strings, images, or object data, in resources files to make them easily available to your application. .NET Framework bietet fünf Möglichkeiten, Ressourcendateien zu erstellen:The .NET Framework offers five ways to create resources files:

  • Erstellen Sie eine Textdatei, die Zeichenfolgenressourcen enthält.Create a text file that contains string resources. Sie können die Textdatei mithilfe des Resource File Generator (Resgen.exe) in eine binäre Ressourcendatei (.resources) konvertieren.You can use Resource File Generator (Resgen.exe) to convert the text file into a binary resource (.resources) file. Anschließend können Sie die binäre Ressourcendatei mit einem Sprachcompiler in eine ausführbare Datei der Anwendung oder eine Anwendungsbibliothek einbetten, oder Sie können sie mithilfe des Assembly Linker (Al.exe) in eine Satellitenassembly einbetten.You can then embed the binary resource file in an application executable or an application library by using a language compiler, or you can embed it in a satellite assembly by using Assembly Linker (Al.exe). Weitere Informationen finden Sie im Abschnitt Ressourcen in Textdateien.For more information, see the Resources in Text Files section.

  • Erstellen Sie eine XML-Ressourcendatei (.resx), die Zeichenfolgen-, Bild- oder Objektdaten enthält.Create an XML resource (.resx) file that contains string, image, or object data. Sie können die RESX-Datei mithilfe des Resource File Generator (Resgen.exe) in eine binäre Ressourcendatei (.resources) konvertieren.You can use Resource File Generator (Resgen.exe) to convert the .resx file into a binary resource (.resources) file. Anschließend können Sie die binäre Ressourcendatei mit einem Sprachcompiler in eine ausführbare Datei der Anwendung oder eine Anwendungsbibliothek einbetten, oder Sie können sie mithilfe des Assembly Linker (Al.exe) in eine Satellitenassembly einbetten.You can then embed the binary resource file in an application executable or an application library by using a language compiler, or you can embed it in a satellite assembly by using Assembly Linker (Al.exe). Weitere Informationen finden Sie im Abschnitt Ressourcen in RESX-Dateien.For more information, see the Resources in .resx Files section.

  • Erstellen Sie programmgesteuert mithilfe von Typen im System.Resources-Namespace eine XML-Ressourcendatei (.resx).Create an XML resource (.resx) file programmatically by using types in the System.Resources namespace. Sie können eine RESX-Datei erstellen, ihre Ressourcen auflisten und bestimmte Ressourcen nach dem Namen abrufen.You can create a .resx file, enumerate its resources, and retrieve specific resources by name. Weitere Informationen finden Sie im Thema Programmgesteuertes Arbeiten mit RESX-Dateien.For more information, see the topic Working with .resx Files Programmatically.

  • Erstellen Sie programmgesteuert eine binäre Ressourcendatei (.resources).Create a binary resource (.resources) file programmatically. Anschließend können Sie die Datei mit einem Sprachcompiler in eine ausführbare Datei der Anwendung oder eine Anwendungsbibliothek einbetten, oder Sie können sie mithilfe des Assembly Linker (Al.exe) in eine Satellitenassembly einbetten.You can then embed the file in an application executable or an application library by using a language compiler, or you can embed it in a satellite assembly by using Assembly Linker (Al.exe). Weitere Informationen finden Sie im Abschnitt Ressourcen in RESOURCES-Dateien.For more information, see the Resources in .resources Files section.

  • Verwenden Sie Visual Studio, um eine Ressourcendatei zu erstellen und in das Projekt einzuschließen.Use Visual Studio to create a resource file and include it in your project. Visual Studio stellt einen Ressourcen-Editor bereit, mit dem Sie Ressourcen hinzufügen, löschen und ändern können.Visual Studio provides a resource editor that lets you add, delete, and modify resources. Zur Kompilierzeit wird die Ressourcendatei automatisch in eine binäre RESOURCES-Datei konvertiert und in eine Anwendungsassembly oder eine Satellitenassembly eingebettet.At compile time, the resource file is automatically converted to a binary .resources file and embedded in an application assembly or satellite assembly. Weitere Informationen finden Sie im Abschnitt Ressourcendateien in Visual Studio.For more information, see the Resource Files in Visual Studio section.

Ressourcen in TextdateienResources in text files

Sie können Textdateien (TXT oder RESTEXT) verwenden, um nur Zeichenfolgenressourcen zu speichern.You can use text (.txt or .restext) files to store string resources only. Verwenden Sie für Nicht-Zeichenfolgenressourcen RESX-Dateien, oder erstellen Sie sie programmgesteuert.For non-string resources, use .resx files or create them programmatically. Textdateien, die Zeichenfolgenressourcen enthalten, haben das folgende Format:Text files that contain string resources have the following format:

# This is an optional comment.
name = value

; This is another optional comment.
name = value

; The following supports conditional compilation if X is defined.
#ifdef X
name1=value1
name2=value2
#endif

# The following supports conditional compilation if Y is undefined.
#if !Y
name1=value1
name2=value2
#endif

Das Ressourcendateiformat von .txt und von .restext-Dateien ist identisch.The resource file format of .txt and .restext files is identical. Die .restext-Dateierweiterung dient lediglich dazu, Textdateien direkt als textbasierte Ressourcendateien identifizierbar zu machen.The .restext file extension merely serves to make text files immediately identifiable as text-based resource files.

Zeichenfolgenressourcen werden als Name/Wert-Paare (name/value pairs) angezeigt, wobei name eine Zeichenfolge ist, die die Ressource identifiziert, und value die Ressourcenzeichenfolge, die zurückgegeben wird, wenn Sie name an eine Ressourcenabrufmethode wie ResourceManager.GetString übergeben.String resources appear as name/value pairs, where name is a string that identifies the resource, and value is the resource string that is returned when you pass name to a resource retrieval method such as ResourceManager.GetString. name und value müssen durch ein Gleichheitszeichen (=) getrennt werden.name and value must be separated by an equal sign (=). Beispiel:For example:

FileMenuName=File
EditMenuName=Edit
ViewMenuName=View
HelpMenuName=Help

Achtung

Verwenden Sie Ressourcendateien nicht, um Kennwörter, sicherheitsrelevante Informationen oder private Daten zu speichern.Do not use resource files to store passwords, security-sensitive information, or private data.

Leere Zeichenfolgen (eine Ressource, deren Wert String.Empty ist) sind in Textdateien zulässig.Empty strings (that is, a resource whose value is String.Empty) are permitted in text files. Beispiel:For example:

EmptyString=

Ab NET Framework 4.5 und in allen Versionen von .NET Core unterstützen Textdateien die bedingte Kompilierung mit den Konstrukten #ifdefSymbol... #endif und #if !Symbol... #endif.Starting with .NET Framework 4.5 and in all versions of .NET Core, text files support conditional compilation with the #ifdefsymbol... #endif and #if !symbol... #endif constructs. Sie können dann den /define-Schalter mit dem Resource File Generator (Resgen.exe) verwenden, um Symbole zu definieren.You can then use the /define switch with Resource File Generator (Resgen.exe) to define symbols. Jede Ressource erfordert ein eigenes Konstrukt, entweder #ifdefSymbol... #endif oder #if !Symbol... #endif.Each resource requires its own #ifdefsymbol... #endif or #if !symbol... #endif construct. Wenn Sie eine #ifdef-Anweisung verwenden und Symbol definiert ist, wird die zugeordnete Ressource in die RESOURCES-Datei einbezogen; andernfalls wird sie nicht eingeschlossen.If you use an #ifdef statement and symbol is defined, the associated resource is included in the .resources file; otherwise, it is not included. Wenn Sie eine #if !-Anweisung verwenden und Symbol nicht definiert ist, wird die zugeordnete Ressource in die RESOURCES-Datei einbezogen; andernfalls wird sie nicht eingeschlossen.If you use an #if ! statement and symbol is not defined, the associated resource is included in the .resources file; otherwise, it is not included.

Kommentare sind in Textdateien optional, und am Anfang einer Zeile wird entweder ein Semikolon (;) vorangestellt oder ein Nummernzeichen (#).Comments are optional in text files and are preceded either by a semicolon (;) or by a pound sign (#) at the beginning of a line. Zeilen, die Kommentare enthalten sind, können an beliebiger Stelle in der Datei eingefügt werden.Lines that contain comments can be placed anywhere in the file. Kommentare sind nicht in einer mit dem Resource File Generator (Resgen.exe) erstellten kompilierten RESOURCES-Datei enthalten.Comments are not included in a compiled .resources file that is created by using Resource File Generator (Resgen.exe).

Alle leeren Zeilen in den Textdateien werden als Leerzeichen angesehen ignoriert.Any blank lines in the text files are considered to be white space and are ignored.

Im folgenden Beispiel werden zwei Zeichenfolgenressourcen mit dem Namen OKButton und CancelButton definiert.The following example defines two string resources named OKButton and CancelButton.

#Define resources for buttons in the user interface.
OKButton=OK
CancelButton=Cancel

Wenn die Textdatei doppelte Vorkommen von name enthält, zeigt der Resource File Generator (Resgen.exe) eine Warnung an und ignoriert den zweiten Namen.If the text file contains duplicate occurrences of name, Resource File Generator (Resgen.exe) displays a warning and ignores the second name.

der Wert darf keine neuen Zeilenzeichen enthalten, Sie können jedoch Escapezeichen im C-Stil verwenden, wie z. b. \n, um eine neue Zeile darzustellen, und \t, um eine Registerkarte darzustellen. Sie können auch einen umgekehrten Schrägstrich einschließen, wenn er mit Escapezeichen versehen ist (z. b. "\\").value cannot contain new line characters, but you can use C language-style escape characters such as \n to represent a new line and \t to represent a tab. You can also include a backslash character if it is escaped (for example, "\\"). Darüber hinaus ist eine leere Zeichenfolge zulässig.In addition, an empty string is permitted.

Sie sollten Ressourcen im Textdateiformat mit UTF-8-Codierung oder UTF-16-Codierung entweder in Little-Endian oder Big-Endian-Bytereihenfolge speichern.You should save resources in text file format by using UTF-8 encoding or UTF-16 encoding in either little-endian or big-endian byte order. Obwohl der Resource File Generator (Resgen.exe) TXT-Dateien in RESOURCES-Dateien konvertiert, behandelt er Dateien standardmäßig als UTF-8.However, Resource File Generator (Resgen.exe), which converts a .txt file to a .resources file, treats files as UTF-8 by default. Wenn "Resgen.exe" eine als UTF-16 codierte Datei erkennen soll, müssen Sie am Anfang der Datei eine Unicode-Bytereihenfolgemarkierung (U+FEFF) angeben.If you want Resgen.exe to recognize a file that was encoded using UTF-16, you must include a Unicode byte order mark (U+FEFF) at the beginning of the file.

Um eine Ressourcendatei im Textformat in eine .NET-Assembly einzubetten, müssen Sie die Datei mit dem Resource File Generator (Resgen.exe) in eine binäre Ressourcendatei (.resources) konvertieren.To embed a resource file in text format into a .NET assembly, you must convert the file to a binary resource (.resources) file by using Resource File Generator (Resgen.exe). Sie können die RESOURCES-Datei dann mit einem Sprachcompiler in eine .NET-Assembly oder mit dem Assembly Linker (Al.exe) in eine Satellitenassembly einbetten.You can then embed the .resources file in a .NET assembly by using a language compiler or embed it in a satellite assembly by using Assembly Linker (Al.exe).

Im folgenden Beispiel wird eine Ressourcendatei im Textformat mit dem Namen "GreetingResources.txt" für eine einfache Konsolenanwendung "Hello World" verwendet.The following example uses a resource file in text format named GreetingResources.txt for a simple "Hello World" console application. Die Textdatei definiert zwei Zeichenfolgen, prompt und greeting, die den Benutzer zur Eingabe des Namens auffordern und einen Gruß anzeigen.The text file defines two strings, prompt and greeting, that prompt the user to enter his or her name and display a greeting.

# GreetingResources.txt
# A resource file in text format for a "Hello World" application.
#
# Initial prompt to the user.
prompt=Enter your name:
# Format string to display the result.
greeting=Hello, {0}!

Die Textdatei wird mit dem folgenden Befehl in eine RESOURCES-Datei konvertiert:The text file is converted to a .resources file by using the following command:

resgen GreetingResources.txt

Im folgenden Beispiel wird der Quellcode für eine Konsolenanwendung veranschaulicht, die dem Benutzer mithilfe der RESOURCES-Datei Nachrichten anzeigt.The following example shows the source code for a console application that uses the .resources file to display messages to the user.

using System;
using System.Reflection;
using System.Resources;

public class Example
{
   public static void Main()
   {
      ResourceManager rm = new ResourceManager("GreetingResources", 
                               typeof(Example).Assembly);
      Console.Write(rm.GetString("prompt"));
      string name = Console.ReadLine();
      Console.WriteLine(rm.GetString("greeting"), name);                                                                          
   }
}
// The example displays output like the following:
//       Enter your name: Wilberforce
//       Hello, Wilberforce!
Imports System.Reflection
Imports System.Resources

Module Example
   Public Sub Main()
      Dim rm As New ResourceManager("GreetingResources", 
                                    GetType(Example).Assembly())
      Console.Write(rm.GetString("prompt"))
      Dim name As String = Console.ReadLine()
      Console.WriteLine(rm.GetString("greeting"), name)                                                                          
   End Sub
End Module
' The example displays output like the following:
'       Enter your name: Wilberforce
'       Hello, Wilberforce!

Wenn Sie Visual Basic verwenden und die Quellcodedatei "Greeting.vb" genannt wird, erstellt der folgende Befehl eine ausführbare Datei, die die eingebettete RESOURCES-Datei einschließt:If you are using Visual Basic, and the source code file is named Greeting.vb, the following command creates an executable file that includes the embedded .resources file:

vbc greeting.vb -resource:GreetingResources.resources

Wenn Sie C# verwenden und die Quellcodedatei "Greeting.cs" genannt wird, erstellt der folgende Befehl eine ausführbare Datei, die die eingebettete RESOURCES-Datei einschließt:If you are using C#, and the source code file is named Greeting.cs, the following command creates an executable file that includes the embedded .resources file:

csc greeting.cs -resource:GreetingResources.resources

Ressourcen in RESX-DateienResources in .resx files

Im Gegensatz zu Textdateien, in denen nur Zeichenfolgenressourcen gespeichert werden können, können in XML-Ressourcendateien (.resx) Zeichenfolgen, Binärdaten wie Bilder, Symbole und Audioclips sowie programmgesteuerte Objekte gespeichert werden.Unlike text files, which can only store string resources, XML resource (.resx) files can store strings, binary data such as images, icons, and audio clips, and programmatic objects. Eine RESX-Datei enthält einen Standardheader, der das Format der Ressourceneinträge beschreibt und die XML-Versioninginformationen zum Interpretieren der Daten angibt.A .resx file contains a standard header, which describes the format of the resource entries and specifies the versioning information for the XML that is used to parse the data. Die Ressourcendateidaten folgen auf den XML-Header.The resource file data follows the XML header. Jedes Datenelement besteht aus einem Name-Wert-Paar, das in einem data-Tag enthalten ist.Each data item consists of a name/value pair that is contained in a data tag. Sein name-Attribut definiert den Ressourcennamen, und das geschachtelte value-Tag enthält den Ressourcenwert.Its name attribute defines the resource name, and the nested value tag contains the resource value. Bei Zeichenfolgendaten enthält das value-Tag die Zeichenfolge.For string data, the value tag contains the string.

Das folgende data-Tag definiert z. B. eine Zeichenfolgenressource mit dem Namen von prompt, deren Wert "Enter your name:" lautet.For example, the following data tag defines a string resource named prompt whose value is "Enter your name:".

<data name="prompt" xml:space="preserve">
  <value>Enter your name:</value>
</data>

Warnung

Verwenden Sie Ressourcendateien nicht, um Kennwörter, sicherheitsrelevante Informationen oder private Daten zu speichern.Do not use resource files to store passwords, security-sensitive information, or private data.

Bei Ressourcenobjekten enthält das Tag data ein type-Attribut, das den Datentyp der Ressource angibt.For resource objects, the data tag includes a type attribute that indicates the data type of the resource. Bei Objekten, die aus Binärdaten bestehen, schließt das data-Tag auch ein mimetype-Attribut ein, das den base64-Typ der Binärdaten angibt.For objects that consist of binary data, the data tag also includes a mimetype attribute, which indicates the base64 type of the binary data.

Hinweis

Alle RESX-Dateien verwenden ein Programm für die binäre Serialisierung, um die Binärdaten für einen bestimmten Typ zu generieren und zu analysieren.All .resx files use a binary serialization formatter to generate and parse the binary data for a specified type. Daher kann eine RESX-Datei ungültig werden, wenn das Format für die binäre Serialisierung für ein Objekt auf nicht kompatible Weise geändert wird.As a result, a .resx file can become invalid if the binary serialization format for an object changes in an incompatible way.

Im folgenden Beispiel wird ein Teil einer RESX-Datei veranschaulicht, die eine Int32-Ressource und ein Bitmapbild enthält.The following example shows a portion of a .resx file that includes an Int32 resource and a bitmap image.

<data name="i1" type="System.Int32, mscorlib">
  <value>20</value>
</data>

<data name="flag" type="System.Drawing.Bitmap, System.Drawing,
    Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
    mimetype="application/x-microsoft.net.object.bytearray.base64">
  <value>
    AAEAAAD/////AQAAAAAAAAAMAgAAADtTeX…
  </value>
</data>

Wichtig

Da RESX-Dateien aus wohlgeformtem XML in einem vordefinierten Format bestehen müssen, empfiehlt es sich nicht, mit RESX-Dateien manuell zu arbeiten, insbesondere, wenn die RESX-Dateien andere Ressourcen als Zeichenfolgen enthalten.Because .resx files must consist of well-formed XML in a predefined format, we do not recommend working with .resx files manually, particularly when the .resx files contain resources other than strings. Stattdessen bietet Visual Studio eine transparente Schnittstelle zum Erstellen und Bearbeiten von RESX-Dateien.Instead, Visual Studio provides a transparent interface for creating and manipulating .resx files. Weitere Informationen finden Sie im Abschnitt Ressourcendateien in Visual Studio.For more information, see the Resource Files in Visual Studio section. Sie können RESX-Dateien auch programmgesteuert erstellen und bearbeiten.You can also create and manipulate .resx files programmatically. Weitere Informationen finden Sie unter Programmgesteuertes Arbeiten mit RESX-Dateien.For more information, see Working with .resx Files Programmatically.

Ressourcen in RESOURCES-DateienResources in .resources files

Mit der System.Resources.ResourceWriter-Klasse können Sie eine binäre Ressourcendatei (.resources) direkt aus Code programmgesteuert erstellen.You can use the System.Resources.ResourceWriter class to programmatically create a binary resource (.resources) file directly from code. Sie können auch mithilfe des Resource File Generator (Resgen.exe) eine RESOURCES-Datei aus einer Textdatei oder einer RESX-Datei erstellen.You can also use Resource File Generator (Resgen.exe) to create a .resources file from a text file or a .resx file. Die RESOURCES-Datei kann neben Zeichenfolgendaten Binärdaten (Bytearrays) und Objektdaten enthalten.The .resources file can contain binary data (byte arrays) and object data in addition to string data. Das programmgesteuerte Erstellen einer RESOURCES-Datei erfordert die folgenden Schritte:Programmatically creating a .resources file requires the following steps:

  1. Erstellen Sie ein ResourceWriter-Objekt mit einem eindeutigen Dateinamen.Create a ResourceWriter object with a unique file name. Geben Sie dazu entweder einen Dateinamen oder einen Dateistream zu einem ResourceWriter-Klassenkonstruktor an.You can do this by specifying either a file name or a file stream to a ResourceWriter class constructor.

  2. Rufen Sie eine der Überladungen der ResourceWriter.AddResource-Methode für jede benannte Ressource an, die der Datei hinzugefügt werden soll.Call one of the overloads of the ResourceWriter.AddResource method for each named resource to add to the file. Die Ressource kann eine Zeichenfolge, ein Objekt oder eine Auflistung der Binärdaten (ein Bytearray) sein.The resource can be a string, an object, or a collection of binary data (a byte array).

  3. Rufen Sie die ResourceWriter.Close-Methode auf, um die Ressourcen in die Datei zu schreiben und das ResourceWriter-Objekt zu schließen.Call the ResourceWriter.Close method to write the resources to the file and to close the ResourceWriter object.

Hinweis

Verwenden Sie Ressourcendateien nicht, um Kennwörter, sicherheitsrelevante Informationen oder private Daten zu speichern.Do not use resource files to store passwords, security-sensitive information, or private data.

Im folgenden Beispiel wird programmgesteuert eine RESOURCES-Datei mit dem Namen "CarResources.resources" erstellt, mit der sechs Zeichenfolgen, ein Symbol und zwei anwendungsdefinierte Objekte (zwei Automobile-Objekte) gespeichert werden.The following example programmatically creates a .resources file named CarResources.resources that stores six strings, an icon, and two application-defined objects (two Automobile objects). Beachten Sie, dass die im Beispiel definierte und instanziierte Automobile-Klasse mit dem SerializableAttribute-Attribut markiert wird, wodurch die Klasse von der binären Serialisierungsformatierung beibehalten werden kann.Note that the Automobile class, which is defined and instantiated in the example, is tagged with the SerializableAttribute attribute, which allows it to be persisted by the binary serialization formatter.

using System;
using System.Drawing;
using System.Resources;

[Serializable()] public class Automobile
{
   private string carMake;
   private string carModel;
   private int carYear;
   private int carDoors;
   private int carCylinders;
   
   public Automobile(string make, string model, int year) :
                     this(make, model, year, 0, 0)
   { }
   
   public Automobile(string make, string model, int year, 
                     int doors, int cylinders)
   {                     
      this.carMake = make;
      this.carModel = model;
      this.carYear = year;
      this.carDoors = doors;
      this.carCylinders = cylinders;
   }

   public string Make {
      get { return this.carMake; }
   }       
   
   public string Model {
      get { return this.carModel; } 
   }       
   
   public int Year {
      get { return this.carYear; }
   }       
   
   public int Doors {
      get { 
         return this.carDoors; }
   }       
   
   public int Cylinders {
      get { 
         return this.carCylinders; }
   }        
}

public class Example
{
   public static void Main()
   {
      // Instantiate an Automobile object.
      Automobile car1 = new Automobile("Ford", "Model N", 1906, 0, 4);
      Automobile car2 = new Automobile("Ford", "Model T", 1909, 2, 4);
      // Define a resource file named CarResources.resx.
      using (ResourceWriter rw = new ResourceWriter(@".\CarResources.resources"))
      {
         rw.AddResource("Title", "Classic American Cars");
         rw.AddResource("HeaderString1", "Make");
         rw.AddResource("HeaderString2", "Model");
         rw.AddResource("HeaderString3", "Year");
         rw.AddResource("HeaderString4", "Doors");
         rw.AddResource("HeaderString5", "Cylinders");
         rw.AddResource("Information", SystemIcons.Information); 
         rw.AddResource("EarlyAuto1", car1);
         rw.AddResource("EarlyAuto2", car2);  
      }
   }
}
Imports System.Drawing
Imports System.Resources

<Serializable()> Public Class Automobile
   Private carMake As String
   Private carModel As String
   Private carYear As Integer
   Private carDoors AS Integer
   Private carCylinders As Integer
   
   Public Sub New(make As String, model As String, year As Integer) 
      Me.New(make, model, year, 0, 0)   
   End Sub
   
   Public Sub New(make As String, model As String, year As Integer, 
                  doors As Integer, cylinders As Integer)
      Me.carMake = make
      Me.carModel = model
      Me.carYear = year
      Me.carDoors = doors
      Me.carCylinders = cylinders
   End Sub

   Public ReadOnly Property Make As String
      Get
         Return Me.carMake
      End Get   
   End Property       
   
   Public ReadOnly Property Model As String
      Get
         Return Me.carModel
      End Get   
   End Property       
   
   Public ReadOnly Property Year As Integer
      Get
         Return Me.carYear
      End Get   
   End Property       
   
   Public ReadOnly Property Doors As Integer
      Get
         Return Me.carDoors
      End Get   
   End Property       
   
   Public ReadOnly Property Cylinders As Integer
      Get
         Return Me.carCylinders
      End Get   
   End Property       
End Class

Module Example
   Public Sub Main()
      ' Instantiate an Automobile object.
      Dim car1 As New Automobile("Ford", "Model N", 1906, 0, 4)
      Dim car2 As New Automobile("Ford", "Model T", 1909, 2, 4)
      ' Define a resource file named CarResources.resx.
      Using rw As New ResourceWriter(".\CarResources.resources")
         rw.AddResource("Title", "Classic American Cars")
         rw.AddResource("HeaderString1", "Make")
         rw.AddResource("HeaderString2", "Model")
         rw.AddResource("HeaderString3", "Year")
         rw.AddResource("HeaderString4", "Doors")
         rw.AddResource("HeaderString5", "Cylinders")
         rw.AddResource("Information", SystemIcons.Information) 
         rw.AddResource("EarlyAuto1", car1)
         rw.AddResource("EarlyAuto2", car2)  
      End Using
   End Sub
End Module

Nachdem Sie die RESOURCES-Datei erstellt haben, können Sie die RESOURCES-Datei in eine ausführbare Datei oder Runtimebibliothek einbetten, indem Sie den /resource-Schalter des Sprachcompilers einschließen, oder Sie betten sie mit dem Assembly Linker (Al.exe) in eine Satellitenassembly ein.After you create the .resources file, you can embed it in a run-time executable or library by including the language compiler's /resource switch, or embed it in a satellite assembly by using Assembly Linker (Al.exe).

Ressourcendateien in Visual StudioResource files in Visual Studio

Wenn Sie dem Visual Studio-Projekt eine Ressourcendatei hinzufügen, wird von Visual Studio im Projektverzeichnis eine RESX-Datei erstellt.When you add a resource file to your Visual Studio project, Visual Studio creates a .resx file in the project directory. Visual Studio stellt Ressourcen-Editoren bereit, die es Ihnen ermöglichen, Zeichenfolgen, Bilder und binäre Objekte hinzuzufügen.Visual Studio provides resource editors that enable you to add strings, images, and binary objects. Da die Editoren nur dazu dienen, statische Daten zu behandeln, können sie nicht zum Speichern programmgesteuerter Objekte verwendet werden. Sie müssen Objektdaten programmgesteuert in eine RESX-Datei oder in eine RESOURCES-Datei schreiben.Because the editors are designed to handle static data only, they cannot be used to store programmatic objects; you must write object data to either a .resx file or to a .resources file programmatically. Weitere Informationen finden Sie in den Abschnitten Programmgesteuertes Arbeiten mit RESX-Dateien und Ressourcen in RESOURCES-Dateien.For more information, see Working with .resx Files Programmatically and the Resources in .resources Files section.

Wenn Sie lokalisierte Ressourcen hinzufügen, geben Sie ihnen den gleichen Stammdateinamen wie der Hauptressourcendatei.If you're adding localized resources, give them the same root file name as the main resource file. Sie sollten auch ihre Kultur im Dateinamen festlegen.You should also designate their culture in the file name. Wenn Sie z. B. eine Ressourcendatei mit dem Namen "Ressourcen.resx" hinzufügen, können Sie auch Ressourcendateien mit dem Namen "Ressourcen.en-US.resx" und "Ressourcen.fr-FR.resx" erstellen, um lokalisierte Ressourcen für die englischen (USA) und französischen (Frankreich) Kulturen zu halten.For example, if you add a resource file named Resources.resx, you might also create resource files named Resources.en-US.resx and Resources.fr-FR.resx to hold localized resources for the English (United States) and French (France) cultures, respectively. Sie sollten auch die Standardkultur der Anwendung festlegen.You should also designate your application's default culture. Die Ressourcen dieser Kultur werden verwendet, wenn keine lokalisierten Ressourcen für eine bestimmte Kultur gefunden werden.This is the culture whose resources are used if no localized resources for a particular culture can be found. Zum Angeben der Standardkultur klicken Sie in Visual Studio im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, zeigen Sie auf "Anwendung", klicken Sie auf Assemblyinformationen, und wählen Sie die entsprechende Sprache/Kultur in der Liste Neutrale Sprache aus.To specify the default culture, in Solution Explorer in Visual Studio, right-click the project name, point to Application, click Assembly Information, and select the appropriate language/culture in the Neutral language list.

Zur Kompilierzeit werden von Visual Studio zuerst die RESX-Dateien in einem Projekt in binäre Ressourcendateien (.resources) konvertiert und im Verzeichnis obj des Projekts in einem Unterverzeichnis gespeichert.At compile time, Visual Studio first converts the .resx files in a project to binary resource (.resources) files and stores them in a subdirectory of the project's obj directory. Visual Studio bettet alle Ressourcendateien ein, die keine lokalisierten Ressourcen in der vom Projekt generierten Hauptassembly enthalten.Visual Studio embeds any resource files that do not contain localized resources in the main assembly that is generated by the project. Wenn Ressourcendateien lokalisierte Ressourcen enthalten, werden diese von Visual Studio für jede lokalisierte Kultur in separate Satellitenassemblys eingebettet.If any resource files contain localized resources, Visual Studio embeds them in separate satellite assemblies for each localized culture. Anschließend wird jede Satellitenassembly in einem Verzeichnis gespeichert, dessen Name der lokalisierten Kultur entspricht.It then stores each satellite assembly in a directory whose name corresponds to the localized culture. Lokalisierte englische Ressourcen (USA) werden z. B. in einer Satellitenassembly im Unterverzeichnis "en-US" gespeichert.For example, localized English (United States) resources are stored in a satellite assembly in the en-US subdirectory.

Siehe auchSee also