Convert.ToBase64String Metode

  • Referensi

Definisi

Ruang nama:
System
Rakitan:
System.Runtime.Extensions.dll
Rakitan:
System.Runtime.dll
Rakitan:
mscorlib.dll
Rakitan:
netstandard.dll

Mengonversi nilai array bilangan bulat tidak bertanda 8-bit ke representasi string setara yang dikodekan dengan digit base-64.

Overload

ToBase64String(Byte[])

Mengonversi array bilangan bulat yang tidak ditandatangani 8-bit ke representasi string setara yang dikodekan dengan digit base-64.
ToBase64String(Byte[], Base64FormattingOptions)

Mengonversi array bilangan bulat yang tidak ditandatangani 8-bit ke representasi string setara yang dikodekan dengan digit base-64. Anda dapat menentukan apakah akan menyisipkan hentian baris dalam nilai yang dikembalikan.
ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Mengonversi bilangan bulat 8-bit yang tidak ditandatangani di dalam rentang baca-saja yang ditentukan ke dalam representasi string yang setara yang dikodekan dengan digit base-64. Anda dapat secara opsional menentukan apakah akan menyisipkan hentian baris dalam nilai yang dikembalikan.
ToBase64String(Byte[], Int32, Int32)

Mengonversi subset array bilangan bulat yang tidak ditandatangani 8-bit ke representasi string setara yang dikodekan dengan digit base-64. Parameter menentukan subset sebagai offset dalam array input, dan jumlah elemen dalam array yang akan dikonversi.
ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)

Mengonversi subset array bilangan bulat yang tidak ditandatangani 8-bit ke representasi string setara yang dikodekan dengan digit base-64. Parameter menentukan subset sebagai offset dalam array input, jumlah elemen dalam array yang akan dikonversi, dan apakah akan menyisipkan pemisah baris dalam nilai yang dikembalikan.

ToBase64String(Byte[])

Sumber:
Convert.cs
Sumber:
Convert.cs
Sumber:
Convert.cs

Mengonversi array bilangan bulat yang tidak ditandatangani 8-bit ke representasi string setara yang dikodekan dengan digit 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

Parameter

inArray
Byte[]

Array bilangan bulat yang tidak ditandatangani 8-bit.

Mengembalikan

String

Representasi string, dalam basis 64, dari konten inArray.

Pengecualian

ArgumentNullException

inArrayadalah null.

Contoh

Contoh berikut menggunakan ToBase64String(Byte[]) metode untuk mengonversi array byte ke string UUencoded (base-64), lalu memanggil FromBase64String(String) metode untuk memulihkan array byte asli.

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

Berikut ini adalah contoh yang lebih kompleks yang membuat array 20 elemen dari bilangan bulat 32-bit. Kemudian menggunakan BitConverter.GetBytes(Int32) metode untuk mengonversi setiap elemen menjadi array byte, yang disimpannya dalam posisi yang sesuai dalam buffer dengan memanggil Array.Copy(Array, Int32, Array, Int32, Int32) metode . Buffer ini kemudian diteruskan ke ToBase64String(Byte[]) metode untuk membuat string UUencoded (base-64). Kemudian memanggil FromBase64String(String) metode untuk mendekode string UUencoded, dan memanggil BitConverter.ToInt32 metode untuk mengonversi setiap set empat byte (ukuran bilangan bulat 32-bit) menjadi bilangan bulat. Output dari contoh menunjukkan bahwa array asli telah berhasil dipulihkan.

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 }

Keterangan

Elemen inArray diambil sebagai nilai numerik dan dikonversi menjadi representasi string yang dikodekan dengan digit base-64.

Digit base-64 dalam urutan naik dari nol adalah karakter huruf besar "A" hingga "Z", karakter huruf kecil "a" hingga "z", angka "0" hingga "9", dan simbol "+" dan "/". Karakter tanpa nilai, "=", digunakan untuk padding berikutnya.

Penting

Metode ToBase64String ini dirancang untuk memproses array byte tunggal yang berisi semua data yang akan dikodekan. Untuk mengodekan data dari aliran, gunakan System.Security.Cryptography.ToBase64Transform kelas .

Biasanya, ToBase64String metode ini tidak digunakan untuk melakukan round-trip string UUEncoded (base-64 encoded). Artinya, jika Anda mendekode string dengan memanggil FromBase64String metode , maka mengodekan array byte yang dikembalikan dengan memanggil ToBase64String metode , string yang dihasilkan tidak selalu identik dengan string asli. String akan melakukan round-trip hanya jika string asli adalah string yang dikodekan base-64 yang valid.

Lihat juga

Berlaku untuk

ToBase64String(Byte[], Base64FormattingOptions)

