Convert.ToBase64CharArray Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

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

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.

C#

public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options);

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

Int32

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

Exceptions

ArgumentNullException

inArray ou outArray est null.

ArgumentOutOfRangeException

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.

ArgumentException

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, « = ».

C#

// 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

*/

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

• FromBase64CharArray(Char[], Int32, Int32)
• ToBase64Transform

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

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.

C#

public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut);

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

Int32

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

Exceptions

ArgumentNullException

inArray ou outArray est null.

ArgumentOutOfRangeException

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.

C#

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);
   }
}

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

• FromBase64CharArray(Char[], Int32, Int32)
• ToBase64Transform