EncoderReplacementFallback Classe
Definizione
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.
Fornisce un meccanismo di gestione degli errori, denominato fallback, per un carattere di input che non può essere convertito in una sequenza di byte di output. Il fallback usa una stringa di sostituzione specificata dall'utente anziché il carattere di input originale. La classe non può essere ereditata.
public ref class EncoderReplacementFallback sealed : System::Text::EncoderFallbackpublic sealed class EncoderReplacementFallback : System.Text.EncoderFallback[System.Serializable]
public sealed class EncoderReplacementFallback : System.Text.EncoderFallbacktype EncoderReplacementFallback = class
inherit EncoderFallback[<System.Serializable>]
type EncoderReplacementFallback = class
inherit EncoderFallbackPublic NotInheritable Class EncoderReplacementFallback
Inherits EncoderFallback- Ereditarietà
- Attributi
Esempio
Nell'esempio seguente viene illustrata la EncoderReplacementFallback classe .
// This example demonstrates the EncoderReplacementFallback class.
using namespace System;
using namespace System::Text;
int main()
{
// Create an encoding, which is equivalent to calling the
// ASCIIEncoding class constructor.
// The EncoderReplacementFallback parameter specifies that the
// string, "(unknown)", replace characters that cannot be encoded.
// A decoder replacement fallback is also specified, but in this
// code example the decoding operation cannot fail.
Encoding^ ascii = Encoding::GetEncoding("us-ascii",
gcnew EncoderReplacementFallback("(unknown)"),
gcnew DecoderReplacementFallback("(error)"));
// The input string consists of the Unicode characters LEFT POINTING
// DOUBLE ANGLE QUOTATION MARK (U+00AB), 'X' (U+0058), and RIGHT
// POINTING DOUBLE ANGLE QUOTATION MARK (U+00BB).
// The encoding can only encode characters in the US-ASCII range of
// U+0000 through U+007F. Consequently, the characters bracketing the
// 'X' character are replaced with the fallback replacement string,
// "(unknown)".
String^ inputString = "\u00abX\u00bb";
String^ decodedString;
String^ twoNewLines = Environment::NewLine + Environment::NewLine;
array <Byte>^ encodedBytes =
gcnew array<Byte>(ascii->GetByteCount(inputString));
int numberOfEncodedBytes = 0;
// ---------------------------------------------------------------------
// Display the name of the encoding.
Console::WriteLine("The name of the encoding is \"{0}\".{1}",
ascii->WebName, Environment::NewLine);
// Display the input string in text.
Console::WriteLine("Input string ({0} characters): \"{1}\"",
inputString->Length, inputString);
// Display the input string in hexadecimal.
Console::Write("Input string in hexadecimal: ");
for each (char c in inputString)
{
Console::Write("0x{0:X2} ", c);
}
Console::Write(twoNewLines);
// ---------------------------------------------------------------------
// Encode the input string.
Console::WriteLine("Encode the input string...");
numberOfEncodedBytes = ascii->GetBytes(inputString, 0, inputString->Length,
encodedBytes, 0);
// Display the encoded bytes.
Console::WriteLine("Encoded bytes in hexadecimal ({0} bytes):{1}",
numberOfEncodedBytes, Environment::NewLine);
for(int i = 0; i < encodedBytes->Length; i++)
{
Console::Write("0x{0:X2} ", encodedBytes[i]);
if(((i + 1) % 6) == 0)
{
Console::WriteLine();
}
}
Console::Write(twoNewLines);
// ---------------------------------------------------------------------
// Decode the encoded bytes, yielding a reconstituted string.
Console::WriteLine("Decode the encoded bytes...");
decodedString = ascii->GetString(encodedBytes);
// Display the input string and the decoded string for comparison.
Console::WriteLine("Input string: \"{0}\"", inputString);
Console::WriteLine("Decoded string:\"{0}\"", decodedString);
}
/*
This code example produces the following results:
The name of the encoding is "us-ascii".
Input string (3 characters): "X"
Input string in hexadecimal: 0xAB 0x58 0xBB
Encode the input string...
Encoded bytes in hexadecimal (19 bytes):
0x28 0x75 0x6E 0x6B 0x6E 0x6F
0x77 0x6E 0x29 0x58 0x28 0x75
0x6E 0x6B 0x6E 0x6F 0x77 0x6E
0x29
Decode the encoded bytes...
Input string: "X"
Decoded string:"(unknown)X(unknown)"
*/
// This example demonstrates the EncoderReplacementFallback class.
using System;
using System.Text;
class Sample
{
public static void Main()
{
// Create an encoding, which is equivalent to calling the
// ASCIIEncoding class constructor.
// The EncoderReplacementFallback parameter specifies that the
// string, "(unknown)", replace characters that cannot be encoded.
// A decoder replacement fallback is also specified, but in this
// code example the decoding operation cannot fail.
Encoding ae = Encoding.GetEncoding(
"us-ascii",
new EncoderReplacementFallback("(unknown)"),
new DecoderReplacementFallback("(error)"));
// The input string consists of the Unicode characters LEFT POINTING
// DOUBLE ANGLE QUOTATION MARK (U+00AB), 'X' (U+0058), and RIGHT POINTING
// DOUBLE ANGLE QUOTATION MARK (U+00BB).
// The encoding can only encode characters in the US-ASCII range of U+0000
// through U+007F. Consequently, the characters bracketing the 'X' character
// are replaced with the fallback replacement string, "(unknown)".
string inputString = "\u00abX\u00bb";
string decodedString;
string twoNewLines = "\n\n";
byte[] encodedBytes = new byte[ae.GetByteCount(inputString)];
int numberOfEncodedBytes = 0;
int ix = 0;
// --------------------------------------------------------------------------
// Display the name of the encoding.
Console.WriteLine("The name of the encoding is \"{0}\".\n", ae.WebName);
// Display the input string in text.
Console.WriteLine("Input string ({0} characters): \"{1}\"",
inputString.Length, inputString);
// Display the input string in hexadecimal.
Console.Write("Input string in hexadecimal: ");
foreach (char c in inputString.ToCharArray())
{
Console.Write("0x{0:X2} ", (int)c);
}
Console.Write(twoNewLines);
// --------------------------------------------------------------------------
// Encode the input string.
Console.WriteLine("Encode the input string...");
numberOfEncodedBytes = ae.GetBytes(inputString, 0, inputString.Length,
encodedBytes, 0);
// Display the encoded bytes.
Console.WriteLine("Encoded bytes in hexadecimal ({0} bytes):\n",
numberOfEncodedBytes);
ix = 0;
foreach (byte b in encodedBytes)
{
Console.Write("0x{0:X2} ", (int)b);
ix++;
if (0 == ix % 6) Console.WriteLine();
}
Console.Write(twoNewLines);
// --------------------------------------------------------------------------
// Decode the encoded bytes, yielding a reconstituted string.
Console.WriteLine("Decode the encoded bytes...");
decodedString = ae.GetString(encodedBytes);
// Display the input string and the decoded string for comparison.
Console.WriteLine("Input string: \"{0}\"", inputString);
Console.WriteLine("Decoded string:\"{0}\"", decodedString);
}
}
/*
This code example produces the following results:
The name of the encoding is "us-ascii".
Input string (3 characters): "«X»"
Input string in hexadecimal: 0xAB 0x58 0xBB
Encode the input string...
Encoded bytes in hexadecimal (19 bytes):
0x28 0x75 0x6E 0x6B 0x6E 0x6F
0x77 0x6E 0x29 0x58 0x28 0x75
0x6E 0x6B 0x6E 0x6F 0x77 0x6E
0x29
Decode the encoded bytes...
Input string: "«X»"
Decoded string:"(unknown)X(unknown)"
*/
' This example demonstrates the EncoderReplacementFallback class.
Imports System.Text
Class Sample
Public Shared Sub Main()
' Create an encoding, which is equivalent to calling the
' ASCIIEncoding class constructor.
' The EncoderReplacementFallback parameter specifies that the
' string, "(unknown)", replace characters that cannot be encoded.
' A decoder replacement fallback is also specified, but in this
' code example the decoding operation cannot fail.
Dim erf As New EncoderReplacementFallback("(unknown)")
Dim drf As New DecoderReplacementFallback("(error)")
Dim ae As Encoding = Encoding.GetEncoding("us-ascii", erf, drf)
' The input string consists of the Unicode characters LEFT POINTING
' DOUBLE ANGLE QUOTATION MARK (U+00AB), 'X' (U+0058), and RIGHT POINTING
' DOUBLE ANGLE QUOTATION MARK (U+00BB).
' The encoding can only encode characters in the US-ASCII range of U+0000
' through U+007F. Consequently, the characters bracketing the 'X' character
' are replaced with the fallback replacement string, "(unknown)".
Dim inputString As String = "«X»"
Dim decodedString As String
Dim twoNewLines As String = vbCrLf & vbCrLf
Dim ix As Integer = 0
Dim numberOfEncodedBytes As Integer = ae.GetByteCount(inputString)
' Counteract the compiler adding an extra byte to the array.
Dim encodedBytes(numberOfEncodedBytes - 1) As Byte
' --------------------------------------------------------------------------
' Display the name of the encoding.
Console.WriteLine("The name of the encoding is ""{0}""." & vbCrLf, ae.WebName)
' Display the input string in text.
Console.WriteLine("Input string ({0} characters): ""{1}""", _
inputString.Length, inputString)
' Display the input string in hexadecimal.
' Each element is converted to an integer with Convert.ToInt32.
Console.Write("Input string in hexadecimal: ")
Dim c As Char
For Each c In inputString.ToCharArray()
Console.Write("0x{0:X2} ", Convert.ToInt32(c))
Next c
Console.Write(twoNewLines)
' --------------------------------------------------------------------------
' Encode the input string.
Console.WriteLine("Encode the input string...")
numberOfEncodedBytes = ae.GetBytes(inputString, 0, inputString.Length, _
encodedBytes, 0)
' Display the encoded bytes.
' Each element is converted to an integer with Convert.ToInt32.
Console.WriteLine("Encoded bytes in hexadecimal ({0} bytes):" & vbCrLf, _
numberOfEncodedBytes)
ix = 0
Dim b As Byte
For Each b In encodedBytes
Console.Write("0x{0:X2} ", Convert.ToInt32(b))
ix += 1
If 0 = ix Mod 6 Then
Console.WriteLine()
End If
Next b
Console.Write(twoNewLines)
' --------------------------------------------------------------------------
' Decode the encoded bytes, yielding a reconstituted string.
Console.WriteLine("Decode the encoded bytes...")
decodedString = ae.GetString(encodedBytes)
' Display the input string and the decoded string for comparison.
Console.WriteLine("Input string: ""{0}""", inputString)
Console.WriteLine("Decoded string:""{0}""", decodedString)
End Sub
End Class
'
'This code example produces the following results:
'
'The name of the encoding is "us-ascii".
'
'Input string (3 characters): "X"
'Input string in hexadecimal: 0xAB 0x58 0xBB
'
'Encode the input string...
'Encoded bytes in hexadecimal (19 bytes):
'
'0x28 0x75 0x6E 0x6B 0x6E 0x6F
'0x77 0x6E 0x29 0x58 0x28 0x75
'0x6E 0x6B 0x6E 0x6F 0x77 0x6E
'0x29
'
'Decode the encoded bytes...
'Input string: "X"
'Decoded string:"(unknown)X(unknown)"
'
Commenti
Un motivo comune per cui un'operazione di codifica o decodifica non riesce è se la classe di codifica sottostante non fornisce un mapping tra un carattere e una sequenza di byte equivalente. Ad esempio, un ASCIIEncoding oggetto non può codificare un carattere con un valore del punto di codice Unicode esterno all'intervallo U+0000 a U+007F. Se il carattere di input non può essere convertito in una sequenza di byte di output, un EncoderReplacementFallback oggetto sostituisce una stringa di sostituzione specificata per il carattere di input originale. Il processo di conversione codifica la stringa di sostituzione e quindi continua a elaborare il resto dell'input originale.
La stringa di sostituzione usata da un EncoderReplacementFallback oggetto è determinata dalla chiamata al relativo costruttore di classe. Sono disponibili due opzioni :
Sostituzione con il carattere predefinito. Se si chiama il costruttore, il EncoderReplacementFallback() carattere di sostituzione è "?" (U+003F).
Sostituire con una stringa di propria scelta. Se si chiama il EncoderReplacementFallback(String) costruttore, specificare la stringa di sostituzione.
Se si sceglie una stringa di fallback da usare con questa classe, assicurarsi che la stringa sia composta interamente da caratteri che possono essere codificati nella codifica di destinazione. In caso contrario, un fallback ricorsivo restituisce risultati, causando un ArgumentExceptionoggetto .
Questa classe è una delle due classi di .NET Framework che implementano diverse strategie di fallback per gestire gli errori di conversione della codifica. L'altra classe è la EncoderExceptionFallback classe che genera un EncoderFallbackException valore quando viene rilevato un carattere non valido.
Costruttori
| EncoderReplacementFallback() |
Inizializza una nuova istanza della classe EncoderReplacementFallback. |
| EncoderReplacementFallback(String) |
Inizializza una nuova istanza della classe EncoderReplacementFallback usando una stringa di sostituzione specificata. |
Proprietà
| DefaultString |
Ottiene la stringa sostitutiva che rappresenta il valore dell'oggetto EncoderReplacementFallback. |
| MaxCharCount |
Ottiene il numero di caratteri contenuti nella stringa sostitutiva per l'oggetto EncoderReplacementFallback. |
Metodi
| CreateFallbackBuffer() |
Crea un oggetto EncoderFallbackBuffer che viene inizializzato con la stringa sostitutiva di questo oggetto EncoderReplacementFallback. |
| Equals(Object) |
Indica se il valore di un oggetto specificato è uguale all'oggetto EncoderReplacementFallback. |
| GetHashCode() |
Recupera il codice hash per il valore dell'oggetto EncoderReplacementFallback. |
| GetType() |
Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object) |
| MemberwiseClone() |
Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object) |
| ToString() |
Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object) |