System.Text.Encoding-klass

Klassen Encoding representerar en teckenkodning.

Kodning är processen att omvandla en uppsättning Unicode-tecken till en sekvens med byte. Avkodning är däremot processen att omvandla en sekvens med kodade byte till en uppsättning Unicode-tecken. Information om Unicode Transformation Format (UTFs) och andra kodningar som stöds av Encodingfinns i Teckenkodning i .NET.

Encoding är avsedd att användas på Unicode-tecken i stället för godtyckliga binära data, till exempel bytematriser. Om du måste koda godtyckliga binära data i text bör du använda ett protokoll som uuencode, som implementeras med metoder som Convert.ToBase64CharArray.

.NET tillhandahåller följande implementeringar av klassen Encoding för att stödja aktuella Unicode-kodningar och andra kodningar:

• ASCIIEncoding kodar Unicode-tecken som enkla 7-bitars ASCII-tecken. Den här kodningen stöder endast teckenvärden mellan U+0000 och U+007F. Kodsida 20127. Finns även tillgänglig via egenskapen ASCII.

• UTF7Encoding kodar Unicode-tecken med UTF-7-kodningen. Den här kodningen stöder alla Unicode-teckenvärden. Kodsida 65000. Finns även tillgänglig via egenskapen UTF7.

• UTF8Encoding kodar Unicode-tecken med UTF-8-kodningen. Den här kodningen stöder alla Unicode-teckenvärden. Kodsida 65001. Finns även tillgänglig via egenskapen UTF8.

• UnicodeEncoding kodar Unicode-tecken med hjälp av UTF-16-kodningen. Både små endianska och stora endianska byterekvenser stöds. Finns även tillgänglig via egenskapen Unicode och egenskapen BigEndianUnicode.

• UTF32Encoding kodar Unicode-tecken med UTF-32-kodningen. Både little endian (kodsida 12000) och big endian (kodsida 12001) byteordningar stöds. Finns även tillgänglig via egenskapen UTF32.

Klassen Encoding är främst avsedd att konvertera mellan olika kodningar och Unicode. Ofta är en av de härledda Unicode-klasserna rätt val för din app.

Använd metoden GetEncoding för att hämta andra kodningar och anropa metoden GetEncodings för att hämta en lista över alla kodningar.

Lista över kodningar

I följande tabell visas de kodningar som stöds av .NET. Den visar varje kodnings kodnings sidnummer och värdena för kodningens EncodingInfo.Name- och EncodingInfo.DisplayName egenskaper. En bockmarkering i .NET Framework-stöd, .NET Core-stödeller .NET 5 och senare stöd kolumn anger att kodsidan stöds internt av .NET-implementeringen, oavsett den underliggande plattformen. För .NET Framework beror tillgängligheten för andra kodningar som anges i tabellen på operativsystemet. För .NET Core- och .NET 5- och senare versioner är andra kodningar tillgängliga med hjälp av klassen System.Text.CodePagesEncodingProvider eller genom att härleda från klassen System.Text.EncodingProvider.

I följande exempel anropas metoderna GetEncoding(Int32) och GetEncoding(String) för att hämta kodningen för den grekiska kodsidan (Windows). Den jämför de Encoding objekt som returneras av metodanropen för att visa att de är lika och mappar visar sedan Unicode-kodpunkten och motsvarande kodsidasvärde för varje tecken i det grekiska alfabetet.

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($"{enc.EncodingName} = Code Page {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

Om data som ska konverteras endast är tillgängliga i sekventiella block (till exempel data som läses från en dataström) eller, om mängden data är så stor att den måste delas upp i mindre block, bör du använda Decoder eller Encoder som tillhandahålls av metoden GetDecoder eller GetEncoder för en härledd klass.

UTF-16- och UTF-32-kodarna kan använda den stora endianska byteordningen (mest betydande byte först) eller den lilla endianska byteordningen (minst betydande byte först). Till exempel serialiseras den latinska versala bokstaven A (U+0041) enligt följande (i hexadecimal):

• UTF-16 stor endian byteordning: 00 41
• UTF-16 lilländsk byte-ordning: 41 00
• UTF-32 stor endian byte ordning: 00 00 00 41
• UTF-32 lite endian byte ordning: 41 00 00 00

Det är vanligtvis mer effektivt att lagra Unicode-tecken med den interna byteordningen. Det är till exempel bättre att använda den lilla endianska byteordningen på små endianska plattformar, till exempel Intel-datorer.

Metoden GetPreamble hämtar en matris med byte som innehåller byteordningsmarkeringen (BOM). Om den här bytematrisen är prefix för en kodad ström hjälper den avkodaren att identifiera det kodningsformat som används.

Mer information om byteordning och byteordningsmarkering finns i Unicode Standard på Unicode-startsidan.

Observera att kodningsklasserna tillåter fel för att:

• Ändra tyst till ett "?"-tecken.
• Använd ett "bäst passande" tecken.
• Ändra till ett programspecifikt beteende med hjälp av EncoderFallback- och DecoderFallback-klasserna med U+FFFD Unicode-ersättningstecknet.

Du bör utlösa ett undantag vid uppstått dataströmsfel. En app använder antingen en "throwonerror"-flagga när det är tillämpligt eller använder klasserna EncoderExceptionFallback och DecoderExceptionFallback. Bästa möjliga återställning rekommenderas ofta inte eftersom det kan orsaka dataförlust eller förvirring och är långsammare än enkla teckenbyten. För ANSI-kodningar är det bästa anpassningsbeteendet standard.