UTF8Encoding Classe

Definizione

Rappresenta una codifica UTF-8 dei caratteri Unicode.

public ref class UTF8Encoding : System::Text::Encoding
public class UTF8Encoding : System.Text.Encoding
[System.Serializable]
public class UTF8Encoding : System.Text.Encoding
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class UTF8Encoding : System.Text.Encoding
type UTF8Encoding = class
    inherit Encoding
[<System.Serializable>]
type UTF8Encoding = class
    inherit Encoding
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type UTF8Encoding = class
    inherit Encoding
Public Class UTF8Encoding
Inherits Encoding
Ereditarietà
UTF8Encoding
Attributi

Esempio

Nell'esempio seguente viene usato un UTF8Encoding oggetto per codificare una stringa di caratteri Unicode e archiviarli in una matrice di byte. La stringa Unicode include due caratteri, Pi (U+03A0) e Sigma (U+03A3), esterni all'intervallo di caratteri ASCII. Quando la matrice di byte codificata viene decodificata in una stringa, i caratteri Pi e Sigma sono ancora presenti.

using namespace System;
using namespace System::Text;
//using namespace System::Collections;

int main()
{
   // Create a UTF-8 encoding.
   UTF8Encoding^ utf8 = gcnew UTF8Encoding;
   
   // A Unicode string with two characters outside an 8-bit code range.
   String^ unicodeString = L"This Unicode string has 2 characters " +
                           L"outside the ASCII range:\n" +
                           L"Pi (\u03a0), and Sigma (\u03a3).";
   Console::WriteLine("Original string:");
   Console::WriteLine(unicodeString);
   
   // Encode the string.
   array<Byte>^ encodedBytes = utf8->GetBytes(unicodeString );
   Console::WriteLine();
   Console::WriteLine("Encoded bytes:");
   for (int ctr = 0; ctr < encodedBytes->Length; ctr++) {
      Console::Write( "{0:X2} ", encodedBytes[ctr]);
      if ((ctr + 1) % 25 == 0)
         Console::WriteLine();
   }

   Console::WriteLine();
   
   // Decode bytes back to string.
   String^ decodedString = utf8->GetString(encodedBytes);
   Console::WriteLine();
   Console::WriteLine("Decoded bytes:");
   Console::WriteLine(decodedString);
}
// The example displays the following output:
//    Original string:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    Encoded bytes:
//    54 68 69 73 20 55 6E 69 63 6F 64 65 20 73 74 72 69 6E 67 20 68 61 73 20 32
//    20 63 68 61 72 61 63 74 65 72 73 20 6F 75 74 73 69 64 65 20 74 68 65 20 41
//    53 43 49 49 20 72 61 6E 67 65 3A 20 0D 0A 50 69 20 28 CE A0 29 2C 20 61 6E
//    64 20 53 69 67 6D 61 20 28 CE A3 29 2E
//
//    Decoded bytes:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
using System;
using System.Text;

class Example
{
    public static void Main()
    {
        // Create a UTF-8 encoding.
        UTF8Encoding utf8 = new UTF8Encoding();
        
        // A Unicode string with two characters outside an 8-bit code range.
        String unicodeString =
            "This Unicode string has 2 characters outside the " +
            "ASCII range:\n" +
            "Pi (\u03a0), and Sigma (\u03a3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(unicodeString);

        // Encode the string.
        Byte[] encodedBytes = utf8.GetBytes(unicodeString);
        Console.WriteLine();
        Console.WriteLine("Encoded bytes:");
        for (int ctr = 0; ctr < encodedBytes.Length; ctr++) {
            Console.Write("{0:X2} ", encodedBytes[ctr]);
            if ((ctr + 1) %  25 == 0)
               Console.WriteLine();
        }
        Console.WriteLine();
        
        // Decode bytes back to string.
        String decodedString = utf8.GetString(encodedBytes);
        Console.WriteLine();
        Console.WriteLine("Decoded bytes:");
        Console.WriteLine(decodedString);
    }
}
// The example displays the following output:
//    Original string:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    Encoded bytes:
//    54 68 69 73 20 55 6E 69 63 6F 64 65 20 73 74 72 69 6E 67 20 68 61 73 20 32
//    20 63 68 61 72 61 63 74 65 72 73 20 6F 75 74 73 69 64 65 20 74 68 65 20 41
//    53 43 49 49 20 72 61 6E 67 65 3A 20 0D 0A 50 69 20 28 CE A0 29 2C 20 61 6E
//    64 20 53 69 67 6D 61 20 28 CE A3 29 2E
//
//    Decoded bytes:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
Imports System.Text

