Partager via


Convert.ToBase64CharArray Méthode

Définition

Convertit un sous-ensemble d'un tableau d'entiers non signés 8 bits en sous-ensemble équivalent d'un tableau de caractères Unicode encodé en chiffres base 64.

Surcharges

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)

Convertit un sous-ensemble d'un tableau d'entiers non signés 8 bits en sous-ensemble équivalent d'un tableau de caractères Unicode encodé en chiffres base 64. Des paramètres spécifient les sous-ensembles en tant qu'offsets des tableaux d'entrée et de sortie, le nombre d'éléments du tableau d'entrée à convertir et indiquent si des sauts de ligne sont insérés dans le tableau de sortie.

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

Convertit un sous-ensemble d'un tableau d'entiers non signés 8 bits en sous-ensemble équivalent d'un tableau de caractères Unicode encodé en chiffres base 64. Des paramètres spécifient les sous-ensembles en tant qu'offsets des tableaux d'entrée et de sortie ainsi que le nombre d'éléments du tableau d'entrée à convertir.

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)

Source:
Convert.cs
Source:
Convert.cs
Source:
Convert.cs

Convertit un sous-ensemble d'un tableau d'entiers non signés 8 bits en sous-ensemble équivalent d'un tableau de caractères Unicode encodé en chiffres base 64. Des paramètres spécifient les sous-ensembles en tant qu'offsets des tableaux d'entrée et de sortie, le nombre d'éléments du tableau d'entrée à convertir et indiquent si des sauts de ligne sont insérés dans le tableau de sortie.

public:
 static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut, Base64FormattingOptions options);
public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options);
static member ToBase64CharArray : byte[] * int * int * char[] * int * Base64FormattingOptions -> int
[<System.Runtime.InteropServices.ComVisible(false)>]
static member ToBase64CharArray : byte[] * int * int * char[] * int * Base64FormattingOptions -> int
Public Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer, options As Base64FormattingOptions) As Integer

Paramètres

inArray
Byte[]

Tableau d'entrée d'entiers non signés 8 bits.

offsetIn
Int32

Position au sein de inArray.

length
Int32

Nombre d'éléments de inArray à convertir.

outArray
Char[]

Tableau de sortie de caractères Unicode.

offsetOut
Int32

Position au sein de outArray.

options
Base64FormattingOptions

InsertLineBreaks pour insérer un saut de ligne tous les 76 caractères, ou None pour ne pas insérer de sauts de ligne.

Retours

Entier 32 bits signé contenant le nombre d'octets dans outArray.

Attributs

Exceptions

inArray ou outArray est null.

offsetIn, offsetOut ou length est un nombre négatif.

- ou -

offsetIn plus length est supérieur à la longueur d’inArray.

- ou -

offsetOut plus le nombre d’éléments à retourner est supérieur à la longueur d’outArray.

options n’est pas une valeur de Base64FormattingOptions valide.

Exemples

L’exemple suivant illustre la ToBase64CharArray méthode. L’entrée est divisée en groupes de trois octets (24 bits) chacun. Par conséquent, chaque groupe se compose de quatre nombres 6 bits où chaque nombre est compris entre 0 et 63. Dans cet exemple, il existe 85 groupes de 3 octets avec un octet restant. Le premier groupe se compose des valeurs hexadécimales 00, 01 et 02, qui produisent quatre valeurs 6 bits égales à la décimale 0, 0, 4 et 2. Ces quatre valeurs correspondent aux chiffres en base 64 « A », « A », « E » et « C » au début de la sortie.

Si un nombre intégral de groupes de 3 octets n’existe pas, les octets restants sont effectivement remplis de zéros pour former un groupe complet. Dans cet exemple, la valeur du dernier octet est hexadécimal FF. Les 6 premiers bits sont égaux à la décimale 63, ce qui correspond au chiffre de base 64 « / » à la fin de la sortie, et les 2 bits suivants sont complétés avec des zéros pour obtenir la décimale 48, qui correspond au chiffre de base 64, « w ». Les deux dernières valeurs 6 bits sont un remplissage et correspondent au caractère de remplissage sans valeur, « = ».

