Auf Englisch lesen

Freigeben über


Convert.ToBase64String Methode

Definition

Wandelt den Wert eines Arrays von 8-Bit-ganzzahlen ohne Vorzeichen in die entsprechende Zeichenfolgendarstellung um, die mit Base64-Ziffern codiert ist.

Überlädt

ToBase64String(Byte[])

Konvertiert ein Array von 8-Bit-ganzzahlen ohne Vorzeichen in die entsprechende Zeichenfolgendarstellung, die mit Base64-Ziffern codiert ist.

ToBase64String(Byte[], Base64FormattingOptions)

Konvertiert ein Array von 8-Bit-ganzzahlen ohne Vorzeichen in die entsprechende Zeichenfolgendarstellung, die mit Base64-Ziffern codiert ist. Sie können angeben, ob Zeilenumbrüche in den Rückgabewert eingefügt werden sollen.

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Wandelt die 8-Bit-Ganzzahlen innerhalb der angegebenen schreibgeschützten Spanne in die entsprechende Zeichenfolgendarstellung um, die mit Base64-Ziffern codiert ist. Optional können Sie angeben, ob Zeilenumbrüche in den Rückgabewert eingefügt werden sollen.

ToBase64String(Byte[], Int32, Int32)

Wandelt eine Teilmenge eines Arrays von 8-Bit-ganzzahlen ohne Vorzeichen in die entsprechende Zeichenfolgendarstellung um, die mit Base64-Ziffern codiert ist. Parameter geben die Teilmenge als Offset im Eingabearray und die Anzahl der zu konvertierenden Elemente im Array an.

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

Wandelt eine Teilmenge eines Arrays von 8-Bit-ganzzahlen ohne Vorzeichen in die entsprechende Zeichenfolgendarstellung um, die mit Base64-Ziffern codiert ist. Parameter geben die Teilmenge als Offset im Eingabearray, die Anzahl der zu konvertierenden Elemente im Array an und ob Zeilenumbrüche in den Rückgabewert eingefügt werden sollen.

ToBase64String(Byte[])

Quelle:
Convert.cs
Quelle:
Convert.cs
Quelle:
Convert.cs

Konvertiert ein Array von 8-Bit-ganzzahlen ohne Vorzeichen in die entsprechende Zeichenfolgendarstellung, die mit Base64-Ziffern codiert ist.

C#
public static string ToBase64String (byte[] inArray);

Parameter

inArray
Byte[]

Ein Array von 8-Bit-ganzzahlen ohne Vorzeichen.

Gibt zurück

Die Zeichenfolgendarstellung in Basis 64 des Inhalts von inArray.

Ausnahmen

inArray ist null.

Beispiele

Im folgenden Beispiel wird die ToBase64String(Byte[])-Methode verwendet, um ein Bytearray in eine UUencoded -Zeichenfolge (Base-64) zu konvertieren, und ruft dann die FromBase64String(String)-Methode auf, um das ursprüngliche Bytearray wiederherzustellen.

C#
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

Im Folgenden sehen Sie ein komplexeres Beispiel, das ein 20-Elementarray mit 32-Bit-Ganzzahlen erstellt. Anschließend wird die BitConverter.GetBytes(Int32)-Methode verwendet, um jedes Element in ein Bytearray zu konvertieren, das in der entsprechenden Position in einem Puffer gespeichert wird, indem die Array.Copy(Array, Int32, Array, Int32, Int32)-Methode aufgerufen wird. Dieser Puffer wird dann an die ToBase64String(Byte[])-Methode übergeben, um eine UUencoded -Zeichenfolge (Base-64) zu erstellen. Anschließend ruft sie die FromBase64String(String)-Methode auf, um die UUencoded-Zeichenfolge zu decodieren, und ruft die BitConverter.ToInt32-Methode auf, um jeden Satz von vier Byte (die Größe einer 32-Bit-Ganzzahl) in eine ganze Zahl zu konvertieren. Die Ausgabe aus dem Beispiel zeigt, dass das ursprüngliche Array erfolgreich wiederhergestellt wurde.

C#
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 }

Hinweise

