Convert.ToBase64String Methode

Definition

Konvertiert den Wert eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.Converts the value of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits.

Überlädt

ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)

Konvertiert eine Teilmenge eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parameter geben die Teilmenge als Offset im Eingabearray, die Anzahl der Elemente im zu konvertierenden Array sowie ggf. im Rückgabewert einzufügende Zeilenumbrüche an.Parameters specify the subset as an offset in the input array, the number of elements in the array to convert, and whether to insert line breaks in the return value.

ToBase64String(Byte[], Int32, Int32)

Konvertiert eine Teilmenge eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parameter geben die Teilmenge als Offset im Eingabearray und die Anzahl der Elemente im zu konvertierenden Array an.Parameters specify the subset as an offset in the input array, and the number of elements in the array to convert.

ToBase64String(Byte[], Base64FormattingOptions)

Konvertiert ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Ein Parameter gibt an, ob im Rückgabewert Zeilenumbrüche eingefügt werden sollen.A parameter specifies whether to insert line breaks in the return value.

ToBase64String(Byte[])

Konvertiert ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits.

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)

Konvertiert eine Teilmenge eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parameter geben die Teilmenge als Offset im Eingabearray, die Anzahl der Elemente im zu konvertierenden Array sowie ggf. im Rückgabewert einzufügende Zeilenumbrüche an.Parameters specify the subset as an offset in the input array, the number of elements in the array to convert, and whether to insert line breaks in the return value.

public:
 static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, int offset, int length, Base64FormattingOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options);
static member ToBase64String : byte[] * int * int * Base64FormattingOptions -> string
Public Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer, options As Base64FormattingOptions) As String

Parameter

inArray
Byte[]

Ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen.An array of 8-bit unsigned integers.

offset
Int32

Ein Offset in inArray.An offset in inArray.

length
Int32

Die Anzahl der zu konvertierenden Elemente aus inArray.The number of elements of inArray to convert.

options
Base64FormattingOptions

InsertLineBreaks, wenn nach je 76 Zeichen ein Zeilenumbruch eingefügt werden soll, oder None, wenn keine Zeilenumbrüche eingefügt werden sollen.InsertLineBreaks to insert a line break every 76 characters, or None to not insert line breaks.

Gibt zurück

Die Zeichenfolgendarstellung von length Elementen von inArray ab Position offset als Base-64.The string representation in base 64 of length elements of inArray, starting at position offset.

Attribute

Ausnahmen

inArray ist null.inArray is null.

offset oder length ist ein negativer Wert.offset or length is negative.

- oder --or- offset plus length ist größer als die Länge von inArray.offset plus length is greater than the length of inArray.

options ist kein gültiger Base64FormattingOptions-Wert.options is not a valid Base64FormattingOptions value.

Beispiele

Das folgende Beispiel veranschaulicht die ToBase64String Methode.The following example demonstrates the ToBase64String method. Die Eingabe ist in Gruppen von jeweils drei Bytes (24 Bits) unterteilt.The input is divided into groups of three bytes (24 bits) each. Folglich besteht jede Gruppe aus vier 6-Bit-Zahlen, wobei jede Zahl zwischen Decimal 0 und 63 liegt.Consequently, each group consists of four 6-bit numbers where each number ranges from decimal 0 to 63. In diesem Beispiel gibt es 85 3-Byte-Gruppen, die ein Byte verbleiben.In this example, there are 85 3-byte groups with one byte remaining. Die erste Gruppe besteht aus den hexadezimalen Werten 00, 01 und 02, die vier 6-Bit-Werte ergeben, die dezimal 0, 0, 4 und 2 entsprechen.The first group consists of the hexadecimal values 00, 01, and 02, which yield four 6-bit values equal to decimal 0, 0, 4, and 2. Diese vier Werte entsprechen den Basis-64-Ziffern "a", "a", "E" und "C" am Anfang der Ausgabe.Those four values correspond to the base-64 digits "A", "A", "E", and "C" at the beginning of the output.

