Convert.FromBase64CharArray(Char[], Int32, Int32) Método

public:
 static cli::array <System::Byte> ^ FromBase64CharArray(cli::array <char> ^ inArray, int offset, int length);

public static byte[] FromBase64CharArray(char[] inArray, int offset, int length);

static member FromBase64CharArray : char[] * int * int -> byte[]

Public Shared Function FromBase64CharArray (inArray As Char(), offset As Integer, length As Integer) As Byte()

Parâmetros

Devoluções

Um array de inteiros sem sinal de 8 bits equivalente a length elementos na posição offset de inArray.

Exceções

Exemplos

O exemplo seguinte demonstra a utilização do FromBase64CharArray(Char[], Int32, Int32) método para decodificar dados UUencoded (base-64) e guardá-los como saída binária.

public void DecodeWithCharArray() {
   System.IO.StreamReader inFile;
   char[] base64CharArray;

   try {
      inFile = new System.IO.StreamReader(inputFileName,
                              System.Text.Encoding.ASCII);
      base64CharArray = new char[inFile.BaseStream.Length];
      inFile.Read(base64CharArray, 0, (int)inFile.BaseStream.Length);
      inFile.Close();
   }
   catch (System.Exception exp) {
      // Error creating stream or reading from it.
      System.Console.WriteLine("{0}", exp.Message);
      return;
   }

   // Convert the Base64 UUEncoded input into binary output.
   byte[] binaryData;
   try {
      binaryData =
         System.Convert.FromBase64CharArray(base64CharArray,
                                    0,
                                    base64CharArray.Length);
   }
   catch ( System.ArgumentNullException ) {
      System.Console.WriteLine("Base 64 character array is null.");
      return;
   }
   catch ( System.FormatException ) {
      System.Console.WriteLine("Base 64 Char Array length is not " +
         "4 or is not an even multiple of 4." );
      return;
   }

   // Write out the decoded data.
   System.IO.FileStream outFile;
   try {
      outFile = new System.IO.FileStream(outputFileName,
                                 System.IO.FileMode.Create,
                                 System.IO.FileAccess.Write);
      outFile.Write(binaryData, 0, binaryData.Length);
      outFile.Close();
   }
   catch (System.Exception exp) {
      // Error creating stream or writing to it.
      System.Console.WriteLine("{0}", exp.Message);
   }
}

let decodeWithCharArray () =
    try
        let inFile =
            new StreamReader(inputFileName, Encoding.ASCII)

        let base64CharArray =
            Array.zeroCreate<char> (int inFile.BaseStream.Length)

        inFile.Read(base64CharArray, 0, (int) inFile.BaseStream.Length)
        |> ignore

        // Convert the Base64 UUEncoded input into binary output.
        let binaryData =
            Convert.FromBase64CharArray(base64CharArray, 0, base64CharArray.Length)
        // Write out the decoded data.
        use outFile =
            new FileStream(outputFileName, FileMode.Create, FileAccess.Write)

        outFile.Write(binaryData, 0, binaryData.Length)
    with
    | :? ArgumentNullException -> printfn "Base 64 character array is null."
    | :? FormatException -> printfn "Base 64 Char Array length is not 4 or is not an even multiple of 4."
    | e -> printfn $"{e.Message}"

Public Sub DecodeWithCharArray()
   Dim inFile As System.IO.StreamReader
   Dim base64CharArray() As Char

   Try
      inFile = New System.IO.StreamReader(inputFileName, _
                                          System.Text.Encoding.ASCII)

      ReDim base64CharArray(inFile.BaseStream.Length - 1)
      inFile.Read(base64CharArray, 0, inFile.BaseStream.Length)
      inFile.Close()
   Catch exp As System.Exception
      ' Error creating stream or reading from it.
      System.Console.WriteLine("{0}", exp.Message)
      Return
   End Try

   ' Convert the Base64 UUEncoded input into binary output.
   Dim binaryData() As Byte
   Try
      binaryData = System.Convert.FromBase64CharArray(base64CharArray, 0, _
                                                base64CharArray.Length)
   Catch exp As System.ArgumentNullException
      System.Console.WriteLine("Base 64 character array is null.")
      Return
   Catch exp As System.FormatException
      System.Console.WriteLine("Base 64 Char Array length is not " + _
               "4 or is not an even multiple of 4")
      Return
   End Try

   ' Write out the decoded data.
   Dim outFile As System.IO.FileStream
   Try
      outFile = New System.IO.FileStream(outputFileName, _
                                         System.IO.FileMode.Create, _
                                         System.IO.FileAccess.Write)
      outFile.Write(binaryData, 0, binaryData.Length - 1)
      outFile.Close()
   Catch exp As System.Exception
      ' Error creating stream or writing to it.
      System.Console.WriteLine("{0}", exp.Message)
   End Try
End Sub