// This example demonstrates the Convert.ToBase64CharArray() and
//                               Convert.FromBase64CharArray methods
using namespace System;
bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 );
int main()
{
   array<Byte>^byteArray1 = gcnew array<Byte>(256);
   array<Byte>^byteArray2 = gcnew array<Byte>(256);
   array<Char>^charArray = gcnew array<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( gcnew 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 ) );
}

bool ArraysAreEqual( array<Byte>^a1, array<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

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

Remarques

Le sous-ensemble d’éléments length du inArray paramètre commençant à la position offsetIn, sont pris en tant que valeur numérique et convertis en un sous-ensemble d’éléments dans le outArray paramètre commençant à la position offsetOut. La valeur de retour indique le nombre d’éléments convertis dans outArray. Le sous-ensemble de outArray se compose de chiffres en base 64.

Les chiffres de base 64 dans l’ordre croissant de zéro sont les caractères majuscules « A » à « Z », les minuscules « a » à « z », les chiffres « 0 » à « 9 » et les symboles « + » et « / ». Le caractère sans valeur « = » est utilisé pour le remplissage de fin.

Les offset paramètres et length sont des nombres signés 32 bits. Les offsetIn paramètres et offsetOut sont des positions de tableau de base zéro.

Important

La ToBase64CharArray méthode est conçue pour traiter un tableau d’octets unique qui contient toutes les données à encoder. Pour créer un tableau de caractères en base 64 à partir d’un flux d’octets, utilisez la System.Security.Cryptography.ToBase64Transform classe .

Si le options paramètre est défini sur et que la sortie de la conversion est supérieure à InsertLineBreaks 76 caractères, un saut de ligne est inséré tous les 76 caractères. Un saut de ligne est défini comme un caractère de retour chariot (U+000D) suivi d’un caractère de flux de ligne (U+000A). Pour plus d’informations, consultez RFC 2045, « Multipurpose Internet Mail Extensions », à l’adresse https://www.rfc-editor.org/.

Voir aussi

S’applique à

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

Source:
Convert.cs
Source:
Convert.cs
Source:
Convert.cs

Convertit un sous-ensemble d'un tableau d'entiers non signés 8 bits en sous-ensemble équivalent d'un tableau de caractères Unicode encodé en chiffres base 64. Des paramètres spécifient les sous-ensembles en tant qu'offsets des tableaux d'entrée et de sortie ainsi que le nombre d'éléments du tableau d'entrée à convertir.

public:
 static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut);
public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut);
static member ToBase64CharArray : byte[] * int * int * char[] * int -> int
Public Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer) As Integer

Paramètres

inArray
Byte[]

Tableau d'entrée d'entiers non signés 8 bits.

offsetIn
Int32

Position au sein de inArray.

length
Int32

Nombre d'éléments de inArray à convertir.

outArray
Char[]

Tableau de sortie de caractères Unicode.

offsetOut
Int32

Position au sein de outArray.

Retours

Entier 32 bits signé contenant le nombre d'octets dans outArray.

Exceptions

inArray ou outArray est null.

offsetIn, offsetOut ou length est un nombre négatif.

- ou -

offsetIn plus length est supérieur à la longueur d’inArray.

- ou -

offsetOut plus le nombre d’éléments à retourner est supérieur à la longueur d’outArray.

Exemples

L’exemple suivant montre comment utiliser la ToBase64CharArray méthode pour UUencode (encoder en base 64) un flux binaire, puis enregistrer l’encodage dans un fichier.