Wenn keine ganzzahlige Anzahl von 3-Byte-Gruppen vorhanden ist, werden die verbleibenden Bytes effektiv mit Nullen aufgefüllt, um eine vollständige Gruppe zu bilden.If an integral number of 3-byte groups does not exist, the remaining bytes are effectively padded with zeros to form a complete group. In diesem Beispiel ist der Wert des letzten Bytes hexadezimal ff.In this example, the value of the last byte is hexadecimal FF. Die ersten 6 Bits sind gleich Decimal 63. Dies entspricht 64 der Ziffer "/" am Ende der Ausgabe, und die nächsten 2 Bits werden mit Nullen aufgefüllt, um Decimal 48 zu erhalten, was der Base-64-Ziffer "w" entspricht.The first 6 bits are equal to decimal 63, which corresponds to the base-64 digit "/" at the end of the output, and the next 2 bits are padded with zeros to yield decimal 48, which corresponds to the base-64 digit, "w". Die letzten zwei 6-Bit-Werte sind Auffüll Zeichen und entsprechen dem Text Füll Zeichen (=).The last two 6-bit values are padding and correspond to the valueless padding character, "=".

// This example demonstrates the Convert.ToBase64String() and 
//                               Convert.FromBase64String() methods
using namespace System;
bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 );
int main()
{
   array<Byte>^inArray = gcnew array<Byte>(256);
   array<Byte>^outArray = gcnew array<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 ) );
}

bool ArraysAreEqual( array<Byte>^a1, array<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

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

*/
' This example demonstrates the Convert.ToBase64String() and 
'                               Convert.FromBase64String() methods
Class Sample
   Public Shared Sub Main()
      Dim inArray(255)  As Byte
      Dim outArray(255) As Byte
      Dim s2 As String
      Dim s3 As String
      Dim step1 As String = "1) The input is a byte array (inArray) of arbitrary data."
      Dim step2 As String = "2) Convert a subarray of the input data array to a base 64 string."
      Dim step3 As String = "3) Convert the entire input data array to a base 64 string."
      Dim step4 As String = "4) The two methods in steps 2 and 3 produce the same result: {0}"
      Dim step5 As String = "5) Convert the base 64 string to an output byte array (outArray)."
      Dim step6 As String = "6) The input and output arrays, inArray and outArray, are equal: {0}"
      Dim x As Integer
      Dim nl As String = Environment.NewLine
      Dim ruler1a As String = "         1         2         3         4"
      Dim ruler2a As String = "1234567890123456789012345678901234567890"
      Dim ruler3a As String = "----+----+----+----+----+----+----+----+"
      Dim ruler1b As String = "         5         6         7      "
      Dim ruler2b As String = "123456789012345678901234567890123456"
      Dim ruler3b As String = "----+----+----+----+----+----+----+-"
      Dim ruler As String = [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 To inArray.Length - 1
         inArray(x) = CByte(x)
         Console.Write("{0:X2} ", inArray(x))
         If (x + 1) Mod 20 = 0 Then
            Console.WriteLine()
         End If
      Next x
      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))
   End Sub
   
   
   Public Shared Function ArraysAreEqual(a1() As Byte, a2() As Byte) As Boolean
      If a1.Length <> a2.Length Then
         Return False
      End If
      Dim i As Integer
      For i = 0 To a1.Length - 1
         If a1(i) <> a2(i) Then
            Return False
         End If
      Next i
      Return True
   End Function 'ArraysAreEqual
End Class
'
'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
'

Hinweise

Die Elemente des inArray -Parameters werden als numerischer Wert angenommen und in Basis 64 in eine Zeichen folgen Darstellung konvertiert.The elements of the inArray parameter are taken as a numeric value and converted to a string representation in base 64.

Die Basis-64-Ziffern in aufsteigender Reihenfolge von NULL sind die Großbuchstaben "a" bis "z", die Kleinbuchstaben "a" bis "z", die Ziffern "0" bis "9" und die Symbole "+" und "/".The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". Das wertlose Zeichen "=" wird für nachfolgende Auffüll Zeichen verwendet.The valueless character "=" is used for trailing padding.

Die offset Parameter length und sind 32-Bit-Nummern mit Vorzeichen.The offset and length parameters are 32-bit signed numbers. Der offset -Parameter ist NULL basiert.The offset parameter is zero-based.

Wichtig

Die ToBase64String -Methode ist so konzipiert, dass Sie ein einzelnes Bytearray verarbeitet, das alle zu codierenden Daten enthält.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. Verwenden Sie die System.Security.Cryptography.ToBase64Transform -Klasse, um Daten aus einem Datenstrom zu codieren.To encode data from a stream, use the System.Security.Cryptography.ToBase64Transform class.

Wenn der options -Parameter auf InsertLineBreaks festgelegt ist und die Ausgabe der Konvertierung länger als 76 Zeichen ist, wird jedes 76-Zeichen ein Zeilenumbruch eingefügt.If the options parameter is set to InsertLineBreaks and the output of the conversion is longer than 76 characters, a line break is inserted every 76 characters. Ein Zeilenumbruch ist als Wagen Rücklauf Zeichen (u + 000D) gefolgt von einem Zeilenvorschub Zeichen (u + 000A) definiert.A line break is defined as a carriage return character (U+000D) followed by a line feed character (U+000A). Weitere Informationen finden Sie unter RFC 2045, "Multipurpose Internet Mail Extensions", unter https://www.rfc-editor.org/.For more information, see RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

Siehe auch

ToBase64String(Byte[], Int32, Int32)

Konvertiert eine Teilmenge eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parameter geben die Teilmenge als Offset im Eingabearray und die Anzahl der Elemente im zu konvertierenden Array an.Parameters specify the subset as an offset in the input array, and the number of elements in the array to convert.

public:
 static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, int offset, int length);
public static string ToBase64String (byte[] inArray, int offset, int length);
static member ToBase64String : byte[] * int * int -> string
Public Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer) As String

Parameter

inArray
Byte[]

Ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen.An array of 8-bit unsigned integers.

offset
Int32

Ein Offset in inArray.An offset in inArray.

length
Int32

Die Anzahl der zu konvertierenden Elemente aus inArray.The number of elements of inArray to convert.

Gibt zurück

Die Zeichenfolgendarstellung von length Elementen von inArray ab Position offset als Base-64.The string representation in base 64 of length elements of inArray, starting at position offset.

Ausnahmen

inArray ist null.inArray is null.

offset oder length ist ein negativer Wert.offset or length is negative.

- oder --or- offset plus length ist größer als die Länge von inArray.offset plus length is greater than the length of inArray.

Hinweise

Die Elemente von inArray werden als numerischer Wert angenommen und in Basis 64 in eine Zeichen folgen Darstellung konvertiert.The elements of inArray are taken as a numeric value and converted to a string representation in base 64.

Die Basis-64-Ziffern in aufsteigender Reihenfolge von NULL sind die Großbuchstaben "a" bis "z", die Kleinbuchstaben "a" bis "z", die Ziffern "0" bis "9" und die Symbole "+" und "/".The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". Das wertlose Zeichen "=" wird für nachfolgende Auffüll Zeichen verwendet.The valueless character, "=", is used for trailing padding.

Die offset Parameter length und sind 32-Bit-Nummern mit Vorzeichen.The offset and length parameters are 32-bit signed numbers. Der offset -Parameter ist NULL basiert.The offset parameter is zero-based.

Wichtig

Die ToBase64String -Methode ist so konzipiert, dass Sie ein einzelnes Bytearray verarbeitet, das alle zu codierenden Daten enthält.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. Verwenden Sie die System.Security.Cryptography.ToBase64Transform -Klasse, um Daten aus einem Datenstrom zu codieren.To encode data from a stream, use the System.Security.Cryptography.ToBase64Transform class.

Siehe auch

ToBase64String(Byte[], Base64FormattingOptions)

