EncoderReplacementFallback Klas

Definitie

Naamruimte:

System.Text

Assembly:

mscorlib.dll

Biedt een mechanisme voor foutafhandeling, een terugval genoemd, voor een invoerteken dat niet kan worden geconverteerd naar een bytevolgorde voor uitvoer. De terugval maakt gebruik van een door de gebruiker opgegeven vervangende tekenreeks in plaats van het oorspronkelijke invoerteken. Deze klasse kan niet worden overgenomen.

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

[System.Serializable]
public sealed class EncoderReplacementFallback : System.Text.EncoderFallback

[<System.Serializable>]
type EncoderReplacementFallback = class
    inherit EncoderFallback

Public NotInheritable Class EncoderReplacementFallback
Inherits EncoderFallback

Overname

Object

EncoderFallback

EncoderReplacementFallback

Kenmerken

SerializableAttribute

Voorbeelden

In het volgende voorbeeld ziet u de EncoderReplacementFallback klasse.

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

Opmerkingen

Een veelvoorkomende reden waarom een coderings- of decoderingsbewerking mislukt, is als de onderliggende coderingsklasse geen toewijzing biedt tussen een teken en een equivalente bytereeks. Een object kan bijvoorbeeld ASCIIEncoding geen teken coderen met een Unicode-codepuntwaarde buiten het bereik U+0000 naar U+0007F. Als het invoerteken niet kan worden geconverteerd naar een uitvoer bytereeks, vervangt een EncoderReplacementFallback object een opgegeven vervangende tekenreeks voor het oorspronkelijke invoerteken. Het conversieproces codeert de vervangende tekenreeks en blijft vervolgens de rest van de oorspronkelijke invoer verwerken.

De vervangende tekenreeks die door een EncoderReplacementFallback object wordt gebruikt, wordt bepaald door de aanroep van de klasseconstructor. Er zijn twee opties beschikbaar:

• Vervangen door het standaardteken. Als u de EncoderReplacementFallback() constructor aanroept, is het vervangende teken '?' (U+003F).

• Vervangen door een tekenreeks van uw keuze. Als u de EncoderReplacementFallback(String) constructor aanroept, geeft u de vervangende tekenreeks op.

Als u een terugvaltekenreeks kiest die u met deze klasse wilt gebruiken, moet u ervoor zorgen dat de tekenreeks volledig bestaat uit tekens die kunnen worden gecodeerd in de doelcodering. Anders veroorzaakt een recursieve terugvalresultaten een ArgumentException.

Deze klasse is een van de twee .NET Framework-klassen die verschillende terugvalstrategieën implementeren voor het afhandelen van coderingsfouten. De andere klasse is de EncoderExceptionFallback klasse, die een EncoderFallbackException ongeldig teken genereert.

Constructors

Name	Description
EncoderReplacementFallback()	Initialiseert een nieuw exemplaar van de EncoderReplacementFallback klasse.
EncoderReplacementFallback(String)	Initialiseert een nieuw exemplaar van de EncoderReplacementFallback klasse met behulp van een opgegeven vervangende tekenreeks.

Eigenschappen

Name	Description
DefaultString	Hiermee haalt u de vervangende tekenreeks op die de waarde van het EncoderReplacementFallback object is.
MaxCharCount	Hiermee haalt u het aantal tekens in de vervangende tekenreeks voor het EncoderReplacementFallback object op.

Methoden

Name	Description
CreateFallbackBuffer()	Hiermee maakt u een EncoderFallbackBuffer object dat wordt geïnitialiseerd met de vervangende tekenreeks van dit EncoderReplacementFallback object.
Equals(Object)	Geeft aan of de waarde van een opgegeven object gelijk is aan het EncoderReplacementFallback object.
GetHashCode()	Haalt de hashcode op voor de waarde van het EncoderReplacementFallback object.
GetType()	Hiermee haalt u de Type huidige instantie op. (Overgenomen van Object)
MemberwiseClone()	Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object)
ToString()	Retourneert een tekenreeks die het huidige object vertegenwoordigt. (Overgenomen van Object)

Zie ook

• EncoderReplacementFallbackBuffer
• EncoderReplacementFallback
• DefaultString
• Informatie over coderingen