Encoding Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt eine Zeichencodierung dar.
public ref class Encoding abstractpublic ref class Encoding abstract : ICloneablepublic abstract class Encodingpublic abstract class Encoding : ICloneable[System.Serializable]
public abstract class Encoding[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Encoding : ICloneabletype Encoding = classtype Encoding = class
interface ICloneable[<System.Serializable>]
type Encoding = class[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Encoding = class
interface ICloneablePublic MustInherit Class EncodingPublic MustInherit Class Encoding
Implements ICloneable- Vererbung
-
Encoding
- Abgeleitet
- Attribute
- Implementiert
Beispiele
Im folgenden Beispiel wird eine Zeichenfolge von einer Codierung in eine andere konvertiert.
Hinweis
Das byte[] Array ist der einzige Typ in diesem Beispiel, der die codierten Daten enthält. Die .net Char -und- String Typen sind selbst Unicode, sodass der- GetChars Rückruf die Daten zurück in Unicode decodiert.
using namespace System;
using namespace System::Text;
int main()
{
String^ unicodeString = "This string contains the unicode character Pi (\u03a0)";
// Create two different encodings.
Encoding^ ascii = Encoding::ASCII;
Encoding^ unicode = Encoding::Unicode;
// Convert the string into a byte array.
array<Byte>^unicodeBytes = unicode->GetBytes( unicodeString );
// Perform the conversion from one encoding to the other.
array<Byte>^asciiBytes = Encoding::Convert( unicode, ascii, unicodeBytes );
// Convert the new Byte into[] a char and[] then into a string.
array<Char>^asciiChars = gcnew array<Char>(ascii->GetCharCount( asciiBytes, 0, asciiBytes->Length ));
ascii->GetChars( asciiBytes, 0, asciiBytes->Length, asciiChars, 0 );
String^ asciiString = gcnew String( asciiChars );
// Display the strings created before and after the conversion.
Console::WriteLine( "Original String*: {0}", unicodeString );
Console::WriteLine( "Ascii converted String*: {0}", asciiString );
}
// The example displays the following output:
// Original string: This string contains the unicode character Pi (Π)
// Ascii converted string: This string contains the unicode character Pi (?)
using System;
using System.Text;
class Example
{
static void Main()
{
string unicodeString = "This string contains the unicode character Pi (\u03a0)";
// Create two different encodings.
Encoding ascii = Encoding.ASCII;
Encoding unicode = Encoding.Unicode;
// Convert the string into a byte array.
byte[] unicodeBytes = unicode.GetBytes(unicodeString);
// Perform the conversion from one encoding to the other.
byte[] asciiBytes = Encoding.Convert(unicode, ascii, unicodeBytes);
// Convert the new byte[] into a char[] and then into a string.
char[] asciiChars = new char[ascii.GetCharCount(asciiBytes, 0, asciiBytes.Length)];
ascii.GetChars(asciiBytes, 0, asciiBytes.Length, asciiChars, 0);
string asciiString = new string(asciiChars);
// Display the strings created before and after the conversion.
Console.WriteLine("Original string: {0}", unicodeString);
Console.WriteLine("Ascii converted string: {0}", asciiString);
}
}
// The example displays the following output:
// Original string: This string contains the unicode character Pi (Π)
// Ascii converted string: This string contains the unicode character Pi (?)
Imports System.Text
Class Example
Shared Sub Main()
Dim unicodeString As String = "This string contains the unicode character Pi (" & ChrW(&H03A0) & ")"
' Create two different encodings.
Dim ascii As Encoding = Encoding.ASCII
Dim unicode As Encoding = Encoding.Unicode
' Convert the string into a byte array.
Dim unicodeBytes As Byte() = unicode.GetBytes(unicodeString)
' Perform the conversion from one encoding to the other.
Dim asciiBytes As Byte() = Encoding.Convert(unicode, ascii, unicodeBytes)
' Convert the new byte array into a char array and then into a string.
Dim asciiChars(ascii.GetCharCount(asciiBytes, 0, asciiBytes.Length)-1) As Char
ascii.GetChars(asciiBytes, 0, asciiBytes.Length, asciiChars, 0)
Dim asciiString As New String(asciiChars)
' Display the strings created before and after the conversion.
Console.WriteLine("Original string: {0}", unicodeString)
Console.WriteLine("Ascii converted string: {0}", asciiString)
End Sub
End Class
' The example displays the following output:
' Original string: This string contains the unicode character Pi (Π)
' Ascii converted string: This string contains the unicode character Pi (?)
Hinweise
Beim Kodieren werden Unicode-Zeichen in eine Bytefolge transformiert. Im Gegensatz dazu ist das Decodieren der Prozess der Transformation einer Sequenz codierter Bytes in eine Gruppe von Unicode-Zeichen. Informationen zu den Unicode-Transformations Formaten (UTFs) und anderen Codierungen, die von unterstützt Encoding werden, finden Sie unter Zeichencodierung in .net.
Beachten Sie, dass für die Verwendung Encoding von Unicode-Zeichen anstelle von willkürlichen Binärdaten (z. b. Byte Arrays) vorgesehen ist. Wenn Sie beliebige Binärdaten in Text codieren müssen, sollten Sie ein Protokoll verwenden, wie z. b. UUEncode, das von Methoden wie implementiert wird Convert.ToBase64CharArray .
.Net bietet die folgenden Implementierungen der Encoding -Klasse, um aktuelle Unicode-Codierungen und andere Codierungen zu unterstützen:
ASCIIEncodingcodiert Unicode-Zeichen als einzelne 7-Bit-ASCII-Zeichen. Diese Codierung unterstützt nur Zeichen Werte zwischen U + 0000 und u + 007F. Codepage 20127. Auch über die- ASCII Eigenschaft verfügbar.
UTF7Encodingcodiert Unicode-Zeichen mithilfe der UTF-7-Codierung. Diese Codierung unterstützt alle Unicode-Zeichen Werte. Codepage 65000. Auch über die- UTF7 Eigenschaft verfügbar.
UTF8Encodingcodiert Unicode-Zeichen mithilfe der UTF-8-Codierung. Diese Codierung unterstützt alle Unicode-Zeichen Werte. Codepage 65001. Auch über die- UTF8 Eigenschaft verfügbar.
UnicodeEncodingcodiert Unicode-Zeichen mithilfe der UTF-16-Codierung. Sowohl Little-Endian-als auch Big-Endian-Byte Bestellungen werden unterstützt. Auch über die Unicode -Eigenschaft und die- BigEndianUnicode Eigenschaft verfügbar.
UTF32Encodingcodiert Unicode-Zeichen mithilfe der UTF-32-Codierung. Es werden sowohl kleine Endian-(Codepage 12000) als auch Big Endian-Byte Bestellungen (Codepage 12001) unterstützt. Auch über die- UTF32 Eigenschaft verfügbar.
Die Encoding -Klasse ist primär für die Konvertierung zwischen verschiedenen Codierungen und Unicode vorgesehen. Häufig ist eine der abgeleiteten Unicode-Klassen die richtige Wahl für Ihre APP.
Verwenden GetEncoding Sie die-Methode, um andere Codierungen abzurufen, und rufen Sie die- GetEncodings Methode auf, um eine Liste aller Codierungen abzurufen.
Liste der Codierungen
In der folgenden Tabelle werden die von .NET unterstützten Codierungen aufgelistet. Sie listet die Code Page Nummer jeder Codierung und die Werte der Codierungs- EncodingInfo.Name und- EncodingInfo.DisplayName Eigenschaften auf. Ein Häkchen in der Spalte .NET Framework Support, .NET Core-Unterstützung oder .NET 5 und höher gibt an, dass die Codepage von dieser .NET-Implementierung nativ unterstützt wird, unabhängig von der zugrunde liegenden Plattform. Für .NET Framework hängt die Verfügbarkeit anderer Codierungen, die in der Tabelle aufgelistet sind, vom Betriebssystem ab. Für .NET Core und .NET 5 und höhere Versionen sind andere Codierungen verfügbar, indem sie die System.Text.CodePagesEncodingProvider -Klasse verwenden oder von der System.Text.EncodingProvider -Klasse abgeleitet werden.
Hinweis
Codepages, deren- EncodingInfo.Name Eigenschaft einem internationalen Standard entspricht, entsprechen nicht notwendigerweise vollständig dem Standard.
| Codepage | name | Angezeigter Name | .NET Framework Unterstützung | .NET Core-Unterstützung | Unterstützung für .NET 5 und höher | |
|---|---|---|---|---|---|---|
| 37 | IBM037 | IBM EBCDIC (USA-Kanada) | ||||
| 437 | IBM437 | OEM-USA | ||||
| 500 | IBM500 | IBM EBCDIC (International) | ||||
| 708 | ASMO-708 | Arabisch (ASMO 708) | ||||
| 720 | DOS-720 | Arabisch (DOS) | ||||
| 737 | ibm737 | Griechisch (DOS) | ||||
| 775 | ibm775 | Baltisch (DOS) | ||||
| 850 | ibm850 | Westeuropäisch (DOS) | ||||
| 852 | ibm852 | Mitteleuropäisch (DOS) | ||||
| 855 | IBM855 | OEM-Kyrillisch | ||||
| 857 | ibm857 | Türkisch (DOS) | ||||
| 858 | IBM00858 | OEM-mehrsprachige lateinische I | ||||
| 860 | IBM860 | Portugiesisch (DOS) | ||||
| 861 | ibm861 | Isländisch (DOS) | ||||
| 862 | DOS-862 | Hebräisch (DOS) | ||||
| 863 | IBM863 | Französisch (Kanada) | ||||
| 864 | IBM864 | Arabisch (864) | ||||
| 865 | IBM865 | Nordisch (DOS) | ||||
| 866 | cp866 | Kyrillisch (DOS) | ||||
| 869 | ibm869 | Griechisch, modern (DOS) | ||||
| 870 | IBM870 | IBM EBCDIC (mehrsprachige lateinische-2) | ||||
| 874 | Windows-874 | Thailändisch (Windows) | ||||
| 875 | cp875 | IBM EBCDIC (griechisch modern) | ||||
| 932 | shift_jis | Japanisch (Shift-JIS) | ||||
| 936 | GB2312 | Chinesisch vereinfacht (GB2312) | ✓ | |||
| 949 | KS_C_5601-1987 | Koreanisch | ||||
| 950 | Big5 | Chinesisch traditionell (Big5) | ||||
| 1026 | IBM1026 | IBM EBCDIC (Türkisch (lateinisch-5) | ||||
| 1047 | IBM01047 | IBM Latin-1 | ||||
| 1140 | IBM01140 | IBM EBCDIC (USA-Kanada-Euro) | ||||
| 1.141 | IBM01141 | IBM EBCDIC (Deutschland-Euro) | ||||
| 1142 | IBM01142 | IBM EBCDIC (Dänemark-Norwegen-Euro) | ||||
| 1143 | IBM01143 | IBM EBCDIC (Finnland-Schweden-Euro) | ||||
| 1144 | IBM01144 | IBM EBCDIC (Italien-Euro) | ||||
| 1145 | IBM01145 | IBM EBCDIC (Spanien-Euro) | ||||
| 1146 | IBM01146 | IBM EBCDIC (UK-Euro) | ||||
| 1147 | IBM01147 | IBM EBCDIC (Frankreich-Euro) | ||||
| 1148 | IBM01148 | IBM EBCDIC (International-Euro) | ||||
| 1149 | IBM01149 | IBM EBCDIC (Isländisch-Euro) | ||||
| 1200 | UTF-16 | Unicode | ✓ | ✓ | ✓ | |
| 1201 | unicodeFFFE | Unicode (Big-tedian) | ✓ | ✓ | ✓ | |
| 1250 | Windows-1250 | Mitteleuropäisch (Windows) | ||||
| 1251 | Windows-1251 | Kyrillisch (Windows) | ||||
| 1252 | Windows-1252 | Westeuropäisch (Windows) | ✓ | |||
| 1253 | Windows-1253 | Griechisch (Windows) | ||||
| 1254 | Windows-1254 | Türkisch (Windows) | ||||
| 1255 | Windows-1255 | Hebräisch (Windows) | ||||
| 1256 | Windows-1256 | Arabisch (Windows) | ||||
| 1257 | Windows-1257 | Baltisch (Windows) | ||||
| 1258 | Windows-1258 | Vietnamesisch (Windows) | ||||
| 1361 | Johab | Koreanisch (Johab) | ||||
| 10000 | Macintosh | Westeuropäisch (Mac) | ||||
| 10001 | x-Mac-Japanisch | Japanisch (Mac) | ||||
| 10002 | x-Mac-chinesetrad | Chinesisch (traditionell) (Mac) | ||||
| 10003 | x-Mac-Koreanisch | Koreanisch (Mac) | ✓ | |||
| 10004 | x-Mac-Arabisch | Arabisch (Mac) | ||||
| 10005 | x-Mac-Hebräisch | Hebräisch (Mac) | ||||
| 10006 | x-Mac-Griechisch | Griechisch (Mac) | ||||
| 10007 | x-Mac-Kyrillisch | Kyrillisch (Mac) | ||||
| 10008 | x-Mac-chinesesimp | Chinesisch vereinfacht (Mac) | ✓ | |||
| 10010 | x-Mac-Rumänisch | Rumänisch (Mac) | ||||
| 10017 | x-Mac-Ukrainisch | Ukrainisch (Mac) | ||||
| 10021 | x-Mac-Thai | Thailändisch (Mac) | ||||
| 10029 | x-Mac-CE | Mitteleuropäisch (Mac) | ||||
| 10079 | x-Mac-Isländisch | Isländisch (Mac) | ||||
| 10081 | x-Mac-Türkisch | Türkisch (Mac) | ||||
| 10082 | x-Mac-Kroatisch | Kroatisch (Mac) | ||||
| 12000 | UTF-32 | Unicode (UTF-32) | ✓ | ✓ | ✓ | |
| 12001 | UTF-32be | Unicode (UTF-32 Big-d) | ✓ | ✓ | ✓ | |
| 20000 | x-Chinesisch-CNS | Chinesisch (traditionell) (CNS) | ||||
| 20001 | x-cp20001 | TCA-Taiwan | ||||
| 20002 | x-Chinesisch-eTEN | Chinesisch (traditionell) (eTEN) | ||||
| 20003 | x-cp20003 | IBM5550 Taiwan | ||||
| 20004 | x-cp20004 | Teletext-Taiwan | ||||
| 20005 | x-cp20005 | Wang Taiwan | ||||
| 20105 | x-IA5 | Westeuropäisch (IA5) | ||||
| 20106 | x-IA5-Deutsch | Deutsch (IA5) | ||||
| 20107 | x-IA5-Schwedisch | Schwedisch (IA5) | ||||
| 20108 | x-IA5-Norwegisch | Norwegisch (IA5) | ||||
| 20127 | US-ASCII | US-ASCII | ✓ | ✓ | ✓ | |
| 20261 | x-cp20261 | T. 61 | ||||
| 20269 | x-cp20269 | ISO-6937 | ||||
| 20273 | IBM273 | IBM EBCDIC (Deutschland) | ||||
| 20277 | IBM277 | IBM EBCDIC (Dänemark-Norwegen) | ||||
| 20278 | IBM278 | IBM EBCDIC (Finnland-Schweden) | ||||
| 20280 | IBM280 | IBM EBCDIC (Italien) | ||||
| 20284 | IBM284 | IBM EBCDIC (Spanien) | ||||
| 20285 | IBM285 | IBM EBCDIC (Vereinigtes Königreich) | ||||
| 20290 | IBM290 | IBM EBCDIC (Japanisch Katakana) | ||||
| 20297 | IBM297 | IBM EBCDIC (Frankreich) | ||||
| 20420 | IBM420 | IBM EBCDIC (Arabisch) | ||||
| 20423 | IBM423 | IBM EBCDIC (Griechisch) | ||||
| 20424 | IBM424 | IBM EBCDIC (Hebräisch) | ||||
| 20833 | x-EBCDIC-koreanextended | IBM EBCDIC (Koreanisch erweitert) | ||||
| 20838 | IBM-Thai | IBM EBCDIC (Thailändisch) | ||||
| 20866 | koi8-r | Kyrillisch (KOI8-R) | ||||
| 20871 | IBM871 | IBM EBCDIC (Isländisch) | ||||
| 20880 | IBM880 | IBM EBCDIC (Kyrillisch Russisch) | ||||
| 20905 | IBM905 | IBM EBCDIC (Türkisch) | ||||
| 20924 | IBM00924 | IBM Latin-1 | ||||
| 20932 | EUC-JP | Japanisch (JIS 0208-1990 und 0212-1990) | ||||
| 20936 | x-cp20936 | Chinesisch vereinfacht (GB2312-80) | ✓ | |||
| 20949 | x-cp20949 | Koreanisch Wansung | ✓ | |||
| 21025 | cp1025 | IBM EBCDIC (Kyrillisch Serbisch-Bulgarisch) | ||||
| 21866 | KOI8-u | Kyrillisch (KOI8-U) | ||||
| 28591 | ISO-8859-1 | Westeuropäisch (ISO) | ✓ | ✓ | ✓ | |
| 28592 | ISO-8859-2 | Mitteleuropäisch (ISO) | ||||
| 28593 | ISO-8859-3 | Lateinisch 3 (ISO) | ||||
| 28594 | ISO-8859-4 | Baltisch (ISO) | ||||
| 28595 | ISO-8859-5 | Kyrillisch (ISO) | ||||
| 28596 | ISO-8859-6 | Arabisch (ISO) | ||||
| 28597 | ISO-8859-7 | Griechisch (ISO) | ||||
| 28598 | ISO-8859-8 | Hebräisch (ISO-Visual) | ✓ | |||
| 28599 | ISO-8859-9 | Türkisch (ISO) | ||||
| 28603 | ISO-8859-13 | Estonian (ISO) | ||||
| 28605 | ISO-8859-15 | Lateinisch 9 (ISO) | ||||
| 29001 | x-Europa | ' | ||||
| 38598 | ISO-8859-8-i | Hebräisch (ISO-logisch) | ✓ | |||
| 50220 | ISO-2022-JP | Japanisch (JIS) | ✓ | |||
| 50221 | csISO2022JP | Japanisch (JIS-1-Byte-Kana zulassen) | ✓ | |||
| 50222 | ISO-2022-JP | Japanisch (JIS-1 Byte Kana-so/SI) | ✓ | |||
| 50225 | ISO-2022-KR | Koreanisch (ISO) | ✓ | |||
| 50227 | x-cp50227 | Chinesisch vereinfacht (ISO-2022) | ✓ | |||
| 51932 | EUC-JP | Japanisch (EUC) | ✓ | |||
| 51936 | EUC-CN | Chinesisch (vereinfacht) (EUC) | ✓ | |||
| 51949 | EUC-KR | Koreanisch (EUC) | ✓ | |||
| 52936 | Hz-GB-2312 | Chinesisch (vereinfacht) (Hz) | ✓ | |||
| 54936 | GB18030 | Chinesisch vereinfacht (GB18030) | ✓ | |||
| 57002 | x-ISCII-de | ISCII-Geräte Abteilung | ✓ | |||
| 57003 | x-ISCII-be | ISCII Bengalisch | ✓ | |||
| 57004 | x-ISCII-Ta | ISCII Tamil | ✓ | |||
| 57005 | x-ISCII-te | ISCII Telugu | ✓ | |||
| 57006 | x-ISCII-as | ISCII-Assamese | ✓ | |||
| 57007 | x-ISCII-or | ISCII Oriya | ✓ | |||
| 57008 | x-ISCII-Ka | ISCII Kannada | ✓ | |||
| 57009 | x-ISCII-MA | ISCII Malayalam | ✓ | |||
| 57010 | x-ISCII-gu | ISCII Gujarati | ✓ | |||
| 57011 | x-ISCII-PA | ISCII Punjabi | ✓ | |||
| 65000 | UTF-7 | Unicode (UTF-7) | ✓ | ✓ | ||
| 65001 | UTF-8 | Unicode (UTF-8) | ✓ | ✓ | ✓ |
Im folgenden Beispiel werden die GetEncoding(Int32) -Methode und die- GetEncoding(String) Methode aufgerufen, um die codierte Codierung (Windows) zu erhalten. Es vergleicht die Encoding von den Methoden Aufrufen zurückgegebenen Objekte, um anzuzeigen, dass Sie gleich sind. Anschließend zeigt Maps den Unicode-Codepunkt und den entsprechenden Codepage-Wert für jedes Zeichen im griechischen Alphabet an.
using System;
using System.Text;
public class Example
{
public static void Main()
{
Encoding enc = Encoding.GetEncoding(1253);
Encoding altEnc = Encoding.GetEncoding("windows-1253");
Console.WriteLine("{0} = Code Page {1}: {2}", enc.EncodingName,
altEnc.CodePage, enc.Equals(altEnc));
string greekAlphabet = "Α α Β β Γ γ Δ δ Ε ε Ζ ζ Η η " +
"Θ θ Ι ι Κ κ Λ λ Μ μ Ν ν Ξ ξ " +
"Ο ο Π π Ρ ρ Σ σ ς Τ τ Υ υ " +
"Φ φ Χ χ Ψ ψ Ω ω";
Console.OutputEncoding = Encoding.UTF8;
byte[] bytes = enc.GetBytes(greekAlphabet);
Console.WriteLine("{0,-12} {1,20} {2,20:X2}", "Character",
"Unicode Code Point", "Code Page 1253");
for (int ctr = 0; ctr < bytes.Length; ctr++) {
if (greekAlphabet[ctr].Equals(' '))
continue;
Console.WriteLine("{0,-12} {1,20} {2,20:X2}", greekAlphabet[ctr],
GetCodePoint(greekAlphabet[ctr]), bytes[ctr]);
}
}
private static string GetCodePoint(char ch)
{
string retVal = "u+";
byte[] bytes = Encoding.Unicode.GetBytes(ch.ToString());
for (int ctr = bytes.Length - 1; ctr >= 0; ctr--)
retVal += bytes[ctr].ToString("X2");
return retVal;
}
}
// The example displays the following output:
// Character Unicode Code Point Code Page 1253
// Α u+0391 C1
// α u+03B1 E1
// Β u+0392 C2
// β u+03B2 E2
// Γ u+0393 C3
// γ u+03B3 E3
// Δ u+0394 C4
// δ u+03B4 E4
// Ε u+0395 C5
// ε u+03B5 E5
// Ζ u+0396 C6
// ζ u+03B6 E6
// Η u+0397 C7
// η u+03B7 E7
// Θ u+0398 C8
// θ u+03B8 E8
// Ι u+0399 C9
// ι u+03B9 E9
// Κ u+039A CA
// κ u+03BA EA
// Λ u+039B CB
// λ u+03BB EB
// Μ u+039C CC
// μ u+03BC EC
// Ν u+039D CD
// ν u+03BD ED
// Ξ u+039E CE
// ξ u+03BE EE
// Ο u+039F CF
// ο u+03BF EF
// Π u+03A0 D0
// π u+03C0 F0
// Ρ u+03A1 D1
// ρ u+03C1 F1
// Σ u+03A3 D3
// σ u+03C3 F3
// ς u+03C2 F2
// Τ u+03A4 D4
// τ u+03C4 F4
// Υ u+03A5 D5
// υ u+03C5 F5
// Φ u+03A6 D6
// φ u+03C6 F6
// Χ u+03A7 D7
// χ u+03C7 F7
// Ψ u+03A8 D8
// ψ u+03C8 F8
// Ω u+03A9 D9
// ω u+03C9 F9
Imports System.Text
Module Example
Public Sub Main()
Dim enc As Encoding = Encoding.GetEncoding(1253)
Dim altEnc As Encoding = Encoding.GetEncoding("windows-1253")
Console.WriteLine("{0} = Code Page {1}: {2}", enc.EncodingName,
altEnc.CodePage, enc.Equals(altEnc))
Dim greekAlphabet As String = "Α α Β β Γ γ Δ δ Ε ε Ζ ζ Η η " +
"Θ θ Ι ι Κ κ Λ λ Μ μ Ν ν Ξ ξ " +
"Ο ο Π π Ρ ρ Σ σ ς Τ τ Υ υ " +
"Φ φ Χ χ Ψ ψ Ω ω"
Console.OutputEncoding = Encoding.UTF8
Dim bytes() As Byte = enc.GetBytes(greekAlphabet)
Console.WriteLine("{0,-12} {1,20} {2,20:X2}", "Character",
"Unicode Code Point", "Code Page 1253")
For ctr As Integer = 0 To bytes.Length - 1
If greekAlphabet(ctr).Equals(" "c) Then Continue For
Console.WriteLine("{0,-12} {1,20} {2,20:X2}", greekAlphabet(ctr),
GetCodePoint(greekAlphabet(ctr)), bytes(ctr))
Next
End Sub
Private Function GetCodePoint(ch As String) As String
Dim retVal As String = "u+"
Dim bytes() As Byte = Encoding.Unicode.GetBytes(ch)
For ctr As Integer = bytes.Length - 1 To 0 Step -1
retVal += bytes(ctr).ToString("X2")
Next
Return retVal
End Function
End Module
' The example displays the following output:
' Character Unicode Code Point Code Page 1253
' Α u+0391 C1
' α u+03B1 E1
' Β u+0392 C2
' β u+03B2 E2
' Γ u+0393 C3
' γ u+03B3 E3
' Δ u+0394 C4
' δ u+03B4 E4
' Ε u+0395 C5
' ε u+03B5 E5
' Ζ u+0396 C6
' ζ u+03B6 E6
' Η u+0397 C7
' η u+03B7 E7
' Θ u+0398 C8
' θ u+03B8 E8
' Ι u+0399 C9
' ι u+03B9 E9
' Κ u+039A CA
' κ u+03BA EA
' Λ u+039B CB
' λ u+03BB EB
' Μ u+039C CC
' μ u+03BC EC
' Ν u+039D CD
' ν u+03BD ED
' Ξ u+039E CE
' ξ u+03BE EE
' Ο u+039F CF
' ο u+03BF EF
' Π u+03A0 D0
' π u+03C0 F0
' Ρ u+03A1 D1
' ρ u+03C1 F1
' Σ u+03A3 D3
' σ u+03C3 F3
' ς u+03C2 F2
' Τ u+03A4 D4
' τ u+03C4 F4
' Υ u+03A5 D5
' υ u+03C5 F5
' Φ u+03A6 D6
' φ u+03C6 F6
' Χ u+03A7 D7
' χ u+03C7 F7
' Ψ u+03A8 D8
' ψ u+03C8 F8
' Ω u+03A9 D9
' ω u+03C9 F9
Wenn die zu konvertierenden Daten nur in sequenziellen Blöcken (z. b. aus einem Stream gelesene Daten) verfügbar sind, oder wenn die Menge der Daten so groß ist, dass Sie in kleinere Blöcke aufgeteilt werden muss, sollten Sie den Decoder oder den bereitstellen, der Encoder von der- GetDecoder Methode bzw. der- GetEncoder Methode der abgeleiteten Klasse bereitgestellt wird.
Der UTF-16-und der UTF-32-Encoder können die Big-Endian-Byte Reihenfolge (signifikanteste Byte zuerst) oder die kleine Endian-Byte Reihenfolge (das am wenigsten signifikante Byte zuerst) verwenden. Beispielsweise wird der lateinische Großbuchstabe A (U + 0041) wie folgt serialisiert (in Hexadezimal):
UTF-16 Big-Endian-Byte Reihenfolge: 00 41
UTF-16 Little-Endian-Byte Reihenfolge: 41 00
UTF-32 Big Endian-Byte Reihenfolge: 00 00 00 41
UTF-32 Little-Endian-Byte Reihenfolge: 41 00 00 00
Es ist in der Regel effizienter, Unicode-Zeichen mithilfe der systemeigenen Byte Reihenfolge zu speichern. Beispielsweise ist es besser, die Little-Endian-Byte Reihenfolge auf kleinen Endian-Plattformen wie z. b. Intel-Computern zu verwenden.
Die- GetPreamble Methode ruft ein Bytearray ab, das die Byte Reihenfolge-Marke (BOM) enthält. Wenn dieses Bytearray einem codierten Stream vorangestellt wird, hilft es dem Decoder, das verwendete Codierungsformat zu identifizieren.
Weitere Informationen zur Byte Reihenfolge und zur Byte Reihenfolge-Markierung finden Sie im Unicode-Standard auf der Unicode-Homepage.
Beachten Sie, dass die Codierungs Klassen Fehler zulassen:
Wechseln Sie im Hintergrund zu einem "?"-Zeichen.
Verwenden Sie ein Zeichen mit der optimalen Anpassung.
Wechseln Sie zu einem anwendungsspezifischen Verhalten, indem Sie die EncoderFallback -Klasse und die- DecoderFallback Klasse mit dem Unicode-Ersatz Zeichen "U + FFFD" verwenden.
Sie sollten für jeden Datenstrom Fehler eine Ausnahme auslösen. Eine APP verwendet entweder das Flag "throwOnError", falls zutreffend, oder verwendet die EncoderExceptionFallback -Klasse und die- DecoderExceptionFallback Klasse. Der Fall Back am besten geeignet ist oft nicht empfehlenswert, da dies zu Datenverlusten oder Verwirrung führen kann und langsamer als einfache Zeichen Ersetzungen ist. Bei ANSI-Codierungen ist das beste Verhalten der Standardeinstellung.
Konstruktoren
| Encoding() |
Initialisiert eine neue Instanz der Encoding-Klasse. |
| Encoding(Int32) |
Initialisiert eine neue Instanz der Encoding-Klasse, die der angegebenen Codepage entspricht. |
| Encoding(Int32, EncoderFallback, DecoderFallback) |
Initialisiert eine neue Instanz der Encoding-Klasse, die der angegebenen Codepage entspricht, mit den angegebenen Fallbackstrategien für Codierer und Decodierer. |
Eigenschaften
| ASCII |
Ruft eine Codierung für den ASCII-Zeichensatz (7-Bit) ab. |
| BigEndianUnicode |
Ruft eine Codierung für das UTF-16-Format mit Big-Endian-Bytereihenfolge ab. |
| BodyName |
Beim Überschreiben in einer abgeleiteten Klasse wird ein Name für die aktuelle Codierung abgerufen, die mit den Body-Tags des E-Mail-Agenten verwendet werden kann. |
| CodePage |
Ruft den Codepagebezeichner der aktuellen Encoding-Klasse beim Überschreiben in einer abgeleiteten Klasse ab. |
| DecoderFallback |
Ruft das DecoderFallback-Objekt für das aktuelle Encoding-Objekt ab. |
| Default |
Ruft die Standardcodierung für diese .NET-Implementierung ab. |
| EncoderFallback |
Ruft das EncoderFallback-Objekt für das aktuelle Encoding-Objekt ab. |
| EncodingName |
Beim Überschreiben in einer abgeleiteten Klasse wird die Klartextbeschreibung der aktuellen Codierung abgerufen. |
| HeaderName |
Beim Überschreiben in einer abgeleiteten Klasse wird ein Name für die aktuelle Codierung abgerufen, die mit den Header-Tags des E-Mail-Agenten verwendet werden kann. |
| IsBrowserDisplay |
Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Browserclients zum Anzeigen des Inhalts verwendet werden kann. |
| IsBrowserSave |
Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Browserclients zum Speichern von Inhalt verwendet werden kann. |
| IsMailNewsDisplay |
Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Mail- und Newsclients zum Anzeigen von Inhalt verwendet werden kann. |
| IsMailNewsSave |
Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Mail- und Newsclients zum Speichern von Inhalt verwendet werden kann. |
| IsReadOnly |
Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob die aktuelle Codierung schreibgeschützt ist. |
| IsSingleByte |
Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob die aktuelle Codierung Einzelbyte-Codepunkte verwendet. |
| Latin1 |
Ruft eine Codierung für den Zeichensatz Latin1 (ISO-8859-1) ab. |
| Preamble |
Gibt beim Überschreiben in einer abgeleiteten Klasse eine Bytefolge zurück, die die verwendete Codierung angibt. |
| Unicode |
Ruft eine Codierung für das UTF-16-Format in der Little-Endian-Bytereihenfolge ab. |
| UTF32 |
Ruft eine Codierung für das UTF-32-Format in der Little-Endian-Bytereihenfolge ab. |
| UTF7 |
Veraltet.
Ruft eine Codierung für das UTF-7-Format ab. |
| UTF8 |
Ruft eine Codierung für das UTF-8-Format ab. |
| WebName |
Beim Überschreiben in einer abgeleiteten Klasse wird der Name für die aktuelle Codierung bei der Internet Assigned Numbers Authority (IANA) registriert. |
| WindowsCodePage |
Beim Überschreiben in einer abgeleiteten Klasse wird die Codepage des Betriebssystems Windows abgerufen, die der aktuellen Codierung am ehesten entspricht. |
Methoden
| Clone() |
Erstellt beim Überschreiben in einer abgeleiteten Klasse eine flache Kopie des aktuellen Encoding-Objekts. |
| Convert(Encoding, Encoding, Byte[]) |
Konvertiert ein vollständiges Bytearray aus einer Codierung in eine andere. |
| Convert(Encoding, Encoding, Byte[], Int32, Int32) |
Konvertiert einen Bereich von Bytes in einem Bytearray aus einer Codierung in eine andere. |
| CreateTranscodingStream(Stream, Encoding, Encoding, Boolean) |
Erstellt einen Stream, der zur Transcodierung von Daten zwischen einer inneren Encoding und einer äußeren Encoding dient, ähnlich wie Convert(Encoding, Encoding, Byte[]). |
| Equals(Object) |
Bestimmt, ob das angegebene Object und die aktuelle Instanz gleich sind. |
| GetByteCount(Char*, Int32) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Bytes, die beim Codieren der Zeichen ab dem Zeichenzeiger erzeugt werden. |
| GetByteCount(Char[]) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren aller Zeichen im angegebenen Zeichenarray erzeugt werden. |
| GetByteCount(Char[], Int32, Int32) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren der Zeichen aus dem angegebenen Zeichenarray erzeugt werden. |
| GetByteCount(ReadOnlySpan<Char>) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren der Zeichen in der angegebenen Zeichenspanne erzeugt werden. |
| GetByteCount(String) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Bytes, die beim Codieren der Zeichen in der angegebenen Zeichenfolge erzeugt werden. |
| GetByteCount(String, Int32, Int32) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren der Zeichen aus der angegebenen Zeichenspanne erzeugt werden. |
| GetBytes(Char*, Int32, Byte*, Int32) |
Beim Überschreiben in einer abgeleiteten Klasse werden die Zeichen beginnend am angegebenen Zeichenzeiger in eine Bytefolge codiert, die ab Beginn des angegebenen Bytezeigers gespeichert wird. |
| GetBytes(Char[]) |
Beim Überschreiben in einer abgeleiteten Klasse werden alle Zeichen im angegebenen Zeichenarray in eine Bytefolge codiert. |
| GetBytes(Char[], Int32, Int32) |
Beim Überschreiben in einer abgeleiteten Klasse werden die Zeichen im angegebenen Zeichenarray in eine Bytefolge codiert. |
| GetBytes(Char[], Int32, Int32, Byte[], Int32) |
Beim Überschreiben in einer abgeleiteten Klasse werden die Zeichen aus dem angegebenen Zeichenarray in das angegebene Bytearray codiert. |
| GetBytes(ReadOnlySpan<Char>, Span<Byte>) |
Codiert beim Überschreiben in einer abgeleiteten Klasse eine Gruppe von Zeichen aus der angegebenen schreibgeschützten Spanne in eine Bytespanne. |
| GetBytes(String) |
Beim Überschreiben in einer abgeleiteten Klasse werden alle Zeichen in der angegebenen Zeichenfolge in eine Bytefolge codiert. |
| GetBytes(String, Int32, Int32) |
Codiert beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Zeichen, die durch |
| GetBytes(String, Int32, Int32, Byte[], Int32) |
Beim Überschreiben in einer abgeleiteten Klasse werden die Zeichen aus der angegebenen Zeichenfolge in das angegebene Bytearray codiert. |
| GetCharCount(Byte*, Int32) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Zeichen, die beim Decodieren einer Bytefolge ab dem angegebenen Bytezeiger erzeugt werden. |
| GetCharCount(Byte[]) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Zeichen, die beim Decodieren aller Bytes in dem angegebenen Bytearray erzeugt werden. |
| GetCharCount(Byte[], Int32, Int32) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Zeichen, die beim Decodieren einer Bytefolge aus dem angegebenen Bytearray erzeugt werden. |
| GetCharCount(ReadOnlySpan<Byte>) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Zeichen, die beim Decodieren der angegebenen schreibgeschützten Bytespanne erzeugt werden. |
| GetChars(Byte*, Int32, Char*, Int32) |
Beim Überschreiben in einer abgeleiteten Klasse wird eine Bytefolge beginnend am angegebenen Bytezeiger in Zeichen decodiert, die ab Beginn des angegebenen Zeichenzeigers gespeichert werden. |
| GetChars(Byte[]) |
Beim Überschreiben in einer abgeleiteten Klasse werden alle Bytes im angegebenen Bytearray in Zeichen decodiert. |
| GetChars(Byte[], Int32, Int32) |
Beim Überschreiben in einer abgeleiteten Klasse wird eine Bytefolge aus dem angegebenen Bytearray in Zeichen decodiert. |
| GetChars(Byte[], Int32, Int32, Char[], Int32) |
Beim Überschreiben in einer abgeleiteten Klasse wird eine Bytefolge aus dem angegebenen Bytearray in das angegebene Zeichenarray decodiert. |
| GetChars(ReadOnlySpan<Byte>, Span<Char>) |
Decodiert beim Überschreiben in einer abgeleiteten Klasse alle Bytes in der angegebenen schreibgeschützten Bytespanne in eine Zeichenspanne. |
| GetDecoder() |
Beim Überschreiben in einer abgeleiteten Klasse wird ein Decoder abgerufen, der eine codierte Bytefolge in Zeichen konvertiert. |
| GetEncoder() |
Beim Überschreiben in einer abgeleiteten Klasse wird ein Encoder abgerufen, der eine Folge von Unicode-Zeichen in eine codierte Bytefolge konvertiert. |
| GetEncoding(Int32) |
Gibt die dem angegebenen Codepagebezeichner zugeordnete Codierung zurück. |
| GetEncoding(Int32, EncoderFallback, DecoderFallback) |
Gibt die dem angegebenen Codepagebezeichner zugeordnete Codierung zurück. Parameter geben einen Fehlerhandler für Zeichen an, die nicht codiert werden können, und für Bytefolgen, die nicht decodiert werden können. |
| GetEncoding(String) |
Gibt die dem angegebenen Codepagenamen zugeordnete Codierung zurück. |
| GetEncoding(String, EncoderFallback, DecoderFallback) |
Gibt die dem angegebenen Codepagenamen zugeordnete Codierung zurück. Parameter geben einen Fehlerhandler für Zeichen an, die nicht codiert werden können, und für Bytefolgen, die nicht decodiert werden können. |
| GetEncodings() |
Gibt ein Array zurück, das alle Codierungen enthält. |
| GetHashCode() |
Gibt den Hashcode für die aktuelle Instanz zurück. |
| GetMaxByteCount(Int32) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die maximale Anzahl der Bytes, die beim Codieren der angegebenen Anzahl von Zeichen erzeugt werden. |
| GetMaxCharCount(Int32) |
Berechnet beim Überschreiben in einer abgeleiteten Klasse die maximale Anzahl an Zeichen, die beim Decodieren der angegebenen Anzahl von Bytes erzeugt werden. |
| GetPreamble() |
Beim Überschreiben in einer abgeleiteten Klasse wird eine Bytefolge zurückgegeben, die die verwendete Codierung angibt. |
| GetString(Byte*, Int32) |
Beim Überschreiben in einer abgeleiteten Klasse wird eine angegebene Anzahl von Bytes ab einer angegebenen Adresse in eine Zeichenfolge decodiert. |
| GetString(Byte[]) |
Beim Überschreiben in einer abgeleiteten Klasse werden alle Bytes im angegebenen Bytearray in eine Zeichenfolge decodiert. |
| GetString(Byte[], Int32, Int32) |
Beim Überschreiben in einer abgeleiteten Klasse wird eine Bytefolge aus dem angegebenen Bytearray in eine Zeichenfolge decodiert. |
| GetString(ReadOnlySpan<Byte>) |
Decodiert beim Überschreiben in einer abgeleiteten Klasse alle Bytes in der angegebenen Bytespanne in eine Zeichenfolge. |
| GetType() |
Ruft den Type der aktuellen Instanz ab. (Geerbt von Object) |
| IsAlwaysNormalized() |
Ruft einen Wert ab, der angibt, ob die aktuelle Codierung immer normalisiert ist. Es wird die Standardnormalisierungsform verwendet. |
| IsAlwaysNormalized(NormalizationForm) |
Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung immer normalisiert ist. Hierzu wird die angegebene Normalisierungsform verwendet. |
| MemberwiseClone() |
Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object) |
| RegisterProvider(EncodingProvider) |
Registriert einen Codierungsanbieter. |
| ToString() |
Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object) |
| TryGetBytes(ReadOnlySpan<Char>, Span<Byte>, Int32) |
Codiert einen Satz von Zeichen aus der angegebenen schreibgeschützten Spanne in eine Bytespanne, wenn das Ziel groß genug ist. |
| TryGetChars(ReadOnlySpan<Byte>, Span<Char>, Int32) |
Decodiert einen Satz von Bytes aus der angegebenen schreibgeschützten Spanne in eine Spanne von Zeichen, wenn das Ziel groß genug ist. |
Erweiterungsmethoden
| GetBytes(Encoding, ReadOnlySequence<Char>) |
Codiert die angegebene ReadOnlySequence<T> unter Verwendung der angegebenen Encoding in ein Byte-Array. |
| GetBytes(Encoding, ReadOnlySequence<Char>, IBufferWriter<Byte>) |
Decodiert die angegebene ReadOnlySequence<T> in |
| GetBytes(Encoding, ReadOnlySequence<Char>, Span<Byte>) |
Codiert die angegebene ReadOnlySequence<T> in |
| GetBytes(Encoding, ReadOnlySpan<Char>, IBufferWriter<Byte>) |
Codiert die angegebene ReadOnlySpan<T> in |
| GetChars(Encoding, ReadOnlySequence<Byte>, IBufferWriter<Char>) |
Decodiert die angegebene ReadOnlySequence<T> in |
| GetChars(Encoding, ReadOnlySequence<Byte>, Span<Char>) |
Decodiert die angegebene ReadOnlySequence<T> in |
| GetChars(Encoding, ReadOnlySpan<Byte>, IBufferWriter<Char>) |
Decodiert die angegebene ReadOnlySpan<T> in |
| GetString(Encoding, ReadOnlySequence<Byte>) |
Decodiert die angegebene ReadOnlySequence<T> unter Verwendung der angegebenen Encoding in einen String. |