Die Elemente von inArray werden als numerischer Wert verwendet und in eine Zeichenfolgendarstellung konvertiert, die mit Base64-Ziffern codiert ist.

Die Base64-Ziffern in aufsteigender Reihenfolge von null sind die Großbuchstaben "A" bis "Z", die Kleinbuchstaben "a" in "z", die Ziffern "0" in "9" und die Symbole "+" und "/". Das wertlose Zeichen "=" wird für nachfolgende Abstände verwendet.

Wichtig

Die ToBase64String-Methode wurde entwickelt, um ein einzelnes Bytearray zu verarbeiten, das alle zu codierenden Daten enthält. Verwenden Sie zum Codieren von Daten aus einem Datenstrom die System.Security.Cryptography.ToBase64Transform Klasse.

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 durch Aufrufen der ToBase64String-Methode, ist die resultierende Zeichenfolge nicht unbedingt identisch mit der ursprünglichen Zeichenfolge. Die Zeichenfolge wird nur gerundet, wenn die ursprüngliche Zeichenfolge eine gültige base64-codierte Zeichenfolge ist.

Weitere Informationen

Gilt für:

.NET 9 und andere Versionen
Produkt Versionen
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

ToBase64String(Byte[], Base64FormattingOptions)

Quelle:
Convert.cs
Quelle:
Convert.cs
Quelle:
Convert.cs

Konvertiert ein Array von 8-Bit-ganzzahlen ohne Vorzeichen in die entsprechende Zeichenfolgendarstellung, die mit Base64-Ziffern codiert ist. Sie können angeben, ob Zeilenumbrüche in den Rückgabewert eingefügt werden sollen.

C#
public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);
C#
[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);

Parameter

inArray
Byte[]

Ein Array von 8-Bit-ganzzahlen ohne Vorzeichen.

options
Base64FormattingOptions

InsertLineBreaks, um einen Zeilenumbruch alle 76 Zeichen einzufügen, oder None, zeilenumbrüche nicht einzufügen.

Gibt zurück

Die Zeichenfolgendarstellung in Der Basis 64 der Elemente in inArray.

Attribute

Ausnahmen

inArray ist null.

options ist kein gültiger Base64FormattingOptions Wert.

Beispiele

Im folgenden Beispiel wird die Convert.ToBase64String(Byte[], Base64FormattingOptions) mit einem Base64FormattingOptions.InsertLineBreaks-Argument aufgerufen, um Zeilenumbrüche in die Zeichenfolge einzufügen, die durch codieren eines Bytearrays mit 100 Elementen erzeugt wird.

C#
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

Wie die Ausgabe aus dem Beispiel zeigt, ist die Convert.FromBase64String erfolgreich, das ursprüngliche Bytearray wiederherzustellen; Die Zeilenumbruchzeichen werden während der Konvertierung ignoriert.

Hinweise

Die Elemente des inArray-Parameters werden als numerischer Wert verwendet und in eine Zeichenfolgendarstellung in Basis 64 konvertiert.

Die Base64-Ziffern in aufsteigender Reihenfolge von null sind die Großbuchstaben "A" bis "Z", die Kleinbuchstaben "a" in "z", die Ziffern "0" in "9" und die Symbole "+" und "/". Das wertlose Zeichen "=" wird für nachfolgende Abstände verwendet.

Wichtig

Die ToBase64String-Methode wurde entwickelt, um ein einzelnes Bytearray zu verarbeiten, das alle zu codierenden Daten enthält. Verwenden Sie zum Codieren von Daten aus einem Datenstrom die System.Security.Cryptography.ToBase64Transform Klasse.

Wenn der parameter options auf InsertLineBreaks festgelegt ist und die Ausgabe der Konvertierung länger als 76 Zeichen ist, wird ein Zeilenumbruch alle 76 Zeichen eingefügt. Ein Zeilenumbruch wird als Wagenrücklaufzeichen (U+000D) gefolgt von einem Zeilenvorschubzeichen (U+000A) definiert. Da Zeilenumbrüche als Leerzeichen in einer Base64-Codierung gelten, werden sie beim Konvertieren einer base64-codierten Zeichenfolge zurück in ein Bytearray ignoriert. Die Zeilenumbrüche sind einfach praktisch, wenn die codierte Zeichenfolge auf einem Steuerelement oder einem Gerät wie einem Konsolenfenster angezeigt wird. Weitere Informationen finden Sie unter RFC 2045, "Multipurpose Internet Mail Extensions", unter https://www.rfc-editor.org/.

Weitere Informationen

Gilt für:

.NET 9 und andere Versionen
Produkt Versionen
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Quelle:
Convert.cs
Quelle:
Convert.cs
Quelle:
Convert.cs

Wandelt die 8-Bit-Ganzzahlen innerhalb der angegebenen schreibgeschützten Spanne in die entsprechende Zeichenfolgendarstellung um, die mit Base64-Ziffern codiert ist. Optional können Sie angeben, ob Zeilenumbrüche in den Rückgabewert eingefügt werden sollen.

C#
public static string ToBase64String (ReadOnlySpan<byte> bytes, Base64FormattingOptions options = System.Base64FormattingOptions.None);

Parameter

bytes
ReadOnlySpan<Byte>

Eine schreibgeschützte Spanne von 8-Bit-ganzzahlen ohne Vorzeichen.

options
Base64FormattingOptions

Einer der Enumerationswerte, die angeben, ob Zeilenumbrüche in den Rückgabewert eingefügt werden sollen. Der Standardwert ist None.

Gibt zurück

Die Zeichenfolgendarstellung in Der Basis 64 der Elemente in bytes. Wenn die Länge von bytes 0 ist, wird eine leere Zeichenfolge zurückgegeben.

Ausnahmen

options ist kein gültiger Base64FormattingOptions Wert.

Die Ausgabelänge war größer als Int32.MaxValue.

Gilt für:

.NET 9 und andere Versionen
Produkt Versionen
.NET Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Standard 2.1

ToBase64String(Byte[], Int32, Int32)

Quelle:
Convert.cs
Quelle:
Convert.cs
Quelle:
Convert.cs

Wandelt eine Teilmenge eines Arrays von 8-Bit-ganzzahlen ohne Vorzeichen in die entsprechende Zeichenfolgendarstellung um, die mit Base64-Ziffern codiert ist. Parameter geben die Teilmenge als Offset im Eingabearray und die Anzahl der zu konvertierenden Elemente im Array an.

C#
public static string ToBase64String (byte[] inArray, int offset, int length);

Parameter

inArray
Byte[]

Ein Array von 8-Bit-ganzzahlen ohne Vorzeichen.

offset
Int32

Ein Offset in inArray.

length
Int32

Die Anzahl der zu konvertierenden Elemente inArray.

Gibt zurück

Die Zeichenfolgendarstellung in Der Basis 64 von length Elementen von inArray, beginnend bei position offset.

Ausnahmen

inArray ist null.

offset oder length ist negativ.

-oder-

offset plus length ist größer als die Länge der inArray.

Hinweise

Die Elemente von inArray werden als numerischer Wert verwendet und in eine Zeichenfolgendarstellung in Basis 64 konvertiert.

Die Base64-Ziffern in aufsteigender Reihenfolge von null sind die Großbuchstaben "A" bis "Z", die Kleinbuchstaben "a" in "z", die Ziffern "0" in "9" und die Symbole "+" und "/". Das wertlose Zeichen "=" wird für nachfolgende Abstände verwendet.

Die Parameter offset und length sind 32-Bit-Signierte Nummern. Der parameter offset ist nullbasiert.

Wichtig

Die ToBase64String-Methode wurde entwickelt, um ein einzelnes Bytearray zu verarbeiten, das alle zu codierenden Daten enthält. Verwenden Sie zum Codieren von Daten aus einem Datenstrom die System.Security.Cryptography.ToBase64Transform Klasse.

Weitere Informationen

Gilt für:

.NET 9 und andere Versionen
Produkt Versionen
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

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

Quelle:
Convert.cs
Quelle:
Convert.cs
Quelle:
Convert.cs

