Zeichencodierung in .NETCharacter Encoding in .NET

Zeichen sind abstrakte Entitäten, die auf viele verschiedene Arten dargestellt werden können.Characters are abstract entities that can be represented in many different ways. Eine Zeichencodierung ist ein System, in dem jedes Zeichen in einem unterstützten Zeichensatz mit einem Wert verknüpft wird, der dieses Zeichen darstellt.A character encoding is a system that pairs each character in a supported character set with some value that represents that character. Beispielsweise handelt es sich beim Morsealphabet um eine Zeichencodierung, die alle Zeichen im römischen Alphabet mit einem Muster aus Punkten und Bindestrichen verknüpft, das für die Übertragung über Telegrafenleitungen geeignet ist.For example, Morse code is a character encoding that pairs each character in the Roman alphabet with a pattern of dots and dashes that are suitable for transmission over telegraph lines. Bei einer Zeichencodierung für Computer wird jedes Zeichen in einem unterstützten Zeichensatz mit einem numerischen Wert verknüpft, der das jeweilige Zeichen darstellt.A character encoding for computers pairs each character in a supported character set with a numeric value that represents that character. Eine Zeichencodierung verfügt über zwei verschiedene Komponenten:A character encoding has two distinct components:

  • Ein Encoder, der eine Folge von Zeichen in eine Folge von numerischen Werten (Bytes) übersetztAn encoder, which translates a sequence of characters into a sequence of numeric values (bytes).

  • Ein Decoder, der eine Bytefolge in eine Folge von Zeichen übersetztA decoder, which translates a sequence of bytes into a sequence of characters.

Die Zeichencodierung gibt die Regeln für die Funktionsweise von Encoder und Decoder an.Character encoding describes the rules by which an encoder and a decoder operate. Zum Beispiel beschreibt die UTF8Encoding -Klasse die Regeln zum Codieren und Decodieren von UTF-8 (8-Bit-Unicode Transformation Format). In diesem Format werden für die Darstellung eines einzelnen Unicode-Zeichens ein bis vier Bytes verwendet.For example, the UTF8Encoding class describes the rules for encoding to, and decoding from, 8-bit Unicode Transformation Format (UTF-8), which uses one to four bytes to represent a single Unicode character. Die Codierung und Decodierung können auch eine Validierung beinhalten.Encoding and decoding can also include validation. Die UnicodeEncoding -Klasse prüft z. B. alle Ersatzzeichen, um sicherzustellen, dass sie gültige Ersatzzeichenpaare bilden.For example, the UnicodeEncoding class checks all surrogates to make sure they constitute valid surrogate pairs. (Ein Ersatzzeichenpaar besteht aus einem Zeichen mit einem Codepunkt zwischen U+D800 und U+DBFF gefolgt von einem Zeichen mit einem Codepunkt zwischen U+DC00 und U+DFFF.) Eine Fallbackstrategie legt fest, wie ein Encoder ungültige Zeichen behandelt oder wie ein Decoder ungültige Bytes behandelt.(A surrogate pair consists of a character with a code point that ranges from U+D800 to U+DBFF followed by a character with a code point that ranges from U+DC00 to U+DFFF.) A fallback strategy determines how an encoder handles invalid characters or how a decoder handles invalid bytes.

Warnung

Die .NET-Codierungsklassen bieten eine Möglichkeit, Zeichendaten zu speichern und zu konvertieren..NET encoding classes provide a way to store and convert character data. Sie sollten nicht verwendet werden, um Binärdaten im Zeichenfolgenformat zu speichern.They should not be used to store binary data in string form. Abhängig von der verwendeten Codierung kann das Konvertieren von Binärdaten in das Zeichenfolgenformat mithilfe der Codierungsklassen zu unerwartetem Verhalten und ungenauen oder beschädigten Daten führen.Depending on the encoding used, converting binary data to string format with the encoding classes can introduce unexpected behavior and produce inaccurate or corrupted data. Um Binärdaten in ein Zeichenfolgenformat zu konvertieren, verwenden Sie die Convert.ToBase64String -Methode.To convert binary data to a string form, use the Convert.ToBase64String method.

.NET verwendet die UTF-16-Codierung (angegeben durch die UnicodeEncoding-Klasse), um Zeichen und Zeichenfolgen darzustellen..NET uses the UTF-16 encoding (represented by the UnicodeEncoding class) to represent characters and strings. Anwendungen, die auf die Common Language Runtime abzielen, verwenden Encoder, um von der Common Language Runtime unterstützte Unicode-Zeichendarstellungen anderen Codierungsschemen zuzuordnen.Applications that target the common language runtime use encoders to map Unicode character representations supported by the common language runtime to other encoding schemes. Decoder werden verwendet, um Zeichen aus Nicht-Unicode-Codierungen Unicode zuzuordnen.They use decoders to map characters from non-Unicode encodings to Unicode.

Dieses Thema enthält folgende Abschnitte:This topic consists of the following sections:

Codierungen in .NETEncodings in .NET

Alle Zeichencodierungsklassen in .NET erben von der abstrakten System.Text.Encoding-Klasse, die die Funktionen definiert, die für alle Zeichencodierungen gleich sind.All character encoding classes in .NET inherit from the System.Text.Encoding class, which is an abstract class that defines the functionality common to all character encodings. Um auf die einzelnen in .NET implementierten Codierungsobjekte zuzugreifen, gehen Sie wie folgt vor:To access the individual encoding objects implemented in .NET, do the following:

  • Verwenden Sie die statischen Eigenschaften der Encoding-Klasse, die Objekte zurückgibt, die die in .NET verfügbaren Standardzeichencodierungen darstellen (ASCII, UTF-7, UTF-8, UTF-16 und UTF-32).Use the static properties of the Encoding class, which return objects that represent the standard character encodings available in .NET (ASCII, UTF-7, UTF-8, UTF-16, and UTF-32). Zum Beispiel gibt die Encoding.Unicode -Eigenschaft ein UnicodeEncoding -Objekt zurück.For example, the Encoding.Unicode property returns a UnicodeEncoding object. Jedes Objekt verwendet einen Ersatzfallback für die Behandlung von Zeichenfolgen, die nicht codiert werden können, und von Bytes, die nicht decodiert werden können.Each object uses replacement fallback to handle strings that it cannot encode and bytes that it cannot decode. (Weitere Informationen finden Sie im Abschnitt Replacement Fallback .)(For more information, see the Replacement Fallback section.)

  • Rufen Sie den Klassenkonstruktor der Codierung auf.Call the encoding's class constructor. Objekte für ASCII-, UTF-7-, UTF-8-, UTF-16- und UTF-32-Codierungen können auf diese Weise instanziiert werden.Objects for the ASCII, UTF-7, UTF-8, UTF-16, and UTF-32 encodings can be instantiated in this way. Standardmäßig verwendet jedes Objekt den Ersatzfallback zur Behandlung von Zeichenfolgen, die nicht codiert werden können, und von Bytes, die nicht decodiert werden können. Sie können aber angeben, dass stattdessen eine Ausnahme ausgelöst werden soll.By default, each object uses replacement fallback to handle strings that it cannot encode and bytes that it cannot decode, but you can specify that an exception should be thrown instead. (Weitere Informationen finden Sie in den Abschnitten Replacement Fallback und Exception Fallback .)(For more information, see the Replacement Fallback and Exception Fallback sections.)

  • Rufen Sie den Encoding.Encoding(Int32) -Konstruktor auf, und übergeben Sie eine ganze Zahl, die die Codierung darstellt.Call the Encoding.Encoding(Int32) constructor and pass it an integer that represents the encoding. Standardcodierungsobjekte verwenden den Ersatzfallback, und Codepage- und DBCS (Doppelbyte-Zeichensatz)-Codierungsobjekte verwenden den Fallback mit ähnlichen Zeichen zur Behandlung von Zeichenfolgen, die nicht codiert werden können, und von Bytes, die nicht decodiert werden können.Standard encoding objects use replacement fallback, and code page and double-byte character set (DBCS) encoding objects use best-fit fallback to handle strings that they cannot encode and bytes that they cannot decode. (Weitere Informationen finden Sie im Abschnitt Best-Fit Fallback .)(For more information, see the Best-Fit Fallback section.)

  • Rufen Sie die Encoding.GetEncoding-Methode auf, die jede in .NET verfügbare Standard-, Codepage- oder DBCS-Codierung zurückgibt.Call the Encoding.GetEncoding method, which returns any standard, code page, or DBCS encoding available in .NET. Mithilfe von Überladungen können Sie sowohl für den Encoder als auch den Decoder ein Fallbackobjekt angeben.Overloads let you specify a fallback object for both the encoder and the decoder.

Hinweis

Gemäß Unicode-Standard werden jedem Zeichen aller unterstützten Skripts ein Codepunkt (eine Zahl) und ein Name zugewiesen.The Unicode Standard assigns a code point (a number) and a name to each character in every supported script. Das Zeichen "A" wird beispielsweise durch den Codepunkt U+0041 und den Namen "LATIN CAPITAL LETTER A" dargestellt.For example, the character "A" is represented by the code point U+0041 and the name "LATIN CAPITAL LETTER A". Die UTF (Unicode-Transformation Format)-Codierungen definieren Möglichkeiten, diesen Codepunkt in eine Abfolge aus einem oder mehreren Bytes zu codieren.The Unicode Transformation Format (UTF) encodings define ways to encode that code point into a sequence of one or more bytes. Ein Unicode-Datencodierungsschema vereinfacht die Entwicklung weltweit einsetzbarer Anwendungen, da es die Darstellung von Zeichen aus beliebigen Zeichensätzen in einer Codierung ermöglicht.A Unicode encoding scheme simplifies world-ready application development because it allows characters from any character set to be represented in a single encoding. Anwendungsentwickler müssen nicht mehr das Codierungsschema verfolgen, das für die Erstellung von Zeichen für eine bestimmte Sprache oder ein Schreibsystem verwendet wurde, und die Daten können länderübergreifend auf allen Systemen verwendet werden, ohne beschädigt zu werden.Application developers no longer have to keep track of the encoding scheme that was used to produce characters for a specific language or writing system, and data can be shared among systems internationally without being corrupted.

.NET unterstützt drei Codierungen, die durch den Unicode-Standard definiert sind: UTF-8, UTF-16 und UTF-32..NET supports three encodings defined by the Unicode standard: UTF-8, UTF-16, and UTF-32. Weitere Informationen finden Sie im Unicode-Standard auf der Unicode-Homepage.For more information, see The Unicode Standard at the Unicode home page.

Sie können Informationen über alle in .NET verfügbaren Codierungen abrufen, indem Sie die Encoding.GetEncodings-Methode aufrufen.You can retrieve information about all the encodings available in .NET by calling the Encoding.GetEncodings method. .NET unterstützt die in der folgenden Tabelle aufgelisteten Zeichencodierungssysteme..NET supports the character encoding systems listed in the following table.