O exemplo seguinte demonstra os ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) métodos e.FromBase64CharArray(Char[], Int32, Int32) A entrada é dividida em grupos de três bytes (24 bits) cada. Consequentemente, cada grupo consiste em quatro números de 6 bits, onde cada número varia de 0 a 63 decimal. Neste exemplo, existem 85 grupos de 3 bytes com um byte restante. O primeiro grupo consiste nos valores hexadecimais 00, 01 e 02, que resultam em quatro valores de 6 bits iguais aos decimais 0, 0, 4 e 2. Esses quatro valores correspondem aos dígitos em base 64, "A", "A", "E" e "C", no início da saída.

Se não existir um número inteiro de grupos de 3 bytes, os bytes restantes são efetivamente preenchidos com zeros para formar um grupo completo. Neste exemplo, o valor do último byte é FF hexadecimal. Os primeiros 6 bits são iguais ao decimal 63, que corresponde ao dígito base 64 "/" no final da saída, e os 2 bits seguintes são preenchidos com zeros para obter o decimal 48, que corresponde ao dígito base 64, "w". Os dois últimos valores de 6 bits são preenchimento e correspondem ao caractere de preenchimento sem valor, "=".

// This example demonstrates the Convert.ToBase64CharArray() and
//                               Convert.FromBase64CharArray methods

using System;

class Sample
{
    public static void Main()
    {
    byte[] byteArray1 = new byte[256];
    byte[] byteArray2 = new byte[256];
    char[] charArray  = new char[352];
    int charArrayLength;
    string nl = Environment.NewLine;

    string ruler1a = "         1         2         3         4";
    string ruler2a = "1234567890123456789012345678901234567890";
    string ruler3a = "----+----+----+----+----+----+----+----+";
    string ruler1b = "         5         6         7      ";
    string ruler2b = "123456789012345678901234567890123456";
    string ruler3b = "----+----+----+----+----+----+----+-";
    string ruler   = String.Concat(ruler1a, ruler1b, nl,
                                   ruler2a, ruler2b, nl,
                                   ruler3a, ruler3b);

// 1) Initialize and display a Byte array of arbitrary data.
    Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl);
    for (int x = 0; x < byteArray1.Length; x++)
    {
    byteArray1[x] = (byte)x;
    Console.Write("{0:X2} ", byteArray1[x]);
    if (((x+1)%20) == 0) Console.WriteLine();
    }
    Console.Write("{0}{0}", nl);

// 2) Convert the input Byte array to a Char array, with newlines inserted.
    charArrayLength =
        Convert.ToBase64CharArray(byteArray1, 0, byteArray1.Length,
                                   charArray, 0, Base64FormattingOptions.InsertLineBreaks);
    Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.");
    Console.Write("   Output: A Char array (length = {0}). ", charArrayLength);
    Console.WriteLine("The elements of the array are:{0}", nl);
    Console.WriteLine(ruler);
    Console.WriteLine(new String(charArray));
    Console.WriteLine();

// 3) Convert the Char array back to a Byte array.
    Console.WriteLine("3) Convert the Char array to an output Byte array.");
    byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength);

// 4) Are the input and output Byte arrays equivalent?
    Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}",
                      ArraysAreEqual(byteArray1, byteArray2));
    }

    public static bool ArraysAreEqual(byte[] a1, byte[] a2)
    {
    if (a1.Length != a2.Length) return false;
    for (int i = 0; i < a1.Length; i++)
        if (a1[i] != a2[i]) return false;
    return true;
    }
}
/*
This example produces the following results:

1) Input: A Byte array of arbitrary data.

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

2) Convert the input Byte array to a Char array with newlines.
   Output: A Char array (length = 352). The elements of the array are:

         1         2         3         4         5         6         7
1234567890123456789012345678901234567890123456789012345678901234567890123456
----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==

3) Convert the Char array to an output Byte array.
4) The output Byte array is equal to the input Byte array: True

*/

// This example demonstrates the Convert.ToBase64CharArray() and
//                               Convert.FromBase64CharArray methods
open System

let arraysAreEqual (a1: byte[]) (a2: byte[]) =
    a1.Length = a2.Length &&
    Array.forall2 (=) a2 a1

let byteArray1 = Array.zeroCreate<byte> 256
let charArray  = Array.zeroCreate<char> 352
let nl = Environment.NewLine

let ruler =
    $"         1         2         3         4         5         6         7      {nl}" +
    $"1234567890123456789012345678901234567890123456789012345678901234567890123456{nl}" +
    "----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-"

// 1) Initialize and display a Byte array of arbitrary data.
printfn $"1) Input: A Byte array of arbitrary data.{nl}"
for i = 0 to byteArray1.Length - 1 do
    byteArray1[i] <- byte i
    printf $"{byteArray1[i]:X2} "
    if (i + 1) % 20 = 0 then 
        printfn ""
printf $"{nl}{nl}"

// 2) Convert the input Byte array to a Char array, with newlines inserted.
let charArrayLength =
    Convert.ToBase64CharArray(byteArray1, 0, byteArray1.Length,
                              charArray, 0, Base64FormattingOptions.InsertLineBreaks)
printfn "2) Convert the input Byte array to a Char array with newlines."
printf $"   Output: A Char array (length = {charArrayLength}). "
printfn $"The elements of the array are:{nl}"
printfn $"{ruler}"
printfn $"{String charArray}"
printfn ""

// 3) Convert the Char array back to a Byte array.
printfn "3) Convert the Char array to an output Byte array."
let byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength)

// 4) Are the input and output Byte arrays equivalent?
printfn $"4) The output Byte array is equal to the input Byte array: {arraysAreEqual byteArray1 byteArray2}"


// This example produces the following results:
//     1) Input: A Byte array of arbitrary data.
//    
//     00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
//     14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
//     28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
//     3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
//     50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
//     64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
//     78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
//     8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
//     A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
//     B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
//     C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
//     DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
//     F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF
//    
//     2) Convert the input Byte array to a Char array with newlines.
//        Output: A Char array (length = 352). The elements of the array are:
//    
//              1         2         3         4         5         6         7
//     1234567890123456789012345678901234567890123456789012345678901234567890123456
//     ----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
//     AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
//     OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
//     cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
//     q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
//     5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==
//    
//     3) Convert the Char array to an output Byte array.
//     4) The output Byte array is equal to the input Byte array: True

' This example demonstrates the Convert.ToBase64CharArray() and 
'                               Convert.FromBase64CharArray methods
Class Sample
   Public Shared Sub Main()
      Dim byteArray1(255) As Byte
      Dim byteArray2(255) As Byte
      Dim charArray(351) As Char
      Dim charArrayLength As Integer
      Dim nl As String = Environment.NewLine
      
      Dim ruler1a As String = "         1         2         3         4"
      Dim ruler2a As String = "1234567890123456789012345678901234567890"
      Dim ruler3a As String = "----+----+----+----+----+----+----+----+"
      Dim ruler1b As String = "         5         6         7      "
      Dim ruler2b As String = "123456789012345678901234567890123456"
      Dim ruler3b As String = "----+----+----+----+----+----+----+-"
      Dim ruler As String = String.Concat(ruler1a, ruler1b, nl, _
                                          ruler2a, ruler2b, nl, _
                                          ruler3a, ruler3b)

      ' 1) Initialize and display a Byte array of arbitrary data.
      Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl)
      Dim x As Integer
      For x = 0 To byteArray1.Length - 1
         byteArray1(x) = CByte(x)
         Console.Write("{0:X2} ", byteArray1(x))
         If(x + 1) Mod 20 = 0 Then
            Console.WriteLine()
         End If
      Next x
      Console.Write("{0}{0}", nl)
      
      ' 2) Convert the input Byte array to a Char array, with newlines inserted.
      charArrayLength = Convert.ToBase64CharArray( _
                                byteArray1, 0, byteArray1.Length, _
                                charArray, 0, _
                                Base64FormattingOptions.InsertLineBreaks)
      Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.")
      Console.Write("   Output: A Char array (length = {0}). ", charArrayLength)
      Console.WriteLine("The elements of the array are:{0}", nl)
      Console.WriteLine(ruler)
      Console.WriteLine(New [String](charArray))
      Console.WriteLine()
      
      ' 3) Convert the Char array back to a Byte array.
      Console.WriteLine("3) Convert the Char array to an output Byte array.")
      byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength)
      
      ' 4) Are the input and output Byte arrays equivalent?
      Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}", _
                            ArraysAreEqual(byteArray1, byteArray2))
   End Sub
   
   Public Shared Function ArraysAreEqual(a1() As Byte, a2() As Byte) As Boolean
      If a1.Length <> a2.Length Then
         Return False
      End If
      Dim i As Integer
      For i = 0 To a1.Length - 1
         If a1(i) <> a2(i) Then
            Return False
         End If
      Next i
      Return True
   End Function 'ArraysAreEqual
End Class
'
'This example produces the following results:
'
'1) Input: A Byte array of arbitrary data.
'
'00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
'14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
'28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
'3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
'50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
'64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
'78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
'8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
'A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
'B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
'C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
'DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
'F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF
'
'2) Convert the input Byte array to a Char array with newlines.
'   Output: A Char array (length = 352). The elements of the array are:
'
'         1         2         3         4         5         6         7
'1234567890123456789012345678901234567890123456789012345678901234567890123456
'----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
'OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
'cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
'q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
'5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==
'
'3) Convert the Char array to an output Byte array.
'4) The output Byte array is equal to the input Byte array: True

Observações

inArray é composta por dígitos em base 64, caracteres de espaço em branco e caracteres de preenchimento final. Os dígitos em base 64, por ordem crescente a partir de zero, são os caracteres maiúsculos "A" a "Z", os caracteres minúsculos "a" a "z", os numerais "0" a "9" e os símbolos "+" e "/".

Os caracteres de espaço em branco, bem como os seus nomes Unicode e pontos de código hexadecimais, são tab (TABULAÇÃO DE CARACTERES, U+0009), nova linha (LINE FEED, U+000A), retorno de carro (CARRIAGE RETURN, U+000D) e blank (SPACE, U+0020). Pode aparecer inArray um número arbitrário de caracteres de espaço em branco porque todos os caracteres de espaço em branco são ignorados.

O caractere sem valor, "=", é usado para preenchimento final. O final pode inArray consistir em zero, um ou dois caracteres de preenchimento (padded).

Ver também

• ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)
• FromBase64Transform