Udostępnij za pośrednictwem

Convert.ToBase64String Metoda

  • Odwołanie

Definicja

Przestrzeń nazw:
System
Zestaw:
System.Runtime.Extensions.dll
Zestaw:
System.Runtime.dll
Zestaw:
mscorlib.dll
Zestaw:
netstandard.dll

Konwertuje wartość tablicy 8-bitowych niepodpisanych liczb całkowitych na równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64.

Przeciążenia

ToBase64String(Byte[])

Konwertuje tablicę 8-bitowych liczb całkowitych bez znaku na równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64.
ToBase64String(Byte[], Base64FormattingOptions)

Konwertuje tablicę 8-bitowych liczb całkowitych bez znaku na równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64. Możesz określić, czy należy wstawić podziały wierszy w wartości zwracanej.
ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Konwertuje 8-bitowe liczby całkowite bez znaku wewnątrz określonego zakresu tylko do odczytu na ich równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64. Opcjonalnie możesz określić, czy należy wstawić podziały wierszy w wartości zwracanej.
ToBase64String(Byte[], Int32, Int32)

Konwertuje podzbiór tablicy 8-bitowych niepodpisanych liczb całkowitych na równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64. Parametry określają podzestaw jako przesunięcie w tablicy wejściowej oraz liczbę elementów w tablicy do przekonwertowania.
ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)

Konwertuje podzbiór tablicy 8-bitowych niepodpisanych liczb całkowitych na równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64. Parametry określają podzbiór jako przesunięcie w tablicy wejściowej, liczbę elementów w tablicy do przekonwertowania oraz to, czy należy wstawić podziały wierszy w wartości zwracanej.

ToBase64String(Byte[])

Źródło:
Convert.cs
Źródło:
Convert.cs
Źródło:
Convert.cs

Konwertuje tablicę 8-bitowych liczb całkowitych bez znaku na równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64.

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

Parametry

inArray
Byte[]

Tablica 8-bitowych niepodpisanych liczb całkowitych.

Zwraca

String

Reprezentacja ciągu w bazie 64 zawartości inArray.

Wyjątki

ArgumentNullException

inArray jest null.

Przykłady

W poniższym przykładzie użyto metody ToBase64String(Byte[]), aby przekonwertować tablicę bajtów na ciąg zakodowany w formacie UU (base-64), a następnie wywołuje metodę FromBase64String(String) w celu przywrócenia oryginalnej tablicy bajtów.

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

Poniżej przedstawiono bardziej złożony przykład, który tworzy 20-elementową tablicę 32-bitowych liczb całkowitych. Następnie używa metody BitConverter.GetBytes(Int32), aby przekonwertować każdy element na tablicę bajtów, która jest przechowywana w odpowiednim miejscu w buforze przez wywołanie metody Array.Copy(Array, Int32, Array, Int32, Int32). Ten bufor jest następnie przekazywany do metody ToBase64String(Byte[]) w celu utworzenia ciągu zakodowanego uu (base-64). Następnie wywołuje metodę FromBase64String(String) w celu dekodowania ciągu zakodowanego przez użytkownika i wywołuje metodę BitConverter.ToInt32, aby przekonwertować każdy zestaw czterech bajtów (rozmiar 32-bitowej liczby całkowitej) na liczbę całkowitą. Dane wyjściowe z przykładu pokazują, że oryginalna tablica została pomyślnie przywrócona.

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 }

Uwagi

Elementy inArray są traktowane jako wartość liczbowa i konwertowane na reprezentację ciągu zakodowaną przy użyciu cyfr base-64.

Cyfry base-64 w kolejności rosnącej od zera to wielkie litery "A" do "Z", małe litery "a" do "z", cyfry "0" do "9", a symbole "+" i "/". Bezwartościowy znak "=" jest używany do dopełniania końcowego.

Ważny

Metoda ToBase64String jest przeznaczona do przetwarzania pojedynczej tablicy bajtów zawierającej wszystkie dane do zakodowania. Aby zakodować dane ze strumienia, użyj klasy System.Security.Cryptography.ToBase64Transform.

Zazwyczaj metoda ToBase64String nie jest używana do zaokrąglania ciągu UUEncoded (zakodowanego w formacie base-64). Oznacza to, że w przypadku dekodowania ciągu przez wywołanie metody FromBase64String kodowanie zwracanej tablicy bajtów przez wywołanie metody ToBase64String wynikowy ciąg nie musi być identyczny z oryginalnym ciągiem. Ciąg będzie zaokrąglony tylko wtedy, gdy oryginalny ciąg jest prawidłowym ciągiem zakodowanym w formacie base-64.

Zobacz też

Dotyczy

ToBase64String(Byte[], Base64FormattingOptions)

