Convert.ToBase64String Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Converte o valor de uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos de base 64.
Sobrecargas
| ToBase64String(Byte[]) |
Converte uma matriz de inteiros sem sinal de 8 bits na representação de cadeia de caracteres equivalente codificada com dígitos de base 64. |
| ToBase64String(Byte[], Base64FormattingOptions) |
Converte uma matriz de inteiros sem sinal de 8 bits na representação de cadeia de caracteres equivalente codificada com dígitos de base 64. Você pode especificar se deseja inserir quebras de linha no valor retornado. |
| ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions) |
Converte os números inteiros sem sinal de 8 bits dentro do intervalo somente leitura especificado em sua representação de cadeia de caracteres equivalente codificada com dígitos de base 64. Opcionalmente, você pode especificar se deseja inserir quebras de linha no valor retornado. |
| ToBase64String(Byte[], Int32, Int32) |
Converte um subconjunto de uma matriz de inteiros sem sinal de 8 bits na representação de cadeia de caracteres equivalente codificada com dígitos de base 64. Parâmetros especificam o subconjunto como um deslocamento na matriz de entrada e o número de elementos na matriz a converter. |
| ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions) |
Converte um subconjunto de uma matriz de inteiros sem sinal de 8 bits na representação de cadeia de caracteres equivalente codificada com dígitos de base 64. Parâmetros especificam o subconjunto como um deslocamento da matriz de entrada, o número de elementos na matriz para converter e se deve ou não inserir quebras de linha no valor retornado. |
ToBase64String(Byte[])
- Origem:
- Convert.cs
- Origem:
- Convert.cs
- Origem:
- Convert.cs
Converte uma matriz de inteiros sem sinal de 8 bits na representação de cadeia de caracteres equivalente codificada com dígitos de base 64.
public:
static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray);public static string ToBase64String (byte[] inArray);static member ToBase64String : byte[] -> stringPublic Shared Function ToBase64String (inArray As Byte()) As StringParâmetros
- inArray
- Byte[]
Uma matriz de inteiros não assinados de 8 bits.
Retornos
A representação de cadeia de caracteres, em base 64, do conteúdo de inArray.
Exceções
inArray é null.
Exemplos
O exemplo a seguir usa o ToBase64String(Byte[]) método para converter uma matriz de bytes em uma cadeia de caracteres UUencoded (base-64) e, em seguida, chama o FromBase64String(String) método para restaurar a matriz de bytes original.
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
Veja a seguir um exemplo mais complexo que cria uma matriz de 20 elementos de inteiros de 32 bits. Em seguida, ele usa o BitConverter.GetBytes(Int32) método para converter cada elemento em uma matriz de bytes, que armazena na posição apropriada em um buffer chamando o Array.Copy(Array, Int32, Array, Int32, Int32) método . Esse buffer é então passado para o ToBase64String(Byte[]) método para criar uma cadeia de caracteres UUencoded (base-64). Em seguida, ele chama o FromBase64String(String) método para decodificar a cadeia de caracteres UUencoded e chama o BitConverter.ToInt32 método para converter cada conjunto de quatro bytes (o tamanho de um inteiro de 32 bits) em um inteiro. A saída do exemplo mostra que a matriz original foi restaurada com êxito.
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 }
Comentários
Os elementos de inArray são tomados como um valor numérico e convertidos em uma representação de cadeia de caracteres codificada com dígitos base-64.
Os dígitos de base 64 em ordem crescente a partir de zero são os caracteres maiúsculos de "A" a "Z", os caracteres minúsculos de "a" a "z", os numerais de "0" a "9" e os símbolos "+" e "/". O caractere sem valor, "=", é usado no preenchimento à direita.
Importante
O ToBase64String método foi projetado para processar uma única matriz de bytes que contém todos os dados a serem codificados. Para codificar dados a partir de um fluxo, use a classe System.Security.Cryptography.ToBase64Transform.
Normalmente, o ToBase64String método não é usado para fazer uma viagem de ida e volta de uma cadeia de caracteres UUEncoded (codificada em base 64). Ou seja, se você decodificar uma cadeia de caracteres chamando o FromBase64String método e codificar a matriz de bytes retornada chamando o ToBase64String método , a cadeia de caracteres resultante não será necessariamente idêntica à cadeia de caracteres original. A cadeia de caracteres só será de ida e volta se a cadeia de caracteres original for uma cadeia de caracteres codificada em base 64 válida.
Confira também
Aplica-se a
ToBase64String(Byte[], Base64FormattingOptions)
- Origem:
- Convert.cs
- Origem:
- Convert.cs
- Origem:
- Convert.cs
Converte uma matriz de inteiros sem sinal de 8 bits na representação de cadeia de caracteres equivalente codificada com dígitos de base 64. Você pode especificar se deseja inserir quebras de linha no valor retornado.
public:
static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, Base64FormattingOptions options);public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);static member ToBase64String : byte[] * Base64FormattingOptions -> string[<System.Runtime.InteropServices.ComVisible(false)>]
static member ToBase64String : byte[] * Base64FormattingOptions -> stringPublic Shared Function ToBase64String (inArray As Byte(), options As Base64FormattingOptions) As StringParâmetros
- inArray
- Byte[]
Uma matriz de inteiros não assinados de 8 bits.
- options
- Base64FormattingOptions
InsertLineBreaks para inserir uma quebra de linha a cada 76 caracteres, ou None para não inserir quebras de linha.
Retornos
A representação de cadeia de caracteres em base 64 dos elementos em inArray.
- Atributos
Exceções
inArray é null.
options não é um valor Base64FormattingOptions válido.
Exemplos
O exemplo a seguir chama o Convert.ToBase64String(Byte[], Base64FormattingOptions) com um Base64FormattingOptions.InsertLineBreaks argumento para inserir quebras de linha na cadeia de caracteres produzida pela codificação de uma matriz de bytes de 100 elementos.
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
Como mostra a saída do exemplo, o Convert.FromBase64String é bem-sucedido na restauração da matriz de bytes original; os caracteres de quebra de linha são ignorados durante a conversão.
Comentários
Os elementos do inArray parâmetro são tomados como um valor numérico e convertidos em uma representação de cadeia de caracteres na base 64.
Os dígitos de base 64 em ordem crescente a partir de zero são os caracteres maiúsculos de "A" a "Z", os caracteres minúsculos de "a" a "z", os numerais de "0" a "9" e os símbolos "+" e "/". O caractere sem valor "=" é usado para preenchimento à direita.
Importante
O ToBase64String método foi projetado para processar uma única matriz de bytes que contém todos os dados a serem codificados. Para codificar dados a partir de um fluxo, use a classe System.Security.Cryptography.ToBase64Transform.
Se o options parâmetro for definido como InsertLineBreaks e a saída da conversão for maior que 76 caracteres, uma quebra de linha será inserida a cada 76 caracteres. Uma quebra de linha é definida como um caractere de retorno de carro (U+000D) seguido por um caractere de alimentação de linha (U+000A). Como as quebras de linha são consideradas caracteres de espaço em branco em uma codificação base-64, elas são ignoradas ao converter uma cadeia de caracteres codificada em base 64 de volta em uma matriz de bytes. As quebras de linha são simplesmente convenientes ao exibir a cadeia de caracteres codificada em um controle ou um dispositivo, como uma janela de console. Para obter mais informações, consulte RFC 2045, "Multipurpose Internet Mail Extensions", em https://www.rfc-editor.org/.
Confira também
Aplica-se a
ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)
- Origem:
- Convert.cs
- Origem:
- Convert.cs
- Origem:
- Convert.cs
Converte os números inteiros sem sinal de 8 bits dentro do intervalo somente leitura especificado em sua representação de cadeia de caracteres equivalente codificada com dígitos de base 64. Opcionalmente, você pode especificar se deseja inserir quebras de linha no valor retornado.
public static string ToBase64String (ReadOnlySpan<byte> bytes, Base64FormattingOptions options = System.Base64FormattingOptions.None);static member ToBase64String : ReadOnlySpan<byte> * Base64FormattingOptions -> stringPublic Shared Function ToBase64String (bytes As ReadOnlySpan(Of Byte), Optional options As Base64FormattingOptions = System.Base64FormattingOptions.None) As StringParâmetros
- bytes
- ReadOnlySpan<Byte>
Um intervalo somente leitura de números inteiros sem sinal de 8 bits.
- options
- Base64FormattingOptions
Um dos valores de enumeração que especifica se é necessário inserir quebras de linha no valor retornado. O valor padrão é None.
Retornos
A representação de cadeia de caracteres em base 64 dos elementos em inArray. Se o comprimento de bytes for 0, uma cadeia de caracteres vazia será retornada.
Exceções
options não é um valor Base64FormattingOptions válido.
O comprimento de saída era maior que Int32.MaxValue.
Aplica-se a
ToBase64String(Byte[], Int32, Int32)
- Origem:
- Convert.cs
- Origem:
- Convert.cs
- Origem:
- Convert.cs
Converte um subconjunto de uma matriz de inteiros sem sinal de 8 bits na representação de cadeia de caracteres equivalente codificada com dígitos de base 64. Parâmetros especificam o subconjunto como um deslocamento na matriz de entrada e o número de elementos na matriz a converter.
public:
static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, int offset, int length);public static string ToBase64String (byte[] inArray, int offset, int length);static member ToBase64String : byte[] * int * int -> stringPublic Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer) As StringParâmetros
- inArray
- Byte[]
Uma matriz de inteiros não assinados de 8 bits.
- offset
- Int32
Um deslocamento em inArray.
- length
- Int32
O número de elementos de inArray a serem convertidos.
Retornos
A representação de cadeia de caracteres em base 64 de elementos length de inArray, começando na posição offset.
Exceções
inArray é null.
offset ou length é negativo.
- ou -
A soma de offset e length é maior que o tamanho de inArray.
Comentários
Os elementos de inArray são tomados como um valor numérico e convertidos em uma representação de cadeia de caracteres na base 64.
Os dígitos de base 64 em ordem crescente a partir de zero são os caracteres maiúsculos de "A" a "Z", os caracteres minúsculos de "a" a "z", os numerais de "0" a "9" e os símbolos "+" e "/". O caractere sem valor, "=", é usado no preenchimento à direita.
Os parâmetros offset e length são números assinados de 32 bits. O offset parâmetro é baseado em zero.
Importante
O ToBase64String método foi projetado para processar uma única matriz de bytes que contém todos os dados a serem codificados. Para codificar dados a partir de um fluxo, use a classe System.Security.Cryptography.ToBase64Transform.
Confira também
Aplica-se a
ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)
- Origem:
- Convert.cs
- Origem:
- Convert.cs
- Origem:
- Convert.cs
Converte um subconjunto de uma matriz de inteiros sem sinal de 8 bits na representação de cadeia de caracteres equivalente codificada com dígitos de base 64. Parâmetros especificam o subconjunto como um deslocamento da matriz de entrada, o número de elementos na matriz para converter e se deve ou não inserir quebras de linha no valor retornado.
public:
static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, int offset, int length, Base64FormattingOptions options);public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options);[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options);static member ToBase64String : byte[] * int * int * Base64FormattingOptions -> string[<System.Runtime.InteropServices.ComVisible(false)>]
static member ToBase64String : byte[] * int * int * Base64FormattingOptions -> stringPublic Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer, options As Base64FormattingOptions) As StringParâmetros
- inArray
- Byte[]
Uma matriz de inteiros não assinados de 8 bits.
- offset
- Int32
Um deslocamento em inArray.
- length
- Int32
O número de elementos de inArray a serem convertidos.
- options
- Base64FormattingOptions
InsertLineBreaks para inserir uma quebra de linha a cada 76 caracteres, ou None para não inserir quebras de linha.
Retornos
A representação de cadeia de caracteres em base 64 de elementos length de inArray, começando na posição offset.
- Atributos
Exceções
inArray é null.
offset ou length é negativo.
- ou -
A soma de offset e length é maior que o tamanho de inArray.
options não é um valor Base64FormattingOptions válido.
Exemplos
O exemplo a seguir demonstra o ToBase64String método. A entrada é dividida em grupos de três bytes (24 bits) cada. Consequentemente, cada grupo consiste em quatro números de 6 bits em que cada número varia de 0 a 63 decimal. Neste exemplo, existem 85 grupos de 3 bytes com um byte restante. O primeiro grupo consiste nos valores hexadecimais 00, 01 e 02, que produzem quatro valores de 6 bits iguais a 0, 0, 4 e 2 decimais. Esses quatro valores correspondem aos dígitos base-64 "A", "A", "E" e "C" no início da saída.
Caso um número integral de grupos de 3 bytes não exista, os bytes restantes são preenchidos efetivamente com zero para formar um grupo completo. Neste exemplo, o valor do último byte é FF hexadecimal. Os primeiros 6 bits são iguais ao decimal 63, que corresponde ao dígito de base 64 "/" no final da saída, e os 2 próximos bits são preenchidos com zeros para produzir o decimal 48, que corresponde ao dígito de base 64, "w". Os dois últimos valores de 6 bits estão sendo preenchidos e correspondem ao caractere de preenchimento sem valor, "=".
// 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
'
Comentários
Os elementos do inArray parâmetro são tomados como um valor numérico e convertidos em uma representação de cadeia de caracteres na base 64.
Os dígitos de base 64 em ordem crescente a partir de zero são os caracteres maiúsculos de "A" a "Z", os caracteres minúsculos de "a" a "z", os numerais de "0" a "9" e os símbolos "+" e "/". O caractere sem valor "=" é usado para preenchimento à direita.
Os parâmetros offset e length são números assinados de 32 bits. O offset parâmetro é baseado em zero.
Importante
O ToBase64String método foi projetado para processar uma única matriz de bytes que contém todos os dados a serem codificados. Para codificar dados a partir de um fluxo, use a classe System.Security.Cryptography.ToBase64Transform.
Se o options parâmetro for definido como InsertLineBreaks e a saída da conversão for maior que 76 caracteres, uma quebra de linha será inserida a cada 76 caracteres. Uma quebra de linha é definida como um caractere de retorno de carro (U+000D) seguido por um caractere de alimentação de linha (U+000A). Para obter mais informações, consulte RFC 2045, "Multipurpose Internet Mail Extensions", em https://www.rfc-editor.org/.
Confira também
Aplica-se a
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de