Konvertiert ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Ein Parameter gibt an, ob im Rückgabewert Zeilenumbrüche eingefügt werden sollen.A parameter specifies whether to insert line breaks in the return value.

public:
 static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, Base64FormattingOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);
static member ToBase64String : byte[] * Base64FormattingOptions -> string
Public Shared Function ToBase64String (inArray As Byte(), options As Base64FormattingOptions) As String

Parameter

inArray
Byte[]

Ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen.An array of 8-bit unsigned integers.

options
Base64FormattingOptions

InsertLineBreaks, wenn nach je 76 Zeichen ein Zeilenumbruch eingefügt werden soll, oder None, wenn keine Zeilenumbrüche eingefügt werden sollen.InsertLineBreaks to insert a line break every 76 characters, or None to not insert line breaks.

Gibt zurück

Die Zeichenfolgendarstellung der Elemente in inArray als Base-64.The string representation in base 64 of the elements in inArray.

Attribute

Ausnahmen

inArray ist null.inArray is null.

options ist kein gültiger Base64FormattingOptions-Wert.options is not a valid Base64FormattingOptions value.

Beispiele

Im folgenden Beispiel wird der Convert.ToBase64String(Byte[], Base64FormattingOptions) mit einem Base64FormattingOptions.InsertLineBreaks -Argument aufgerufen, um Zeilenumbrüche in der Zeichenfolge einzufügen, die durch Codieren eines 100-Element-Bytearrays erzeugt wird.The following example calls the Convert.ToBase64String(Byte[], Base64FormattingOptions) with a Base64FormattingOptions.InsertLineBreaks argument to insert line breaks in the string that is produced by encoding a 100-element byte array.

using System;

public class Example
{
   public static void Main()
   {
       // Define a byte array.
       var bytes = new byte[100];
       int originalTotal = 0;
       for (int ctr = 0; ctr <= bytes.GetUpperBound(0); ctr++) {
          bytes[ctr] = (byte)(ctr + 1);
          originalTotal += bytes[ctr];
       }
       // Display summary information about the array.
       Console.WriteLine("The original byte array:");
       Console.WriteLine("   Total elements: {0}", bytes.Length);
       Console.WriteLine("   Length of String Representation: {0}",
                         BitConverter.ToString(bytes).Length);
       Console.WriteLine("   Sum of elements: {0:N0}", originalTotal);                  
       Console.WriteLine();
       
       // Convert the array to a base 64 string.
       string s = Convert.ToBase64String(bytes, 
                                         Base64FormattingOptions.InsertLineBreaks);
       Console.WriteLine("The base 64 string:\n   {0}\n", s);
       
       // Restore the byte array.
       Byte[] newBytes = Convert.FromBase64String(s);
       int newTotal = 0;
       foreach (var newByte in newBytes)
          newTotal += newByte;

       // Display summary information about the restored array.
       Console.WriteLine("   Total elements: {0}", newBytes.Length);
       Console.WriteLine("   Length of String Representation: {0}",
                         BitConverter.ToString(newBytes).Length);
       Console.WriteLine("   Sum of elements: {0:N0}", newTotal);                  
   }
}
// The example displays the following output:
//   The original byte array:
//      Total elements: 100
//      Length of String Representation: 299
//      Sum of elements: 5,050
//   
//   The base 64 string:
//      AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5
//   Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZA==
//   
//      Total elements: 100
//      Length of String Representation: 299
//      Sum of elements: 5,050
Module Example
   Public Sub Main()
       ' Define a byte array.
       Dim bytes(99) As Byte
       Dim originalTotal As Integer = 0
       For ctr As Integer = 0 To bytes.GetUpperBound(0)
          bytes(ctr) = CByte(ctr + 1)
          originalTotal += bytes(ctr)
       Next
       ' Display summary information about the array.
       Console.WriteLine("The original byte array:")
       Console.WriteLine("   Total elements: {0}", bytes.Length)
       Console.WriteLine("   Length of String Representation: {0}",
                         BitConverter.ToString(bytes).Length)
       Console.WriteLine("   Sum of elements: {0:N0}", originalTotal)                  
       Console.WriteLine()
       
       ' Convert the array to a base 64 string.
       Dim s As String = Convert.ToBase64String(bytes, 
                                               Base64FormattingOptions.InsertLineBreaks)
       Console.WriteLine("The base 64 string:{1}   {0}{1}", 
                         s, vbCrLf)
       
       ' Restore the byte array.
       Dim newBytes() As Byte = Convert.FromBase64String(s)
       Dim newTotal As Integer = 0
       For Each newByte In newBytes
          newTotal += newByte
       Next
       ' Display summary information about the restored array.
       Console.WriteLine("   Total elements: {0}", newBytes.Length)
       Console.WriteLine("   Length of String Representation: {0}",
                         BitConverter.ToString(newBytes).Length)
       Console.WriteLine("   Sum of elements: {0:N0}", newTotal)                  
   End Sub