CodierungEncoding KlasseClass BeschreibungDescription Vorteile/NachteileAdvantages/disadvantages
ASCIIASCII ASCIIEncoding Codiert einen begrenzten Bereich von Zeichen mithilfe der unteren sieben Bits eines Bytes.Encodes a limited range of characters by using the lower seven bits of a byte. Da diese Codierung nur Zeichenwerte von U+0000 bis U+007F unterstützt, ist sie in den meisten Fällen für weltweit einsetzbare Anwendungen nicht geeignet.Because this encoding only supports character values from U+0000 through U+007F, in most cases it is inadequate for internationalized applications.
UTF-7UTF-7 UTF7Encoding Stellt Zeichen als Sequenzen von 7-Bit-ASCII-Zeichen dar.Represents characters as sequences of 7-bit ASCII characters. Nicht-ASCII-Unicode-Zeichen werden durch eine Escapesequenz von ASCII-Zeichen dargestellt.Non-ASCII Unicode characters are represented by an escape sequence of ASCII characters. UTF-7 unterstützt Protokolle wie E-Mail- und Newsgroupprotokolle.UTF-7 supports protocols such as email and newsgroup protocols. UTF-7 ist jedoch nicht besonders sicher oder robust.However, UTF-7 is not particularly secure or robust. In einigen Fällen kann die Änderung eines Bits die Interpretation einer gesamten UTF-7-Zeichenfolge radikal ändern.In some cases, changing one bit can radically alter the interpretation of an entire UTF-7 string. In anderen Fällen können verschiedene UTF-7-Zeichenfolgen denselben Text codieren.In other cases, different UTF-7 strings can encode the same text. Bei Sequenzen, die Nicht-ASCII-Zeichen enthalten, benötigt UTF-7 mehr Speicherplatz als UTF-8, und auch die Codierung/Decodierung erfolgt langsamer.For sequences that include non-ASCII characters, UTF-7 requires more space than UTF-8, and encoding/decoding is slower. Daher sollten Sie nach Möglichkeit UTF-8 anstelle von UTF-7 verwenden.Consequently, you should use UTF-8 instead of UTF-7 if possible.
UTF-8UTF-8 UTF8Encoding Stellt jeden Unicode-Codepunkt als eine Folge von einem bis vier Bytes dar.Represents each Unicode code point as a sequence of one to four bytes. UTF-8 unterstützt 8-Bit-Datengrößen und funktioniert mit vielen vorhandenen Betriebssystemen.UTF-8 supports 8-bit data sizes and works well with many existing operating systems. Im ASCII-Zeichenbereich ist UTF-8 mit der ASCII-Codierung identisch und ermöglicht einen umfangreicheren Zeichensatz.For the ASCII range of characters, UTF-8 is identical to ASCII encoding and allows a broader set of characters. Für CJK-Skripts (Chinesisch, Japanisch, Koreanisch) können bei UTF-8 jedoch drei Bytes für jedes Zeichen erforderlich sein, und es können größere Datengrößen als bei UTF-16 entstehen.However, for Chinese-Japanese-Korean (CJK) scripts, UTF-8 can require three bytes for each character, and can potentially cause larger data sizes than UTF-16. Manchmal wird die größere Datengröße für den CJK-Bereich jedoch durch die Menge an ASCII-Daten, z. B. HTML-Tags, gerechtfertigt.Note that sometimes the amount of ASCII data, such as HTML tags, justifies the increased size for the CJK range.
UTF-16UTF-16 UnicodeEncoding Stellt jeden Unicode-Codepunkt als Folge von einer oder zwei 16-Bit-Ganzzahlen dar.Represents each Unicode code point as a sequence of one or two 16-bit integers. Die meisten allgemeinen Unicode-Zeichen erfordern nur einen UTF-16-Codepunkt. Ergänzende Unicode-Zeichen (U+10000 und höher) erfordern allerdings zwei UTF-16-Ersatzzeichen-Codepunkte.Most common Unicode characters require only one UTF-16 code point, although Unicode supplementary characters (U+10000 and greater) require two UTF-16 surrogate code points. Sowohl Little-Endian- als auch Big-Endian-Bytereihenfolgen werden unterstützt.Both little-endian and big-endian byte orders are supported. Die UTF-16-Codierung wird von der Common Language Runtime zur Darstellung von Char -Werten und String -Werten und vom Windows-Betriebssystem zur Darstellung von WCHAR -Werten verwendet.UTF-16 encoding is used by the common language runtime to represent Char and String values, and it is used by the Windows operating system to represent WCHAR values.
UTF-32UTF-32 UTF32Encoding Stellt jeden Unicode-Codepunkt als 32-Bit-Ganzzahl dar.Represents each Unicode code point as a 32-bit integer. Sowohl Little-Endian- als auch Big-Endian-Bytereihenfolgen werden unterstützt.Both little-endian and big-endian byte orders are supported. Die UTF-32-Codierung wird verwendet, wenn Anwendungen das Verhalten mit Ersatzzeichen-Codepunkten der UTF-16-Codierung unter Betriebssystemen vermeiden möchten, bei denen codierter Speicherplatz von zu großer Bedeutung ist.UTF-32 encoding is used when applications want to avoid the surrogate code point behavior of UTF-16 encoding on operating systems for which encoded space is too important. Einzelne Symbole, die in einer Anzeige gerendert werden, können dennoch mit mehr als einem UTF-32-Zeichen codiert werden.Single glyphs rendered on a display can still be encoded with more than one UTF-32 character.
ANSI/ISO-CodierungenANSI/ISO encodings Bietet Unterstützung für eine Vielzahl von Codepages.Provides support for a variety of code pages. Unter Windows-Betriebssystemen werden Codepages verwendet, um eine bestimmte Sprache oder Sprachgruppe zu unterstützen.On Windows operating systems, code pages are used to support a specific language or group of languages. Eine Tabelle, in der die von .NET unterstützten Codepages aufgeführt werden, finden Sie unter der Encoding-Klasse.For a table that lists the code pages supported by .NET, see the Encoding class. Sie können ein Codierungsobjekt für eine bestimmte Codepage abrufen, indem Sie die Encoding.GetEncoding(Int32) -Methode aufrufen.You can retrieve an encoding object for a particular code page by calling the Encoding.GetEncoding(Int32) method. Eine Codepage enthält 256 Codepunkte und ist nullbasiert.A code page contains 256 code points and is zero-based. Bei den meisten Codepages stellen die Codepunkte 0 bis 127 den ASCII-Zeichensatz dar. Die Codepunkte 128 bis 255 weichen zwischen den Codepages erheblich voneinander ab.In most code pages, code points 0 through 127 represent the ASCII character set, and code points 128 through 255 differ significantly between code pages. Die Codepage 1252 enthält beispielsweise die Zeichen für lateinische Schreibsysteme, einschließlich Englisch, Deutsch und Französisch.For example, code page 1252 provides the characters for Latin writing systems, including English, German, and French. Die letzten 128 Codepunkte der Codepage 1252 enthalten die Akzentzeichen.The last 128 code points in code page 1252 contain the accent characters. Die Codepage 1253 enthält die Zeichencodes für das griechische Schreibsystem.Code page 1253 provides character codes that are required in the Greek writing system. Die letzten 128 Codepunkte der Codepage 1253 enthalten die griechischen Zeichen.The last 128 code points in code page 1253 contain the Greek characters. Daher kann eine auf ANSI-Codepages beruhende Anwendung Griechisch und Deutsch nicht in demselben Textstream speichern, sofern kein Bezeichner eingeschlossen ist, der die referenzierte Codepage angibt.As a result, an application that relies on ANSI code pages cannot store Greek and German in the same text stream unless it includes an identifier that indicates the referenced code page.
DBCS-Codierungen (Double-Byte Character Set, Doppelbyte-Zeichensatz)Double-byte character set (DBCS) encodings Unterstützt Sprachen wie Chinesisch, Japanisch und Koreanisch, die mehr als 256 Zeichen enthalten.Supports languages, such as Chinese, Japanese, and Korean, that contain more than 256 characters. In einem DBCS wird jedes Zeichen durch ein Paar Codepunkte (ein Doppelbyte) dargestellt.In a DBCS, a pair of code points (a double byte) represents each character. Die Encoding.IsSingleByte -Eigenschaft gibt für DBCS-Codierungen false zurück.The Encoding.IsSingleByte property returns false for DBCS encodings. Sie können ein Codierungsobjekt für einen bestimmten Doppelbyte-Zeichensatz abrufen, indem Sie die Encoding.GetEncoding(Int32) -Methode aufrufen.You can retrieve an encoding object for a particular DBCS by calling the Encoding.GetEncoding(Int32) method. In einem DBCS wird jedes Zeichen durch ein Paar Codepunkte (ein Doppelbyte) dargestellt.In a DBCS, a pair of code points (a double byte) represents each character. Wenn eine Anwendung DBCS-Daten behandelt, wird das erste Byte eines DBCS-Zeichens (das führende Byte) in Kombination mit dem unmittelbar nachfolgenden Byte verarbeitet.When an application handles DBCS data, the first byte of a DBCS character (the lead byte) is processed in combination with the trail byte that immediately follows it. Da ein einzelnes Paar von DBCS-Codepunkten je nach Codepage unterschiedliche Zeichen darstellen kann, lässt auch dieses Schema keine Kombination zweier Sprachen wie Japanisch und Chinesisch in einem Datenstream zu.Because a single pair of double-byte code points can represent different characters depending on the code page, this scheme still does not allow for the combination of two languages, such as Japanese and Chinese, in the same data stream.

Diese Codierungen ermöglichen Ihnen die Verwendung von Unicode-Zeichen und von Codierungen, die in älteren Anwendungen am häufigsten verwendet werden.These encodings enable you to work with Unicode characters as well as with encodings that are most commonly used in legacy applications. Außerdem können Sie eine benutzerdefinierte Codierung erstellen, indem Sie eine von Encoding erbende Klasse definieren und deren Member überschreiben.In addition, you can create a custom encoding by defining a class that derives from Encoding and overriding its members.

Hinweise zur Plattform: .NET CorePlatform Notes: .NET Core

Standardmäßig stellt .NET Core keine anderen Codepagecodierungen als Codepage 28591 und Unicode-Codierungen (z.B. UTF-8 und UTF-16) bereit.By default, .NET Core does not make available any code page encodings other than code page 28591 and the Unicode encodings, such as UTF-8 and UTF-16. Allerdings können Sie Ihrer App die Codepagecodierungen hinzufügen, die in Standard-Windows-Apps verwendet werden, die .NET als Ziel nutzen.However, you can add the code page encodings found in standard Windows apps that target .NET to your app. Vollständige Informationen finden Sie im Thema CodePagesEncodingProvider .For complete information, see the CodePagesEncodingProvider topic.

Auswählen einer Encoding-KlasseSelecting an Encoding Class

Wenn Sie die Möglichkeit haben, die von der Anwendung verwendete Codierung auszuwählen, sollten Sie eine Unicode-Codierung verwenden, vorzugsweise UTF8Encoding oder UnicodeEncoding.If you have the opportunity to choose the encoding to be used by your application, you should use a Unicode encoding, preferably either UTF8Encoding or UnicodeEncoding. (.NET unterstützt auch eine dritte Unicode-Codierung, UTF32Encoding.)(.NET also supports a third Unicode encoding, UTF32Encoding.)

Wenn Sie eine ASCII-Codierung (ASCIIEncoding) verwenden möchten, wählen Sie stattdessen UTF8Encoding .If you are planning to use an ASCII encoding (ASCIIEncoding), choose UTF8Encoding instead. Die beiden Codierungen sind für den ASCII-Zeichensatz identisch. UTF8Encoding bietet allerdings die folgenden Vorteile:The two encodings are identical for the ASCII character set, but UTF8Encoding has the following advantages:

  • Alle Unicode-Zeichen können dargestellt werden, während ASCIIEncoding nur die Unicode-Zeichenwerte zwischen U+0000 und U+007F unterstützt.It can represent every Unicode character, whereas ASCIIEncoding supports only the Unicode character values between U+0000 and U+007F.

  • Weitere Vorteile sind die Fehlererkennung und die verbesserte Sicherheit.It provides error detection and better security.

  • Die Geschwindigkeit wurde optimiert und sollte schneller sein als jede andere Codierung.It has been tuned to be as fast as possible and should be faster than any other encoding. Selbst bei Inhalten, bei denen es sich um reine ASCII-Daten handelt, erfolgen mit UTF8Encoding durchgeführte Operationen schneller als mit ASCIIEncodingdurchgeführte Operationen.Even for content that is entirely ASCII, operations performed with UTF8Encoding are faster than operations performed with ASCIIEncoding.