Class Example
    Public Shared Sub Main()
        ' Create a UTF-8 encoding.
        Dim utf8 As New UTF8Encoding()
        
        ' A Unicode string with two characters outside an 8-bit code range.
        Dim unicodeString 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(unicodeString)
        
        ' Encode the string.
        Dim encodedBytes As Byte() = utf8.GetBytes(unicodeString)
        Console.WriteLine()
        Console.WriteLine("Encoded bytes:")
        For ctr As Integer = 0 To encodedBytes.Length - 1
            Console.Write("{0:X2} ", encodedBytes(ctr))
            If (ctr + 1) Mod 25 = 0 Then Console.WriteLine
        Next
        Console.WriteLine()
        
        ' Decode bytes back to string.
        Dim decodedString As String = utf8.GetString(encodedBytes)
        Console.WriteLine()
        Console.WriteLine("Decoded bytes:")
        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 (Σ).
'
'    Encoded bytes:
'    54 68 69 73 20 55 6E 69 63 6F 64 65 20 73 74 72 69 6E 67 20 68 61 73 20 32
'    20 63 68 61 72 61 63 74 65 72 73 20 6F 75 74 73 69 64 65 20 74 68 65 20 41
'    53 43 49 49 20 72 61 6E 67 65 3A 20 0D 0A 50 69 20 28 CE A0 29 2C 20 61 6E
'    64 20 53 69 67 6D 61 20 28 CE A3 29 2E
'
'    Decoded bytes:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).