End Module
' The example displays the following output:
'   The original byte array:
'      Total elements: 100
'      Length of String Representation: 299
'      Sum of elements: 5,050
'   
'   The base 64 string:
'      AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5
'   Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZA==
'   
'      Total elements: 100
'      Length of String Representation: 299
'      Sum of elements: 5,050

Wie die Ausgabe des Beispiels zeigt, ist Convert.FromBase64String die Wiederherstellung des ursprünglichen Bytearrays erfolgreich. die Zeilenumbruch Zeichen werden während der Konvertierung ignoriert.As the output from the example shows, the Convert.FromBase64String succeeds in restoring the original byte array; the line break characters are ignored during the conversion.

Hinweise

Die Elemente des inArray -Parameters werden als numerischer Wert angenommen und in Basis 64 in eine Zeichen folgen Darstellung konvertiert.The elements of the inArray parameter are taken as a numeric value and converted to a string representation in base 64.

Die Basis-64-Ziffern in aufsteigender Reihenfolge von NULL sind die Großbuchstaben "a" bis "z", die Kleinbuchstaben "a" bis "z", die Ziffern "0" bis "9" und die Symbole "+" und "/".The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". Das wertlose Zeichen "=" wird für nachfolgende Auffüll Zeichen verwendet.The valueless character "=" is used for trailing padding.

Wichtig

Die ToBase64String -Methode ist so konzipiert, dass Sie ein einzelnes Bytearray verarbeitet, das alle zu codierenden Daten enthält.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. Verwenden Sie die System.Security.Cryptography.ToBase64Transform -Klasse, um Daten aus einem Datenstrom zu codieren.To encode data from a stream, use the System.Security.Cryptography.ToBase64Transform class.

Wenn der options -Parameter auf InsertLineBreaks festgelegt ist und die Ausgabe der Konvertierung länger als 76 Zeichen ist, wird jedes 76-Zeichen ein Zeilenumbruch eingefügt.If the options parameter is set to InsertLineBreaks and the output of the conversion is longer than 76 characters, a line break is inserted every 76 characters. Ein Zeilenumbruch ist als Wagen Rücklauf Zeichen (u + 000D) gefolgt von einem Zeilenvorschub Zeichen (u + 000A) definiert.A line break is defined as a carriage return character (U+000D) followed by a line feed character (U+000A). Da Zeilenumbrüche als Leerzeichen in einer Base-64-Codierung angesehen werden, werden Sie ignoriert, wenn eine Base-64-codierte Zeichenfolge zurück in ein Bytearray umgerechnet wird.Because line breaks are considered white-space characters in a base-64 encoding, they are ignored when converting a base-64 encoded string back to a byte array. Die Zeilenumbrüche sind einfach einfach, wenn die codierte Zeichenfolge für ein Steuerelement oder ein Gerät wie z. b. ein Konsolenfenster angezeigt wird.The line breaks are simply convenient when displaying the encoded string to a control or a device such as a console window. Weitere Informationen finden Sie unter RFC 2045, "Multipurpose Internet Mail Extensions", unter https://www.rfc-editor.org/.For more information, see RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