Sie sollten daher in Erwägung ziehen, ASCIIEncoding nur für ältere Anwendungen zu verwenden.You should consider using ASCIIEncoding only for legacy applications. Allerdings kann UTF8Encoding auch für ältere Anwendungen aus folgenden Gründen die bessere Wahl sein (ausgehend von den Standardeinstellungen):However, even for legacy applications, UTF8Encoding might be a better choice for the following reasons (assuming default settings):

  • Wenn die Anwendung Inhalte, die keine reinen ASCII-Daten sind, mit ASCIIEncodingcodiert, wird jedes Nicht-ASCII-Zeichen als Fragezeichen (?) codiert.If your application has content that is not strictly ASCII and encodes it with ASCIIEncoding, each non-ASCII character encodes as a question mark (?). Wenn die Anwendung diese Daten anschließend decodiert, gehen die Informationen verloren.If the application then decodes this data, the information is lost.

  • Wenn die Anwendung Inhalte, die keine reinen ASCII-Daten sind, mit UTF8Encodingcodiert und als ASCII-Daten interpretiert, erscheint das Ergebnis unverständlich.If your application has content that is not strictly ASCII and encodes it with UTF8Encoding, the result seems unintelligible if interpreted as ASCII. Wenn die Anwendung dann jedoch einen UTF-8-Decoder verwendet, um diese Daten zu decodieren, durchlaufen sie einen erfolgreichen Roundtrip.However, if the application then uses a UTF-8 decoder to decode this data, the data performs a round trip successfully.

In einer Webanwendung sollten die Zeichen, die als Antwort auf eine Webanforderung an den Client gesendet werden, die auf dem Client verwendete Codierung widerspiegeln.In a web application, characters sent to the client in response to a web request should reflect the encoding used on the client. In den meisten Fällen sollten Sie die HttpResponse.ContentEncoding -Eigenschaft auf den Wert festlegen, der von der HttpRequest.ContentEncoding -Eigenschaft zurückgegeben wird, um Text in der vom Benutzer erwarteten Codierung anzuzeigen.In most cases, you should set the HttpResponse.ContentEncoding property to the value returned by the HttpRequest.ContentEncoding property to display text in the encoding that the user expects.

Verwenden eines CodierungsobjektsUsing an Encoding Object

Ein Codierer konvertiert eine Zeichenfolge (meistens Unicode-Zeichen) in die numerische Entsprechung (Byte).An encoder converts a string of characters (most commonly, Unicode characters) to its numeric (byte) equivalent. Beispielsweise können Sie einen ASCII-Encoder verwenden, um Unicode-Zeichen in ASCII zu konvertieren, damit sie in der Konsole angezeigt werden können.For example, you might use an ASCII encoder to convert Unicode characters to ASCII so that they can be displayed at the console. Um die Konvertierung auszuführen, rufen Sie die Encoding.GetBytes -Methode auf.To perform the conversion, you call the Encoding.GetBytes method. Wenn Sie vor Ausführung der Codierung ermitteln möchten, wie viele Bytes zum Speichern der codierten Zeichen benötigt werden, können Sie die GetByteCount -Methode aufrufen.If you want to determine how many bytes are needed to store the encoded characters before performing the encoding, you can call the GetByteCount method.

Im folgenden Beispiel wird ein einzelnes Bytearray verwendet, um Zeichenfolgen in zwei separaten Vorgängen zu codieren.The following example uses a single byte array to encode strings in two separate operations. Ein verwalteter Index gibt die Anfangsposition im Bytearray für die nächste Gruppe von ASCII-codierten Bytes an.It maintains an index that indicates the starting position in the byte array for the next set of ASCII-encoded bytes. Die ASCIIEncoding.GetByteCount(String) -Methode wird aufgerufen, um sicherzustellen, dass das Bytearray groß genug für die codierte Zeichenfolge ist.It calls the ASCIIEncoding.GetByteCount(String) method to ensure that the byte array is large enough to accommodate the encoded string. Dann wird die ASCIIEncoding.GetBytes(String, Int32, Int32, Byte[], Int32) -Methode aufgerufen, um die Zeichen in der Zeichenfolge zu codieren.It then calls the ASCIIEncoding.GetBytes(String, Int32, Int32, Byte[], Int32) method to encode the characters in the string.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      string[] strings= { "This is the first sentence. ", 
                          "This is the second sentence. " };
      Encoding asciiEncoding = Encoding.ASCII;
      
      // Create array of adequate size.
      byte[] bytes = new byte[49];
      // Create index for current position of array.
      int index = 0;
      
      Console.WriteLine("Strings to encode:");
      foreach (var stringValue in strings) {
         Console.WriteLine("   {0}", stringValue);
         
         int count = asciiEncoding.GetByteCount(stringValue);
         if (count + index >=  bytes.Length)
            Array.Resize(ref bytes, bytes.Length + 50);

         int written = asciiEncoding.GetBytes(stringValue, 0, 
                                              stringValue.Length, 
                                              bytes, index);    
    
         index = index + written; 
      } 
      Console.WriteLine("\nEncoded bytes:");
      Console.WriteLine("{0}", ShowByteValues(bytes, index));
      Console.WriteLine();
      
      // Decode Unicode byte array to a string.
      string newString = asciiEncoding.GetString(bytes, 0, index);
      Console.WriteLine("Decoded: {0}", newString);
   }
   
   private static string ShowByteValues(byte[] bytes, int last ) 
   {
      string returnString = "   ";
      for (int ctr = 0; ctr <= last - 1; ctr++) {
         if (ctr % 20 == 0)
            returnString += "\n   ";
         returnString += String.Format("{0:X2} ", bytes[ctr]);
      }
      return returnString;
   }
}
// The example displays the following output:
//       Strings to encode:
//          This is the first sentence.
//          This is the second sentence.
//       
//       Encoded bytes:
//       
//          54 68 69 73 20 69 73 20 74 68 65 20 66 69 72 73 74 20 73 65
//          6E 74 65 6E 63 65 2E 20 54 68 69 73 20 69 73 20 74 68 65 20
//          73 65 63 6F 6E 64 20 73 65 6E 74 65 6E 63 65 2E 20
//       
//       Decoded: This is the first sentence. This is the second sentence.
Imports System.Text

Module Example
   Public Sub Main()
      Dim strings() As String = { "This is the first sentence. ", 
                                  "This is the second sentence. " }
      Dim asciiEncoding As Encoding = Encoding.ASCII
      
      ' Create array of adequate size.
      Dim bytes(50) As Byte
      ' Create index for current position of array.
      Dim index As Integer = 0
      
      Console.WriteLine("Strings to encode:")
      For Each stringValue In strings
         Console.WriteLine("   {0}", stringValue)
         
         Dim count As Integer = asciiEncoding.GetByteCount(stringValue)
         If count + index >=  bytes.Length Then
            Array.Resize(bytes, bytes.Length + 50)
         End If
         Dim written As Integer = asciiEncoding.GetBytes(stringValue, 0, 
                                                         stringValue.Length, 
                                                         bytes, index)    
    
         index = index + written 
      Next 
      Console.WriteLine()
      Console.WriteLine("Encoded bytes:")
      Console.WriteLine("{0}", ShowByteValues(bytes, index))
      Console.WriteLine()
      
      ' Decode Unicode byte array to a string.
      Dim newString As String = asciiEncoding.GetString(bytes, 0, index)
      Console.WriteLine("Decoded: {0}", newString)
   End Sub
   
   Private Function ShowByteValues(bytes As Byte(), last As Integer) As String
      Dim returnString As String = "   "
      For ctr As Integer = 0 To last - 1
         If ctr Mod 20 = 0 Then returnString += vbCrLf + "   "
         returnString += String.Format("{0:X2} ", bytes(ctr))
      Next
      Return returnString
   End Function
End Module
' The example displays the following output:
'       Strings to encode:
'          This is the first sentence.
'          This is the second sentence.
'       
'       Encoded bytes:
'       
'          54 68 69 73 20 69 73 20 74 68 65 20 66 69 72 73 74 20 73 65
'          6E 74 65 6E 63 65 2E 20 54 68 69 73 20 69 73 20 74 68 65 20
'          73 65 63 6F 6E 64 20 73 65 6E 74 65 6E 63 65 2E 20
'       
'       Decoded: This is the first sentence. This is the second sentence.

Ein Decoder konvertiert ein Bytearray, das eine spezifische Zeichencodierung darstellt, in einen Satz von Zeichen, d. h. entweder in ein Zeichenarray oder in eine Zeichenfolge.A decoder converts a byte array that reflects a particular character encoding into a set of characters, either in a character array or in a string. Um ein Bytearray in ein Zeichenarray zu decodieren, rufen Sie die Encoding.GetChars -Methode auf.To decode a byte array into a character array, you call the Encoding.GetChars method. Um ein Bytearray in eine Zeichenfolge zu decodieren, rufen Sie die GetString -Methode auf.To decode a byte array into a string, you call the GetString method. Wenn Sie vor Ausführung der Decodierung ermitteln möchten, wie viele Zeichen zum Speichern der decodierten Bytes benötigt werden, können Sie die GetCharCount -Methode aufrufen.If you want to determine how many characters are needed to store the decoded bytes before performing the decoding, you can call the GetCharCount method.

Im folgenden Beispiel werden drei Zeichenfolgen codiert und dann in einzelnes Array von Zeichen decodiert.The following example encodes three strings and then decodes them into a single array of characters. Ein verwalteter Index gibt die Anfangsposition im Zeichenarray für die nächste Gruppe von decodierten Zeichen an.It maintains an index that indicates the starting position in the character array for the next set of decoded characters. Die GetCharCount -Methode wird aufgerufen, um sicherzustellen, dass das Zeichenarray groß genug für alle decodierten Zeichen ist.It calls the GetCharCount method to ensure that the character array is large enough to accommodate all the decoded characters. Dann wird die ASCIIEncoding.GetChars(Byte[], Int32, Int32, Char[], Int32) -Methode aufgerufen, um das Bytearray zu decodieren.It then calls the ASCIIEncoding.GetChars(Byte[], Int32, Int32, Char[], Int32) method to decode the byte array.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      string[] strings = { "This is the first sentence. ", 
                           "This is the second sentence. ",
                           "This is the third sentence. " };
      Encoding asciiEncoding = Encoding.ASCII;
      // Array to hold encoded bytes.
      byte[] bytes;
      // Array to hold decoded characters.
      char[] chars = new char[50];
      // Create index for current position of character array.
      int index = 0;     
      
      foreach (var stringValue in strings) {
         Console.WriteLine("String to Encode: {0}", stringValue);
         // Encode the string to a byte array.
         bytes = asciiEncoding.GetBytes(stringValue);
         // Display the encoded bytes.
         Console.Write("Encoded bytes: ");
         for (int ctr = 0; ctr < bytes.Length; ctr++)
            Console.Write(" {0}{1:X2}", 
                          ctr % 20 == 0 ? Environment.NewLine : "", 
                          bytes[ctr]);
         Console.WriteLine();

         // Decode the bytes to a single character array.
         int count = asciiEncoding.GetCharCount(bytes);
         if (count + index >=  chars.Length)
            Array.Resize(ref chars, chars.Length + 50);

         int written = asciiEncoding.GetChars(bytes, 0, 
                                              bytes.Length, 
                                              chars, index);              
         index = index + written;
         Console.WriteLine();       
      }
      
      // Instantiate a single string containing the characters.
      string decodedString = new string(chars, 0, index - 1);
      Console.WriteLine("Decoded string: ");
      Console.WriteLine(decodedString);
   }
}
// The example displays the following output:
//    String to Encode: This is the first sentence.
//    Encoded bytes:
//    54 68 69 73 20 69 73 20 74 68 65 20 66 69 72 73 74 20 73 65
//    6E 74 65 6E 63 65 2E 20
//    
//    String to Encode: This is the second sentence.
//    Encoded bytes:
//    54 68 69 73 20 69 73 20 74 68 65 20 73 65 63 6F 6E 64 20 73
//    65 6E 74 65 6E 63 65 2E 20
//    
//    String to Encode: This is the third sentence.
//    Encoded bytes:
//    54 68 69 73 20 69 73 20 74 68 65 20 74 68 69 72 64 20 73 65
//    6E 74 65 6E 63 65 2E 20
//    
//    Decoded string:
//    This is the first sentence. This is the second sentence. This is the third sentence.
Imports System.Text

