Encoding Class
Assembly: mscorlib (in mscorlib.dll)
[SerializableAttribute] [ComVisibleAttribute(true)] public ref class Encoding abstract : ICloneable
/** @attribute SerializableAttribute() */ /** @attribute ComVisibleAttribute(true) */ public abstract class Encoding implements ICloneable
SerializableAttribute ComVisibleAttribute(true) public abstract class Encoding implements ICloneable
Not applicable.
Encoding is the process of transforming a set of Unicode characters into a sequence of bytes. In contrast, decoding is the process of transforming a sequence of encoded bytes into a set of Unicode characters. For information about the Unicode Transformation Formats (UTFs) and other encodings supported by Encoding, see Understanding Encodings. See also Using Unicode Encoding.
Note that Encoding is intended to operate on Unicode characters instead of arbitrary binary data, such as byte arrays. If your application must encode arbitrary binary data into text, it should use a protocol such as uuencode, which is implemented by methods such as System.Convert.ToBase64CharArray.
The .NET Framework provides the following implementations of the Encoding class to support current Unicode encodings and other encodings:
-
ASCIIEncoding encodes Unicode characters as single 7-bit ASCII characters. This encoding only supports character values between U+0000 and U+007F. Code page 20127. Also available through the ASCII property.
-
UTF7Encoding encodes Unicode characters using the UTF-7 encoding. This encoding supports all Unicode character values. Code page 65000. Also available through the UTF7 property.
-
UTF8Encoding encodes Unicode characters using the UTF-8 encoding. This encoding supports all Unicode character values. Code page 65001. Also available through the UTF8 property.
-
UnicodeEncoding encodes Unicode characters using the UTF-16 encoding. Both little endian (code page 1200) and big endian (code page 1201) byte orders are supported. Also available through the Unicode property and the BigEndianUnicode property.
-
UTF32Encoding encodes Unicode characters using the UTF-32 encoding. Both little endian (code page 65005) and big endian (code page 65006) byte orders are supported. Also available through the UTF32 property.
The Encoding class is primarily intended to convert between different encodings and Unicode. Often one of the derived Unicode classes is the correct choice for your application.
Your applications use the GetEncoding method to obtain other encodings. They should use the GetEncodings method to get a list of all encodings.
The following table lists the supported encodings and their associated code pages. An asterisk in the last column indicates that the code page is natively supported by the .NET Framework, regardless of the underlying platform.
| Code Page | Name | Display Name | |
|---|---|---|---|
| 37 | IBM037 | IBM EBCDIC (US-Canada) | |
| 437 | IBM437 | OEM United States | |
| 500 | IBM500 | IBM EBCDIC (International) | |
| 708 | ASMO-708 | Arabic (ASMO 708) | |
| 720 | DOS-720 | Arabic (DOS) | |
| 737 | ibm737 | Greek (DOS) | |
| 775 | ibm775 | Baltic (DOS) | |
| 850 | ibm850 | Western European (DOS) | |
| 852 | ibm852 | Central European (DOS) | |
| 855 | IBM855 | OEM Cyrillic | |
| 857 | ibm857 | Turkish (DOS) | |
| 858 | IBM00858 | OEM Multilingual Latin I | |
| 860 | IBM860 | Portuguese (DOS) | |
| 861 | ibm861 | Icelandic (DOS) | |
| 862 | DOS-862 | Hebrew (DOS) | |
| 863 | IBM863 | French Canadian (DOS) | |
| 864 | IBM864 | Arabic (864) | |
| 865 | IBM865 | Nordic (DOS) | |
| 866 | cp866 | Cyrillic (DOS) | |
| 869 | ibm869 | Greek, Modern (DOS) | |
| 870 | IBM870 | IBM EBCDIC (Multilingual Latin-2) | |
| 874 | windows-874 | Thai (Windows) | |
| 875 | cp875 | IBM EBCDIC (Greek Modern) | |
| 932 | shift_jis | Japanese (Shift-JIS) | |
| 936 | gb2312 | Chinese Simplified (GB2312) | * |
| 949 | ks_c_5601-1987 | Korean | |
| 950 | big5 | Chinese Traditional (Big5) | |
| 1026 | IBM1026 | IBM EBCDIC (Turkish Latin-5) | |
| 1047 | IBM01047 | IBM Latin-1 | |
| 1140 | IBM01140 | IBM EBCDIC (US-Canada-Euro) | |
| 1141 | IBM01141 | IBM EBCDIC (Germany-Euro) | |
| 1142 | IBM01142 | IBM EBCDIC (Denmark-Norway-Euro) | |
| 1143 | IBM01143 | IBM EBCDIC (Finland-Sweden-Euro) | |
| 1144 | IBM01144 | IBM EBCDIC (Italy-Euro) | |
| 1145 | IBM01145 | IBM EBCDIC (Spain-Euro) | |
| 1146 | IBM01146 | IBM EBCDIC (UK-Euro) | |
| 1147 | IBM01147 | IBM EBCDIC (France-Euro) | |
| 1148 | IBM01148 | IBM EBCDIC (International-Euro) | |
| 1149 | IBM01149 | IBM EBCDIC (Icelandic-Euro) | |
| 1200 | utf-16 | Unicode | * |
| 1201 | unicodeFFFE | Unicode (Big endian) | * |
| 1250 | windows-1250 | Central European (Windows) | |
| 1251 | windows-1251 | Cyrillic (Windows) | |
| 1252 | Windows-1252 | Western European (Windows) | * |
| 1253 | windows-1253 | Greek (Windows) | |
| 1254 | windows-1254 | Turkish (Windows) | |
| 1255 | windows-1255 | Hebrew (Windows) | |
| 1256 | windows-1256 | Arabic (Windows) | |
| 1257 | windows-1257 | Baltic (Windows) | |
| 1258 | windows-1258 | Vietnamese (Windows) | |
| 1361 | Johab | Korean (Johab) | |
| 10000 | macintosh | Western European (Mac) | |
| 10001 | x-mac-japanese | Japanese (Mac) | |
| 10002 | x-mac-chinesetrad | Chinese Traditional (Mac) | |
| 10003 | x-mac-korean | Korean (Mac) | * |
| 10004 | x-mac-arabic | Arabic (Mac) | |
| 10005 | x-mac-hebrew | Hebrew (Mac) | |
| 10006 | x-mac-greek | Greek (Mac) | |
| 10007 | x-mac-cyrillic | Cyrillic (Mac) | |
| 10008 | x-mac-chinesesimp | Chinese Simplified (Mac) | * |
| 10010 | x-mac-romanian | Romanian (Mac) | |
| 10017 | x-mac-ukrainian | Ukrainian (Mac) | |
| 10021 | x-mac-thai | Thai (Mac) | |
| 10029 | x-mac-ce | Central European (Mac) | |
| 10079 | x-mac-icelandic | Icelandic (Mac) | |
| 10081 | x-mac-turkish | Turkish (Mac) | |
| 10082 | x-mac-croatian | Croatian (Mac) | |
| 12000 | utf-32 | Unicode (UTF-32) | * |
| 12001 | utf-32BE | Unicode (UTF-32 Big endian) | * |
| 20000 | x-Chinese-CNS | Chinese Traditional (CNS) | |
| 20001 | x-cp20001 | TCA Taiwan | |
| 20002 | x-Chinese-Eten | Chinese Traditional (Eten) | |
| 20003 | x-cp20003 | IBM5550 Taiwan | |
| 20004 | x-cp20004 | TeleText Taiwan | |
| 20005 | x-cp20005 | Wang Taiwan | |
| 20105 | x-IA5 | Western European (IA5) | |
| 20106 | x-IA5-German | German (IA5) | |
| 20107 | x-IA5-Swedish | Swedish (IA5) | |
| 20108 | x-IA5-Norwegian | Norwegian (IA5) | |
| 20127 | us-ascii | US-ASCII | * |
| 20261 | x-cp20261 | T.61 | |
| 20269 | x-cp20269 | ISO-6937 | |
| 20273 | IBM273 | IBM EBCDIC (Germany) | |
| 20277 | IBM277 | IBM EBCDIC (Denmark-Norway) | |
| 20278 | IBM278 | IBM EBCDIC (Finland-Sweden) | |
| 20280 | IBM280 | IBM EBCDIC (Italy) | |
| 20284 | IBM284 | IBM EBCDIC (Spain) | |
| 20285 | IBM285 | IBM EBCDIC (UK) | |
| 20290 | IBM290 | IBM EBCDIC (Japanese katakana) | |
| 20297 | IBM297 | IBM EBCDIC (France) | |
| 20420 | IBM420 | IBM EBCDIC (Arabic) | |
| 20423 | IBM423 | IBM EBCDIC (Greek) | |
| 20424 | IBM424 | IBM EBCDIC (Hebrew) | |
| 20833 | x-EBCDIC-KoreanExtended | IBM EBCDIC (Korean Extended) | |
| 20838 | IBM-Thai | IBM EBCDIC (Thai) | |
| 20866 | koi8-r | Cyrillic (KOI8-R) | |
| 20871 | IBM871 | IBM EBCDIC (Icelandic) | |
| 20880 | IBM880 | IBM EBCDIC (Cyrillic Russian) | |
| 20905 | IBM905 | IBM EBCDIC (Turkish) | |
| 20924 | IBM00924 | IBM Latin-1 | |
| 20932 | EUC-JP | Japanese (JIS 0208-1990 and 0212-1990) | |
| 20936 | x-cp20936 | Chinese Simplified (GB2312-80) | * |
| 20949 | x-cp20949 | Korean Wansung | * |
| 21025 | cp1025 | IBM EBCDIC (Cyrillic Serbian-Bulgarian) | |
| 21866 | koi8-u | Cyrillic (KOI8-U) | |
| 28591 | iso-8859-1 | Western European (ISO) | * |
| 28592 | iso-8859-2 | Central European (ISO) | |
| 28593 | iso-8859-3 | Latin 3 (ISO) | |
| 28594 | iso-8859-4 | Baltic (ISO) | |
| 28595 | iso-8859-5 | Cyrillic (ISO) | |
| 28596 | iso-8859-6 | Arabic (ISO) | |
| 28597 | iso-8859-7 | Greek (ISO) | |
| 28598 | iso-8859-8 | Hebrew (ISO-Visual) | * |
| 28599 | iso-8859-9 | Turkish (ISO) | |
| 28603 | iso-8859-13 | Estonian (ISO) | |
| 28605 | iso-8859-15 | Latin 9 (ISO) | |
| 29001 | x-Europa | Europa | |
| 38598 | iso-8859-8-i | Hebrew (ISO-Logical) | * |
| 50220 | iso-2022-jp | Japanese (JIS) | * |
| 50221 | csISO2022JP | Japanese (JIS-Allow 1 byte Kana) | * |
| 50222 | iso-2022-jp | Japanese (JIS-Allow 1 byte Kana - SO/SI) | * |
| 50225 | iso-2022-kr | Korean (ISO) | * |
| 50227 | x-cp50227 | Chinese Simplified (ISO-2022) | * |
| 51932 | euc-jp | Japanese (EUC) | * |
| 51936 | EUC-CN | Chinese Simplified (EUC) | * |
| 51949 | euc-kr | Korean (EUC) | * |
| 52936 | hz-gb-2312 | Chinese Simplified (HZ) | * |
| 54936 | GB18030 | Chinese Simplified (GB18030) | * |
| 57002 | x-iscii-de | ISCII Devanagari | * |
| 57003 | x-iscii-be | ISCII Bengali | * |
| 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) | * |
The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. The GetBytes method expects discrete conversions, in contrast to the GetBytes method, which handles multiple conversions on a single input stream.
Several versions of GetByteCount and GetBytes are supported. The following are some programming considerations for use of these methods:
-
The application might need to encode many input characters to a code page and process the characters using multiple calls. In this case, your application probably needs to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.
-
If the application handles string inputs, it is recommended to use the string version of GetBytes.
-
The Unicode character buffer version of GetBytes allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.
-
If your application must convert a large amount of data, it should reuse the output buffer. In this case, the GetBytes version that supports byte arrays is the best choice.
-
Consider using the System.Text.Encoder.Convert method instead of GetByteCount. The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. For continuous encoding of a stream, this method is often the best choice.
The GetCharCount method determines how many characters result in decoding a sequence of bytes, and the GetChars method performs the actual decoding. The GetChars method expects discrete conversions, in contrast to the GetChars method, which handles multiple passes on a single input stream.
Several versions of GetCharCount and GetChar are supported. The following are some programming considerations for use of these methods:
-
The application might need to decode multiple input bytes from a code page and process the bytes using multiple calls. In this case, your application probably needs to maintain state between calls.
-
If the application handles string outputs, it is recommended to use the GetString method. Since this method must check string length and allocate a buffer, it is slightly slower, but the resulting String type is to be preferred.
-
The byte version of GetChar allows some fast techniques, particularly with multiple calls to large buffers. Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.
-
If your application must convert a large amount of data, it should reuse the output buffer. In this case, the GetChar version that supports output character buffers is the best choice.
-
Consider using the System.Text.Decoder.Convert method instead of GetCharCount. The conversion method converts as much data as possible and throws an exception if the output buffer is too small. For continuous decoding of a stream, this method is often the best choice.
If the data to be converted is available only in sequential blocks (such as data read from a stream) or if the amount of data is so large that it needs to be divided into smaller blocks, your application should use the Decoder or the Encoder provided by the GetDecoder method or the GetEncoder method, respectively, of a derived class.
The UTF-16 and the UTF-32 encoders can use the big endian byte order (most significant byte first) or the little endian byte order (least significant byte first). For example, the Latin Capital Letter A (U+0041) is serialized as follows (in hexadecimal):
-
UTF-16 big endian byte order: 00 41
-
UTF-16 little endian byte order: 41 00
-
UTF-32 big endian byte order: 00 00 00 41
-
UTF-32 little endian byte order: 41 00 00 00
It is generally more efficient to store Unicode characters using the native byte order. For example, it is better to use the little endian byte order on little endian platforms, such as Intel computers.
The GetPreamble method retrieves an array of bytes that includes the byte order mark (BOM). If this byte array is prefixed to an encoded stream, it helps the decoder to identify the encoding format used.
For more information on byte order and the byte order mark, see The Unicode Standard at the Unicode home page.
Note that the encoding classes allow errors to:
-
Silently change to a "?" character.
-
Use a "best fit" character.
-
Change to an application-specific behavior through use of the EncoderFallback and DecoderFallback classes with the U+FFFD Unicode replacement character.
Your applications are recommended to throw exceptions on all data stream errors. An application either uses a "throwonerror" flag when applicable or uses the EncoderExceptionFallback and DecoderExceptionFallback classes. Best fit fallback is often not recommended because it can cause data loss or confusion and is slower than simple character replacements. For ANSI encodings, the best fit behavior is the default.
The following code example converts a string from one encoding to another.
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->Item[]. 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. // This is a slightly different approach to converting to illustrate // the use of GetCharCount/GetChars. 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 ); }
package ConvertExample;
import System.*;
import System.Text.*;
class ConvertExampleClass
{
public static void main(String[] args)
{
String unicodeString =
"This string contains the unicode character Pi(\u03a0)";
// Create two different encodings.
Encoding ascii = Encoding.get_ASCII();
Encoding unicode = Encoding.get_Unicode();
// Convert the string into a byte[].
ubyte unicodeBytes[] = unicode.GetBytes(unicodeString);
// Perform the conversion from one encoding to the other.
ubyte asciiBytes[] = Encoding.Convert(unicode, ascii, unicodeBytes);
// Convert the new byte[] into a char[] and then into a string.
// This is a slightly different approach to converting to illustrate
// the use of GetCharCount/GetChars.
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);
} //main
} //ConvertExampleClass
Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.