Siehe auch

ToBase64String(Byte[])

Konvertiert ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits.

public:
 static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray);
public static string ToBase64String (byte[] inArray);
static member ToBase64String : byte[] -> string
Public Shared Function ToBase64String (inArray As Byte()) As String

Parameter

inArray
Byte[]

Ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen.An array of 8-bit unsigned integers.

Gibt zurück

Die Zeichenfolgendarstellung des Inhalts von inArray als Base-64.The string representation, in base 64, of the contents of inArray.

Ausnahmen

inArray ist null.inArray is null.

Beispiele

Im folgenden Beispiel wird die ToBase64String(Byte[]) -Methode verwendet, um ein Bytearray in eine uucodierte Zeichenfolge (Base-64) FromBase64String(String) zu konvertieren. Anschließend wird die-Methode aufgerufen, um das ursprüngliche Bytearray wiederherzustellen.The following example uses the ToBase64String(Byte[]) method to convert a byte array to a UUencoded (base-64) string, and then calls the FromBase64String(String) method to restore the original byte array.

using System;

public class Example
{
   public static void Main()
   {
       // Define a byte array.
       byte[] bytes = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
       Console.WriteLine("The byte array: ");
       Console.WriteLine("   {0}\n", BitConverter.ToString(bytes));
       
       // Convert the array to a base 64 string.
       string s = Convert.ToBase64String(bytes);
       Console.WriteLine("The base 64 string:\n   {0}\n", s);
       
       // Restore the byte array.
       byte[] newBytes = Convert.FromBase64String(s);
       Console.WriteLine("The restored byte array: ");
       Console.WriteLine("   {0}\n", BitConverter.ToString(newBytes));
   }
}
// The example displays the following output:
//     The byte array:
//        02-04-06-08-0A-0C-0E-10-12-14
//     
//     The base 64 string:
//        AgQGCAoMDhASFA==
//     
//     The restored byte array:
//        02-04-06-08-0A-0C-0E-10-12-14
Module Example
   Public Sub Main()
       ' Define a byte array.
       Dim bytes As Byte() = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }
       Console.WriteLine("The byte array: ")
       Console.WriteLine("   {0}", BitConverter.ToString(bytes))
       Console.WriteLine()
       
       ' Convert the array to a base 64 string.
       Dim s As String = Convert.ToBase64String(bytes)
       Console.WriteLine("The base 64 string:{1}   {0}{1}", 
                         s, vbCrLf)
       
       ' Restore the byte array.
       Dim newBytes As Byte() = Convert.FromBase64String(s)
       Console.WriteLine("The restored byte array: ")
       Console.WriteLine("   {0}", BitConverter.ToString(newBytes))
       Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'     The byte array:
'        02-04-06-08-0A-0C-0E-10-12-14
'     
'     The base 64 string:
'        AgQGCAoMDhASFA==
'     
'     The restored byte array:
'        02-04-06-08-0A-0C-0E-10-12-14

Im folgenden finden Sie ein komplexeres Beispiel, in dem ein 20-Element-Array mit ganzen Zahlen mit 32 Bit erstellt wird.The following is a more complex example that creates a 20-element array of 32-bit integers. Anschließend wird die BitConverter.GetBytes(Int32) -Methode verwendet, um jedes Element in ein Bytearray zu konvertieren, das durch Aufrufen der Array.Copy(Array, Int32, Array, Int32, Int32) -Methode an der entsprechenden Position in einem Puffer gespeichert wird.It then uses the BitConverter.GetBytes(Int32) method to convert each element into a byte array, which it stores in the appropriate position in a buffer by calling the Array.Copy(Array, Int32, Array, Int32, Int32) method. Dieser Puffer wird dann an die ToBase64String(Byte[]) -Methode weitergegeben, um eine uucodierte Zeichenfolge (Base-64) zu erstellen.This buffer is then passed to the ToBase64String(Byte[]) method to create a UUencoded (base-64) string. Anschließend wird die FromBase64String(String) -Methode aufgerufen, um die uucodierte Zeichenfolge zu decodieren, und die BitConverter.ToInt32 -Methode wird aufgerufen, um jeden Satz von vier Bytes (die Größe einer 32-Bit-Ganzzahl) in eine ganze Zahl zu konvertieren.It then calls the FromBase64String(String) method to decode the UUencoded string, and calls the BitConverter.ToInt32 method to convert each set of four bytes (the size of a 32-bit integer) to an integer. Die Ausgabe des Beispiels zeigt, dass das ursprüngliche Array erfolgreich wieder hergestellt wurde.The output from the example shows that the original array has been successfully restored.