Module Example
   Public Sub Main()
      Dim strings() As String = { "This is the first sentence. ", 
                                  "This is the second sentence. ",
                                  "This is the third sentence. " }
      Dim asciiEncoding As Encoding = Encoding.ASCII
      ' Array to hold encoded bytes.
      Dim bytes() As Byte
      ' Array to hold decoded characters.
      Dim chars(50) As Char
      ' Create index for current position of character array.
      Dim index As Integer     
      
      For Each stringValue In strings
         Console.WriteLine("String to Encode: {0}", stringValue)
         ' Encode the string to a byte array.
         bytes = asciiEncoding.GetBytes(stringValue)
         ' Display the encoded bytes.
         Console.Write("Encoded bytes: ")
         For ctr As Integer = 0 To bytes.Length - 1
            Console.Write(" {0}{1:X2}", If(ctr Mod 20 = 0, vbCrLf, ""), 
                                        bytes(ctr))
         Next         
         Console.WriteLine()

         ' Decode the bytes to a single character array.
         Dim count As Integer = asciiEncoding.GetCharCount(bytes)
         If count + index >=  chars.Length Then
            Array.Resize(chars, chars.Length + 50)
         End If
         Dim written As Integer = asciiEncoding.GetChars(bytes, 0, 
                                                         bytes.Length, 
                                                         chars, index)              
         index = index + written
         Console.WriteLine()       
      Next
      
      ' Instantiate a single string containing the characters.
      Dim decodedString As New String(chars, 0, index - 1)
      Console.WriteLine("Decoded string: ")
      Console.WriteLine(decodedString)
   End Sub
End Module
' The example displays the following output:
'    String to Encode: This is the first sentence.
'    Encoded bytes:
'    54 68 69 73 20 69 73 20 74 68 65 20 66 69 72 73 74 20 73 65
'    6E 74 65 6E 63 65 2E 20
'    
'    String to Encode: This is the second sentence.
'    Encoded bytes:
'    54 68 69 73 20 69 73 20 74 68 65 20 73 65 63 6F 6E 64 20 73
'    65 6E 74 65 6E 63 65 2E 20
'    
'    String to Encode: This is the third sentence.
'    Encoded bytes:
'    54 68 69 73 20 69 73 20 74 68 65 20 74 68 69 72 64 20 73 65
'    6E 74 65 6E 63 65 2E 20
'    
'    Decoded string:
'    This is the first sentence. This is the second sentence. This is the third sentence.

Die Codierungs- und Decodierungsmethoden einer von Encoding abgeleiteten Klasse sind für die Behandlung eines vollständigen Satzes von Daten vorgesehen, d. h., alle zu codierenden oder decodierenden Daten werden in einem einzelnen Methodenaufruf angegeben.The encoding and decoding methods of a class derived from Encoding are designed to work on a complete set of data; that is, all the data to be encoded or decoded is supplied in a single method call. In einigen Fällen sind Daten jedoch in einem Stream verfügbar, und die zu codierenden und decodierenden Daten sind möglicherweise nur über separate Lesevorgänge verfügbar.However, in some cases, data is available in a stream, and the data to be encoded or decoded may be available only from separate read operations. Der Codierungs- oder Decodierungsvorgang muss hierbei jeden gespeicherten Zustand aus dem vorherigen Aufruf speichern.This requires the encoding or decoding operation to remember any saved state from its previous invocation. Methoden von Klassen, die von Encoder und Decoder abgeleitet sind, können Codierungs- und Decodierungsvorgänge behandeln, die mehrere Methodenaufrufe umfassen.Methods of classes derived from Encoder and Decoder are able to handle encoding and decoding operations that span multiple method calls.

Ein Encoder -Objekt für eine bestimmte Codierung ist über die Encoding.GetEncoder -Eigenschaft dieser Codierung verfügbar.An Encoder object for a particular encoding is available from that encoding's Encoding.GetEncoder property. Ein Decoder -Objekt für eine bestimmte Codierung ist über die Encoding.GetDecoder -Eigenschaft dieser Codierung verfügbar.A Decoder object for a particular encoding is available from that encoding's Encoding.GetDecoder property. Bei Decodierungsvorgängen beinhalten die von Decoder abgeleiteten Klassen eine Decoder.GetChars -Methode, jedoch keine Methode, die Encoding.GetStringentspricht.For decoding operations, note that classes derived from Decoder include a Decoder.GetChars method, but they do not have a method that corresponds to Encoding.GetString.

Das folgende Beispiel veranschaulicht den Unterschied zwischen der Verwendung der Encoding.GetChars -Methode und der Decoder.GetChars -Methode zum Decodieren eines Unicode-Bytearrays.The following example illustrates the difference between using the Encoding.GetChars and Decoder.GetChars methods for decoding a Unicode byte array. Im Beispiel wird eine Zeichenfolge, die einige Unicode-Zeichen enthält, in eine Datei codiert. Anschließend werden die Zeichen mithilfe der zwei Decodierungsmethoden immer um je zehn Bytes decodiert.The example encodes a string that contains some Unicode characters to a file, and then uses the two decoding methods to decode them ten bytes at a time. Da im zehnten und elften Byte ein Ersatzzeichenpaar auftritt, erfolgt die Decodierung mit separaten Methodenaufrufen.Because a surrogate pair occurs in the tenth and eleventh bytes, it is decoded in separate method calls. Die Ausgabe zeigt, dass die Encoding.GetChars -Methode die Bytes nicht ordnungsgemäß decodieren kann und sie stattdessen durch U+FFFD (REPLACEMENT CHARACTER) ersetzt.As the output shows, the Encoding.GetChars method is not able to correctly decode the bytes and instead replaces them with U+FFFD (REPLACEMENT CHARACTER). Die Decoder.GetChars -Methode kann das Bytearray hingegen erfolgreich decodieren, um die ursprüngliche Zeichenfolge abzurufen.On the other hand, the Decoder.GetChars method is able to successfully decode the byte array to get the original string.

using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      // Use default replacement fallback for invalid encoding.
      UnicodeEncoding enc = new UnicodeEncoding(true, false, false);
      
      // Define a string with various Unicode characters.
      string str1 = "AB YZ 19 \uD800\udc05 \u00e4"; 
      str1 += "Unicode characters. \u00a9 \u010C s \u0062\u0308"; 
      Console.WriteLine("Created original string...\n");
      
      // Convert string to byte array.                     
      byte[] bytes = enc.GetBytes(str1);
       
      FileStream fs = File.Create(@".\characters.bin");
      BinaryWriter bw = new BinaryWriter(fs);
      bw.Write(bytes);
      bw.Close();
      
      // Read bytes from file.
      FileStream fsIn = File.OpenRead(@".\characters.bin");
      BinaryReader br = new BinaryReader(fsIn);
      
      const int count = 10;            // Number of bytes to read at a time. 
      byte[] bytesRead = new byte[10]; // Buffer (byte array).
      int read;                        // Number of bytes actually read. 
      string str2 = String.Empty;      // Decoded string.

      // Try using Encoding object for all operations.
      do { 
         read = br.Read(bytesRead, 0, count);
         str2 += enc.GetString(bytesRead, 0, read); 
      } while (read == count);
      br.Close();
      Console.WriteLine("Decoded string using UnicodeEncoding.GetString()...");
      CompareForEquality(str1, str2);
      Console.WriteLine();
      
      // Use Decoder for all operations.
      fsIn = File.OpenRead(@".\characters.bin");
      br = new BinaryReader(fsIn);
      Decoder decoder = enc.GetDecoder();
      char[] chars = new char[50];
      int index = 0;                   // Next character to write in array.
      int written = 0;                 // Number of chars written to array.
      do { 
         read = br.Read(bytesRead, 0, count);
         if (index + decoder.GetCharCount(bytesRead, 0, read) - 1 >= chars.Length) 
            Array.Resize(ref chars, chars.Length + 50);

         written = decoder.GetChars(bytesRead, 0, read, chars, index);
         index += written;                          
      } while (read == count);
      br.Close();            
      // Instantiate a string with the decoded characters.
      string str3 = new String(chars, 0, index); 
      Console.WriteLine("Decoded string using UnicodeEncoding.Decoder.GetString()...");
      CompareForEquality(str1, str3); 
   }

   private static void CompareForEquality(string original, string decoded)
   {
      bool result = original.Equals(decoded);
      Console.WriteLine("original = decoded: {0}", 
                        original.Equals(decoded, StringComparison.Ordinal));
      if (! result) {
         Console.WriteLine("Code points in original string:");
         foreach (var ch in original)
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));
         Console.WriteLine();
         
         Console.WriteLine("Code points in decoded string:");
         foreach (var ch in decoded)
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    Created original string...
//    
//    Decoded string using UnicodeEncoding.GetString()...
//    original = decoded: False
//    Code points in original string:
//    0041 0042 0020 0059 005A 0020 0031 0039 0020 D800 DC05 0020 00E4 0055 006E 0069 0063 006F
//    0064 0065 0020 0063 0068 0061 0072 0061 0063 0074 0065 0072 0073 002E 0020 00A9 0020 010C
//    0020 0073 0020 0062 0308
//    Code points in decoded string:
//    0041 0042 0020 0059 005A 0020 0031 0039 0020 FFFD FFFD 0020 00E4 0055 006E 0069 0063 006F
//    0064 0065 0020 0063 0068 0061 0072 0061 0063 0074 0065 0072 0073 002E 0020 00A9 0020 010C
//    0020 0073 0020 0062 0308
//    
//    Decoded string using UnicodeEncoding.Decoder.GetString()...
//    original = decoded: True
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      ' Use default replacement fallback for invalid encoding.
      Dim enc As New UnicodeEncoding(True, False, False)
      
      ' Define a string with various Unicode characters.
      Dim str1 As String = String.Format("AB YZ 19 {0}{1} {2}", 
                                         ChrW(&hD800), ChrW(&hDC05), ChrW(&h00e4))
      str1 += String.Format("Unicode characters. {0} {1} s {2}{3}", 
                            ChrW(&h00a9), ChrW(&h010C), ChrW(&h0062), ChrW(&h0308))
      Console.WriteLine("Created original string...")
      Console.WriteLine()
      
      ' Convert string to byte array.                     
      Dim bytes() As Byte = enc.GetBytes(str1)
       
      Dim fs As FileStream = File.Create(".\characters.bin")
      Dim bw As New BinaryWriter(fs)
      bw.Write(bytes)
      bw.Close()
      
      ' Read bytes from file.
      Dim fsIn As FileStream = File.OpenRead(".\characters.bin")
      Dim br As New BinaryReader(fsIn)
      
      Const count As Integer = 10      ' Number of bytes to read at a time. 
      Dim bytesRead(9) As Byte         ' Buffer (byte array).
      Dim read As Integer              ' Number of bytes actually read. 
      Dim str2 As String = ""          ' Decoded string.

      ' Try using Encoding object for all operations.
      Do 
         read = br.Read(bytesRead, 0, count)
         str2 += enc.GetString(bytesRead, 0, read) 
      Loop While read = count
      br.Close()
      Console.WriteLine("Decoded string using UnicodeEncoding.GetString()...")
      CompareForEquality(str1, str2)
      Console.WriteLine()
      
      ' Use Decoder for all operations.
      fsIn = File.OpenRead(".\characters.bin")
      br = New BinaryReader(fsIn)
      Dim decoder As Decoder = enc.GetDecoder()
      Dim chars(50) As Char
      Dim index As Integer = 0         ' Next character to write in array.
      Dim written As Integer = 0       ' Number of chars written to array.
      Do 
         read = br.Read(bytesRead, 0, count)
         If index + decoder.GetCharCount(bytesRead, 0, read) - 1 >= chars.Length Then 
            Array.Resize(chars, chars.Length + 50)
         End If   
         written = decoder.GetChars(bytesRead, 0, read, chars, index)
         index += written                          
      Loop While read = count
      br.Close()            
      ' Instantiate a string with the decoded characters.
      Dim str3 As New String(chars, 0, index) 
      Console.WriteLine("Decoded string using UnicodeEncoding.Decoder.GetString()...")
      CompareForEquality(str1, str3) 
   End Sub
   
   Private Sub CompareForEquality(original As String, decoded As String)
      Dim result As Boolean = original.Equals(decoded)
      Console.WriteLine("original = decoded: {0}", 
                        original.Equals(decoded, StringComparison.Ordinal))
      If Not result Then
         Console.WriteLine("Code points in original string:")
         For Each ch In original
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
         Next
         Console.WriteLine()
         
         Console.WriteLine("Code points in decoded string:")
         For Each ch In decoded
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
         Next
         Console.WriteLine()
      End If
   End Sub
End Module
' The example displays the following output:
'    Created original string...
'    
'    Decoded string using UnicodeEncoding.GetString()...
'    original = decoded: False
'    Code points in original string:
'    0041 0042 0020 0059 005A 0020 0031 0039 0020 D800 DC05 0020 00E4 0055 006E 0069 0063 006F
'    0064 0065 0020 0063 0068 0061 0072 0061 0063 0074 0065 0072 0073 002E 0020 00A9 0020 010C
'    0020 0073 0020 0062 0308
'    Code points in decoded string:
'    0041 0042 0020 0059 005A 0020 0031 0039 0020 FFFD FFFD 0020 00E4 0055 006E 0069 0063 006F
'    0064 0065 0020 0063 0068 0061 0072 0061 0063 0074 0065 0072 0073 002E 0020 00A9 0020 010C
'    0020 0073 0020 0062 0308
'    
'    Decoded string using UnicodeEncoding.Decoder.GetString()...
'    original = decoded: True

Auswählen einer FallbackstrategieChoosing a Fallback Strategy

Wenn eine Methode versucht, ein Zeichen zu codieren oder zu decodieren, aber keine Zuordnung vorhanden ist, muss eine Fallbackstrategie implementiert werden. Diese legt fest, wie die fehlende Zuordnung behandelt werden soll.When a method tries to encode or decode a character but no mapping exists, it must implement a fallback strategy that determines how the failed mapping should be handled. Es gibt drei Arten von Fallbackstrategien:There are three types of fallback strategies:

  • Best-Fit FallbackBest-fit fallback

  • Replacement FallbackReplacement fallback

  • Exception FallbackException fallback

Wichtig

Bei Codierungsvorgängen treten Probleme am häufigsten dann auf, wenn ein Unicode-Zeichen keiner bestimmten Codepagecodierung zugeordnet werden kann.The most common problems in encoding operations occur when a Unicode character cannot be mapped to a particular code page encoding. Zu den am häufigsten auftretenden Problem bei Decodierungsvorgängen gehört es, wenn ungültige Bytefolgen nicht in gültige Unicode-Zeichen übersetzt werden können.The most common problems in decoding operations occur when invalid byte sequences cannot be translated into valid Unicode characters. Aus diesen Gründen sollten Sie wissen, welche Fallbackstrategien von bestimmten Codierungsobjekten verwendet werden.For these reasons, you should know which fallback strategy a particular encoding object uses. Nach Möglichkeit sollten Sie die von einem Codierungsobjekt verwendete Fallbackstrategie beim Instanziieren des Objekts festlegen.Whenever possible, you should specify the fallback strategy used by an encoding object when you instantiate the object.

Best-Fit FallbackBest-Fit Fallback

Wenn ein Zeichen nicht über eine genaue Entsprechung in der Zielcodierung verfügt, kann der Encoder versuchen, eine Zuordnung zu einem ähnlichen Zeichen zu erstellen.When a character does not have an exact match in the target encoding, the encoder can try to map it to a similar character. (Ein Fallback mit ähnlichen Zeichen ist meist vielmehr ein Codierungs- als ein Decodierungsproblem.(Best-fit fallback is mostly an encoding rather than a decoding issue. Es gibt sehr wenige Codepages, die Zeichen enthalten, die in Unicode nicht erfolgreich zugeordnet werden können.) Der Fallback mit ähnlichen Zeichen ist die Standardeinstellung für Codepage- und DBCS-Codierungen, die von der Encoding.GetEncoding(Int32)-Überladung und der Encoding.GetEncoding(String)-Überladung abgerufen werden.There are very few code pages that contain characters that cannot be successfully mapped to Unicode.) Best-fit fallback is the default for code page and double-byte character set encodings that are retrieved by the Encoding.GetEncoding(Int32) and Encoding.GetEncoding(String) overloads.

Hinweis

Theoretisch unterstützen die in .NET bereitgestellten Unicode-Codierungsklassen (UTF8Encoding, UnicodeEncoding und UTF32Encoding) alle Zeichen in jedem Zeichensatz, sodass sie verwendet werden können, um Probleme beim Fallback mit ähnlichen Zeichen zu vermeiden.In theory, the Unicode encoding classes provided in .NET (UTF8Encoding, UnicodeEncoding, and UTF32Encoding) support every character in every character set, so they can be used to eliminate best-fit fallback issues.

Strategien mit ähnlichen Zeichen variieren für unterschiedliche Codepages.Best-fit strategies vary for different code pages. Beispielsweise werden bei einigen Codepages lateinische Zeichen in voller Breite den gängigeren halbbreiten lateinischen Zeichen zugeordnet.For example, for some code pages, full-width Latin characters map to the more common half-width Latin characters. Bei anderen Codepages hingegen erfolgt diese Zuordnung nicht.For other code pages, this mapping is not made. Selbst bei einer aggressiven Strategie mit ähnlichen Zeichen besteht in einigen Codierungen für manche Zeichen keine denkbare Zuordnung.Even under an aggressive best-fit strategy, there is no imaginable fit for some characters in some encodings. Ein chinesisches ideografisches Zeichen hat z. B. keine angemessene Zuordnung in der Codepage 1252.For example, a Chinese ideograph has no reasonable mapping to code page 1252. Im diesem Fall wird eine Ersatzzeichenfolge verwendet.In this case, a replacement string is used. Standardmäßig handelt es sich bei dieser Zeichenfolge um ein einzelnes QUESTION MARK (Fragezeichen, U+003F).By default, this string is just a single QUESTION MARK (U+003F).

Hinweis

Strategien mit ähnlichen Zeichen sind nicht detailliert dokumentiert.Best-fit strategies are not documented in detail. Einige Codepages sind jedoch auf der Website des Unicode-Konsortiums dokumentiert.However, several code pages are documented at the Unicode Consortium's website. Lesen Sie die readme.txt-Datei in diesem Ordner, um zu erfahren, wie die Zuordnungsdateien interpretiert werden.Please review the readme.txt file in that folder for a description of how to interpret the mapping files.

Im folgenden Beispiel wird die Codepage 1252 (Windows-Codepage für westeuropäische Sprachen) verwendet, um eine Zuordnung mit ähnlichen Zeichen und deren Nachteile zu veranschaulichen.The following example uses code page 1252 (the Windows code page for Western European languages) to illustrate best-fit mapping and its drawbacks. Die Encoding.GetEncoding(Int32) -Methode wird verwendet, um ein Codierungsobjekt für Codepage 1252 abzurufen.The Encoding.GetEncoding(Int32) method is used to retrieve an encoding object for code page 1252. Standardmäßig wird eine Zuordnung mit ähnlichen Zeichen für nicht unterstützte Unicode-Zeichen verwendet.By default, it uses a best-fit mapping for Unicode characters that it does not support. Im Beispiel wird eine Zeichenfolge instanziiert, die drei durch Leerzeichen getrennte Nicht-ASCII-Zeichen enthält: CIRCLED LATIN CAPITAL LETTER S (eingekreister lateinischer Großbuchstabe S, U+24C8), SUPERSCRIPT FIVE (hochgestellte Fünf, U+2075) und INFINITY (Unendlichkeit, U+221E).The example instantiates a string that contains three non-ASCII characters - CIRCLED LATIN CAPITAL LETTER S (U+24C8), SUPERSCRIPT FIVE (U+2075), and INFINITY (U+221E) - separated by spaces. Die Ausgabe im Beispiel zeigt, dass die drei ursprünglichen Nicht-Leerzeichen bei der Codierung der Zeichenfolge durch QUESTION MARK (Fragezeichen, U+003F), DIGIT FIVE (Ziffer Fünf, U+0035) und DIGIT EIGHT (Ziffer Acht, U+0038) ersetzt.As the output from the example shows, when the string is encoded, the three original non-space characters are replaced by QUESTION MARK (U+003F), DIGIT FIVE (U+0035), and DIGIT EIGHT (U+0038). Insbesondere DIGIT EIGHT (Ziffer Acht) ist ein ungeeigneter Ersatz für das nicht unterstützte INFINITY-Zeichen (Unendlichkeit), und QUESTION MARK (Fragezeichen) weist darauf hin, dass für das ursprüngliche Zeichen keine Zuordnung verfügbar war.DIGIT EIGHT is a particularly poor replacement for the unsupported INFINITY character, and QUESTION MARK indicates that no mapping was available for the original character.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      // Get an encoding for code page 1252 (Western Europe character set).
      Encoding cp1252 = Encoding.GetEncoding(1252);
      
      // Define and display a string.
      string str = "\u24c8 \u2075 \u221e";
      Console.WriteLine("Original string: " + str);
      Console.Write("Code points in string: ");
      foreach (var ch in str)
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

      Console.WriteLine("\n");   
      
      // Encode a Unicode string.
      Byte[] bytes = cp1252.GetBytes(str);
      Console.Write("Encoded bytes: ");
      foreach (byte byt in bytes)
         Console.Write("{0:X2} ", byt);
      Console.WriteLine("\n");
            
      // Decode the string.
      string str2 = cp1252.GetString(bytes);
      Console.WriteLine("String round-tripped: {0}", str.Equals(str2));
      if (! str.Equals(str2)) {
         Console.WriteLine(str2);
         foreach (var ch in str2)
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));
      }
   }
}
// The example displays the following output:
//       Original string: Ⓢ ⁵ ∞
//       Code points in string: 24C8 0020 2075 0020 221E
//       
//       Encoded bytes: 3F 20 35 20 38
//       
//       String round-tripped: False
//       ? 5 8
//       003F 0020 0035 0020 0038
Imports System.Text

Module Example
   Public Sub Main()
      ' Get an encoding for code page 1252 (Western Europe character set).
      Dim cp1252 As Encoding = Encoding.GetEncoding(1252)
      
      ' Define and display a string.
      Dim str As String = String.Format("{0} {1} {2}", ChrW(&h24c8), ChrW(&H2075), ChrW(&h221E))
      Console.WriteLine("Original string: " + str)
      Console.Write("Code points in string: ")
      For Each ch In str
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
      Next
      Console.WriteLine()   
      Console.WriteLine()
      
      ' Encode a Unicode string.
      Dim bytes() As Byte = cp1252.GetBytes(str)
      Console.Write("Encoded bytes: ")
      For Each byt In bytes
         Console.Write("{0:X2} ", byt)
      Next
      Console.WriteLine()
      Console.WriteLine()
      
      ' Decode the string.
      Dim str2 As String = cp1252.GetString(bytes)
      Console.WriteLine("String round-tripped: {0}", str.Equals(str2))
      If Not str.Equals(str2) Then
         Console.WriteLine(str2)
         For Each ch In str2
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
         Next
      End If
   End Sub
End Module
' The example displays the following output:
'       Original string: Ⓢ ⁵ ∞
'       Code points in string: 24C8 0020 2075 0020 221E
'       
'       Encoded bytes: 3F 20 35 20 38
'       
'       String round-tripped: False
'       ? 5 8
'       003F 0020 0035 0020 0038

Die Zuordnung mit ähnlichen Zeichen ist das Standardverhalten für ein Encoding -Objekt, das Unicode-Daten in Codepagedaten codiert. Es gibt ältere Anwendungen, die auf diesem Verhalten basieren.Best-fit mapping is the default behavior for an Encoding object that encodes Unicode data into code page data, and there are legacy applications that rely on this behavior. In den meisten neuen Anwendungen sollte dieses Verhalten jedoch aus Sicherheitsgründen vermieden werden.However, most new applications should avoid best-fit behavior for security reasons. Durch eine Codierung mit ähnlichen Zeichen sollten Anwendungen z. B. keinen Domänennamen ausdrücken.For example, applications should not put a domain name through a best-fit encoding.

Hinweis

Sie können für eine Codierung auch eine benutzerdefinierte Zuordnung mit einem Fallback mit ähnlichen Zeichen implementieren.You can also implement a custom best-fit fallback mapping for an encoding. Weitere Informationen finden Sie im Abschnitt Implementing a Custom Fallback Strategy .For more information, see the Implementing a Custom Fallback Strategy section.

