Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Convert.FromBase64CharArray méthode (Char[], Int32, Int32)

 

Date de publication : novembre 2016

Convertit un sous-ensemble d'un tableau de caractères Unicode, qui encode les données binaires en chiffres base 64, en un tableau équivalent d'entiers non signés 8 bits. Des paramètres spécifient le sous-ensemble du tableau d'entrée et le nombre d'éléments à convertir.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

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

Paramètres

inArray
Type: System.Char[]

Tableau de caractères Unicode.

offset
Type: System.Int32

Position au sein de inArray.

length
Type: System.Int32

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

Valeur de retour

Type: System.Byte[]

Tableau d'entiers non signés 8 bits équivalent aux éléments length situés à la position offset dans inArray.

Exception Condition
ArgumentNullException

inArray a la valeur null.

ArgumentOutOfRangeException

offset ou length est inférieur à 0.

ou

offset plus length indique une position qui n’appartient pas à inArray.

FormatException

La longueur d’inArray, en ignorant les espaces blancs, n’est pas zéro ou un multiple de 4.

ou

Le format d’inArray n’est pas valide. inArray contient un caractère non-Base 64, plus de deux caractères de remplissage ou un caractère différent d’un espace blanc parmi les caractères de remplissage.

inArray est constitué de chiffres en base 64, les espaces blancs et les espaces de remplissage. Les chiffres en base 64 dans l’ordre croissant à partir de zéro sont les caractères majuscules « A » à « Z », les caractères minuscules « a » à « z », les chiffres « 0 » à « 9 », ainsi que les symboles « + » et « / ».

Les caractères d’espace blanc et que leurs noms Unicode et points de code hexadécimaux, sont onglet (CHARACTER TABULATION, U + 0009), saut de ligne (LINE FEED, U + 000D), retour chariot (retour chariot, U + 000D) et espace (SPACE, U + 0020). Un nombre arbitraire d’espaces blancs peut apparaître dans inArray car tous les espaces blancs sont ignorés.

Le caractère sans valeur, « = », est utilisé pour le remplissage à droite. La fin de inArray peut se composer de zéro, un ou deux caractères de remplissage.

System_CAPS_importantImportant

Le FromBase64CharArray méthode est conçue pour traiter un tableau de caractères unique qui contient toutes les données à décoder. Pour décoder les données caractères en base 64 à partir d’un flux de données, utilisez la System.Security.Cryptography.FromBase64Transform classe.

L’exemple suivant illustre l’utilisation de la FromBase64CharArray(Char[], Int32, Int32) méthode pour décoder les données UUEncode (base 64) et enregistrez-le en tant que sortie binaire.

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

L’exemple suivant illustre la ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) et FromBase64CharArray(Char[], Int32, Int32) méthodes. L’entrée est divisée en groupes de trois octets (24 bits) chacun. Par conséquent, chaque groupe se compose de quatre nombres de 6 bits où chaque chiffre varie du décimal 0 à 63. Dans cet exemple, il existe de 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 de 6 bits égales à 0, 0, 4 et 2 décimales. 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 remplis avec des zéros pour former un groupe complet. Dans cet exemple, la valeur du dernier octet est la valeur hexadécimale FF. Les 6 premiers bits sont égaux au décimal 63, qui correspond au chiffre en base 64 « / » à la fin de la sortie, et les 2 bits suivants sont remplis avec des zéros pour obtenir le décimal 48, qui correspond au caractère en base 64, « w ». Les deux dernières valeurs de 6 bits sont de remplissage et correspondent à l’aide caractère de remplissage, « = ».

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

*/

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: