Convert.ToBase64String Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Konvertiert den Wert eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.
Überlädt
| ToBase64String(Byte[]) |
Konvertiert ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung. |
| ToBase64String(Byte[], Base64FormattingOptions) |
Konvertiert ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung. Sie können festlegen, ob im Rückgabewert Zeilenumbrüche eingefügt werden sollen. |
| ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions) |
Konvertiert die 8-Bit-Ganzzahlen ohne Vorzeichen in der angegebenen schreibgeschützten Spanne in eine entsprechende Zeichenfolgendarstellung, die mit Base64-Ziffern codiert ist. Sie können optional angeben, ob im Rückgabewert Zeilenumbrüche eingefügt werden sollen. |
| ToBase64String(Byte[], Int32, Int32) |
Konvertiert eine Teilmenge eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung. Parameter geben die Teilmenge als Offset im Eingabearray und die Anzahl der Elemente im zu konvertierenden Array an. |
| 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. 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. |
ToBase64String(Byte[])
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Konvertiert ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung.
public:
static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray);public static string ToBase64String (byte[] inArray);static member ToBase64String : byte[] -> stringPublic Shared Function ToBase64String (inArray As Byte()) As StringParameter
- inArray
- Byte[]
Ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen.
Gibt zurück
Die Zeichenfolgendarstellung des Inhalts von inArray als Base-64.
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 dann wird die -Methode aufgerufen, um das FromBase64String(String) ursprüngliche Bytearray wiederherzustellen.
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
open System
// Define a byte array.
let bytes = [| 2uy; 4uy; 6uy; 8uy; 10uy; 12uy; 14uy; 16uy; 18uy; 20uy |]
printfn $"The byte array:\n {BitConverter.ToString bytes}\n"
// Convert the array to a base 64 string.
let s = Convert.ToBase64String bytes
printfn $"The base 64 string:\n {s}\n"
// Restore the byte array.
let newBytes = Convert.FromBase64String s
printfn $"The restored byte array:\n {BitConverter.ToString newBytes}\n"
// 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, das ein 20-Element-Array von 32-Bit-Ganzzahlen erstellt. Anschließend wird die BitConverter.GetBytes(Int32) -Methode verwendet, um jedes Element in ein Bytearray zu konvertieren, das an 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 wird die FromBase64String(String) -Methode aufgerufen, um die UUencoded-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. Die Ausgabe des Beispiels zeigt, dass das ursprüngliche Array erfolgreich wiederhergestellt wurde.
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 }
open System
let displayArray (arr: 'a[]) =
printfn "The array:"
printf "{ "
for i = 0 to arr.GetUpperBound(0) - 1 do
printf $"{arr[i]}, "
if (i + 1) % 10 = 0 then
printf "\n "
printfn $"{arr[arr.GetUpperBound 0]} }}\n"
// Define an array of 20 elements and display it.
let arr = Array.zeroCreate<int> 20
let mutable value = 1
for i = 0 to arr.GetUpperBound 0 do
arr[i] <- value
value <- value * 2 + 1
displayArray arr
// Convert the array of integers to a byte array.
let bytes = Array.zeroCreate<byte> (arr.Length * 4)
for i = 0 to arr.Length - 1 do
Array.Copy(BitConverter.GetBytes(arr[i]), 0, bytes, i * 4, 4)
// Encode the byte array using Base64 encoding
let base64 = Convert.ToBase64String bytes
printfn "The encoded string: "
printfn $"{base64}\n"
// Convert the string back to a byte array.
let newBytes = Convert.FromBase64String base64
// Convert the byte array back to an integer array.
let newArr = Array.zeroCreate<int> (newBytes.Length / 4)
for i = 0 to newBytes.Length / 4 - 1 do
newArr[i] <- BitConverter.ToInt32(newBytes, i * 4)
displayArray newArr
// 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/wMAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8HAP//DwA=
//
// 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 verwendet und in eine Zeichenfolgendarstellung konvertiert, die mit Base-64-Ziffern codiert ist.
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 "/". Das wertlose Zeichen "=" wird für die nachgestellte Auffüllung verwendet.
Wichtig
Die ToBase64String -Methode ist für die Verarbeitung eines einzelnen Bytearrays konzipiert, das alle zu codierenden Daten enthält. Verwenden Sie die System.Security.Cryptography.ToBase64Transform -Klasse, um Daten aus einem Stream zu codieren.
Normalerweise wird die ToBase64String -Methode nicht zum Roundtrip einer UUEncoded-Zeichenfolge (base-64-codiert) verwendet. Das heißt, wenn Sie eine Zeichenfolge durch Aufrufen der FromBase64String -Methode decodieren und dann das zurückgegebene Bytearray durch Aufrufen der ToBase64String -Methode codieren, ist die resultierende Zeichenfolge nicht notwendigerweise mit der ursprünglichen Zeichenfolge identisch. Die Zeichenfolge wird nur dann roundtripen, wenn die ursprüngliche Zeichenfolge eine gültige Base64-codierte Zeichenfolge ist.
Weitere Informationen
Gilt für:
ToBase64String(Byte[], Base64FormattingOptions)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Konvertiert ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung. Sie können festlegen, ob im Rückgabewert Zeilenumbrüche eingefügt werden sollen.
public:
static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, Base64FormattingOptions options);public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);static member ToBase64String : byte[] * Base64FormattingOptions -> string[<System.Runtime.InteropServices.ComVisible(false)>]
static member ToBase64String : byte[] * Base64FormattingOptions -> stringPublic Shared Function ToBase64String (inArray As Byte(), options As Base64FormattingOptions) As StringParameter
- inArray
- Byte[]
Ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen.
- options
- Base64FormattingOptions
InsertLineBreaks, wenn nach je 76 Zeichen ein Zeilenumbruch eingefügt werden soll, oder None, wenn keine Zeilenumbrüche eingefügt werden sollen.
Gibt zurück
Die Zeichenfolgendarstellung der Elemente in inArray als Base-64.
- Attribute
Ausnahmen
inArray ist null.
options ist kein gültiger Base64FormattingOptions-Wert.
Beispiele
Im folgenden Beispiel wird mit Convert.ToBase64String(Byte[], Base64FormattingOptions) einem Base64FormattingOptions.InsertLineBreaks Argument aufgerufen, um Zeilenumbrüche in die Zeichenfolge einzufügen, die durch codieren eines 100-Element-Bytearrays erzeugt wird.
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
open System
// Define a byte array.
let bytes = Array.init 100 (fun i -> i + 1 |> byte)
let originalTotal = Array.sumBy int bytes
// Display summary information about the array.
printfn "The original byte array:"
printfn $" Total elements: {bytes.Length}"
printfn $" Length of String Representation: {BitConverter.ToString(bytes).Length}"
printfn $" Sum of elements: {originalTotal:N0}\n"
// Convert the array to a base 64 string.
let s =
Convert.ToBase64String(bytes, Base64FormattingOptions.InsertLineBreaks)
printfn $"The base 64 string:\n {s}\n"
// Restore the byte array.
let newBytes = Convert.FromBase64String s
let newTotal = Array.sumBy int newBytes
// Display summary information about the restored array.
printfn $" Total elements: {newBytes.Length}"
printfn $" Length of String Representation: {BitConverter.ToString(newBytes).Length}"
printfn $" Sum of elements: {newTotal:N0}"
// 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 aus dem Beispiel zeigt, kann das Convert.FromBase64String ursprüngliche Bytearray wiederhergestellt werden. 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 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 "/". Das wertlose Zeichen "=" wird für den nachgestellten Abstand verwendet.
Wichtig
Die ToBase64String -Methode ist für die Verarbeitung eines einzelnen Bytearrays konzipiert, das alle zu codierenden Daten enthält. Verwenden Sie die System.Security.Cryptography.ToBase64Transform -Klasse, um Daten aus einem Stream zu codieren.
Wenn der options Parameter auf InsertLineBreaks festgelegt ist und die Ausgabe der Konvertierung länger als 76 Zeichen ist, wird alle 76 Zeichen ein Zeilenumbruch 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 ignoriert, wenn eine Base64-codierte Zeichenfolge zurück in ein Bytearray konvertiert wird. Die Zeilenumbrüche sind einfach praktisch, wenn die codierte Zeichenfolge für ein Steuerelement oder ein Gerät wie ein 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:
ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Konvertiert die 8-Bit-Ganzzahlen ohne Vorzeichen in der angegebenen schreibgeschützten Spanne in eine entsprechende Zeichenfolgendarstellung, die mit Base64-Ziffern codiert ist. Sie können optional angeben, ob im Rückgabewert Zeilenumbrüche eingefügt werden sollen.
public static string ToBase64String (ReadOnlySpan<byte> bytes, Base64FormattingOptions options = System.Base64FormattingOptions.None);static member ToBase64String : ReadOnlySpan<byte> * Base64FormattingOptions -> stringPublic Shared Function ToBase64String (bytes As ReadOnlySpan(Of Byte), Optional options As Base64FormattingOptions = System.Base64FormattingOptions.None) As StringParameter
- bytes
- ReadOnlySpan<Byte>
Eine schreibgeschützte Spanne von 8-Bit-Ganzzahlen ohne Vorzeichen.
- options
- Base64FormattingOptions
Einer der Enumerationswerte, die angeben, ob im Rückgabewert Zeilenumbrüche eingefügt werden sollen. Der Standardwert ist None.
Gibt zurück
Die Zeichenfolgendarstellung der Elemente in inArray als Base-64. 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:
ToBase64String(Byte[], Int32, Int32)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Konvertiert eine Teilmenge eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung. Parameter geben die Teilmenge als Offset im Eingabearray und die Anzahl der Elemente im zu konvertierenden Array an.
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 -> stringPublic Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer) As StringParameter
- inArray
- Byte[]
Ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen.
- offset
- Int32
Ein Offset in inArray.
- length
- Int32
Die Anzahl der zu konvertierenden Elemente aus inArray.
Gibt zurück
Die Zeichenfolgendarstellung von length Elementen von inArray ab Position offset als Base-64.
Ausnahmen
inArray ist null.
offset oder length ist ein negativer Wert.
- oder -
offset plus length ist größer als die Länge von inArray.
Hinweise
Die Elemente von inArray werden als numerischer Wert verwendet und in eine Zeichenfolgendarstellung in Basis 64 konvertiert.
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 "/". Das wertlose Zeichen "=" wird für die nachgestellte Auffüllung verwendet.
Die offset Parameter und length sind 32-Bit-Nummern mit Vorzeichen. Der offset Parameter ist nullbasiert.
Wichtig
Die ToBase64String -Methode ist für die Verarbeitung eines einzelnen Bytearrays konzipiert, das alle zu codierenden Daten enthält. Verwenden Sie die System.Security.Cryptography.ToBase64Transform -Klasse, um Daten aus einem Stream zu codieren.
Weitere Informationen
Gilt für:
ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Konvertiert eine Teilmenge eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in die entsprechende mit Base-64-Ziffern codierte Zeichenfolgendarstellung. 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.
public:
static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, int offset, int length, Base64FormattingOptions options);public static string ToBase64String (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[<System.Runtime.InteropServices.ComVisible(false)>]
static member ToBase64String : byte[] * int * int * Base64FormattingOptions -> stringPublic Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer, options As Base64FormattingOptions) As StringParameter
- inArray
- Byte[]
Ein Array von 8-Bit-Ganzzahlen ohne Vorzeichen.
- offset
- Int32
Ein Offset in inArray.
- length
- Int32
Die Anzahl der zu konvertierenden Elemente aus inArray.
- options
- Base64FormattingOptions
InsertLineBreaks, wenn nach je 76 Zeichen ein Zeilenumbruch eingefügt werden soll, oder None, wenn keine Zeilenumbrüche eingefügt werden sollen.
Gibt zurück
Die Zeichenfolgendarstellung von length Elementen von inArray ab Position offset als Base-64.
- Attribute
Ausnahmen
inArray ist null.
offset oder length ist ein negativer Wert.
- oder -
offset plus length ist größer als die Länge von inArray.
options ist kein gültiger Base64FormattingOptions-Wert.
Beispiele
Das folgende Beispiel veranschaulicht die ToBase64String Methode. Die Eingabe ist in Gruppen von jeweils drei Bytes (24 Bits) unterteilt. Folglich besteht jede Gruppe aus vier 6-Bit-Zahlen, wobei jede Zahl zwischen 0 und 63 dezimal liegt. In diesem Beispiel gibt es 85 3-Byte-Gruppen mit einem verbleibenden Byte. Die erste Gruppe besteht aus den Hexadezimalwerten 00, 01 und 02, die vier 6-Bit-Werte ergeben, die 0, 0, 4 und 2 entsprechen. 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 Byte hexadezimal ff. Die ersten 6 Bits sind gleich 63 dezimal, was der Basis-64-Ziffer "/" am Ende der Ausgabe entspricht, und die nächsten 2 Bits sind mit Nullen aufgefüllt, um eine Dezimalzahl 48 zu erhalten, die der Basis-64-Ziffer entspricht, "w". Die letzten beiden 6-Bit-Werte sind aufgefüllt und entsprechen dem wertlosen Abstandszeichen "=".
// 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
open System
let arraysAreEqual (a1: byte[]) (a2: byte[]) =
a1.Length = a2.Length &&
Array.forall2 (=) a1 a2
let step1 = "1) The input is a byte array (inArray) of arbitrary data."
let step2 = "2) Convert a subarray of the input data array to a base 64 string."
let step3 = "3) Convert the entire input data array to a base 64 string."
let step4 = "4) The two methods in steps 2 and 3 produce the same result: {0}"
let step5 = "5) Convert the base 64 string to an output byte array (outArray)."
let step6 = "6) The input and output arrays, inArray and outArray, are equal: {0}"
let nl = Environment.NewLine
let ruler =
$" 1 2 3 4 5 6 7 {nl}" +
$"1234567890123456789012345678901234567890123456789012345678901234567890123456{nl}" +
$"----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-{nl}"
// 1) Display an arbitrary array of input data (inArray). The data could be
// derived from user input, a file, an algorithm, etc.
printfn $"{step1}\n"
let inArray =
[| for i = 0 to 255 do
printf $"{i:X2} "
if (i + 1) % 20 = 0 then
printfn ""
byte i |]
printf $"{nl}{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.
printfn $"{step2}"
let s2 = Convert.ToBase64String(inArray, 0, inArray.Length, Base64FormattingOptions.InsertLineBreaks)
printfn $"{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.
printfn $"{step3}"
let s3 = Convert.ToBase64String(inArray, Base64FormattingOptions.InsertLineBreaks)
// 4) Test whether the methods in steps 2 and 3 produce the same result.
printfn $"{step4} {s2.Equals s3}"
// 5) Convert the base 64 string to an output array (outArray).
printfn $"{step5}"
let outArray = Convert.FromBase64String s2
// 6) Is outArray equal to inArray?
printfn $"{step6} {arraysAreEqual inArray outArray}"
// 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 verwendet und in eine Zeichenfolgendarstellung in Basis 64 konvertiert.
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 "/". Das wertlose Zeichen "=" wird für den nachgestellten Abstand verwendet.
Die offset Parameter und length sind 32-Bit-Nummern mit Vorzeichen. Der offset Parameter ist nullbasiert.
Wichtig
Die ToBase64String -Methode ist für die Verarbeitung eines einzelnen Bytearrays konzipiert, das alle zu codierenden Daten enthält. Verwenden Sie die System.Security.Cryptography.ToBase64Transform -Klasse, um Daten aus einem Stream zu codieren.
Wenn der options Parameter auf InsertLineBreaks festgelegt ist und die Ausgabe der Konvertierung länger als 76 Zeichen ist, wird alle 76 Zeichen ein Zeilenumbruch 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:
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für