using System;

public class Example
{
   public static void Main()
   {
      // Define an array of 20 elements and display it.
      int[] arr = new int[20]; 
      int value = 1;
      for (int ctr = 0; ctr <= arr.GetUpperBound(0); ctr++) {
         arr[ctr] = value;
         value = value * 2 + 1;
      }
      DisplayArray(arr);

      // Convert the array of integers to a byte array.
      byte[] bytes = new byte[arr.Length * 4];
      for (int ctr = 0; ctr < arr.Length; ctr++) {
         Array.Copy(BitConverter.GetBytes(arr[ctr]), 0, 
                    bytes, ctr * 4, 4);
      }
         
      // Encode the byte array using Base64 encoding
      String base64 = Convert.ToBase64String(bytes);
      Console.WriteLine("The encoded string: ");
      for (int ctr = 0; ctr <= base64.Length / 50; ctr++) 
         Console.WriteLine(base64.Substring(ctr * 50, 
                                            ctr * 50 + 50 <= base64.Length 
                                               ? 50 : base64.Length - ctr * 50));
      Console.WriteLine();
      
      // Convert the string back to a byte array.
      byte[] newBytes = Convert.FromBase64String(base64);

      // Convert the byte array back to an integer array.
      int[] newArr = new int[newBytes.Length/4];
      for (int ctr = 0; ctr < newBytes.Length / 4; ctr ++)
         newArr[ctr] = BitConverter.ToInt32(newBytes, ctr * 4);
         
      DisplayArray(newArr);
   }

   private static void DisplayArray(Array arr)
   {
      Console.WriteLine("The array:");
      Console.Write("{ ");
      for (int ctr = 0; ctr < arr.GetUpperBound(0); ctr++) {
         Console.Write("{0}, ", arr.GetValue(ctr));
         if ((ctr + 1) % 10 == 0) 
            Console.Write("\n  ");
      }
      Console.WriteLine("{0} {1}", arr.GetValue(arr.GetUpperBound(0)), "}");
      Console.WriteLine();
   }
}
// The example displays the following output:
// The array:
// { 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023,
//   2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575 }
// 
// The encoded string:
// AQAAAAMAAAAHAAAADwAAAB8AAAA/AAAAfwAAAP8AAAD/AQAA/w
// MAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8H
// 
// The array:
// { 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023,
//   2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575 }
Module Example
   Public Sub Main()
      ' Define an array of 20 elements and display it.
      Dim arr(19) As Integer 
      Dim value As Integer = 1
      For ctr As Integer = 0 To arr.GetUpperBound(0)
         arr(ctr) = value
         value = value * 2 + 1
      Next
      DisplayArray(arr)

      ' Convert the array of integers to a byte array.
      Dim bytes(arr.Length * 4 - 1) As Byte 
      For ctr As Integer = 0 To arr.Length - 1
         Array.Copy(BitConverter.GetBytes(arr(ctr)), 0, 
                    bytes, ctr * 4, 4)
      Next
         
      ' Encode the byte array using Base64 encoding
      Dim base64 As String = Convert.ToBase64String(bytes)
      Console.WriteLine("The encoded string: ")
      For ctr As Integer = 0 To base64.Length \ 50 - 1 
         Console.WriteLine(base64.Substring(ctr * 50, 
                                            If(ctr * 50 + 50 <= base64.Length, 
                                               50, base64.Length - ctr * 50)))
      Next
      Console.WriteLine()
      
      ' Convert the string back to a byte array.
      Dim newBytes() As Byte = Convert.FromBase64String(base64)

      ' Convert the byte array back to an integer array.
      Dim newArr(newBytes.Length\4 - 1) As Integer
      For ctr As Integer = 0 To newBytes.Length \ 4 - 1
         newArr(ctr) = BitConverter.ToInt32(newBytes, ctr * 4)
      Next   
      DisplayArray(newArr)
   End Sub

   Private Sub DisplayArray(arr As Array)
      Console.WriteLine("The array:")
      Console.Write("{ ")
      For ctr As Integer = 0 To arr.GetUpperBound(0) - 1
         Console.Write("{0}, ", arr.GetValue(ctr))
         If (ctr + 1) Mod 10 = 0 Then Console.Write("{0}  ", vbCrLf)
      Next
      Console.WriteLine("{0} {1}", arr.GetValue(arr.GetUpperBound(0)), "}")
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'     The array:
'     { 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023,
'       2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575 }
'     
'     The encoded string:
'     AQAAAAMAAAAHAAAADwAAAB8AAAA/AAAAfwAAAP8AAAD/AQAA/w
'     MAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8H
'     
'     The array:
'     { 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023,
'       2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575 }

Hinweise

Die Elemente von inArray werden als numerischer Wert übernommen und in eine Zeichen folgen Darstellung konvertiert, die mit Base-64-Ziffern codiert ist.The elements of inArray are taken as a numeric value and converted to a string representation that is encoded with base-64 digits.

Die Basis-64-Ziffern in aufsteigender Reihenfolge von NULL sind die Großbuchstaben "a" bis "z", die Kleinbuchstaben "a" bis "z", die Ziffern "0" bis "9" und die Symbole "+" und "/".The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". Das wertlose Zeichen "=" wird für nachfolgende Auffüll Zeichen verwendet.The valueless character, "=", is used for trailing padding.

Wichtig

Die ToBase64String -Methode ist so konzipiert, dass Sie ein einzelnes Bytearray verarbeitet, das alle zu codierenden Daten enthält.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. Verwenden Sie die System.Security.Cryptography.ToBase64Transform -Klasse, um Daten aus einem Datenstrom zu codieren.To encode data from a stream, use the System.Security.Cryptography.ToBase64Transform class.

Normalerweise wird ToBase64String die-Methode nicht dazu verwendet, eine uucodierte Zeichenfolge (Base-64-codiert) zu runden.Ordinarily, the ToBase64String method is not used to round-trip a UUEncoded (base-64 encoded) string. Wenn Sie also eine Zeichenfolge durch Aufrufen der FromBase64String -Methode decodieren, codieren Sie das zurückgegebene Bytearray, indem Sie die ToBase64String -Methode aufrufen. die resultierende Zeichenfolge ist nicht notwendigerweise identisch mit der ursprünglichen Zeichenfolge.That is, if you decode a string by calling the FromBase64String method, then encode the returned byte array by calling the ToBase64String method, the resulting string will not necessarily be identical to the original string. Die Zeichenfolge führt einen Roundtrip nur aus, wenn die ursprüngliche Zeichenfolge eine gültige Base-64-codierte Zeichenfolge ist.The string will round-trip only if the original string is a valid base-64 encoded string.

Siehe auch

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

public static string ToBase64String (ReadOnlySpan<byte> bytes, Base64FormattingOptions options = System.Base64FormattingOptions.None);
static member ToBase64String : ReadOnlySpan<byte> * Base64FormattingOptions -> string
Public Shared Function ToBase64String (bytes As ReadOnlySpan(Of Byte), Optional options As Base64FormattingOptions = System.Base64FormattingOptions.None) As String

Parameter

Gibt zurück

Gilt für: