DecoderFallbackException Class

Imports System.Text

Public Module Example
   Public Sub Demo(outputBlock As System.Windows.Controls.TextBlock)
      ' Retrieve a UTF8 encoding object that throws an exception if the
      ' encoding/decoding operation fails. 
      Dim enc8 As Encoding = New UTF8Encoding(False, True)
      Dim inputString As String = "XYZ"
      Dim decodedString As String = String.Empty
      Dim numberOfEncodedBytes As Integer = enc8.GetByteCount(inputString)

      ' Create array to hold encoded bytes.
      Dim encodedBytes(numberOfEncodedBytes - 1) As Byte

      ' Display the input string in text.
      outputBlock.Text += String.Format("String to encode with {2} encoding: '{1}' ({0} characters)", _
                        inputString.Length, inputString, enc8.WebName) + vbCrLf 

      ' Display the hexadecimal equivalent of the Char values.
      outputBlock.Text += "Input string in hexadecimal: "
      For ctr As Integer = 0 to inputString.Length - 1
         outputBlock.Text += String.Format("0x{0:X2} ", Convert.ToInt32(inputString.Chars(ctr)))
      Next 
      outputBlock.Text += vbCrLf

      ' Encode the input string and display the encoded bytes. 
      numberOfEncodedBytes = enc8.GetBytes(inputString, 0, inputString.Length, _
                                           encodedBytes, 0)
      outputBlock.Text += String.Format("Encoded bytes in hexadecimal ({0} bytes): ", _
                         numberOfEncodedBytes) 
      For Each b As Byte In encodedBytes
         outputBlock.Text += String.Format("0x{0:X2} ", Convert.ToInt32(b))
      Next
      outputBlock.Text += vbCrLf

      ' Replace the encoded byte sequences for the characters 'X' and 'Z' with the 
      ' invalid value 0xFF.  
      encodedBytes(0) = &HFF
      encodedBytes(2) = &HFF

      outputBlock.Text += String.Format("The corrupted byte sequence in hexadecimal ({0} bytes): ", _
                         numberOfEncodedBytes)
      For Each b As Byte In encodedBytes
         outputBlock.Text += String.Format("0x{0:X2} ", Convert.ToInt32(b))
      Next b
      outputBlock.Text += vbCrLf

      ' Try to decode the corrupted bytes. (This throws an exception.)
      Try
         decodedString += enc8.GetString(encodedBytes, 0, encodedBytes.Length)
      Catch e As DecoderFallbackException
         Dim byteString As String = String.Empty
         For Each unknownByte As Byte In e.BytesUnknown
            byteString = String.Format("0x{0:X2} ", unknownByte)
         Next

         ' Retrieve decoder to translate byte array.
         Dim enc8Decoder As Decoder = enc8.GetDecoder()
         Dim index As Integer = 0         
         Dim sb As New StringBuilder()
         ' A character can be encoded in up to four bytes (though 4 is rare).

         ' Since an exception has occurred, decode on a character-by character basis.
         Do While index < encodedBytes.Length   
            Dim success As Boolean = False
            ' Each character can be from 1 to 4 bytes.   
            Const bytesPerChar As Integer = 4
            For nBytes As Integer = 1 To bytesPerChar 
               Try
                  If index + nBytes > encodedBytes.Length Then Continue For

                  Dim chars(enc8Decoder.GetCharCount(encodedBytes, index, nBytes) - 1) As Char 
                  enc8Decoder.GetChars(encodedBytes, index, nBytes, chars, 0)
                  sb.Append(chars)
                  index += nBytes
                  success = True
                  Exit For
               Catch de As DecoderFallbackException
                  success = False
                  ' Do nothing.         
               End Try   
            Next
            ' Conversion attempt failed.

            If Not success Then 
               ' Append "*" as fallback character.
               sb.Append("*")                            
               index += 1 
            End If   
         Loop
         decodedString = sb.ToString()
      End Try
      outputBlock.Text += String.Format("Decoded string: '{0}'", decodedString) + vbCrLf 
   End Sub
End Module
' The example displays the following output:
'       String to encode with utf-8 encoding: 'XYZ' (3 characters)
'       Input string in hexadecimal: 0x58 0x59 0x5A
'       Encoded bytes in hexadecimal (3 bytes): 0x58 0x59 0x5A
'       The corrupted byte sequence in hexadecimal (3 bytes): 0xFF 0x59 0xFF
'       Decoded string: '*Y*'

