UTF32Encoding Classe

Riferimento

Definizione

Spazio dei nomi:: System.Text

Assembly:: mscorlib.dll, System.Text.Encoding.Extensions.dll

Assembly:: System.Text.Encoding.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origine:: UTF32Encoding.cs

Origine:: UTF32Encoding.cs

Origine:: UTF32Encoding.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Rappresenta una codifica UTF-32 dei caratteri Unicode.

public ref class UTF32Encoding sealed : System::Text::Encoding

public sealed class UTF32Encoding : System.Text.Encoding

[System.Serializable]
public sealed class UTF32Encoding : System.Text.Encoding

type UTF32Encoding = class
    inherit Encoding

[<System.Serializable>]
type UTF32Encoding = class
    inherit Encoding

Public NotInheritable Class UTF32Encoding
Inherits Encoding

Ereditarietà: Object

Encoding
UTF32Encoding

Attributi: SerializableAttribute

Esempio

Nell'esempio seguente viene illustrato il comportamento degli UTF32Encoding oggetti con e senza rilevamento degli errori abilitato. Crea una matrice di byte i cui ultimi quattro byte rappresentano una coppia surrogata non valida; l'alto surrogato U+D8FF è seguito da un U+01FF, che è all'esterno dell'intervallo di surrogati bassi (0xDC00 attraverso 0xDFFF). Senza rilevamento errori, il decodificatore UTF32 usa il fallback sostitutivo per sostituire la coppia surrogata non valida con REPLACEMENT CHARACTER (U+FFFD).

using namespace System;
using namespace System::Text;
void PrintDecodedString( array<Byte>^bytes, Encoding^ enc );
int main()
{
   
   // Create an instance of UTF32Encoding using little-endian byte order.
   // This will be used for encoding.
   UTF32Encoding^ u32LE = gcnew UTF32Encoding( false,true );
   
   // Create two instances of UTF32Encoding using big-endian byte order: one with error detection and one without.
   // These will be used for decoding.
   UTF32Encoding^ u32withED = gcnew UTF32Encoding( true,true,true );
   UTF32Encoding^ u32noED = gcnew UTF32Encoding( true,true,false );
   
   // Create byte arrays from the same string containing the following characters:
   //    Latin Small Letter Z (U+007A)
   //    Latin Small Letter A (U+0061)
   //    Combining Breve (U+0306)
   //    Latin Small Letter AE With Acute (U+01FD)
   //    Greek Small Letter Beta (U+03B2)
   String^ myStr = L"za\u0306\u01FD\u03B2\xD8FF\xDCFF";
   
   // Encode the string using little-endian byte order.
   array<Byte>^myBytes = gcnew array<Byte>(u32LE->GetByteCount( myStr ));
   u32LE->GetBytes( myStr, 0, myStr->Length, myBytes, 0 );
   
   // Decode the byte array with error detection.
   Console::WriteLine( "Decoding with error detection:" );
   PrintDecodedString( myBytes, u32withED );
   
   // Decode the byte array without error detection.
   Console::WriteLine( "Decoding without error detection:" );
   PrintDecodedString( myBytes, u32noED );
}