Nell'esempio seguente viene usata la stessa stringa dell'esempio 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-8 encoding that supports a BOM.
        Encoding utf8 = new UTF8Encoding(true);

        // A Unicode string with two characters outside an 8-bit code range.
        String unicodeString =
            "This Unicode string has 2 characters outside the " +
            "ASCII range:\n" +
            "Pi (\u03A0)), and Sigma (\u03A3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(unicodeString);
        Console.WriteLine();

        // Encode the string.
        Byte[] encodedBytes = utf8.GetBytes(unicodeString);
        Console.WriteLine("The encoded string has {0} bytes.",
                          encodedBytes.Length);
        Console.WriteLine();

        // Write the bytes to a file with a BOM.
        var fs = new FileStream(@".\UTF8Encoding.txt", FileMode.Create);
        Byte[] bom = utf8.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.
        var sr = new StreamReader(@".\UTF8Encoding.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(@".\UTF8Encoding.txt", FileMode.Open);
        Byte[] bytes = new Byte[fs.Length];
        fs.Read(bytes, 0, (int)fs.Length);
        fs.Close();

        String decodedString = utf8.GetString(bytes);
        Console.WriteLine("Decoded bytes:");
        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 88 bytes.
//
//    Wrote 91 bytes to the file.
//
//    String read using StreamReader:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    Decoded bytes:
//    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-8 encoding that supports a BOM.
        Dim utf8 As New UTF8Encoding(True)
        
        ' A Unicode string with two characters outside an 8-bit code range.
        Dim unicodeString 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(unicodeString)
        Console.WriteLine()
        
        ' Encode the string.
        Dim encodedBytes As Byte() = utf8.GetBytes(unicodeString)
        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(".\UTF8Encoding.txt", FileMode.Create)
        Dim bom() As Byte = utf8.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(".\UTF8Encoding.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(".\UTF8Encoding.txt", FileMode.Open)
        Dim bytes(fs.Length - 1) As Byte
        fs.Read(bytes, 0, fs.Length)
        fs.Close()

        Dim decodedString As String = utf8.GetString(bytes)
        Console.WriteLine("Decoded bytes:")
        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 88 bytes.
'
'    Wrote 91 bytes to the file.
'
'    String read using StreamReader:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    Decoded bytes:
'    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.

UTF-8 è una codifica Unicode che rappresenta ogni punto di codice come sequenza da uno a quattro byte. A differenza delle codifiche UTF-16 e UTF-32, la codifica UTF-8 non richiede "endianness"; lo schema di codifica è lo stesso indipendentemente dal fatto che il processore sia big-endian o little-endian. UTF8Encoding corrisponde alla tabella codici di Windows 65001. Per altre informazioni sulle funzioni definite dall'utente e altre codifiche supportate da System.Text, vedere Codifica dei caratteri in .NET Framework.

È possibile creare un'istanza di un UTF8Encoding oggetto in diversi modi, a seconda che si voglia specificare un indicatore di ordine di byte (BOM) e se si desidera abilitare il rilevamento degli errori. Nella tabella seguente sono elencati i costruttori e la Encoding proprietà che restituiscono un UTF8Encoding oggetto .

Membro BOM Rilevamento dell'errore
Encoding.UTF8 No (fallback di sostituzione)
UTF8Encoding.UTF8Encoding() No No (fallback di sostituzione)
UTF8Encoding.UTF8Encoding(Boolean) Configurabile No (fallback di sostituzione)
UTF8Encoding.UTF8Encoding(Boolean, Boolean) 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 .

Facoltativamente, l'oggetto UTF8Encoding fornisce un byte order mark (BOM), ovvero una matrice di byte che può essere preceduta dall'inizio del flusso di byte risultante dal processo di codifica. Se un flusso di byte con codifica UTF-8 è preceduto da un byte order mark (BOM), consente al decodificatore di determinare l'ordine dei byte e il formato di trasformazione o UTF. Si noti, tuttavia, che lo standard Unicode non richiede né consiglia un BOM nei flussi con codifica UTF-8. Per ulteriori informazioni sull'ordine dei byte e sulla byte order mark, vedere lo standard Unicode nella Home Page Unicode.

Se il codificatore è configurato per fornire un BOM, è possibile recuperarlo chiamando il GetPreamble metodo ; in caso contrario, il metodo restituisce una matrice vuota. Si noti che, anche se un UTF8Encoding 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 UTF8Encoding classe non eseguono questa operazione automaticamente.

Attenzione

Per abilitare il rilevamento degli errori e rendere più sicura l'istanza della classe, è necessario chiamare il UTF8Encoding(Boolean, Boolean) costruttore e impostare il throwOnInvalidBytes parametro su true. Con il rilevamento degli errori abilitato, 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.

Nota

Lo stato di un oggetto con codifica UTF-8 non viene mantenuto se l'oggetto viene serializzato e deserializzato usando versioni diverse di .NET Framework.

Costruttori

UTF8Encoding()

Inizializza una nuova istanza della classe UTF8Encoding.

UTF8Encoding(Boolean)

Inizializza una nuova istanza della classe UTF8Encoding. Un parametro specifica se fornire un byte order mark Unicode.

UTF8Encoding(Boolean, Boolean)

Inizializza una nuova istanza della classe UTF8Encoding. I parametri specificano 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-8, 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 specificato è uguale all'oggetto UTF8Encoding 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*, Int32)

Quando ne viene eseguito l'override in una classe derivata, calcola il numero di byte prodotti dalla codifica di un set di caratteri a partire dal puntatore ai caratteri specificato.

(Ereditato da Encoding)
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>)

Calcola il numero di byte prodotti dalla codifica dell'intervallo di caratteri specificato.

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*, Int32, Byte*, Int32)

Quando ne viene eseguito l'override in una classe derivata, 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.

(Ereditato da Encoding)
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>)

Codifica l'intervallo di caratteri specificato nell'intervallo di byte specificato.

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)

Codifica i caratteri in un oggetto String specificato in una sequenza di byte.

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*, Int32)

Quando ne viene eseguito l'override in una classe derivata, calcola il numero di caratteri prodotti dalla decodifica di una sequenza di byte a partire dal puntatore ai byte specificato.

(Ereditato da Encoding)
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>)

Calcola il numero di caratteri prodotti dalla decodifica dell'intervallo di byte specificato.

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*, Int32, Char*, Int32)

Quando ne viene eseguito l'override in una classe derivata, 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.

(Ereditato da Encoding)
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>)

Decodifica l'intervallo di byte specificato nell'intervallo di caratteri specificato.

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 che converte una sequenza di byte con codifica UTF-8 in una sequenza di caratteri Unicode.

GetEncoder()

Ottiene un codificatore che converte una sequenza di caratteri Unicode in una sequenza di byte con codifica UTF-8.

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-8, se l'oggetto di codifica UTF8Encoding è 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(Byte[], Int32, Int32)

Quando ne viene eseguito l'override in una classe derivata, decodifica una sequenza di byte dalla matrice di byte specificata in una stringa.

(Ereditato da Encoding)
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.

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.

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

Vedi anche