using System;
using System.Text;

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      // Retrieve a UTF8 encoding object that throws an exception if the
      // encoding/decoding operation fails. 
      Encoding enc8 = new UTF8Encoding(false, true);
      string inputString = "XYZ";
      string decodedString = String.Empty;
      int numberOfEncodedBytes = enc8.GetByteCount(inputString);

      // Create array to hold encoded bytes.
      byte[] encodedBytes = new byte[numberOfEncodedBytes]; 

      // Display the input string in text.
      outputBlock.Text += String.Format("String to encode with {2} encoding: '{1}' ({0} characters)\n", 
                        inputString.Length, inputString, enc8.WebName);

      // Display the hexadecimal equivalent of the Char values.
      outputBlock.Text += "Input string in hexadecimal: ";
      for (int ctr = 0; ctr <= inputString.Length - 1; ctr++)
         outputBlock.Text += String.Format("0x{0:X2} ", Convert.ToInt32(inputString[ctr]));

      outputBlock.Text += "\n";

      // Encode the input string and display the encoded bytes. 
      numberOfEncodedBytes = enc8.GetBytes(inputString, 0, inputString.Length, 
                                           encodedBytes, 0);
      outputBlock.Text += String.Format("Encoded bytes in hexadecimal ({0} bytes): ", 
                         numberOfEncodedBytes);
      foreach (byte b in encodedBytes)
         outputBlock.Text += String.Format("0x{0:X2} ", Convert.ToInt32(b));

      outputBlock.Text += "\n";

      // Replace the encoded byte sequences for the characters 'X// and 'Z// with the 
      // invalid value 0xFF.  
      encodedBytes[0] = 0xFF;
      encodedBytes[2] = 0xFF;

      outputBlock.Text += String.Format("The corrupted byte sequence in hexadecimal ({0} bytes): ", 
                         numberOfEncodedBytes);
      foreach (byte b in encodedBytes)
         outputBlock.Text += String.Format("0x{0:X2} ", Convert.ToInt32(b));

      outputBlock.Text += "\n";

      // Try to decode the corrupted bytes. (This throws an exception.)
      try {
         decodedString += enc8.GetString(encodedBytes, 0, encodedBytes.Length);
      }
      catch (DecoderFallbackException e)
      {
         string byteString = String.Empty;
         foreach (byte unknownByte in e.BytesUnknown)
            byteString = String.Format("0x{0:X2} ", unknownByte);

         // Retrieve decoder to translate byte array.
         Decoder enc8Decoder = enc8.GetDecoder();
         int index = 0;         
         StringBuilder sb = new StringBuilder();
         // A character can be encoded in up to four bytes (though 4 is rare).

         // Since an exception has occurred, decode on a character-by character basis.
         while (index < encodedBytes.Length)
         {
            bool success = false;
            // Each character can be from 1 to 4 bytes.   
            const int bytesPerChar = 4;
            for (int nBytes = 1; nBytes <= bytesPerChar; nBytes++)
            { 
               try {
                  if (index + nBytes <= encodedBytes.Length)
                  {
                     char[] chars = new char[enc8Decoder.GetCharCount(encodedBytes, index, nBytes)]; 
                     enc8Decoder.GetChars(encodedBytes, index, nBytes, chars, 0);
                     sb.Append(chars);
                     index += nBytes;
                     success = true;
                     break;
                  }
               }
               catch (DecoderFallbackException) {
                  success = false;
                  // Do nothing.         
               } 
            }
            // Conversion attempt failed.

            if (! success)
            { 
               // Append "*" as fallback character.
               sb.Append("*");                            
               index += 1; 
            }   
         }
         decodedString = sb.ToString();
      }
      outputBlock.Text += String.Format("Decoded string: '{0}'\n", decodedString);   
   }
}
// The example displays the following output:
//       String to encode with utf-8 encoding: 'XYZ' (3 characters)
//       Input string in hexadecimal: 0x58 0x59 0x5A
//       Encoded bytes in hexadecimal (3 bytes): 0x58 0x59 0x5A
//       The corrupted byte sequence in hexadecimal (3 bytes): 0xFF 0x59 0xFF
//       Decoded string: '*Y*'