public:
   void EncodeWithCharArray()
   {
      FileStream^ inFile;
      array<Byte>^binaryData;

      try
      {
         inFile = gcnew FileStream( inputFileName,
                                    FileMode::Open,
                                    FileAccess::Read );
         binaryData = gcnew array<Byte>((int)(inFile->Length));
         long bytesRead = inFile->Read( binaryData, 0,
                                        (int)inFile->Length );
         inFile->Close();
      }
      catch ( Exception^ exp ) 
      {
         // Error creating stream or reading from it.
         Console::WriteLine( "{0}", exp->Message );
         return;
      }
      
      // Convert the binary input into Base64 UUEncoded output.
      // Each 3 Byte sequence in the source data becomes a 4 Byte
      // sequence in the character array. 
      long arrayLength = (long)((4.0 / 3.0) * binaryData->Length);
      
      // If array length is not divisible by 4, go up to the next
      // multiple of 4.
      if ( arrayLength % 4 != 0 )
      {
         arrayLength += 4 - arrayLength % 4;
      }

      array<Char>^ base64CharArray = gcnew array<Char>(arrayLength);
      try
      {
         Convert::ToBase64CharArray( binaryData,
                                     0,
                                     binaryData->Length,
                                     base64CharArray, 0 );
      }
      catch ( ArgumentNullException^ ) 
      {
         Console::WriteLine( "Binary data array is null." );
         return;
      }
      catch ( ArgumentOutOfRangeException^ ) 
      {
         Console::WriteLine( "Char Array is not large enough." );
         return;
      }
      
      // Write the UUEncoded version to the output file.
      StreamWriter^ outFile;
      try
      {
         outFile = gcnew StreamWriter( outputFileName,
                                       false,
                                       Text::Encoding::ASCII );
         outFile->Write( base64CharArray );
         outFile->Close();
      }
      catch ( Exception^ exp ) 
      {
         // Error creating stream or writing to it.
         Console::WriteLine( " {0}", exp->Message );
      }
   }
public void EncodeWithCharArray() {
   System.IO.FileStream inFile;
   byte[]             binaryData;

   try {
      inFile = new System.IO.FileStream(inputFileName,
                                 System.IO.FileMode.Open,
                                System.IO.FileAccess.Read);
      binaryData = new Byte[inFile.Length];
      long bytesRead = inFile.Read(binaryData, 0,
                           (int) inFile.Length);
      inFile.Close();
   }
   catch (System.Exception exp) {
      // Error creating stream or reading from it.
      System.Console.WriteLine("{0}", exp.Message);
      return;
   }

   // Convert the binary input into Base64 UUEncoded output.
   // Each 3 byte sequence in the source data becomes a 4 byte
   // sequence in the character array.
   long arrayLength = (long) ((4.0d/3.0d) * binaryData.Length);

   // If array length is not divisible by 4, go up to the next
   // multiple of 4.
   if (arrayLength % 4 != 0) {
      arrayLength += 4 - arrayLength % 4;
   }

   char[] base64CharArray = new char[arrayLength];
   try {
      System.Convert.ToBase64CharArray(binaryData,
                               0,
                               binaryData.Length,
                               base64CharArray,
                               0);
   }
   catch (System.ArgumentNullException) {
      System.Console.WriteLine("Binary data array is null.");
      return;
   }
   catch (System.ArgumentOutOfRangeException) {
      System.Console.WriteLine("Char Array is not large enough.");
      return;
   }

   // Write the UUEncoded version to the output file.
   System.IO.StreamWriter outFile;
   try {
      outFile = new System.IO.StreamWriter(outputFileName,
                              false,
                              System.Text.Encoding.ASCII);
      outFile.Write(base64CharArray);
      outFile.Close();
   }
   catch (System.Exception exp) {
      // Error creating stream or writing to it.
      System.Console.WriteLine("{0}", exp.Message);
   }
}
let encodeWithCharArray () =
    try
        use inFile =
            new FileStream(inputFileName, FileMode.Open, FileAccess.Read)

        let binaryData =
            Array.zeroCreate<byte> (int inFile.Length)

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

        // Convert the binary input into Base64 UUEncoded output.
        // Each 3 byte sequence in the source data becomes a 4 byte
        // sequence in the character array.
        let arrayLength =
            (4. / 3.) * float binaryData.Length |> int64

        // If array length is not divisible by 4, shadow up to the next multiple of 4.
        let arrayLength =
            if arrayLength % 4L <> 0L then
                arrayLength + (4L - arrayLength % 4L)
            else
                arrayLength

        let base64CharArray = Array.zeroCreate<char> (int arrayLength)

        Convert.ToBase64CharArray(binaryData, 0, binaryData.Length, base64CharArray, 0)
        |> ignore
        // Write the UUEncoded version to the output file.
        use outFile =
            new StreamWriter(outputFileName, false, Encoding.ASCII)

        outFile.Write(base64CharArray)
        outFile.Close()
    with
    | :? ArgumentNullException -> printfn "Binary data array is null."
    | :? ArgumentOutOfRangeException -> printfn "Char Array is not large enough."
    | e ->
        // Error creating stream or writing to it.
        printfn $"{e.Message}"
Public Sub EncodeWithCharArray()
   Dim inFile As System.IO.FileStream
   Dim binaryData() As Byte

   Try
      inFile = New System.IO.FileStream(inputFileName, _
                                        System.IO.FileMode.Open, _
                                        System.IO.FileAccess.Read)
      ReDim binaryData(inFile.Length)
      Dim bytesRead As Long = inFile.Read(binaryData, _
                                          0, _
                                          CInt(inFile.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 binary input into Base64 UUEncoded output.
   ' Each 3 byte sequence in the source data becomes a 4 byte
   ' sequence in the character array. 
   Dim arrayLength As Long 
   arrayLength = (4 / 3) * binaryData.Length
   If arrayLength Mod 4 <> 0 Then
      arrayLength = arrayLength + 4 - arrayLength Mod 4
   End If

   Dim base64CharArray(arrayLength - 1) As Char
   Try
      System.Convert.ToBase64CharArray(binaryData, _
                                       0, _
                                       binaryData.Length, _
                                       base64CharArray, 0)
   Catch exp As System.ArgumentNullException
      System.Console.WriteLine("Binary data array is null.")
      Return
   Catch exp As System.ArgumentOutOfRangeException
      System.Console.WriteLine("Char Array is not large enough.")
      Return
   End Try

   ' Write the UUEncoded version to the output file.
   Dim outFile As System.IO.StreamWriter
   Try
      outFile = New System.IO.StreamWriter(outputFileName, _
                                           False, _
                                           System.Text.Encoding.ASCII)
      outFile.Write(base64CharArray)
      outFile.Close()
   Catch exp As System.Exception
      ' Error creating stream or writing to it.
      System.Console.WriteLine("{0}", exp.Message)
   End Try
End Sub

Remarques

Le sous-ensemble d’éléments length de inArray commençant à la position offsetIn, sont pris en tant que valeur numérique et convertis en un sous-ensemble d’éléments en outArray commençant à la position offsetOut. La valeur de retour indique le nombre d’éléments convertis dans outArray. Le sous-ensemble de outArray se compose de chiffres en base 64.

Les chiffres de base 64 dans l’ordre croissant de zéro sont les caractères majuscules « A » à « Z », les minuscules « a » à « z », les chiffres « 0 » à « 9 » et les symboles « + » et « / ». Le caractère sans valeur, « = », est utilisé pour le remplissage de fin.

Les offset paramètres et length sont des nombres signés 32 bits. Les offsetIn paramètres et offsetOut sont des positions de tableau de base zéro.

Important

La ToBase64CharArray méthode est conçue pour traiter un tableau d’octets unique qui contient toutes les données à encoder. Pour créer un tableau de caractères en base 64 à partir d’un flux d’octets, utilisez la System.Security.Cryptography.ToBase64Transform classe .

Voir aussi

S’applique à