Wandelt eine Teilmenge eines Arrays von 8-Bit-ganzzahlen ohne Vorzeichen in die entsprechende Zeichenfolgendarstellung um, die mit Base64-Ziffern codiert ist. Parameter geben die Teilmenge als Offset im Eingabearray, die Anzahl der zu konvertierenden Elemente im Array an und ob Zeilenumbrüche in den Rückgabewert eingefügt werden sollen.

C#
public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options);
C#
[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options);

Parameter

inArray
Byte[]

Ein Array von 8-Bit-ganzzahlen ohne Vorzeichen.

offset
Int32

Ein Offset in inArray.

length
Int32

Die Anzahl der zu konvertierenden Elemente inArray.

options
Base64FormattingOptions

InsertLineBreaks, um einen Zeilenumbruch alle 76 Zeichen einzufügen, oder None, zeilenumbrüche nicht einzufügen.

Gibt zurück

Die Zeichenfolgendarstellung in Der Basis 64 von length Elementen von inArray, beginnend bei position offset.

Attribute

Ausnahmen

inArray ist null.

offset oder length ist negativ.

-oder-

offset plus length ist größer als die Länge der inArray.

options ist kein gültiger Base64FormattingOptions Wert.

Beispiele

Im folgenden Beispiel wird die ToBase64String-Methode veranschaulicht. Die Eingabe wird in Gruppen von drei Bytes (jeweils 24 Bit) unterteilt. Folglich besteht jede Gruppe aus vier 6-Bit-Zahlen, bei denen jede Zahl zwischen Dezimalzahl 0 und 63 liegt. In diesem Beispiel gibt es 85 3-Byte-Gruppen mit einem byte verbleibenden Byte. Die erste Gruppe besteht aus den Hexadezimalwerten 00, 01 und 02, die vier 6-Bit-Werte mit dezimal 0, 0, 4 und 2 ergeben. Diese vier Werte entsprechen den Basis-64 Ziffern "A", "A", "E" und "C" am Anfang der Ausgabe.

Wenn keine integrale Anzahl von 3-Byte-Gruppen vorhanden ist, werden die verbleibenden Bytes effektiv mit Nullen aufgefüllt, um eine vollständige Gruppe zu bilden. In diesem Beispiel ist der Wert des letzten Bytes hexadezimal FF. Die ersten 6 Bits sind gleich dezimal 63, was der Basis-64-Ziffer "/" am Ende der Ausgabe entspricht, und die nächsten 2 Bits werden mit Nullen aufgefüllt, um eine Dezimalzahl von 48 zu erzielen, die der Basis-64-Ziffer "w" entspricht. Die letzten beiden 6-Bit-Werte sind Abstand und entsprechen dem wertlosen Abstandszeichen "=".

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

*/

Hinweise

Die Elemente des inArray-Parameters werden als numerischer Wert verwendet und in eine Zeichenfolgendarstellung in Basis 64 konvertiert.

Die Base64-Ziffern in aufsteigender Reihenfolge von null sind die Großbuchstaben "A" bis "Z", die Kleinbuchstaben "a" in "z", die Ziffern "0" in "9" und die Symbole "+" und "/". Das wertlose Zeichen "=" wird für nachfolgende Abstände verwendet.

Die Parameter offset und length sind 32-Bit-Signierte Nummern. Der parameter offset ist nullbasiert.

Wichtig

Die ToBase64String-Methode wurde entwickelt, um ein einzelnes Bytearray zu verarbeiten, das alle zu codierenden Daten enthält. Verwenden Sie zum Codieren von Daten aus einem Datenstrom die System.Security.Cryptography.ToBase64Transform Klasse.

Wenn der parameter options auf InsertLineBreaks festgelegt ist und die Ausgabe der Konvertierung länger als 76 Zeichen ist, wird ein Zeilenumbruch alle 76 Zeichen eingefügt. Ein Zeilenumbruch wird als Wagenrücklaufzeichen (U+000D) gefolgt von einem Zeilenvorschubzeichen (U+000A) definiert. Weitere Informationen finden Sie unter RFC 2045, "Multipurpose Internet Mail Extensions", unter https://www.rfc-editor.org/.

Weitere Informationen

Gilt für:

.NET 9 und andere Versionen
Produkt Versionen
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1