Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Convert.ToBase64String (Byte[], Int32, Int32, Base64FormattingOptions)

 

Data di pubblicazione: ottobre 2016

Converte un subset di una matrice di interi senza segno a 8 bit nella relativa rappresentazione di stringa equivalente codificata con cifre base 64. I parametri specificano il subset come offset nella matrice di input, il numero di elementi nella matrice da convertire e se inserire interruzioni di riga nel valore restituito.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

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

Parametri

inArray
Type: System.Byte[]

Matrice di interi senza segno a 8 bit.

offset
Type: System.Int32

Offset in inArray.

length
Type: System.Int32

Numero di elementi di inArray da convertire.

options
Type: System.Base64FormattingOptions

InsertLineBreaks per inserire un'interruzione di riga ogni 76 caratteri o None per non inserire le interruzioni di riga.

Valore restituito

Type: System.String

Rappresentazione di stringa in base 64 di elementi length di inArray, a partire dalla posizione offset.

Exception Condition
ArgumentNullException

inArray è null.

ArgumentOutOfRangeException

offset o length è negativo.

-oppure-

La somma di offset e length è maggiore della lunghezza di inArray.

ArgumentException

options non è un valore valido di Base64FormattingOptions.

Gli elementi del inArray parametro viene considerato come un valore numerico e convertita in una rappresentazione di stringa in base 64.

Le cifre base 64 in ordine crescente da zero sono i caratteri maiuscoli "A" a "Z", i caratteri minuscoli "a" a "z", i numeri da "0" e "9" e i simboli "+" e "/". Il carattere non significativo "=" viene utilizzato per la spaziatura interna finale.

Il offset e length i parametri sono numeri con segno a 32 bit. Il offset in base zero.

System_CAPS_importantImportante

Il ToBase64String metodo è progettato per elaborare una matrice a byte singolo che contiene tutti i dati da codificare. Per codificare i dati da un flusso, utilizzare la System.Security.Cryptography.ToBase64Transform classe.

Se il options parametro è impostato su InsertLineBreaks e l'output della conversione è più lungo di 76 caratteri, viene inserita un'interruzione di riga ogni 76 caratteri. Un'interruzione di riga è definita come un ritorno a capo (U + 000D) seguito da una riga (U + 000A) carattere di avanzamento. Per ulteriori informazioni, vedere RFC 2045, "Multipurpose Internet Mail Extensions", all'indirizzo http://www.rfc-editor.org/.

Nell'esempio seguente viene illustrato il ToBase64String metodo. L'input viene diviso in gruppi di tre byte (24 bit) ogni. Di conseguenza, ogni gruppo è costituito da quattro numeri 6 bit dove ogni numero compreso tra 0 a 63 decimale. In questo esempio, sono presenti gruppi di 3 byte 85 con un byte rimanenti. Il primo gruppo è costituito da valori esadecimali 00, 01 e 02, ovvero quattro valori a 6 bit uguali a 0, 0, 4 e 2 decimale. Questi quattro valori corrispondono alle cifre base 64 "A", "A", "E" e "C" all'inizio dell'output.

Se non esiste un numero integrale di gruppi da 3 byte, i byte rimanenti vengono completati con zeri in modo da formare un gruppo completo. In questo esempio, il valore dell'ultimo byte è FF esadecimale. I primi 6 bit sono uguali a 63 decimale, che corrisponde alla cifra base 64 "/" alla fine dell'output, e i 2 bit successivi vengono riempite con zeri per ottenere il 48 decimale, che corrisponde alla cifra base 64, "w". Gli ultimi due valori di bit 6 sono la spaziatura interna e corrispondono a non significativo carattere di spaziatura interna "=".

// 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
Disponibile da 2.0
Torna all'inizio
Mostra: