Convert.FromBase64CharArray, méthode

Convertit un sous-ensemble d'un tableau de caractères Unicode (qui encode les données binaires en chiffres en base 64) en un tableau équivalent d'entiers non signés 8 bits. Les paramètres spécifient le sous-ensemble dans le 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 équivalant aux éléments length situés à la position offset dans inArray.

ExceptionCondition
ArgumentNullException

inArray a la valeur null.

ArgumentOutOfRangeException

offset ou length est inférieur à 0.

ou

offset plus length indique une position en dehors de inArray.

FormatException

La longueur de inArray n'est pas zéro ou un multiple de 4 (en ignorant les espaces blancs).

ou

Le format de inArray n'est pas valide. inArray contient un caractère qui n'est pas en base 64, plus de deux caractères de remplissage ou un caractère autre qu'espace blanc parmi les caractères de remplissage.

inArray se compose de chiffres en base 64, d'espaces blancs et d'espaces de remplissage à droite. En base 64 et en partant de zéro, les caractères sont, par ordre croissant : les caractères majuscules « A » à « Z », les caractères minuscules « a » à « z », les chiffres « 0 » à « 9 », ainsi que les symboles « + » et « / ».

Les espaces blancs, ainsi que leurs noms Unicode et points de code au format hexadécimal, sont les suivants : tabulation (CHARACTER TABULATION, U+0009), saut de ligne (LINE FEED, U+000A), retour chariot (CARRIAGE RETURN, U+000D) et espace (SPACE, U+0020). Un nombre arbitraire d'espaces blancs peut s'afficher 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 comporter zéro, un ou deux caractères de remplissage.

Remarque importanteImportant

La méthode FromBase64CharArray 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 d'un flux de données, utilisez la classe System.Security.Cryptography.FromBase64Transform.

L'exemple suivant illustre l'utilisation de la méthode FromBase64CharArray(Char[], Int32, Int32) pour le décodage de données encodées à l'aide d'UUencode (base 64) et leur enregistrement sous forme de 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 le fonctionnement des méthodes ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) et FromBase64CharArray(Char[], Int32, Int32). 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 dont chaque chiffre varie du décimal 0 au décimal 63. Dans cet exemple, il y a 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 correspondant aux décimaux 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.

S'il n'existe pas de nombre intégral de groupes de 3 octets, 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 caractère « / » 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 « w » en base 64. Les deux dernières valeurs de 6 bits sont remplies à l'aide du caractère de remplissage sans valeur, "=".


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

*/


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.
Cela vous a-t-il été utile ?
(1500 caractères restants)
Merci pour vos suggestions.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft