EncoderReplacementFallback Osztály

Definíció

Névtér:

System.Text

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

EncoderReplacementFallback.cs

Hibakezelési mechanizmust, úgynevezett tartalékot biztosít olyan bemeneti karakterhez, amely nem konvertálható kimeneti bájtsorozattá. A tartalék egy felhasználó által megadott helyettesítő sztringet használ az eredeti bemeneti karakter helyett. Ez az osztály nem örökölhető.

public ref class EncoderReplacementFallback sealed : System::Text::EncoderFallback

public sealed class EncoderReplacementFallback : System.Text.EncoderFallback

type EncoderReplacementFallback = class
    inherit EncoderFallback

Public NotInheritable Class EncoderReplacementFallback
Inherits EncoderFallback

Öröklődés

Object

EncoderFallback

EncoderReplacementFallback

Példák

Az alábbi példa az osztályt EncoderReplacementFallback mutatja be.

// 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)"
'

Megjegyzések

A kódolási vagy dekódolási művelet meghiúsulásának gyakori oka, hogy a mögöttes kódolási osztály nem biztosít leképezést egy karakter és egy ezzel egyenértékű bájtsor között. Egy objektum például nem kódolhat olyan karaktereket, ASCIIEncoding amelyek Unicode-kódpont-értékkel rendelkeznek, amely az U+0000 és U+007F tartományon kívül esik. Ha a bemeneti karakter nem konvertálható kimeneti bájtsorozattá, az EncoderReplacementFallback objektum egy megadott helyettesítő sztringet helyettesít az eredeti bemeneti karakterrel. A konvertálási folyamat kódolja a helyettesítő sztringet, majd folytatja az eredeti bemenet fennmaradó részének feldolgozását.

Az objektum által használt helyettesítő sztringet EncoderReplacementFallback az osztálykonstruktor hívása határozza meg. Két beállítást választhat:

• Csere az alapértelmezett karakterrel. Ha meghívja a konstruktort EncoderReplacementFallback() , a helyettesítő karakter a "?" (U+003F).

• Csere egy tetszőleges sztringgel. Ha meghívja a konstruktort EncoderReplacementFallback(String) , adja meg a helyettesítő sztringet.

Ha az osztályhoz használandó tartalék sztringet választja, győződjön meg arról, hogy a sztring teljes egészében olyan karakterekből áll, amelyek kódolhatók a célkódolásban. Ellenkező esetben a rekurzív tartalék eredmények okozzák a ArgumentException.

Ez az osztály egyike annak a két .NET keretrendszerosztálynak, amelyek különböző tartalék stratégiákat implementálnak a kódolási konverziós hibák kezelésére. A másik osztály az EncoderExceptionFallback osztály, amely érvénytelen karakter észlelésekor ad választ EncoderFallbackException .

Konstruktorok

Name	Description
EncoderReplacementFallback()	Inicializálja a EncoderReplacementFallback osztály új példányát.
EncoderReplacementFallback(String)	Inicializálja az EncoderReplacementFallback osztály új példányát egy megadott helyettesítő sztring használatával.

Tulajdonságok

Name	Description
DefaultString	Lekéri az objektum értékét tartalmazó helyettesítő sztringet EncoderReplacementFallback .
MaxCharCount	Lekéri az objektum helyettesítő sztringjének EncoderReplacementFallback karaktereinek számát.

Metódusok

Name	Description
CreateFallbackBuffer()	Létrehoz egy EncoderFallbackBuffer objektumot, amely inicializálva van az EncoderReplacementFallback objektum helyettesítő sztringjével.
Equals(Object)	Azt jelzi, hogy egy adott objektum értéke megegyezik-e az EncoderReplacementFallback objektummal.
GetHashCode()	Lekéri az objektum értékének kivonatkódját EncoderReplacementFallback .
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)

Lásd még

• EncoderReplacementFallbackBuffer
• EncoderReplacementFallback
• DefaultString
• A kódolások ismertetése