Sumber:
Convert.cs
Sumber:
Convert.cs
Sumber:
Convert.cs

Mengonversi array bilangan bulat yang tidak ditandatangani 8-bit ke representasi string setara yang dikodekan dengan digit base-64. Anda dapat menentukan apakah akan menyisipkan hentian baris dalam nilai yang dikembalikan.

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

Parameter

inArray
Byte[]

Array bilangan bulat yang tidak ditandatangani 8-bit.

options
Base64FormattingOptions

InsertLineBreaks untuk menyisipkan pemisah baris setiap 76 karakter, atau None untuk tidak menyisipkan hentian baris.

Mengembalikan

String

Representasi string dalam basis 64 elemen di inArray.

Atribut
ComVisibleAttribute

Pengecualian

ArgumentNullException

inArrayadalah null.

ArgumentException

options bukan nilai yang valid Base64FormattingOptions .

Contoh

Contoh berikut memanggil Convert.ToBase64String(Byte[], Base64FormattingOptions) dengan Base64FormattingOptions.InsertLineBreaks argumen untuk menyisipkan pemisah baris dalam string yang dihasilkan dengan mengodekan array byte 100 elemen.

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

Seperti yang ditunjukkan oleh output dari contoh, Convert.FromBase64String berhasil memulihkan array byte asli; karakter pemisah baris diabaikan selama konversi.

Keterangan

Elemen inArray parameter diambil sebagai nilai numerik dan dikonversi ke representasi string di basis 64.

Digit base-64 dalam urutan naik dari nol adalah karakter huruf besar "A" hingga "Z", karakter huruf kecil "a" hingga "z", angka "0" hingga "9", dan simbol "+" dan "/". Karakter tak bernilai "=" digunakan untuk padding berikutnya.

Penting

Metode ToBase64String ini dirancang untuk memproses array byte tunggal yang berisi semua data yang akan dikodekan. Untuk mengodekan data dari aliran, gunakan System.Security.Cryptography.ToBase64Transform kelas .

options Jika parameter diatur ke InsertLineBreaks dan output konversi lebih panjang dari 76 karakter, pemisah baris disisipkan setiap 76 karakter. Pemisah baris didefinisikan sebagai karakter pengembalian pengangkutan (U+000D) diikuti dengan karakter umpan baris (U+000A). Karena hentian baris dianggap sebagai karakter spasi putih dalam pengodean base-64, pemisahan tersebut diabaikan saat mengonversi string yang dikodekan base-64 kembali ke array byte. Jeda baris hanya nyaman saat menampilkan string yang dikodekan ke kontrol atau perangkat seperti jendela konsol. Untuk informasi selengkapnya, lihat RFC 2045, "Ekstensi Email Internet Multiguna", di https://www.rfc-editor.org/.

Lihat juga

Berlaku untuk

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Sumber:
Convert.cs
Sumber:
Convert.cs
Sumber:
Convert.cs

Mengonversi bilangan bulat 8-bit yang tidak ditandatangani di dalam rentang baca-saja yang ditentukan ke dalam representasi string yang setara yang dikodekan dengan digit base-64. Anda dapat secara opsional menentukan apakah akan menyisipkan hentian baris dalam nilai yang dikembalikan.

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

Parameter

bytes
ReadOnlySpan<Byte>

Rentang baca-saja dari bilangan bulat 8-bit yang tidak ditandatangani.

options
Base64FormattingOptions

Salah satu nilai enumerasi yang menentukan apakah akan menyisipkan hentian baris dalam nilai yang dikembalikan. Nilai defaultnya adalah None.

Mengembalikan

String

Representasi string dalam basis 64 elemen di inArray. Jika panjangnya bytes adalah 0, string kosong dikembalikan.

Pengecualian

ArgumentException

options bukan nilai yang valid Base64FormattingOptions .

OutOfMemoryException

Panjang output lebih besar dari Int32.MaxValue.

Berlaku untuk

ToBase64String(Byte[], Int32, Int32)

Sumber:
Convert.cs
Sumber:
Convert.cs
Sumber:
Convert.cs

Mengonversi subset array bilangan bulat yang tidak ditandatangani 8-bit ke representasi string setara yang dikodekan dengan digit base-64. Parameter menentukan subset sebagai offset dalam array input, dan jumlah elemen dalam array yang akan dikonversi.

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

Parameter

inArray
Byte[]

Array bilangan bulat yang tidak ditandatangani 8-bit.

offset
Int32

Offset di inArray.

length
Int32

Jumlah elemen yang akan dikonversi inArray .

Mengembalikan

String

Representasi string dalam basis 64 length elemen inArray, dimulai pada posisi offset.

Pengecualian

ArgumentNullException

inArrayadalah null.

ArgumentOutOfRangeException

offset atau length negatif.

-atau-

offset plus length lebih besar dari panjang inArray.

Keterangan

Elemen inArray diambil sebagai nilai numerik dan dikonversi menjadi representasi string di basis 64.

Digit base-64 dalam urutan naik dari nol adalah karakter huruf besar "A" hingga "Z", karakter huruf kecil "a" hingga "z", angka "0" hingga "9", dan simbol "+" dan "/". Karakter tanpa nilai, "=", digunakan untuk padding berikutnya.

Parameter offset dan length adalah angka bertanda tangan 32-bit. Parameter offset berbasis nol.

Penting

Metode ToBase64String ini dirancang untuk memproses array byte tunggal yang berisi semua data yang akan dikodekan. Untuk mengodekan data dari aliran, gunakan System.Security.Cryptography.ToBase64Transform kelas .

Lihat juga

Berlaku untuk

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

Sumber:
Convert.cs
Sumber:
Convert.cs
Sumber:
Convert.cs

Mengonversi subset array bilangan bulat yang tidak ditandatangani 8-bit ke representasi string setara yang dikodekan dengan digit base-64. Parameter menentukan subset sebagai offset dalam array input, jumlah elemen dalam array yang akan dikonversi, dan apakah akan menyisipkan pemisah baris dalam nilai yang dikembalikan.

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

Parameter

inArray
Byte[]

Array bilangan bulat yang tidak ditandatangani 8-bit.

offset
Int32

Offset di inArray.

length
Int32

Jumlah elemen yang akan dikonversi inArray .

options
Base64FormattingOptions

InsertLineBreaks untuk menyisipkan pemisah baris setiap 76 karakter, atau None untuk tidak menyisipkan hentian baris.

Mengembalikan

String

Representasi string dalam basis 64 length elemen inArray, dimulai pada posisi offset.

Atribut
ComVisibleAttribute

Pengecualian

ArgumentNullException

inArrayadalah null.

ArgumentOutOfRangeException

offset atau length negatif.

-atau-

offset plus length lebih besar dari panjang inArray.

ArgumentException

options bukan nilai yang valid Base64FormattingOptions .

Contoh

Contoh berikut menunjukkan ToBase64String metode . Input dibagi menjadi beberapa kelompok yang masing-masing terdiri dari tiga byte (24 bit). Akibatnya, setiap grup terdiri dari empat angka 6-bit di mana setiap angka berkisar dari desimal 0 hingga 63. Dalam contoh ini, ada 85 grup 3-byte dengan satu byte tersisa. Grup pertama terdiri dari nilai heksadesimal 00, 01, dan 02, yang menghasilkan empat nilai 6-bit yang sama dengan desimal 0, 0, 4, dan 2. Keempat nilai tersebut sesuai dengan digit base-64 "A", "A", "E", dan "C" di awal output.

Jika jumlah integral grup 3-byte tidak ada, byte yang tersisa secara efektif dilapisi dengan nol untuk membentuk grup lengkap. Dalam contoh ini, nilai byte terakhir adalah heksadesimal FF. 6 bit pertama sama dengan desimal 63, yang sesuai dengan basis-64 digit "/" di akhir output, dan 2 bit berikutnya dilapisi dengan nol untuk menghasilkan desimal 48, yang sesuai dengan digit base-64, "w". Dua nilai 6-bit terakhir adalah padding dan sesuai dengan karakter padding yang tidak bernilai, "=".

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

Keterangan

Elemen inArray parameter diambil sebagai nilai numerik dan dikonversi ke representasi string di basis 64.

Digit base-64 dalam urutan naik dari nol adalah karakter huruf besar "A" hingga "Z", karakter huruf kecil "a" hingga "z", angka "0" hingga "9", dan simbol "+" dan "/". Karakter tak bernilai "=" digunakan untuk padding berikutnya.

Parameter offset dan length adalah angka bertanda tangan 32-bit. Parameter offset berbasis nol.

Penting

Metode ToBase64String ini dirancang untuk memproses array byte tunggal yang berisi semua data yang akan dikodekan. Untuk mengodekan data dari aliran, gunakan System.Security.Cryptography.ToBase64Transform kelas .

options Jika parameter diatur ke InsertLineBreaks dan output konversi lebih panjang dari 76 karakter, pemisah baris disisipkan setiap 76 karakter. Pemisah baris didefinisikan sebagai karakter pengembalian pengangkutan (U+000D) diikuti dengan karakter umpan baris (U+000A). Untuk informasi selengkapnya, lihat RFC 2045, "Ekstensi Email Internet Multiguna", di https://www.rfc-editor.org/.

Lihat juga

Berlaku untuk