Cette page vous a-t-elle été utile ?
Votre avis sur ce contenu est important. N'hésitez pas à nous faire part de vos commentaires.
Vous avez d'autres commentaires ?
1500 caractères restants
ToBase64String, méthode (Byte[], Int32, Int32, Base64FormattingOptions)
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Convert.ToBase64String, méthode (Byte[], Int32, Int32, Base64FormattingOptions)

Convertit un sous-ensemble d'un tableau d'entiers non signés 8 bits en sa représentation sous forme de chaîne équivalente qui est encodée à l'aide de chiffres en base 64. Les paramètres spécifient le sous-ensemble en tant qu'offset dans le tableau d'entrée, le nombre d'éléments dans le tableau à convertir et précisent s'il faut insérer des sauts de ligne dans la valeur de retour.

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

[ComVisibleAttribute(false)]
public static string ToBase64String(
	byte[] inArray,
	int offset,
	int length,
	Base64FormattingOptions options
)

Paramètres

inArray
Type : System.Byte[]
Tableau d'entiers non signés 8 bits.
offset
Type : System.Int32
Offset dans inArray.
length
Type : System.Int32
Nombre d'éléments de inArray à convertir.
options
Type : System.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.

Valeur de retour

Type : System.String
Représentation sous forme de chaîne, en base 64, des éléments length de inArray, en commençant à la position offset.

ExceptionCondition
ArgumentNullException

inArray a la valeur null.

ArgumentOutOfRangeException

offset ou length est négatif.

ou

offset plus length est supérieur à la longueur de inArray.

ArgumentException

options n'est pas une valeur Base64FormattingOptions valide.

Les éléments du paramètre inArray constituent une valeur numérique et sont convertis en une représentation sous forme de chaîne en base 64.

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 « a » à « z », les chiffres « 0 » « 9 », ainsi que les symboles « + » et « / ». Le caractère sans valeur "=" est utilisé pour le remplissage à droite.

Les paramètres offset et length sont des nombres signés 32 bits. Le paramètre offset est de base zéro.

Remarque importanteImportant

La méthode ToBase64String est conçue pour traiter un tableau d'octets unique qui contient toutes les données à encoder. Pour encoder des données à partir d'un flux, utilisez la classe System.Security.Cryptography.ToBase64Transform.

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

L'exemple de code suivant illustre la méthode ToBase64String. 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.ToBase64String() and 
//                               Convert.FromBase64String() methods

using System;
class Sample 
{
    public static void Main() 
    {
    byte[] inArray  = new byte[256];
    byte[] outArray = new byte[256];
    string s2;
    string s3;
    string step1 = "1) The input is a byte array (inArray) of arbitrary data.";
    string step2 = "2) Convert a subarray of the input data array to a base 64 string.";
    string step3 = "3) Convert the entire input data array to a base 64 string.";
    string step4 = "4) The two methods in steps 2 and 3 produce the same result: {0}";
    string step5 = "5) Convert the base 64 string to an output byte array (outArray).";
    string step6 = "6) The input and output arrays, inArray and outArray, are equal: {0}";
    int x;
    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, nl);

// 1) Display an arbitrary array of input data (inArray). The data could be 
//    derived from user input, a file, an algorithm, etc.

    Console.WriteLine(step1);
    Console.WriteLine();
    for (x = 0; x < inArray.Length; x++)
        {
        inArray[x] = (byte)x;
        Console.Write("{0:X2} ", inArray[x]);
        if (((x+1)%20) == 0) Console.WriteLine();
        }
    Console.Write("{0}{0}", nl);

// 2) Convert a subarray of the input data to a base64 string. In this case, 
//    the subarray is the entire input data array. New lines (CRLF) are inserted.

    Console.WriteLine(step2);
    s2 = Convert.ToBase64String(inArray, 0, inArray.Length, 
                                Base64FormattingOptions.InsertLineBreaks);
    Console.WriteLine("{0}{1}{2}{3}", nl, ruler, s2, nl);

// 3) Convert the input data to a base64 string. In this case, the entire 
//    input data array is converted by default. New lines (CRLF) are inserted.

    Console.WriteLine(step3);
    s3 = Convert.ToBase64String(inArray, Base64FormattingOptions.InsertLineBreaks);

// 4) Test whether the methods in steps 2 and 3 produce the same result.
    Console.WriteLine(step4, s2.Equals(s3));

// 5) Convert the base 64 string to an output array (outArray).
    Console.WriteLine(step5);
    outArray = Convert.FromBase64String(s2);

// 6) Is outArray equal to inArray?
   Console.WriteLine(step6, ArraysAreEqual(inArray, outArray));
   }

    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) The input is a byte array (inArray) 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 a subarray of the input data array to a base 64 string.

         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 entire input data array to a base 64 string.
4) The two methods in steps 2 and 3 produce the same result: True
5) Convert the base 64 string to an output byte array (outArray).
6) The input and output arrays, inArray and outArray, are equal: True

*/


.NET Framework

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

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

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.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2015 Microsoft