Źródło:
Convert.cs
Źródło:
Convert.cs
Źródło:
Convert.cs

Konwertuje tablicę 8-bitowych liczb całkowitych bez znaku na równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64. Możesz określić, czy należy wstawić podziały wierszy w wartości zwracanej.

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 -> string
Public Shared Function ToBase64String (inArray As Byte(), options As Base64FormattingOptions) As String

Parametry

inArray
Byte[]

Tablica 8-bitowych niepodpisanych liczb całkowitych.

options
Base64FormattingOptions

InsertLineBreaks, aby wstawić podział wiersza co 76 znaków lub None, aby nie wstawiać podziałów wierszy.

Zwraca

String

Reprezentacja ciągu w bazie 64 elementów w inArray.

Atrybuty
ComVisibleAttribute

Wyjątki

ArgumentNullException

inArray jest null.

ArgumentException

options nie jest prawidłową wartością Base64FormattingOptions.

Przykłady

Poniższy przykład wywołuje Convert.ToBase64String(Byte[], Base64FormattingOptions) z argumentem Base64FormattingOptions.InsertLineBreaks, aby wstawić podziały wierszy w ciągu generowanym przez kodowanie tablicy bajtów 100 elementów.

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

Jak pokazuje dane wyjściowe z przykładu, Convert.FromBase64String kończy się powodzeniem w przywracaniu oryginalnej tablicy bajtów; znaki podziału wiersza są ignorowane podczas konwersji.

Uwagi

Elementy parametru inArray są traktowane jako wartość liczbowa i konwertowane na reprezentację ciągu w bazie 64.

Cyfry base-64 w kolejności rosnącej od zera to wielkie litery "A" do "Z", małe litery "a" do "z", cyfry "0" do "9", a symbole "+" i "/". Znak bezwartościowy "=" jest używany do wypełnienia końcowego.

Ważny

Metoda ToBase64String jest przeznaczona do przetwarzania pojedynczej tablicy bajtów zawierającej wszystkie dane do zakodowania. Aby zakodować dane ze strumienia, użyj klasy System.Security.Cryptography.ToBase64Transform.

Jeśli parametr options jest ustawiony na InsertLineBreaks, a dane wyjściowe konwersji są dłuższe niż 76 znaków, wstawiono podział wiersza co 76 znaków. Podział wiersza jest definiowany jako znak powrotu karetki (U+000D), po którym następuje znak kanału informacyjnego wiersza (U+000A). Ponieważ podziały wierszy są uważane za znaki odstępu w kodowaniu base-64, są ignorowane podczas konwertowania zakodowanego ciągu base-64 z powrotem do tablicy bajtów. Podziały wierszy są po prostu wygodne podczas wyświetlania zakodowanego ciągu do kontrolki lub urządzenia, takiego jak okno konsoli. Aby uzyskać więcej informacji, zobacz RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

Zobacz też

Dotyczy

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Źródło:
Convert.cs
Źródło:
Convert.cs
Źródło:
Convert.cs

Konwertuje 8-bitowe liczby całkowite bez znaku wewnątrz określonego zakresu tylko do odczytu na ich równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64. Opcjonalnie możesz określić, czy należy wstawić podziały wierszy w wartości zwracanej.

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

Parametry

bytes
ReadOnlySpan<Byte>

Zakres tylko do odczytu z 8-bitowych niepodpisanych liczb całkowitych.

options
Base64FormattingOptions

Jedna z wartości wyliczenia określająca, czy należy wstawić podziały wierszy w wartości zwracanej. Wartość domyślna to None.

Zwraca

String

Reprezentacja ciągu w bazie 64 elementów w bytes. Jeśli długość bytes wynosi 0, zwracany jest pusty ciąg.

Wyjątki

ArgumentException

options nie jest prawidłową wartością Base64FormattingOptions.

OutOfMemoryException

Długość danych wyjściowych była większa niż Int32.MaxValue.

Dotyczy

ToBase64String(Byte[], Int32, Int32)

Źródło:
Convert.cs
Źródło:
Convert.cs
Źródło:
Convert.cs

Konwertuje podzbiór tablicy 8-bitowych niepodpisanych liczb całkowitych na równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64. Parametry określają podzestaw jako przesunięcie w tablicy wejściowej oraz liczbę elementów w tablicy do przekonwertowania.

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

Parametry

inArray
Byte[]

Tablica 8-bitowych niepodpisanych liczb całkowitych.

offset
Int32

Przesunięcie w inArray.

length
Int32

Liczba elementów inArray do konwersji.

Zwraca

String

Reprezentacja ciągu w bazie 64 elementów lengthinArray, począwszy od pozycji offset.

Wyjątki

ArgumentNullException

inArray jest null.

ArgumentOutOfRangeException

offset lub length jest ujemna.

