Convert.ToBase64String Метод

  • Ссылка

Определение

Пространство имен:
System
Сборка:
System.Runtime.Extensions.dll
Сборка:
System.Runtime.dll
Сборка:
mscorlib.dll
Сборка:
netstandard.dll

Преобразует значение массива 8-разрядных целых чисел без знака в эквивалентное строковое представление, состоящее из цифр в кодировке Base64.

Перегрузки

ToBase64String(Byte[])

Преобразует массив 8-разрядных целых чисел без знака в эквивалентное строковое представление, состоящее из цифр в кодировке Base64.
ToBase64String(Byte[], Base64FormattingOptions)

Преобразует массив 8-разрядных целых чисел без знака в эквивалентное строковое представление, состоящее из цифр в кодировке Base64. Вы можете указать, следует ли вставлять в возвращаемое значение разрывы строки.
ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Преобразует 8-разрядные целые числа без знака внутри указанного диапазона только для чтения в эквивалентное строковое представление, состоящее из цифр в кодировке Base64. Вы также можете указать, следует ли вставлять в возвращаемое значение разрывы строки.
ToBase64String(Byte[], Int32, Int32)

Преобразует подмножество массива 8-разрядных целых чисел без знака в эквивалентное строковое представление, состоящее из цифр в кодировке Base64. В параметрах задается подмножество как смещение во входном массиве и количество преобразуемых элементов этого массива.
ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)

Преобразует подмножество массива 8-разрядных целых чисел без знака в эквивалентное строковое представление, состоящее из цифр в кодировке Base64. В параметрах задаются подмножество как смещение во входном массиве и количество преобразуемых элементов этого массива, а также значение, указывающее, следует ли вставлять в выходной массив разрывы строки.

ToBase64String(Byte[])

Исходный код:
Convert.cs
Исходный код:
Convert.cs
Исходный код:
Convert.cs

Преобразует массив 8-разрядных целых чисел без знака в эквивалентное строковое представление, состоящее из цифр в кодировке Base64.

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

Параметры

inArray
Byte[]

Массив 8-битовых целых чисел без знака.

Возвращаемое значение

String

Строковое представление содержимого массива inArray в кодировке Base64.

Исключения

ArgumentNullException

inArray имеет значение null.

Примеры

В следующем примере метод используется ToBase64String(Byte[]) для преобразования массива байтов в строку UUencoded (base-64), а затем вызывает FromBase64String(String) метод для восстановления исходного массива байтов.

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

Ниже приведен более сложный пример, который создает 20-элементный массив из 32-разрядных целых чисел. Затем он использует BitConverter.GetBytes(Int32) метод для преобразования каждого элемента в массив байтов, который сохраняется в соответствующем положении в буфере Array.Copy(Array, Int32, Array, Int32, Int32) путем вызова метода . Затем этот буфер передается ToBase64String(Byte[]) в метод для создания строки UUencoded (base-64). Затем он вызывает FromBase64String(String) метод для декодирования строки UUencoded и вызывает BitConverter.ToInt32 метод для преобразования каждого набора из четырех байтов (размер 32-разрядного целого числа) в целое число. Выходные данные из примера показывают, что исходный массив успешно восстановлен.

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 }

Комментарии

Элементы inArray берутся в виде числовых значений и преобразуются в строковое представление, закодированное цифрами base-64.

Цифры base-64 в порядке возрастания от нуля — это символы верхнего регистра от "A" до "Z", символы нижнего регистра от "a" до "z", числа от "0" до "9", а также символы "+" и "/". Для отбивки в конце используется бесценный символ "=".

Важно!

Метод ToBase64String предназначен для обработки одного массива байтов, содержащего все кодируемые данные. Для кодирования данных из потока используйте System.Security.Cryptography.ToBase64Transform класс .

Обычно ToBase64String метод не используется для кругового пути строки UUEncoded (в кодировке Base-64). То есть, если декодировать строку путем вызова FromBase64String метода , а затем кодировать возвращенный массив байтов путем вызова ToBase64String метода, результирующая строка не обязательно будет идентична исходной строке. Строка будет циклироваться только в том случае, если исходная строка является допустимой строкой в кодировке Base-64.

См. также раздел

Применяется к

ToBase64String(Byte[], Base64FormattingOptions)

Исходный код:
Convert.cs
Исходный код:
Convert.cs
Исходный код:
Convert.cs

Преобразует массив 8-разрядных целых чисел без знака в эквивалентное строковое представление, состоящее из цифр в кодировке Base64. Вы можете указать, следует ли вставлять в возвращаемое значение разрывы строки.

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

Параметры

inArray
Byte[]

Массив 8-битовых целых чисел без знака.

options
Base64FormattingOptions

InsertLineBreaks для вставки разрыва строки после каждых 76 знаков или None, чтобы разрывы строки не вставлялись.

Возвращаемое значение

String

Строковое представление элементов массива inArray в кодировке Base64.

Атрибуты
ComVisibleAttribute

Исключения

ArgumentNullException

inArray имеет значение null.

ArgumentException

options не является допустимым значением Base64FormattingOptions.

Примеры

В следующем примере вызывается Convert.ToBase64String(Byte[], Base64FormattingOptions) с аргументом Base64FormattingOptions.InsertLineBreaks для вставки разрывов строк в строку, созданную при кодировании массива байтов из 100 элементов.

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

Как показано в выходных данных примера, Convert.FromBase64String объекту удалось восстановить исходный массив байтов. Символы разрыва строки игнорируются во время преобразования.

Комментарии

Элементы inArray параметра принимаются в виде числовых значений и преобразуются в строковое представление в base 64.

Цифры base-64 в порядке возрастания от нуля — это символы верхнего регистра от "A" до "Z", символы нижнего регистра от "a" до "z", числа от "0" до "9", а также символы "+" и "/". Для отбивки в конце используется бесценный символ "=".

Важно!

Метод ToBase64String предназначен для обработки одного массива байтов, содержащего все кодируемые данные. Для кодирования данных из потока используйте System.Security.Cryptography.ToBase64Transform класс .

options Если параметр имеет значение InsertLineBreaks , а выходные данные преобразования длиннее 76 символов, разрыв строки вставляется каждые 76 символов. Разрыв строки определяется как символ возврата каретки (U+000D), за которым следует символ перевода строки (U+000A). Так как разрывы строк считаются символами пробелов в кодировке Base-64, они игнорируются при преобразовании строки в кодировке Base-64 обратно в массив байтов. Разрывы строк просто удобны при отображении закодированной строки в элементе управления или на устройстве, например в окне консоли. Дополнительные сведения см. в статье RFC 2045, "Многоцелевые расширения почты Интернета" на странице https://www.rfc-editor.org/.

См. также раздел

Применяется к

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Исходный код:
Convert.cs
Исходный код:
Convert.cs
Исходный код:
Convert.cs

Преобразует 8-разрядные целые числа без знака внутри указанного диапазона только для чтения в эквивалентное строковое представление, состоящее из цифр в кодировке Base64. Вы также можете указать, следует ли вставлять в возвращаемое значение разрывы строки.

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

Параметры

bytes
ReadOnlySpan<Byte>

Доступный только для чтения диапазон 8-разрядных целых чисел без знака.

options
Base64FormattingOptions

Одно из значений перечисления, указывающее, следует ли вставлять разрывы строк в возвращаемое значение. Значение по умолчанию — None.

Возвращаемое значение

String

Строковое представление элементов массива inArray в кодировке Base64. Если длина bytes составляет 0, возвращается пустая строка.

Исключения

ArgumentException

options не является допустимым значением Base64FormattingOptions.

OutOfMemoryException

Длина выходных данных была больше, чем Int32.MaxValue.

Применяется к

ToBase64String(Byte[], Int32, Int32)

Исходный код:
Convert.cs
Исходный код:
Convert.cs
Исходный код:
Convert.cs

Преобразует подмножество массива 8-разрядных целых чисел без знака в эквивалентное строковое представление, состоящее из цифр в кодировке Base64. В параметрах задается подмножество как смещение во входном массиве и количество преобразуемых элементов этого массива.

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

Параметры

inArray
Byte[]

Массив 8-битовых целых чисел без знака.

offset
Int32

Смещение в массиве inArray.

length
Int32

Число преобразуемых элементов inArray.

Возвращаемое значение

String

Строковое представление length элементов массива inArray в кодировке Base64, начиная с позиции offset.

Исключения

ArgumentNullException

inArray имеет значение null.

ArgumentOutOfRangeException

offset или length является отрицательным значением.

-или-

Сумма значений offset и length превышает длину массива inArray.

Комментарии

Элементы используются inArray в виде числовых значений и преобразуются в строковое представление в base 64.

Цифры base-64 в порядке возрастания от нуля — это символы верхнего регистра от "A" до "Z", символы нижнего регистра от "a" до "z", числа от "0" до "9", а также символы "+" и "/". Для отбивки в конце используется бесценный символ "=".

Параметры offset и length представляют собой 32-разрядные цифры со знаком. Параметр offset отсчитывается от нуля.

Важно!

Метод ToBase64String предназначен для обработки одного массива байтов, содержащего все кодируемые данные. Для кодирования данных из потока используйте System.Security.Cryptography.ToBase64Transform класс .

См. также раздел

Применяется к

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

Исходный код:
Convert.cs
Исходный код:
Convert.cs
Исходный код:
Convert.cs

Преобразует подмножество массива 8-разрядных целых чисел без знака в эквивалентное строковое представление, состоящее из цифр в кодировке Base64. В параметрах задаются подмножество как смещение во входном массиве и количество преобразуемых элементов этого массива, а также значение, указывающее, следует ли вставлять в выходной массив разрывы строки.

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

Параметры

inArray
Byte[]

Массив 8-битовых целых чисел без знака.

offset
Int32

Смещение в массиве inArray.

length
Int32

Число преобразуемых элементов inArray.

options
Base64FormattingOptions

InsertLineBreaks для вставки разрыва строки после каждых 76 знаков или None, чтобы разрывы строки не вставлялись.

Возвращаемое значение

String

Строковое представление length элементов массива inArray в кодировке Base64, начиная с позиции offset.

Атрибуты
ComVisibleAttribute

Исключения

ArgumentNullException

inArray имеет значение null.

ArgumentOutOfRangeException

offset или length является отрицательным значением.

-или-

Сумма значений offset и length превышает длину массива inArray.

ArgumentException

options не является допустимым значением Base64FormattingOptions.

Примеры

В следующем примере демонстрируется ToBase64String метод. Входные данные делятся на группы по три байта (по 24 бита). Следовательно, каждая группа состоит из четырех 6-разрядных чисел, в которых каждое число имеет диапазон от десятичных разрядов от 0 до 63. В этом примере существует 85 3-байтовых групп с одним оставшимся байтом. Первая группа состоит из шестнадцатеричных значений 00, 01 и 02, которые дают четыре 6-разрядных значения, равные десятичным 0, 0, 4 и 2. Эти четыре значения соответствуют 64-разрядным цифрам "A", "A", "E" и "C" в начале выходных данных.

Если целое число 3-байтовых групп не существует, оставшиеся байты фактически заполняются нулями, чтобы сформировать полную группу. В этом примере значение последнего байта — шестнадцатеричное значение FF. Первые 6 бит равны десятичному разряду 63, что соответствует цифре "/" в конце выходных данных, а следующие 2 бита заполняются нулями, чтобы получить десятичное число 48, соответствующее цифре base-64, "w". Последние два 6-разрядных значения являются заполнением и соответствуют символу заполнения без значений "=".

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

Комментарии

Элементы inArray параметра принимаются в виде числовых значений и преобразуются в строковое представление в base 64.

Цифры base-64 в порядке возрастания от нуля — это символы верхнего регистра от "A" до "Z", символы нижнего регистра от "a" до "z", числа от "0" до "9", а также символы "+" и "/". Для отбивки в конце используется бесценный символ "=".

Параметры offset и length представляют собой 32-разрядные цифры со знаком. Параметр offset отсчитывается от нуля.

Важно!

Метод ToBase64String предназначен для обработки одного массива байтов, содержащего все кодируемые данные. Для кодирования данных из потока используйте System.Security.Cryptography.ToBase64Transform класс .

options Если параметр имеет значение InsertLineBreaks , а выходные данные преобразования длиннее 76 символов, разрыв строки вставляется каждые 76 символов. Разрыв строки определяется как символ возврата каретки (U+000D), за которым следует символ перевода строки (U+000A). Дополнительные сведения см. в статье RFC 2045, "Многоцелевые расширения почты Интернета" на странице https://www.rfc-editor.org/.

См. также раздел

Применяется к