Wenn der Fallback mit ähnlichen Zeichen die Standardeinstellung für ein Codierungsobjekt ist, können Sie eine andere Fallbackstrategie auswählen, wenn Sie ein Encoding -Objekt abrufen, indem Sie die Encoding.GetEncoding(Int32, EncoderFallback, DecoderFallback) -Überladung aufrufen oder die Encoding.GetEncoding(String, EncoderFallback, DecoderFallback) -Überladung aufrufen.If best-fit fallback is the default for an encoding object, you can choose another fallback strategy when you retrieve an Encoding object by calling the Encoding.GetEncoding(Int32, EncoderFallback, DecoderFallback) or Encoding.GetEncoding(String, EncoderFallback, DecoderFallback) overload. Der folgende Abschnitt enthält ein Beispiel, in dem jedes Zeichen, das Codepage 1252 nicht zugeordnet werden kann, durch ein Sternchen (*) ersetzt wird.The following section includes an example that replaces each character that cannot be mapped to code page 1252 with an asterisk (*).

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      Encoding cp1252r = Encoding.GetEncoding(1252, 
                                  new EncoderReplacementFallback("*"),
                                  new DecoderReplacementFallback("*"));
      
      string str1 = "\u24C8 \u2075 \u221E";
      Console.WriteLine(str1);
      foreach (var ch in str1)
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

      Console.WriteLine();

      byte[] bytes = cp1252r.GetBytes(str1);
      string str2 = cp1252r.GetString(bytes);
      Console.WriteLine("Round-trip: {0}", str1.Equals(str2));
      if (! str1.Equals(str2)) {
         Console.WriteLine(str2);
         foreach (var ch in str2)
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

         Console.WriteLine();
      } 
   }
}
// The example displays the following output:
//       Ⓢ ⁵ ∞
//       24C8 0020 2075 0020 221E
//       Round-trip: False
//       * * *
//       002A 0020 002A 0020 002A
Imports System.Text

Module Example
   Public Sub Main()
      Dim cp1252r As Encoding = Encoding.GetEncoding(1252, 
                                         New EncoderReplacementFallback("*"),
                                         New DecoderReplacementFallback("*"))
      
      Dim str1 As String = String.Format("{0} {1} {2}", ChrW(&h24C8), ChrW(&h2075), ChrW(&h221E))
      Console.WriteLine(str1)
      For Each ch In str1
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
      Next    
      Console.WriteLine()

      Dim bytes() As Byte = cp1252r.GetBytes(str1)
      Dim str2 As String = cp1252r.GetString(bytes)
      Console.WriteLine("Round-trip: {0}", str1.Equals(str2))
      If Not str1.Equals(str2) Then
         Console.WriteLine(str2)
         For Each ch In str2
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
         Next    
         Console.WriteLine()
      End If 
   End Sub
End Module
' The example displays the following output:
'       Ⓢ ⁵ ∞
'       24C8 0020 2075 0020 221E
'       Round-trip: False
'       * * *
'       002A 0020 002A 0020 002A

Replacement FallbackReplacement Fallback

Wenn ein Zeichen nicht über eine genaue Entsprechung im Zielschema verfügt und kein entsprechendes Zeichen für eine Zuordnung vorhanden ist, kann die Anwendung ein Ersatzzeichen oder eine Ersatzzeichenfolge angeben.When a character does not have an exact match in the target scheme, but there is no appropriate character that it can be mapped to, the application can specify a replacement character or string. Dies ist das Standardverhalten für den Unicode-Decoder, der jede 2-Byte-Sequenz ersetzt, die nicht mit REPLACEMENT_CHARACTER (Ersatzzeichen, U+FFFD) decodiert werden kann.This is the default behavior for the Unicode decoder, which replaces any two-byte sequence that it cannot decode with REPLACEMENT_CHARACTER (U+FFFD). Dies ist auch das Standardverhalten der ASCIIEncoding -Klasse, die jedes Zeichen, das nicht codiert oder decodiert werden kann, durch ein Fragezeichen ersetzt.It is also the default behavior of the ASCIIEncoding class, which replaces each character that it cannot encode or decode with a question mark. Das folgende Beispiel veranschaulicht das Ersetzen von Zeichen für die Unicode-Zeichenfolge aus dem vorherigen Beispiel.The following example illustrates character replacement for the Unicode string from the previous example. Wie die Ausgabe zeigt, wird jedes Zeichen, das nicht in einen ASCII-Bytewert decodiert werden kann, durch 0x3F ersetzt, dem ASCII-Code für ein Fragezeichen.As the output shows, each character that cannot be decoded into an ASCII byte value is replaced by 0x3F, which is the ASCII code for a question mark.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      Encoding enc = Encoding.ASCII;
      
      string str1 = "\u24C8 \u2075 \u221E";
      Console.WriteLine(str1);
      foreach (var ch in str1)
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

      Console.WriteLine("\n");

      // Encode the original string using the ASCII encoder.
      byte[] bytes = enc.GetBytes(str1);
      Console.Write("Encoded bytes: ");
      foreach (var byt in bytes)
         Console.Write("{0:X2} ", byt);
      Console.WriteLine("\n");

      // Decode the ASCII bytes.
      string str2 = enc.GetString(bytes);
      Console.WriteLine("Round-trip: {0}", str1.Equals(str2));
      if (! str1.Equals(str2)) {
         Console.WriteLine(str2);
         foreach (var ch in str2)
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

         Console.WriteLine();
      } 
   }
}
// The example displays the following output:
//       Ⓢ ⁵ ∞
//       24C8 0020 2075 0020 221E
//       
//       Encoded bytes: 3F 20 3F 20 3F
//       
//       Round-trip: False
//       ? ? ?
//       003F 0020 003F 0020 003F
Imports System.Text

Module Example
   Public Sub Main()
      Dim enc As Encoding = Encoding.Ascii
      
      Dim str1 As String = String.Format("{0} {1} {2}", ChrW(&h24C8), ChrW(&h2075), ChrW(&h221E))
      Console.WriteLine(str1)
      For Each ch In str1
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
      Next    
      Console.WriteLine()
      Console.WriteLine() 

      ' Encode the original string using the ASCII encoder.
      Dim bytes() As Byte = enc.GetBytes(str1)
      Console.Write("Encoded bytes: ")
      For Each byt In bytes
         Console.Write("{0:X2} ", byt)
      Next
      Console.WriteLine()
      Console.WriteLine()

      ' Decode the ASCII bytes.
      Dim str2 As String = enc.GetString(bytes)
      Console.WriteLine("Round-trip: {0}", str1.Equals(str2))
      If Not str1.Equals(str2) Then
         Console.WriteLine(str2)
         For Each ch In str2
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
         Next    
         Console.WriteLine()
      End If 
   End Sub
End Module
' The example displays the following output:
'       Ⓢ ⁵ ∞
'       24C8 0020 2075 0020 221E
'       
'       Encoded bytes: 3F 20 3F 20 3F
'       
'       Round-trip: False
'       ? ? ?
'       003F 0020 003F 0020 003F

.NET enthält die EncoderReplacementFallback-Klasse und die DecoderReplacementFallback-Klasse, die eine Ersatzzeichenfolge verwenden, wenn in einem Codierungs- oder Decodierungsvorgang keine genaue Zuordnung für ein Zeichen möglich ist..NET includes the EncoderReplacementFallback and DecoderReplacementFallback classes, which substitute a replacement string if a character does not map exactly in an encoding or decoding operation. Standardmäßig ist diese Ersatzzeichenfolge ein Fragezeichen. Sie können jedoch eine Klassenkonstruktorüberladung aufrufen, um eine andere Zeichenfolge auszuwählen.By default, this replacement string is a question mark, but you can call a class constructor overload to choose a different string. In der Regel handelt es sich bei der Ersatzzeichenfolge um ein einzelnes Zeichen. Dies ist aber nicht erforderlich.Typically, the replacement string is a single character, although this is not a requirement. Im folgenden Beispiel wird das Verhalten des Encoders für Codepage 1252 geändert, indem ein EncoderReplacementFallback -Objekt instanziiert wird, das ein Sternchen (*) als Ersatzzeichenfolge verwendet.The following example changes the behavior of the code page 1252 encoder by instantiating an EncoderReplacementFallback object that uses an asterisk (*) as a replacement string.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      Encoding cp1252r = Encoding.GetEncoding(1252, 
                                  new EncoderReplacementFallback("*"),
                                  new DecoderReplacementFallback("*"));
      
      string str1 = "\u24C8 \u2075 \u221E";
      Console.WriteLine(str1);
      foreach (var ch in str1)
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

      Console.WriteLine();

      byte[] bytes = cp1252r.GetBytes(str1);
      string str2 = cp1252r.GetString(bytes);
      Console.WriteLine("Round-trip: {0}", str1.Equals(str2));
      if (! str1.Equals(str2)) {
         Console.WriteLine(str2);
         foreach (var ch in str2)
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

         Console.WriteLine();
      } 
   }
}
// The example displays the following output:
//       Ⓢ ⁵ ∞
//       24C8 0020 2075 0020 221E
//       Round-trip: False
//       * * *
//       002A 0020 002A 0020 002A
Imports System.Text

Module Example
   Public Sub Main()
      Dim cp1252r As Encoding = Encoding.GetEncoding(1252, 
                                         New EncoderReplacementFallback("*"),
                                         New DecoderReplacementFallback("*"))
      
      Dim str1 As String = String.Format("{0} {1} {2}", ChrW(&h24C8), ChrW(&h2075), ChrW(&h221E))
      Console.WriteLine(str1)
      For Each ch In str1
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
      Next    
      Console.WriteLine()

      Dim bytes() As Byte = cp1252r.GetBytes(str1)
      Dim str2 As String = cp1252r.GetString(bytes)
      Console.WriteLine("Round-trip: {0}", str1.Equals(str2))
      If Not str1.Equals(str2) Then
         Console.WriteLine(str2)
         For Each ch In str2
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
         Next    
         Console.WriteLine()
      End If 
   End Sub
End Module
' The example displays the following output:
'       Ⓢ ⁵ ∞
'       24C8 0020 2075 0020 221E
'       Round-trip: False
'       * * *
'       002A 0020 002A 0020 002A

Hinweis

Sie können für eine Codierung auch eine Ersatzklasse implementieren.You can also implement a replacement class for an encoding. Weitere Informationen finden Sie im Abschnitt Implementing a Custom Fallback Strategy .For more information, see the Implementing a Custom Fallback Strategy section.

Zusätzlich zu QUESTION MARK (Fragezeichen, U+003F) wird in der Regel REPLACEMENT CHARACTER (Unicode-Ersatzzeichen, U+FFFD) als Ersatzzeichenfolge verwendet, insbesondere bei der Decodierung von Bytesequenzen, die nicht erfolgreich in Unicode-Zeichen übersetzt werden können.In addition to QUESTION MARK (U+003F), the Unicode REPLACEMENT CHARACTER (U+FFFD) is commonly used as a replacement string, particularly when decoding byte sequences that cannot be successfully translated into Unicode characters. Allerdings können Sie eine beliebige Ersatzzeichenfolge auswählen, die mehrere Zeichen enthalten kann.However, you are free to choose any replacement string, and it can contain multiple characters.

Exception FallbackException Fallback

Anstatt einen Fallback mit ähnlichen Zeichen oder eine Ersatzzeichenfolge bereitzustellen, kann ein Encoder eine EncoderFallbackException auslösen, wenn die Codierung eines Satzes von Zeichen nicht möglich ist, und ein Decoder kann eine DecoderFallbackException auslösen, wenn ein Bytearray nicht decodiert werden kann.Instead of providing a best-fit fallback or a replacement string, an encoder can throw an EncoderFallbackException if it is unable to encode a set of characters, and a decoder can throw a DecoderFallbackException if it is unable to decode a byte array. Um eine Ausnahme in Codierungs- und Decodierungsvorgängen auszulösen, übergeben Sie ein EncoderExceptionFallback -Objekt bzw. ein DecoderExceptionFallback -Objekt an die Encoding.GetEncoding(String, EncoderFallback, DecoderFallback) -Methode.To throw an exception in encoding and decoding operations, you supply an EncoderExceptionFallback object and a DecoderExceptionFallback object, respectively, to the Encoding.GetEncoding(String, EncoderFallback, DecoderFallback) method. Im folgenden Beispiel wird ein Ausnahmefallback mit der ASCIIEncoding -Klasse veranschaulicht.The following example illustrates exception fallback with the ASCIIEncoding class.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      Encoding enc = Encoding.GetEncoding("us-ascii", 
                                          new EncoderExceptionFallback(), 
                                          new DecoderExceptionFallback());
      
      string str1 = "\u24C8 \u2075 \u221E";
      Console.WriteLine(str1);
      foreach (var ch in str1)
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

      Console.WriteLine("\n");

      // Encode the original string using the ASCII encoder.
      byte[] bytes = {};
      try {
         bytes = enc.GetBytes(str1);
         Console.Write("Encoded bytes: ");
         foreach (var byt in bytes)
            Console.Write("{0:X2} ", byt);

         Console.WriteLine();
      }
      catch (EncoderFallbackException e) {
         Console.Write("Exception: ");
         if (e.IsUnknownSurrogate())
            Console.WriteLine("Unable to encode surrogate pair 0x{0:X4} 0x{1:X3} at index {2}.", 
                              Convert.ToUInt16(e.CharUnknownHigh), 
                              Convert.ToUInt16(e.CharUnknownLow), 
                              e.Index);
         else
            Console.WriteLine("Unable to encode 0x{0:X4} at index {1}.", 
                              Convert.ToUInt16(e.CharUnknown), 
                              e.Index);
         return;
      }
      Console.WriteLine();

      // Decode the ASCII bytes.
      try {
         string str2 = enc.GetString(bytes);
         Console.WriteLine("Round-trip: {0}", str1.Equals(str2));
         if (! str1.Equals(str2)) {
            Console.WriteLine(str2);
            foreach (var ch in str2)
               Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

            Console.WriteLine();
         } 
      }
      catch (DecoderFallbackException e) {
         Console.Write("Unable to decode byte(s) ");
         foreach (byte unknown in e.BytesUnknown)
            Console.Write("0x{0:X2} ");

         Console.WriteLine("at index {0}", e.Index);
      }
   }
}
// The example displays the following output:
//       Ⓢ ⁵ ∞
//       24C8 0020 2075 0020 221E
//       
//       Exception: Unable to encode 0x24C8 at index 0.
Imports System.Text

Module Example
   Public Sub Main()
      Dim enc As Encoding = Encoding.GetEncoding("us-ascii", 
                                                 New EncoderExceptionFallback(), 
                                                 New DecoderExceptionFallback())
      
      Dim str1 As String = String.Format("{0} {1} {2}", ChrW(&h24C8), ChrW(&h2075), ChrW(&h221E))
      Console.WriteLine(str1)
      For Each ch In str1
         Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
      Next    
      Console.WriteLine()
      Console.WriteLine() 

      ' Encode the original string using the ASCII encoder.
      Dim bytes() As Byte = {}
      Try
         bytes = enc.GetBytes(str1)
         Console.Write("Encoded bytes: ")
         For Each byt In bytes
            Console.Write("{0:X2} ", byt)
         Next
         Console.WriteLine()
      Catch e As EncoderFallbackException
         Console.Write("Exception: ")
         If e.IsUnknownSurrogate() Then
            Console.WriteLine("Unable to encode surrogate pair 0x{0:X4} 0x{1:X3} at index {2}.", 
                              Convert.ToUInt16(e.CharUnknownHigh), 
                              Convert.ToUInt16(e.CharUnknownLow), 
                              e.Index)
         Else
            Console.WriteLine("Unable to encode 0x{0:X4} at index {1}.", 
                              Convert.ToUInt16(e.CharUnknown), 
                              e.Index)
         End If                              
         Exit Sub
      End Try
      Console.WriteLine()

      ' Decode the ASCII bytes.
      Try
         Dim str2 As String = enc.GetString(bytes)
         Console.WriteLine("Round-trip: {0}", str1.Equals(str2))
         If Not str1.Equals(str2) Then
            Console.WriteLine(str2)
            For Each ch In str2
               Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
            Next    
            Console.WriteLine()
         End If 
      Catch e As DecoderFallbackException
         Console.Write("Unable to decode byte(s) ")
         For Each unknown As Byte In e.BytesUnknown
            Console.Write("0x{0:X2} ")
         Next
         Console.WriteLine("at index {0}", e.Index)
      End Try
   End Sub
End Module
' The example displays the following output:
'       Ⓢ ⁵ ∞
'       24C8 0020 2075 0020 221E
'       
'       Exception: Unable to encode 0x24C8 at index 0.

Hinweis

Sie können für einen Codierungsvorgang auch einen benutzerdefinierten Ausnahmehandler implementieren.You can also implement a custom exception handler for an encoding operation. Weitere Informationen finden Sie im Abschnitt Implementing a Custom Fallback Strategy .For more information, see the Implementing a Custom Fallback Strategy section.

Das EncoderFallbackException -Objekt und das DecoderFallbackException -Objekt stellen die folgenden Informationen über die Bedingung bereit, durch die die Ausnahme ausgelöst wurde:The EncoderFallbackException and DecoderFallbackException objects provide the following information about the condition that caused the exception:

Obwohl das EncoderFallbackException -Objekt und das DecoderFallbackException -Objekt angemessene Diagnoseinformationen zu der Ausnahme bereitstellen, ermöglichen sie keinen Zugriff auf den Codierungs- oder Decodierungspuffer.Although the EncoderFallbackException and DecoderFallbackException objects provide adequate diagnostic information about the exception, they do not provide access to the encoding or decoding buffer. Daher ist es nicht möglich, innerhalb der Codierungs- oder Decodierungsmethode ungültige Daten zu ersetzen oder zu korrigieren.Therefore, they do not allow invalid data to be replaced or corrected within the encoding or decoding method.

Implementing a Custom Fallback StrategyImplementing a Custom Fallback Strategy

Neben der Zuordnung mit ähnlichen Zeichen, die intern von Codepages implementiert wird, beinhaltet .NET die folgenden Klassen für die Implementierung einer Fallbackstrategie:In addition to the best-fit mapping that is implemented internally by code pages, .NET includes the following classes for implementing a fallback strategy:

Darüber hinaus können Sie eine benutzerdefinierte Lösung implementieren, die den Fallback mit ähnlichen Zeichen, den Ersatzfallback oder den Ausnahmefallback verwendet. Führen Sie hierzu folgende Schritte aus:In addition, you can implement a custom solution that uses best-fit fallback, replacement fallback, or exception fallback, by following these steps:

  1. Leiten Sie für Codierungsvorgänge eine Klasse von EncoderFallback und für Decodierungsvorgänge eine Klasse von DecoderFallback ab.Derive a class from EncoderFallback for encoding operations, and from DecoderFallback for decoding operations.

  2. Leiten Sie für Codierungsvorgänge eine Klasse von EncoderFallbackBuffer und für Decodierungsvorgänge eine Klasse von DecoderFallbackBuffer ab.Derive a class from EncoderFallbackBuffer for encoding operations, and from DecoderFallbackBuffer for decoding operations.

  3. Wenn die vordefinierte EncoderFallbackException -Klasse und die vordefinierte DecoderFallbackException -Klasse für Ausnahmefallbacks nicht Ihren Anforderungen entspricht, leiten Sie eine Klasse von einem Ausnahmeobjekt ab, z. B. Exception oder ArgumentException.For exception fallback, if the predefined EncoderFallbackException and DecoderFallbackException classes do not meet your needs, derive a class from an exception object such as Exception or ArgumentException.

Ableiten von EncoderFallback oder DecoderFallbackDeriving from EncoderFallback or DecoderFallback

Um eine benutzerdefinierte Fallbacklösung zu implementieren, müssen Sie für Codierungsvorgänge eine Klasse erstellen, die von EncoderFallback erbt. Für Decodierungsvorgänge erstellen Sie eine Klasse, die von DecoderFallback erbt.To implement a custom fallback solution, you must create a class that inherits from EncoderFallback for encoding operations, and from DecoderFallback for decoding operations. Instanzen dieser Klassen werden an die Encoding.GetEncoding(String, EncoderFallback, DecoderFallback) -Methode übergeben und dienen als Vermittler zwischen der Codierungsklasse und der Fallbackimplementierung.Instances of these classes are passed to the Encoding.GetEncoding(String, EncoderFallback, DecoderFallback) method and serve as the intermediary between the encoding class and the fallback implementation.

Beim Erstellen einer benutzerdefinierten Fallbacklösung für einen Encoder oder einen Decoder müssen Sie die folgenden Member implementieren:When you create a custom fallback solution for an encoder or decoder, you must implement the following members:

Ableiten von EncoderFallbackBuffer oder DecoderFallbackBufferDeriving from EncoderFallbackBuffer or DecoderFallbackBuffer

Um eine benutzerdefinierte Fallbacklösung zu implementieren, müssen Sie für Codierungsvorgänge außerdem eine Klasse erstellen, die von EncoderFallbackBuffer erbt. Für Decodierungsvorgänge erstellen Sie eine Klasse, die von DecoderFallbackBuffer erbt.To implement a custom fallback solution, you must also create a class that inherits from EncoderFallbackBuffer for encoding operations, and from DecoderFallbackBuffer for decoding operations. Instanzen dieser Klasse werden von der CreateFallbackBuffer -Methode der EncoderFallback -Klasse und der DecoderFallback -Klasse zurückgegeben.Instances of these classes are returned by the CreateFallbackBuffer method of the EncoderFallback and DecoderFallback classes. Die EncoderFallback.CreateFallbackBuffer -Methode wird vom Encoder aufgerufen, wenn das erste Zeichen erkannt wird, das nicht codiert werden kann. Die DecoderFallback.CreateFallbackBuffer -Methode wird vom Decoder aufgerufen, wenn ein oder mehrere Bytes erkannt werden, die nicht decodiert werden können.The EncoderFallback.CreateFallbackBuffer method is called by the encoder when it encounters the first character that it is not able to encode, and the DecoderFallback.CreateFallbackBuffer method is called by the decoder when it encounters one or more bytes that it is not able to decode. Die EncoderFallbackBuffer -Klasse und die DecoderFallbackBuffer -Klasse stellen die Fallbackimplementierung bereit.The EncoderFallbackBuffer and DecoderFallbackBuffer classes provide the fallback implementation. Jede Instanz stellt einen Puffer dar, der die Fallbackzeichen enthält, die das Zeichen ersetzen, das nicht codiert werden kann, bzw. die die Bytesequenz ersetzen, die nicht decodiert werden kann.Each instance represents a buffer that contains the fallback characters that will replace the character that cannot be encoded or the byte sequence that cannot be decoded.

Beim Erstellen einer benutzerdefinierten Fallbacklösung für einen Encoder oder einen Decoder müssen Sie die folgenden Member implementieren:When you create a custom fallback solution for an encoder or decoder, you must implement the following members:

Wenn es sich bei der Fallbackimplementierung um einen Fallback mit ähnlichen Zeichen oder einen Ersatzfallback handelt, enthalten die von EncoderFallbackBuffer und DecoderFallbackBuffer abgeleiteten Klassen außerdem zwei private Instanzfelder: die genaue Anzahl von Zeichen im Puffer und der Index des nächsten Zeichens im Puffer, das zurückgegeben werden soll.If the fallback implementation is a best-fit fallback or a replacement fallback, the classes derived from EncoderFallbackBuffer and DecoderFallbackBuffer also maintain two private instance fields: the exact number of characters in the buffer; and the index of the next character in the buffer to return.

Ein EncoderFallback-BeispielAn EncoderFallback Example

In einem früheren Beispiel wurde ein Ersatzfallback verwendet, um Unicode-Zeichen, die keinen ASCII-Zeichen entsprachen, durch ein Sternchen (*) zu ersetzen.An earlier example used replacement fallback to replace Unicode characters that did not correspond to ASCII characters with an asterisk (*). Im folgenden Beispiel wird stattdessen eine benutzerdefinierte Implementierung mit ähnlichen Zeichen verwendet, um eine bessere Zuordnung von Nicht-ASCII-Zeichen zu ermöglichen.The following example uses a custom best-fit fallback implementation instead to provide a better mapping of non-ASCII characters.