-lub-

offset plus length jest większa niż długość inArray.

Uwagi

Elementy inArray są traktowane jako wartość liczbowa i konwertowane na reprezentację ciągu w bazie 64.

Cyfry base-64 w kolejności rosnącej od zera to wielkie litery "A" do "Z", małe litery "a" do "z", cyfry "0" do "9", a symbole "+" i "/". Bezwartościowy znak "=" jest używany do dopełniania końcowego.

Parametry offset i length to 32-bitowe cyfry ze znakiem. Parametr offset jest oparty na zerze.

Ważny

Metoda ToBase64String jest przeznaczona do przetwarzania pojedynczej tablicy bajtów zawierającej wszystkie dane do zakodowania. Aby zakodować dane ze strumienia, użyj klasy System.Security.Cryptography.ToBase64Transform.

Zobacz też

Dotyczy

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

Źródło:
Convert.cs
Źródło:
Convert.cs
Źródło:
Convert.cs

Konwertuje podzbiór tablicy 8-bitowych niepodpisanych liczb całkowitych na równoważną reprezentację ciągu zakodowaną przy użyciu cyfr base-64. Parametry określają podzbiór jako przesunięcie w tablicy wejściowej, liczbę elementów w tablicy do przekonwertowania oraz to, czy należy wstawić podziały wierszy w wartości zwracanej.

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 -> string
Public Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer, options As Base64FormattingOptions) As String

Parametry

inArray
Byte[]

Tablica 8-bitowych niepodpisanych liczb całkowitych.

offset
Int32

Przesunięcie w inArray.

length
Int32

Liczba elementów inArray do konwersji.

options
Base64FormattingOptions

InsertLineBreaks, aby wstawić podział wiersza co 76 znaków lub None, aby nie wstawiać podziałów wierszy.

Zwraca

String

Reprezentacja ciągu w bazie 64 elementów lengthinArray, począwszy od pozycji offset.

Atrybuty
ComVisibleAttribute

Wyjątki

ArgumentNullException

inArray jest null.

ArgumentOutOfRangeException

offset lub length jest ujemna.

-lub-

offset plus length jest większa niż długość inArray.

ArgumentException

options nie jest prawidłową wartością Base64FormattingOptions.

Przykłady

W poniższym przykładzie pokazano metodę ToBase64String. Dane wejściowe są podzielone na grupy trzech bajtów (24 bity). W związku z tym każda grupa składa się z czterech liczb 6-bitowych, w których każda liczba waha się od liczby dziesiętnej od 0 do 63. W tym przykładzie istnieje 85 3-bajtowych grup z pozostałymi jednym bajtem. Pierwsza grupa składa się z wartości szesnastkowej 00, 01 i 02, które dają cztery wartości 6-bitowe równe 0, 0, 4 i 2. Te cztery wartości odpowiadają cyfrom base-64 "A", "A", "E" i "C" na początku danych wyjściowych.

Jeśli liczba całkowita 3-bajtowych grup nie istnieje, pozostałe bajty są skutecznie wypełniane zerami, aby utworzyć pełną grupę. W tym przykładzie wartość ostatniego bajtu to szesnastkowe FF. Pierwsze 6 bitów są równe dziesiętnym 63, co odpowiada cyfrze base-64 "/" na końcu danych wyjściowych, a kolejne 2 bity są wypełnione zerami, aby uzyskać dziesiętne 48, co odpowiada cyfrze base-64, "w". Ostatnie dwie wartości 6-bitowe są dopełniające i odpowiadają bezwartościowemu znakowi wypełnienia "=".

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

Uwagi

Elementy parametru inArray są traktowane jako wartość liczbowa i konwertowane na reprezentację ciągu w bazie 64.

Cyfry base-64 w kolejności rosnącej od zera to wielkie litery "A" do "Z", małe litery "a" do "z", cyfry "0" do "9", a symbole "+" i "/". Znak bezwartościowy "=" jest używany do wypełnienia końcowego.

Parametry offset i length to 32-bitowe cyfry ze znakiem. Parametr offset jest oparty na zerze.

Ważny

Metoda ToBase64String jest przeznaczona do przetwarzania pojedynczej tablicy bajtów zawierającej wszystkie dane do zakodowania. Aby zakodować dane ze strumienia, użyj klasy System.Security.Cryptography.ToBase64Transform.

Jeśli parametr options jest ustawiony na InsertLineBreaks, a dane wyjściowe konwersji są dłuższe niż 76 znaków, wstawiono podział wiersza co 76 znaków. Podział wiersza jest definiowany jako znak powrotu karetki (U+000D), po którym następuje znak kanału informacyjnego wiersza (U+000A). Aby uzyskać więcej informacji, zobacz RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

Zobacz też

Dotyczy