// Decode the bytes and display the string.
void PrintDecodedString( array<Byte>^bytes, Encoding^ enc )
{
   try
   {
      Console::WriteLine( "   Decoded string: {0}", enc->GetString( bytes, 0, bytes->Length ) );
   }
   catch ( System::ArgumentException^ e ) 
   {
      Console::WriteLine( e );
   }

   Console::WriteLine();
}

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
     // Create a UTF32Encoding object with error detection enabled.
      var encExc = new UTF32Encoding(! BitConverter.IsLittleEndian, true, true);
      // Create a UTF32Encoding object with error detection disabled.
      var encRepl = new UTF32Encoding(! BitConverter.IsLittleEndian, true, false);

      // Create a byte arrays from a string, and add an invalid surrogate pair, as follows.
      //    Latin Small Letter Z (U+007A)
      //    Latin Small Letter A (U+0061)
      //    Combining Breve (U+0306)
      //    Latin Small Letter AE With Acute (U+01FD)
      //    Greek Small Letter Beta (U+03B2)
      //    a high-surrogate value (U+D8FF)
      //    an invalid low surrogate (U+01FF)
      String s = "za\u0306\u01FD\u03B2";

      // Encode the string using little-endian byte order.
      int index = encExc.GetByteCount(s);
      Byte[] bytes = new Byte[index + 4];
      encExc.GetBytes(s, 0, s.Length, bytes, 0);
      bytes[index] = 0xFF;
      bytes[index + 1] = 0xD8;
      bytes[index + 2] = 0xFF;
      bytes[index + 3] = 0x01;

      // Decode the byte array with error detection.
      Console.WriteLine("Decoding with error detection:");
      PrintDecodedString(bytes, encExc);

      // Decode the byte array without error detection.
      Console.WriteLine("Decoding without error detection:");
      PrintDecodedString(bytes, encRepl);
   }

   // Decode the bytes and display the string.
   public static void PrintDecodedString(Byte[] bytes, Encoding enc)
   {
      try {
         Console.WriteLine("   Decoded string: {0}", enc.GetString(bytes, 0, bytes.Length));
      }
      catch (DecoderFallbackException e) {
         Console.WriteLine(e.ToString());
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Decoding with error detection:
//    System.Text.DecoderFallbackException: Unable to translate bytes [FF][D8][FF][01] at index
//    20 from specified code page to Unicode.
//       at System.Text.DecoderExceptionFallbackBuffer.Throw(Byte[] bytesUnknown, Int32 index)
//       at System.Text.DecoderExceptionFallbackBuffer.Fallback(Byte[] bytesUnknown, Int32 index
//    )
//       at System.Text.DecoderFallbackBuffer.InternalFallback(Byte[] bytes, Byte* pBytes)
//       at System.Text.UTF32Encoding.GetCharCount(Byte* bytes, Int32 count, DecoderNLS baseDeco
//    der)
//       at System.Text.UTF32Encoding.GetString(Byte[] bytes, Int32 index, Int32 count)
//       at Example.PrintDecodedString(Byte[] bytes, Encoding enc)
//
//    Decoding without error detection:
//       Decoded string: zăǽβ�

Imports System.Text

Public Module Example
   Public Sub Main()
      ' Create a UTF32Encoding object with error detection enabled.
      Dim encExc As New UTF32Encoding(Not BitConverter.IsLittleEndian, True, True)
      ' Create a UTF32Encoding object with error detection disabled.
      Dim encRepl As New UTF32Encoding(Not BitConverter.IsLittleEndian, True, False)

      ' Create a byte arrays from a string, and add an invalid surrogate pair, as follows.
      '    Latin Small Letter Z (U+007A)
      '    Latin Small Letter A (U+0061)
      '    Combining Breve (U+0306)
      '    Latin Small Letter AE With Acute (U+01FD)
      '    Greek Small Letter Beta (U+03B2)
      '    a high-surrogate value (U+D8FF)
      '    an invalid low surrogate (U+01FF)
      Dim s As String = "za" & ChrW(&H0306) & ChrW(&H01FD) & ChrW(&H03B2)

      ' Encode the string using little-endian byte order.
      Dim index As Integer = encExc.GetBytecount(s)
      Dim bytes(index + 3) As Byte
      encExc.GetBytes(s, 0, s.Length, bytes, 0)
      bytes(index) = &hFF
      bytes(index + 1) = &hD8
      bytes(index + 2) = &hFF
      bytes(index + 3) = &h01

      ' Decode the byte array with error detection.
      Console.WriteLine("Decoding with error detection:")
      PrintDecodedString(bytes, encExc)

      ' Decode the byte array without error detection.
      Console.WriteLine("Decoding without error detection:")
      PrintDecodedString(bytes, encRepl)
   End Sub

   ' Decode the bytes and display the string.
   Public Sub PrintDecodedString(bytes() As Byte, enc As Encoding)
      Try
         Console.WriteLine("   Decoded string: {0}", enc.GetString(bytes, 0, bytes.Length))
      Catch e As DecoderFallbackException
         Console.WriteLine(e.ToString())
      End Try
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Decoding with error detection:
'    System.Text.DecoderFallbackException: Unable to translate bytes [FF][D8][FF][01] at index
'    20 from specified code page to Unicode.
'       at System.Text.DecoderExceptionFallbackBuffer.Throw(Byte[] bytesUnknown, Int32 index)
'       at System.Text.DecoderExceptionFallbackBuffer.Fallback(Byte[] bytesUnknown, Int32 index
'    )
'       at System.Text.DecoderFallbackBuffer.InternalFallback(Byte[] bytes, Byte* pBytes)
'       at System.Text.UTF32Encoding.GetCharCount(Byte* bytes, Int32 count, DecoderNLS baseDeco
'    der)
'       at System.Text.UTF32Encoding.GetString(Byte[] bytes, Int32 index, Int32 count)
'       at Example.PrintDecodedString(Byte[] bytes, Encoding enc)
'
'    Decoding without error detection:
'       Decoded string: zăǽβ�

Nell'esempio seguente viene codificata una stringa di caratteri Unicode in una matrice di byte usando un UTF32Encoding oggetto . La matrice di byte viene quindi decodificata in una stringa per dimostrare che non esiste alcuna perdita di dati.

using System;
using System.Text;

public class Example
{
    public static void Main()
    {
        // The encoding.
        var enc = new UTF32Encoding();
        
        // Create a string.
        String s = "This string contains two characters " +
                   "with codes outside the ASCII code range: " +
                   "Pi (\u03A0) and Sigma (\u03A3).";
        Console.WriteLine("Original string:");
        Console.WriteLine("   {0}", s);
        
        // Encode the string.
        Byte[] encodedBytes = enc.GetBytes(s);
        Console.WriteLine();
        Console.WriteLine("Encoded bytes:");
        for (int ctr = 0; ctr < encodedBytes.Length; ctr++) {
            Console.Write("[{0:X2}]{1}", encodedBytes[ctr],
                                         (ctr + 1) % 4 == 0 ? " " : "" );
            if ((ctr + 1) % 16 == 0) Console.WriteLine();
        }
        Console.WriteLine();
        
        // Decode bytes back to string.
        // Notice Pi and Sigma characters are still present.
        String decodedString = enc.GetString(encodedBytes);
        Console.WriteLine();
        Console.WriteLine("Decoded string:");
        Console.WriteLine("   {0}", decodedString);
    }
}
// The example displays the following output:
//    Original string:
//       This string contains two characters with codes outside the ASCII code range:
//    Pi (π) and Sigma (Σ).
//
//    Encoded bytes:
//    [54][00][00][00] [68][00][00][00] [69][00][00][00] [73][00][00][00]
//    [20][00][00][00] [73][00][00][00] [74][00][00][00] [72][00][00][00]
//    [69][00][00][00] [6E][00][00][00] [67][00][00][00] [20][00][00][00]
//    [63][00][00][00] [6F][00][00][00] [6E][00][00][00] [74][00][00][00]
//    [61][00][00][00] [69][00][00][00] [6E][00][00][00] [73][00][00][00]
//    [20][00][00][00] [74][00][00][00] [77][00][00][00] [6F][00][00][00]
//    [20][00][00][00] [63][00][00][00] [68][00][00][00] [61][00][00][00]
//    [72][00][00][00] [61][00][00][00] [63][00][00][00] [74][00][00][00]
//    [65][00][00][00] [72][00][00][00] [73][00][00][00] [20][00][00][00]
//    [77][00][00][00] [69][00][00][00] [74][00][00][00] [68][00][00][00]
//    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
//    [65][00][00][00] [73][00][00][00] [20][00][00][00] [6F][00][00][00]
//    [75][00][00][00] [74][00][00][00] [73][00][00][00] [69][00][00][00]
//    [64][00][00][00] [65][00][00][00] [20][00][00][00] [74][00][00][00]
//    [68][00][00][00] [65][00][00][00] [20][00][00][00] [41][00][00][00]
//    [53][00][00][00] [43][00][00][00] [49][00][00][00] [49][00][00][00]
//    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
//    [65][00][00][00] [20][00][00][00] [72][00][00][00] [61][00][00][00]
//    [6E][00][00][00] [67][00][00][00] [65][00][00][00] [3A][00][00][00]
//    [20][00][00][00] [50][00][00][00] [69][00][00][00] [20][00][00][00]
//    [28][00][00][00] [A0][03][00][00] [29][00][00][00] [20][00][00][00]
//    [61][00][00][00] [6E][00][00][00] [64][00][00][00] [20][00][00][00]
//    [53][00][00][00] [69][00][00][00] [67][00][00][00] [6D][00][00][00]
//    [61][00][00][00] [20][00][00][00] [28][00][00][00] [A3][03][00][00]
//    [29][00][00][00] [2E][00][00][00]
//
//    Decoded string:
//       This string contains two characters with codes outside the ASCII code range:
//    Pi (π) and Sigma (Σ).

Imports System.Text

Class Example
    Public Shared Sub Main()
        ' The encoding.
        Dim enc As New UTF32Encoding()
        
        ' Create a string.
        Dim s As String =
            "This string contains two characters " &
            "with codes outside the ASCII code range: " &
            "Pi (" & ChrW(&h03A0) & ") and Sigma (" & ChrW(&h03A3) & ")."
        Console.WriteLine("Original string:")
        Console.WriteLine("   {0}", s)
        
        ' Encode the string.
        Dim encodedBytes As Byte() = enc.GetBytes(s)
        Console.WriteLine()
        Console.WriteLine("Encoded bytes:")
        For ctr As Integer = 0 To encodedBytes.Length - 1
            Console.Write("[{0:X2}]{1}", encodedBytes(ctr),
                                         If((ctr + 1) Mod 4 = 0, " ", "" ))
            If (ctr + 1) Mod 16 = 0 Then Console.WriteLine()
        Next
        Console.WriteLine()
        
        ' Decode bytes back to string.
        ' Notice Pi and Sigma characters are still present.
        Dim decodedString As String = enc.GetString(encodedBytes)
        Console.WriteLine()
        Console.WriteLine("Decoded string:")
        Console.WriteLine("   {0}", decodedString)
    End Sub
End Class
' The example displays the following output:
'    Original string:
'       This string contains two characters with codes outside the ASCII code range:
'    Pi (π) and Sigma (Σ).
'
'    Encoded bytes:
'    [54][00][00][00] [68][00][00][00] [69][00][00][00] [73][00][00][00]
'    [20][00][00][00] [73][00][00][00] [74][00][00][00] [72][00][00][00]
'    [69][00][00][00] [6E][00][00][00] [67][00][00][00] [20][00][00][00]
'    [63][00][00][00] [6F][00][00][00] [6E][00][00][00] [74][00][00][00]
'    [61][00][00][00] [69][00][00][00] [6E][00][00][00] [73][00][00][00]
'    [20][00][00][00] [74][00][00][00] [77][00][00][00] [6F][00][00][00]
'    [20][00][00][00] [63][00][00][00] [68][00][00][00] [61][00][00][00]
'    [72][00][00][00] [61][00][00][00] [63][00][00][00] [74][00][00][00]
'    [65][00][00][00] [72][00][00][00] [73][00][00][00] [20][00][00][00]
'    [77][00][00][00] [69][00][00][00] [74][00][00][00] [68][00][00][00]
'    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
'    [65][00][00][00] [73][00][00][00] [20][00][00][00] [6F][00][00][00]
'    [75][00][00][00] [74][00][00][00] [73][00][00][00] [69][00][00][00]
'    [64][00][00][00] [65][00][00][00] [20][00][00][00] [74][00][00][00]
'    [68][00][00][00] [65][00][00][00] [20][00][00][00] [41][00][00][00]
'    [53][00][00][00] [43][00][00][00] [49][00][00][00] [49][00][00][00]
'    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
'    [65][00][00][00] [20][00][00][00] [72][00][00][00] [61][00][00][00]
'    [6E][00][00][00] [67][00][00][00] [65][00][00][00] [3A][00][00][00]
'    [20][00][00][00] [50][00][00][00] [69][00][00][00] [20][00][00][00]
'    [28][00][00][00] [A0][03][00][00] [29][00][00][00] [20][00][00][00]
'    [61][00][00][00] [6E][00][00][00] [64][00][00][00] [20][00][00][00]
'    [53][00][00][00] [69][00][00][00] [67][00][00][00] [6D][00][00][00]
'    [61][00][00][00] [20][00][00][00] [28][00][00][00] [A3][03][00][00]
'    [29][00][00][00] [2E][00][00][00]
'
'    Decoded string:
'       This string contains two characters with codes outside the ASCII code range:
'    Pi (π) and Sigma (Σ).

Nell'esempio seguente viene usata la stessa stringa della precedente, ad eccezione del fatto che scrive i byte codificati in un file e prefissi il flusso di byte con un contrassegno di ordine byte (BOM). Legge quindi il file in due modi diversi: come file di testo usando un StreamReader oggetto e come file binario. Come si prevede, nessuna stringa di nuova lettura include la BOM.

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

public class Example
{
    public static void Main()
    {
        // Create a UTF-32 encoding that supports a BOM.
        var enc = new UTF32Encoding();
        
        // A Unicode string with two characters outside an 8-bit code range.
        String s = "This Unicode string has 2 characters " +
                   "outside the ASCII range: \n" +
                   "Pi (\u03A0), and Sigma (\u03A3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(s);
        Console.WriteLine();
        
        // Encode the string.
        Byte[] encodedBytes = enc.GetBytes(s);
        Console.WriteLine("The encoded string has {0} bytes.\n",
                          encodedBytes.Length);

        // Write the bytes to a file with a BOM.
        var fs = new FileStream(@".\UTF32Encoding.txt", FileMode.Create);
        Byte[] bom = enc.GetPreamble();
        fs.Write(bom, 0, bom.Length);
        fs.Write(encodedBytes, 0, encodedBytes.Length);
        Console.WriteLine("Wrote {0} bytes to the file.\n", fs.Length);
        fs.Close();

        // Open the file using StreamReader.
        var sr = new StreamReader(@".\UTF32Encoding.txt");
        String newString = sr.ReadToEnd();
        sr.Close();
        Console.WriteLine("String read using StreamReader:");
        Console.WriteLine(newString);
        Console.WriteLine();
        
        // Open the file as a binary file and decode the bytes back to a string.
        fs = new FileStream(@".\Utf32Encoding.txt", FileMode.Open);
        Byte[] bytes = new Byte[fs.Length];
        fs.Read(bytes, 0, (int)fs.Length);
        fs.Close();

        String decodedString = enc.GetString(bytes);
        Console.WriteLine("Decoded bytes from binary file:");
        Console.WriteLine(decodedString);
    }
}
// The example displays the following output:
//    Original string:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    The encoded string has 340 bytes.
//
//    Wrote 344 bytes to the file.
//
//    String read using StreamReader:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    Decoded bytes from binary file:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).

Imports System.IO
Imports System.Text

Class Example
    Public Shared Sub Main()
        ' Create a UTF-32 encoding that supports a BOM.
        Dim enc As New UTF32Encoding()
        
        ' A Unicode string with two characters outside an 8-bit code range.
        Dim s As String = _
            "This Unicode string has 2 characters outside the " &
            "ASCII range: " & vbCrLf &
            "Pi (" & ChrW(&h03A0) & "), and Sigma (" & ChrW(&h03A3) & ")."
        Console.WriteLine("Original string:")
        Console.WriteLine(s)
        Console.WriteLine()
        
        ' Encode the string.
        Dim encodedBytes As Byte() = enc.GetBytes(s)
        Console.WriteLine("The encoded string has {0} bytes.",
                          encodedBytes.Length)
        Console.WriteLine()
        
        ' Write the bytes to a file with a BOM.
        Dim fs As New FileStream(".\UTF32Encoding.txt", FileMode.Create)
        Dim bom() As Byte = enc.GetPreamble()
        fs.Write(bom, 0, bom.Length)
        fs.Write(encodedBytes, 0, encodedBytes.Length)
        Console.WriteLine("Wrote {0} bytes to the file.", fs.Length)
        fs.Close()
        Console.WriteLine()
        
        ' Open the file using StreamReader.
        Dim sr As New StreamReader(".\UTF32Encoding.txt")
        Dim newString As String = sr.ReadToEnd()
        sr.Close()
        Console.WriteLine("String read using StreamReader:")
        Console.WriteLine(newString)
        Console.WriteLine()
        
        ' Open the file as a binary file and decode the bytes back to a string.
        fs = new FileStream(".\Utf32Encoding.txt", FileMode.Open)
        Dim bytes(fs.Length - 1) As Byte
        fs.Read(bytes, 0, fs.Length)
        fs.Close()

        Dim decodedString As String = enc.GetString(bytes)
        Console.WriteLine("Decoded bytes from binary file:")
        Console.WriteLine(decodedString)
    End Sub
End Class
' The example displays the following output:
'    Original string:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    The encoded string has 344 bytes.
'
'    Wrote 348 bytes to the file.
'
'    String read using StreamReader:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    Decoded bytes from binary file:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).

Commenti

La codifica è il processo di trasformazione di un insieme di caratteri Unicode in una sequenza di byte. Decodifica è il processo di trasformazione di una sequenza di byte codificati in un set di caratteri Unicode.

Unicode Standard assegna un punto di codice (un numero) a ogni carattere in ogni script supportato. Un formato di trasformazione Unicode (UTF) è un modo per codificare tale punto di codice. Unicode Standard usa le UTF seguenti:

UTF-8, che rappresenta ogni punto di codice come sequenza di uno a quattro byte.
UTF-16, che rappresenta ogni punto di codice come sequenza di uno a due interi a 16 bit.
UTF-32, che rappresenta ogni punto di codice come intero a 32 bit.

Per altre informazioni sulle UTFs e altre codifica supportate da System.Text, vedere Codifica dei caratteri in .NET.

La UTF32Encoding classe rappresenta una codifica UTF-32. Il codificatore può usare l'ordine di byte big endian (primo byte significativo) o l'ordine di byte endian piccolo (primo byte minimo significativo). Ad esempio, la lettera maiuscola latina A (punto di codice U+0041) viene serializzata come segue (in esadecimale):

Ordine byte big endian: 00 00 00 41
Ordine dei byte little endian: 41 00 00 00

È in genere più efficiente archiviare i caratteri Unicode usando l'ordine dei byte nativi. Ad esempio, è preferibile usare l'ordine dei byte little endian sulle piattaforme little endian, ad esempio i computer Intel. UTF32Encoding corrisponde alle tabelle codici di Windows 12000 (ordine byte little endian) e 12001 (ordine di byte big endian). È possibile determinare la "endianness" di una particolare architettura chiamando il BitConverter.IsLittleEndian metodo .

Facoltativamente, l'oggetto UTF32Encoding fornisce un byte order mark (BOM), ovvero una matrice di byte che può essere preceduta dalla sequenza di byte risultante dal processo di codifica. Se il preambolo contiene un indicatore di ordine byte (BOM), consente al decodificatore di determinare l'ordine dei byte e il formato di trasformazione o UTF di una matrice di byte.

Se l'istanza UTF32Encoding è configurata per fornire un BOM, è possibile recuperarla chiamando il GetPreamble metodo ; in caso contrario, il metodo restituisce una matrice vuota. Si noti che, anche se un UTF32Encoding oggetto è configurato per il supporto bom, è necessario includere l'BOM all'inizio del flusso di byte codificato in base alle esigenze. I metodi di codifica della UTF32Encoding classe non eseguono questa operazione automaticamente.

Attenzione

Per abilitare il rilevamento degli errori e rendere più sicura l'istanza della classe, è necessario creare un'istanza di un UTF32Encoding oggetto chiamando il costruttore e impostandone throwOnInvalidBytes l'argomento UTF32Encoding(Boolean, Boolean, Boolean) su true. Con il rilevamento degli errori, un metodo che rileva una sequenza di caratteri o byte non valida genera un'eccezione ArgumentException . Senza il rilevamento degli errori, non viene generata alcuna eccezione e la sequenza non valida viene in genere ignorata.

È possibile creare un'istanza di un UTF32Encoding oggetto in diversi modi, a seconda che si voglia specificare un indicatore di ordine di byte (BOM), indipendentemente dal fatto che si voglia eseguire la codifica big-endian o little-endian e se si desidera abilitare il rilevamento degli errori. Nella tabella seguente sono elencati i UTF32Encoding costruttori e le Encoding proprietà che restituiscono un UnicodeEncoding oggetto .

Membro	Ordine dei byte	BOM	Rilevamento dell'errore
Encoding.UTF32	Little-endian	Sì	No (fallback di sostituzione)
UTF32Encoding.UTF32Encoding()	Little-endian	Sì	No (fallback di sostituzione)
UTF32Encoding.UTF32Encoding(Boolean, Boolean)	Configurabile	Configurabile	No (fallback di sostituzione)
UTF32Encoding.UTF32Encoding(Boolean, Boolean, Boolean)	Configurabile	Configurabile	Configurabile

Il GetByteCount metodo determina il numero di byte che comportano la codifica di un set di caratteri Unicode e il GetBytes metodo esegue la codifica effettiva.

Analogamente, il GetCharCount metodo determina il numero di caratteri che determinano la decodifica di una sequenza di byte e i GetChars metodi e GetString eseguono la decodifica effettiva.

Per un codificatore o un decodificatore in grado di salvare le informazioni sullo stato durante la codifica o la decodifica di dati che si estendono su più blocchi ,ad esempio una stringa di 1 milione di caratteri codificati in segmenti di 100.000 caratteri, usare rispettivamente le GetEncoder proprietà e GetDecoder .

Costruttori

UTF32Encoding()	Inizializza una nuova istanza della classe UTF32Encoding.
UTF32Encoding(Boolean, Boolean)	Inizializza una nuova istanza della classe UTF32Encoding. I parametri specificano se usare l'ordine dei byte big-endian e se il metodo GetPreamble() restituisce un byte order mark Unicode.
UTF32Encoding(Boolean, Boolean, Boolean)	Inizializza una nuova istanza della classe UTF32Encoding. I parametri specificano se usare l'ordine dei byte big-endian, se fornire un byte order mark Unicode e se generare un'eccezione quando viene rilevata una codifica non valida.

Proprietà

BodyName	Quando ne viene eseguito l'override in una classe derivata, ottiene un nome per la codifica corrente che può essere usato con i tag body degli agenti di posta. (Ereditato da Encoding)
CodePage	Quando ne viene eseguito l'override in una classe derivata, ottiene l'identificatore della tabella codici dell'oggetto Encoding corrente. (Ereditato da Encoding)
DecoderFallback	Ottiene o imposta l'oggetto DecoderFallback per l'oggetto Encoding corrente. (Ereditato da Encoding)
EncoderFallback	Ottiene o imposta l'oggetto EncoderFallback per l'oggetto Encoding corrente. (Ereditato da Encoding)
EncodingName	Quando ne viene eseguito l'override in una classe derivata, ottiene la descrizione leggibile della codifica corrente. (Ereditato da Encoding)
HeaderName	Quando ne viene eseguito l'override in una classe derivata, ottiene un nome per la codifica corrente che può essere usato con i tag di intestazione degli agenti di posta. (Ereditato da Encoding)
IsBrowserDisplay	Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se la codifica corrente può essere usata dai browser client per visualizzare il contenuto. (Ereditato da Encoding)
IsBrowserSave	Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se la codifica corrente può essere usata dai browser client per salvare il contenuto. (Ereditato da Encoding)
IsMailNewsDisplay	Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se la codifica corrente può essere usata dai client di posta e dai client delle news per visualizzare il contenuto. (Ereditato da Encoding)
IsMailNewsSave	Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se la codifica corrente può essere usata dai client di posta e dai client delle news per salvare il contenuto. (Ereditato da Encoding)
IsReadOnly	Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se la codifica corrente è di sola lettura. (Ereditato da Encoding)
IsSingleByte	Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se la codifica corrente usa punti di codice a un byte. (Ereditato da Encoding)
Preamble	Ottiene un byte order mark Unicode codificato in formato UTF-32, se questo oggetto è configurato per fornirne uno.
Preamble	Quando ne viene eseguito l'override in una classe derivata, restituisce un intervallo contenente la sequenza di byte che specifica la codifica usata. (Ereditato da Encoding)
WebName	Quando ne viene eseguito l'override in una classe derivata, ottiene il nome registrato con IANA (Internet Assigned Numbers Authority) per la codifica corrente. (Ereditato da Encoding)
WindowsCodePage	Quando ne viene eseguito l'override in una classe derivata, ottiene la tabella codici del sistema operativo Windows che meglio corrisponde alla codifica corrente. (Ereditato da Encoding)

Metodi

Clone()	Quando ne viene eseguito l'override in una classe derivata, crea una copia superficiale dell'oggetto Encoding corrente. (Ereditato da Encoding)
Equals(Object)	Determina se l'oggetto Object specificato è uguale all'oggetto UTF32Encoding corrente.
GetByteCount(Char*, Int32)	Calcola il numero di byte prodotti dalla codifica di un set di caratteri a partire dal puntatore ai caratteri specificato.
GetByteCount(Char[])	Quando ne viene eseguito l'override in una classe derivata, calcola il numero di byte prodotti dalla codifica di tutti i caratteri nella matrice di caratteri specificata. (Ereditato da Encoding)
GetByteCount(Char[], Int32, Int32)	Calcola il numero di byte prodotti dalla codifica di un set di caratteri dalla matrice di caratteri specificata.
GetByteCount(ReadOnlySpan<Char>)	Quando ne viene eseguito l'override in una classe derivata, calcola il numero di byte prodotti dalla codifica dei caratteri nell'intervallo di caratteri specificato. (Ereditato da Encoding)
GetByteCount(String)	Calcola il numero di byte prodotti dalla codifica dei caratteri nell'oggetto String specificato.
GetByteCount(String, Int32, Int32)	Quando ne viene eseguito l'override in una classe derivata, calcola il numero di byte prodotti dalla codifica di un set di caratteri dalla stringa specificata. (Ereditato da Encoding)
GetBytes(Char, Int32, Byte, Int32)	Codifica un set di caratteri a partire dal puntatore ai caratteri specificato in una sequenza di byte archiviati a partire dal puntatore ai byte specificato.
GetBytes(Char[])	Quando ne viene eseguito l'override in una classe derivata, codifica tutti i caratteri nella matrice di caratteri specificata in una sequenza di byte. (Ereditato da Encoding)
GetBytes(Char[], Int32, Int32)	Quando ne viene eseguito l'override in una classe derivata, codifica un set di caratteri dalla matrice di caratteri specificata in una sequenza di byte. (Ereditato da Encoding)
GetBytes(Char[], Int32, Int32, Byte[], Int32)	Codifica un set di caratteri dalla matrice di caratteri specificata nella matrice di byte specificata.
GetBytes(ReadOnlySpan<Char>, Span<Byte>)	Quando ne viene eseguito l'override in una classe derivata, codifica un set di caratteri dall'intervallo di sola lettura specificato in un intervallo di byte. (Ereditato da Encoding)
GetBytes(String)	Quando ne viene eseguito l'override in una classe derivata, codifica tutti i caratteri nella stringa specificata in una sequenza di byte. (Ereditato da Encoding)
GetBytes(String, Int32, Int32)	Quando ne viene eseguito l'override in una classe derivata, codifica in una matrice di byte il numero di caratteri specificato da `count` nella stringa specificata, a partire dal valore di `index` specificato. (Ereditato da Encoding)
GetBytes(String, Int32, Int32, Byte[], Int32)	Codifica un set di caratteri dall'oggetto String specificato nella matrice di byte specificata.
GetCharCount(Byte*, Int32)	Calcola il numero di caratteri prodotti dalla decodifica di una sequenza di byte a partire dal puntatore ai byte specificato.
GetCharCount(Byte[])	Quando ne viene eseguito l'override in una classe derivata, calcola il numero di caratteri prodotti dalla decodifica di tutti i byte nella matrice di byte specificata. (Ereditato da Encoding)
GetCharCount(Byte[], Int32, Int32)	Calcola il numero di caratteri prodotti dalla decodifica di una sequenza di byte dalla matrice di byte specificata.
GetCharCount(ReadOnlySpan<Byte>)	Quando ne viene eseguito l'override in una classe derivata, calcola il numero di caratteri prodotti dalla decodifica dell'intervallo di byte di sola lettura specificato. (Ereditato da Encoding)
GetChars(Byte, Int32, Char, Int32)	Decodifica una sequenza di byte a partire dal puntatore ai byte specificato in un set di caratteri archiviati a partire dal puntatore ai caratteri specificato.
GetChars(Byte[])	Quando ne viene eseguito l'override in una classe derivata, decodifica tutti i byte nella matrice di byte specificata in un set di caratteri. (Ereditato da Encoding)
GetChars(Byte[], Int32, Int32)	Quando ne viene eseguito l'override in una classe derivata, decodifica una sequenza di byte dalla matrice di byte specificata in un set di caratteri. (Ereditato da Encoding)
GetChars(Byte[], Int32, Int32, Char[], Int32)	Decodifica una sequenza di byte dalla matrice di byte specificata nella matrice di caratteri specificata.
GetChars(ReadOnlySpan<Byte>, Span<Char>)	Quando ne viene eseguito l'override in una classe derivata, decodifica tutti i byte nell'intervallo di byte di sola lettura specificato in un intervallo di caratteri. (Ereditato da Encoding)
GetDecoder()	Ottiene un decodificatore in grado di convertire una sequenza di byte codificati UTF-32 in una sequenza di caratteri Unicode.
GetEncoder()	Ottiene un codificatore in grado di convertire una sequenza di caratteri Unicode in una sequenza di byte codificati UTF-32.
GetHashCode()	Restituisce il codice hash per l'istanza corrente.
GetMaxByteCount(Int32)	Calcola il numero massimo di byte prodotti dalla codifica del numero di caratteri specificato.
GetMaxCharCount(Int32)	Calcola il numero massimo di caratteri prodotti dalla decodifica del numero di byte specificato.
GetPreamble()	Restituisce un byte order mark Unicode codificato in formato UTF-32, se l'oggetto di codifica UTF32Encoding è configurato per fornirne uno.
GetString(Byte*, Int32)	Quando ne viene eseguito l'override in una classe derivata, decodifica un numero di byte specificato partendo da un indirizzo specificato in una stringa. (Ereditato da Encoding)
GetString(Byte[])	Quando ne viene eseguito l'override in una classe derivata, decodifica tutti i byte nella matrice di byte specificata in una stringa. (Ereditato da Encoding)
GetString(Byte[], Int32, Int32)	Decodifica un intervallo di byte da una matrice di byte in una stringa.
GetString(ReadOnlySpan<Byte>)	Quando ne viene eseguito l'override in una classe derivata, decodifica tutti i byte nell'intervallo di byte specificato in una stringa. (Ereditato da Encoding)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
IsAlwaysNormalized()	Ottiene un valore che indica se la codifica corrente è sempre normalizzata, usando il formato di normalizzazione predefinito. (Ereditato da Encoding)
IsAlwaysNormalized(NormalizationForm)	Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se la codifica corrente viene sempre normalizzata, usando il formato di normalizzazione specificato. (Ereditato da Encoding)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
TryGetBytes(ReadOnlySpan<Char>, Span<Byte>, Int32)	Codifica in un intervallo di byte un set di caratteri dall'intervallo di sola lettura specificato se la destinazione è sufficiente. (Ereditato da Encoding)
TryGetChars(ReadOnlySpan<Byte>, Span<Char>, Int32)	Decodifica in un intervallo di caratteri un set di byte dall'intervallo di sola lettura specificato se la destinazione è abbastanza grande. (Ereditato da Encoding)

Metodi di estensione

GetBytes(Encoding, ReadOnlySequence<Char>)	Codifica l'oggetto ReadOnlySequence<T> specificato in una matrice Byte usando l'oggetto Encoding specificato.
GetBytes(Encoding, ReadOnlySequence<Char>, IBufferWriter<Byte>)	Decodifica l'oggetto ReadOnlySequence<T> specificato in `byte` usando l'oggetto Encoding specificato e scrive il risultato in `writer`.
GetBytes(Encoding, ReadOnlySequence<Char>, Span<Byte>)	Codifica l'oggetto ReadOnlySequence<T> specificato in `byte` usando l'oggetto Encoding specificato e visualizza il risultato in `bytes`.
GetBytes(Encoding, ReadOnlySpan<Char>, IBufferWriter<Byte>)	Codifica l'oggetto ReadOnlySpan<T> specificato in `byte` usando l'oggetto Encoding specificato e scrive il risultato in `writer`.
GetChars(Encoding, ReadOnlySequence<Byte>, IBufferWriter<Char>)	Decodifica l'oggetto ReadOnlySequence<T> specificato in `char` usando l'oggetto Encoding specificato e scrive il risultato in `writer`.
GetChars(Encoding, ReadOnlySequence<Byte>, Span<Char>)	Decodifica l'oggetto ReadOnlySequence<T> specificato in `char` usando l'oggetto Encoding specificato e visualizza il risultato in `chars`.
GetChars(Encoding, ReadOnlySpan<Byte>, IBufferWriter<Char>)	Decodifica l'oggetto ReadOnlySpan<T> specificato in `char` usando l'oggetto Encoding specificato e scrive il risultato in `writer`.
GetString(Encoding, ReadOnlySequence<Byte>)	Decodifica l'oggetto ReadOnlySequence<T> specificato in una String usando l'oggetto Encoding specificato.

Si applica a

Condividi tramite