Der folgende Code definiert eine von CustomMapper abgeleitete Klasse mit dem Namen EncoderFallback , um die Zuordnung mit ähnlichen Zeichen für Nicht-ASCII-Zeichen zu behandeln.The following code defines a class named CustomMapper that is derived from EncoderFallback to handle the best-fit mapping of non-ASCII characters. Die CreateFallbackBuffer -Methode gibt ein CustomMapperFallbackBuffer -Objekt zurück, das die EncoderFallbackBuffer -Implementierung bereitstellt.Its CreateFallbackBuffer method returns a CustomMapperFallbackBuffer object, which provides the EncoderFallbackBuffer implementation. Die CustomMapper -Klasse verwendet ein Dictionary<TKey,TValue> -Objekt, um die Zuordnungen von nicht unterstützten Unicode-Zeichen (Schlüsselwert) und den entsprechenden 8-Bit-Zeichen (die in zwei aufeinander folgenden Bytes in einer 64-Bit-Ganzzahl gespeichert sind) zu speichern.The CustomMapper class uses a Dictionary<TKey,TValue> object to store the mappings of unsupported Unicode characters (the key value) and their corresponding 8-bit characters (which are stored in two consecutive bytes in a 64-bit integer). Um dem Fallbackpuffer diese Zuordnung zur Verfügung zu stellen, wird die CustomMapper -Instanz als Parameter an den CustomMapperFallbackBuffer -Klassenkonstruktor übergeben.To make this mapping available to the fallback buffer, the CustomMapper instance is passed as a parameter to the CustomMapperFallbackBuffer class constructor. Da die längste Zuordnung die Zeichenfolge "INF" für das Unicode-Zeichen U+221E ist, gibt die MaxCharCount -Eigenschaft 3 zurück.Because the longest mapping is the string "INF" for the Unicode character U+221E, the MaxCharCount property returns 3.

public class CustomMapper : EncoderFallback
{
   public string DefaultString;
   internal Dictionary<ushort, ulong> mapping;

   public CustomMapper() : this("*")
   {   
   }
   
   public CustomMapper(string defaultString)
   {
      this.DefaultString = defaultString;

      // Create table of mappings
      mapping = new Dictionary<ushort, ulong>();
      mapping.Add(0x24C8, 0x53);
      mapping.Add(0x2075, 0x35);
      mapping.Add(0x221E, 0x49004E0046);
   }

   public override EncoderFallbackBuffer CreateFallbackBuffer()
   {
      return new CustomMapperFallbackBuffer(this);
   }

   public override int MaxCharCount
   {
      get { return 3; }
   } 
}
Public Class CustomMapper : Inherits EncoderFallback
   Public DefaultString As String
   Friend mapping As Dictionary(Of UShort, ULong)

   Public Sub New()
      Me.New("?")
   End Sub

   Public Sub New(ByVal defaultString As String)
      Me.DefaultString = defaultString

      ' Create table of mappings
      mapping = New Dictionary(Of UShort, ULong)
      mapping.Add(&H24C8, &H53)
      mapping.Add(&H2075, &H35)
      mapping.Add(&H221E, &H49004E0046)
   End Sub

   Public Overrides Function CreateFallbackBuffer() As System.Text.EncoderFallbackBuffer
      Return New CustomMapperFallbackBuffer(Me)
   End Function

   Public Overrides ReadOnly Property MaxCharCount As Integer
      Get
         Return 3
      End Get
   End Property
End Class

Der folgende Code definiert die CustomMapperFallbackBuffer -Klasse, die von EncoderFallbackBufferabgeleitet wird.The following code defines the CustomMapperFallbackBuffer class, which is derived from EncoderFallbackBuffer. Das Wörterbuch, das die Zuordnung mit ähnlichen Zeichen enthält und in der CustomMapper -Instanz definiert ist, ist über den Klassenkonstruktor verfügbar.The dictionary that contains best-fit mappings and that is defined in the CustomMapper instance is available from its class constructor. Die Fallback -Methode gibt true zurück, wenn eines der Unicode-Zeichen, das der ASCII-Encoder nicht codieren kann, im Zuordnungswörterbuch definiert ist. Andernfalls wird falsezurückgegeben.Its Fallback method returns true if any of the Unicode characters that the ASCII encoder cannot encode are defined in the mapping dictionary; otherwise, it returns false. Bei jedem Fallback gibt die private count -Variable die Anzahl von Zeichen an, die noch zurückgegeben werden. Die private index -Variable gibt die Position im Zeichenfolgenpuffer ( charsToReturn) des nächsten zurückzugebenden Zeichens an.For each fallback, the private count variable indicates the number of characters that remain to be returned, and the private index variable indicates the position in the string buffer, charsToReturn, of the next character to return.

public class CustomMapperFallbackBuffer : EncoderFallbackBuffer
{
   int count = -1;                   // Number of characters to return
   int index = -1;                   // Index of character to return
   CustomMapper fb; 
   string charsToReturn; 

   public CustomMapperFallbackBuffer(CustomMapper fallback)
   {
      this.fb = fallback;
   }

   public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
   {
      // Do not try to map surrogates to ASCII.
      return false;
   }

   public override bool Fallback(char charUnknown, int index)
   {
      // Return false if there are already characters to map.
      if (count >= 1) return false;

      // Determine number of characters to return.
      charsToReturn = String.Empty;

      ushort key = Convert.ToUInt16(charUnknown);
      if (fb.mapping.ContainsKey(key)) {
         byte[] bytes = BitConverter.GetBytes(fb.mapping[key]);
         int ctr = 0;
         foreach (var byt in bytes) {
            if (byt > 0) {
               ctr++;
               charsToReturn += (char) byt;
            }
         }
         count = ctr;
      }
      else {
         // Return default.
         charsToReturn = fb.DefaultString;
         count = 1;
      }
      this.index = charsToReturn.Length - 1;

      return true;
   }

   public override char GetNextChar()
   {
      // We'll return a character if possible, so subtract from the count of chars to return.
      count--;
      // If count is less than zero, we've returned all characters.
      if (count < 0) 
         return '\u0000';

      this.index--;
      return charsToReturn[this.index + 1];
   }

   public override bool MovePrevious()
   {
      // Original: if count >= -1 and pos >= 0
      if (count >= -1) {
         count++;
         return true;
      }
      else {
         return false;
      }
   }

   public override int Remaining 
   {
      get { return count < 0 ? 0 : count; }
   }

   public override void Reset()
   {
      count = -1;
      index = -1;
   }
}
Public Class CustomMapperFallbackBuffer : Inherits EncoderFallbackBuffer

   Dim count As Integer = -1        ' Number of characters to return
   Dim index As Integer = -1        ' Index of character to return
   Dim fb As CustomMapper
   Dim charsToReturn As String

   Public Sub New(ByVal fallback As CustomMapper)
      MyBase.New()
      Me.fb = fallback
   End Sub

   Public Overloads Overrides Function Fallback(ByVal charUnknownHigh As Char, ByVal charUnknownLow As Char, ByVal index As Integer) As Boolean
      ' Do not try to map surrogates to ASCII.
      Return False
   End Function

   Public Overloads Overrides Function Fallback(ByVal charUnknown As Char, ByVal index As Integer) As Boolean
      ' Return false if there are already characters to map.
      If count >= 1 Then Return False

      ' Determine number of characters to return.
      charsToReturn = String.Empty

      Dim key As UShort = Convert.ToUInt16(charUnknown)
      If fb.mapping.ContainsKey(key) Then
         Dim bytes() As Byte = BitConverter.GetBytes(fb.mapping.Item(key))
         Dim ctr As Integer
         For Each byt In bytes
            If byt > 0 Then
               ctr += 1
               charsToReturn += Chr(byt)
            End If
         Next
         count = ctr
      Else
         ' Return default.
         charsToReturn = fb.DefaultString
         count = 1
      End If
      Me.index = charsToReturn.Length - 1

      Return True
   End Function

   Public Overrides Function GetNextChar() As Char
      ' We'll return a character if possible, so subtract from the count of chars to return.
      count -= 1
      ' If count is less than zero, we've returned all characters.
      If count < 0 Then Return ChrW(0)

      Me.index -= 1
      Return charsToReturn(Me.index + 1)
   End Function

   Public Overrides Function MovePrevious() As Boolean
      ' Original: if count >= -1 and pos >= 0
      If count >= -1 Then
         count += 1
         Return True
      Else
         Return False
      End If
   End Function

   Public Overrides ReadOnly Property Remaining As Integer
      Get
         Return If(count < 0, 0, count)
      End Get
   End Property

   Public Overrides Sub Reset()
      count = -1
      index = -1
   End Sub
End Class

Dann instanziiert der folgende Code das CustomMapper -Objekt und übergibt eine Instanz dieses Objekts an die Encoding.GetEncoding(String, EncoderFallback, DecoderFallback) -Methode.The following code then instantiates the CustomMapper object and passes an instance of it to the Encoding.GetEncoding(String, EncoderFallback, DecoderFallback) method. Die Ausgabe zeigt, dass die Fallbackimplementierung mit ähnlichen Zeichen die drei Nicht-ASCII-Zeichen in der ursprünglichen Zeichenfolge erfolgreich behandelt.The output indicates that the best-fit fallback implementation successfully handles the three non-ASCII characters in the original string.

using System;
using System.Collections.Generic;
using System.Text;

class Program
{
   static void Main()
   {
      Encoding enc = Encoding.GetEncoding("us-ascii", new CustomMapper(), new DecoderExceptionFallback());

      string str1 = "\u24C8 \u2075 \u221E";
      Console.WriteLine(str1);
      for (int ctr = 0; ctr <= str1.Length - 1; ctr++) {
         Console.Write("{0} ", Convert.ToUInt16(str1[ctr]).ToString("X4"));
         if (ctr == str1.Length - 1) 
            Console.WriteLine();
      }
      Console.WriteLine();

      // Encode the original string using the ASCII encoder.
      byte[] bytes = enc.GetBytes(str1);
      Console.Write("Encoded bytes: ");
      foreach (var byt in bytes)
         Console.Write("{0:X2} ", byt);

      Console.WriteLine("\n");

      // Decode the ASCII bytes.
      string str2 = enc.GetString(bytes);
      Console.WriteLine("Round-trip: {0}", str1.Equals(str2));
      if (! str1.Equals(str2)) {
         Console.WriteLine(str2);
         foreach (var ch in str2)
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"));

         Console.WriteLine();
      }
   }
}
Imports System.Text
Imports System.Collections.Generic

Module Module1

   Sub Main()
      Dim enc As Encoding = Encoding.GetEncoding("us-ascii", New CustomMapper(), New DecoderExceptionFallback())

      Dim str1 As String = String.Format("{0} {1} {2}", ChrW(&H24C8), ChrW(&H2075), ChrW(&H221E))
      Console.WriteLine(str1)
      For ctr As Integer = 0 To str1.Length - 1
         Console.Write("{0} ", Convert.ToUInt16(str1(ctr)).ToString("X4"))
         If ctr = str1.Length - 1 Then Console.WriteLine()
      Next
      Console.WriteLine()

      ' Encode the original string using the ASCII encoder.
      Dim bytes() As Byte = enc.GetBytes(str1)
      Console.Write("Encoded bytes: ")
      For Each byt In bytes
         Console.Write("{0:X2} ", byt)
      Next
      Console.WriteLine()
      Console.WriteLine()

      ' Decode the ASCII bytes.
      Dim str2 As String = enc.GetString(bytes)
      Console.WriteLine("Round-trip: {0}", str1.Equals(str2))
      If Not str1.Equals(str2) Then
         Console.WriteLine(str2)
         For Each ch In str2
            Console.Write("{0} ", Convert.ToUInt16(ch).ToString("X4"))
         Next
         Console.WriteLine()
      End If
   End Sub
End Module

Siehe auchSee also