Convert.ToBase64String Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Convierte el valor de una matriz de enteros de 8 bits sin signo en su representación de cadena equivalente, que se codifica con dígitos de base 64.
Sobrecargas
| ToBase64String(Byte[]) |
Convierte una matriz de enteros de 8 bits sin signo en su representación de cadena equivalente, que se codifica con dígitos de base 64. |
| ToBase64String(Byte[], Base64FormattingOptions) |
Convierte una matriz de enteros de 8 bits sin signo en su representación de cadena equivalente, que se codifica con dígitos de base 64. Puede especificar si se van a insertar saltos de línea en el valor devuelto. |
| ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions) |
Convierte los enteros sin signo de 8 bits del intervalo de solo lectura especificado en su representación de cadena equivalente, que se codifica con dígitos en base 64. Opcionalmente puede especificar si se van a insertar saltos de línea en el valor devuelto. |
| ToBase64String(Byte[], Int32, Int32) |
Convierte un subconjunto de una matriz de enteros de 8 bits sin signo en su representación de cadena equivalente, que se codifica con dígitos de base 64. Los parámetros especifican el subconjunto como una posición de desplazamiento en la matriz de entrada y el número de elementos de la matriz que se van a convertir. |
| ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions) |
Convierte un subconjunto de una matriz de enteros de 8 bits sin signo en su representación de cadena equivalente, que se codifica con dígitos de base 64. Los parámetros especifican el subconjunto como una posición de desplazamiento en la matriz de entrada, el número de elementos en la matriz que se convierten y si se insertan saltos de línea en el valor devuelto. |
ToBase64String(Byte[])
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Convierte una matriz de enteros de 8 bits sin signo en su representación de cadena equivalente, que se codifica con 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[]
Matriz de enteros de 8 bits sin signo.
Devoluciones
Representación de cadena, en base 64, del contenido de inArray.
Excepciones
inArray es null.
Ejemplos
En el ejemplo siguiente se usa el ToBase64String(Byte[]) método para convertir una matriz de bytes en una cadena codificada en UU (base-64) y, a continuación, se llama al FromBase64String(String) método para restaurar la 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
A continuación se muestra un ejemplo más complejo que crea una matriz de 20 elementos de enteros de 32 bits. A continuación, usa el BitConverter.GetBytes(Int32) método para convertir cada elemento en una matriz de bytes, que almacena en la posición adecuada en un búfer llamando al Array.Copy(Array, Int32, Array, Int32, Int32) método . A continuación, este búfer se pasa al ToBase64String(Byte[]) método para crear una cadena codificada en UU (base-64). A continuación, llama al FromBase64String(String) método para descodificar la cadena codificada en UU y llama al BitConverter.ToInt32 método para convertir cada conjunto de cuatro bytes (el tamaño de un entero de 32 bits) en un entero. La salida del ejemplo muestra que la matriz original se ha restaurado correctamente.
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 }
Comentarios
Los elementos de inArray se toman como un valor numérico y se convierten en una representación de cadena codificada con dígitos base 64.
Los dígitos base-64 en orden ascendente de cero son los caracteres en mayúsculas "A" a "Z", los caracteres en minúsculas "a" a "z", los números "0" a "9", y los símbolos "+" y "/". El carácter sin valor , "=", se usa para relleno final.
Importante
El ToBase64String método está diseñado para procesar una única matriz de bytes que contiene todos los datos que se van a codificar. Para codificar datos de una secuencia, use la System.Security.Cryptography.ToBase64Transform clase .
Normalmente, el ToBase64String método no se usa para realizar un recorrido de ida y vuelta una cadena UUEncoded (codificada en base 64). Es decir, si descodifica una cadena llamando al FromBase64String método , codifique la matriz de bytes devuelta llamando al ToBase64String método , la cadena resultante no será necesariamente idéntica a la cadena original. La cadena solo realizará un recorrido de ida y vuelta si la cadena original es una cadena codificada en base 64 válida.
Consulte también
Se aplica a
ToBase64String(Byte[], Base64FormattingOptions)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Convierte una matriz de enteros de 8 bits sin signo en su representación de cadena equivalente, que se codifica con dígitos de base 64. Puede especificar si se van a insertar saltos de línea en el valor devuelto.
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[]
Matriz de enteros de 8 bits sin signo.
- options
- Base64FormattingOptions
InsertLineBreaks para insertar un salto de línea cada 76 caracteres o None para no insertar saltos de línea.
Devoluciones
Representación de cadena en base 64 de los elementos de inArray.
- Atributos
Excepciones
inArray es null.
options no es un valor Base64FormattingOptions válido.
Ejemplos
En el Convert.ToBase64String(Byte[], Base64FormattingOptions) ejemplo siguiente se llama a con un Base64FormattingOptions.InsertLineBreaks argumento para insertar saltos de línea en la cadena que se genera mediante la codificación de una 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 se muestra en la salida del ejemplo, se Convert.FromBase64String restaura correctamente la matriz de bytes original; los caracteres de salto de línea se omiten durante la conversión.
Comentarios
Los elementos del inArray parámetro se toman como un valor numérico y se convierten en una representación de cadena en base 64.
Los dígitos base-64 en orden ascendente de cero son los caracteres en mayúsculas "A" a "Z", los caracteres en minúsculas "a" a "z", los números "0" a "9", y los símbolos "+" y "/". El carácter sin valor "=" se usa para relleno final.
Importante
El ToBase64String método está diseñado para procesar una única matriz de bytes que contiene todos los datos que se van a codificar. Para codificar datos de una secuencia, use la System.Security.Cryptography.ToBase64Transform clase .
Si el options parámetro se establece InsertLineBreaks en y la salida de la conversión tiene más de 76 caracteres, se inserta un salto de línea cada 76 caracteres. Un salto de línea se define como un carácter de retorno de carro (U+000D) seguido de un carácter de avance de línea (U+000A). Dado que los saltos de línea se consideran caracteres de espacio en blanco en una codificación base 64, se omiten al convertir una cadena codificada en base 64 en una matriz de bytes. Los saltos de línea son simplemente cómodos al mostrar la cadena codificada en un control o un dispositivo, como una ventana de consola. Para obtener más información, vea RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.
Consulte también
Se aplica a
ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Convierte los enteros sin signo de 8 bits del intervalo de solo lectura especificado en su representación de cadena equivalente, que se codifica con dígitos en base 64. Opcionalmente puede especificar si se van a insertar saltos de línea en el valor devuelto.
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>
Un intervalo de solo lectura de enteros sin signo de 8 bits.
- options
- Base64FormattingOptions
Uno de los valores de enumeración que especifican si se van a insertar saltos de línea en el valor devuelto. El valor predeterminado es None.
Devoluciones
Representación de cadena en base 64 de los elementos de inArray. Si la longitud de bytes es 0, se devuelve una cadena vacía.
Excepciones
options no es un valor Base64FormattingOptions válido.
La longitud de salida era mayor que Int32.MaxValue.
Se aplica a
ToBase64String(Byte[], Int32, Int32)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Convierte un subconjunto de una matriz de enteros de 8 bits sin signo en su representación de cadena equivalente, que se codifica con dígitos de base 64. Los parámetros especifican el subconjunto como una posición de desplazamiento en la matriz de entrada y el número de elementos de la matriz que se van a convertir.
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[]
Matriz de enteros de 8 bits sin signo.
- offset
- Int32
Posición de desplazamiento en inArray.
- length
- Int32
Número de elementos de inArray que se van a convertir.
Devoluciones
Representación de cadena en base 64 de los elementos length de inArray, empezando en la posición offset.
Excepciones
inArray es null.
offset o length es negativo.
O bien
offset más length es mayor que la longitud de inArray.
Comentarios
Los elementos de inArray se toman como un valor numérico y se convierten en una representación de cadena en base 64.
Los dígitos base-64 en orden ascendente de cero son los caracteres en mayúsculas "A" a "Z", los caracteres en minúsculas "a" a "z", los números "0" a "9", y los símbolos "+" y "/". El carácter sin valor , "=", se usa para relleno final.
Los offset parámetros y length son números con signo de 32 bits. El offset parámetro está basado en cero.
Importante
El ToBase64String método está diseñado para procesar una única matriz de bytes que contiene todos los datos que se van a codificar. Para codificar datos de una secuencia, use la System.Security.Cryptography.ToBase64Transform clase .
Consulte también
Se aplica a
ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Convierte un subconjunto de una matriz de enteros de 8 bits sin signo en su representación de cadena equivalente, que se codifica con dígitos de base 64. Los parámetros especifican el subconjunto como una posición de desplazamiento en la matriz de entrada, el número de elementos en la matriz que se convierten y si se insertan saltos de línea en el valor devuelto.
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[]
Matriz de enteros de 8 bits sin signo.
- offset
- Int32
Posición de desplazamiento en inArray.
- length
- Int32
Número de elementos de inArray que se van a convertir.
- options
- Base64FormattingOptions
InsertLineBreaks para insertar un salto de línea cada 76 caracteres o None para no insertar saltos de línea.
Devoluciones
Representación de cadena en base 64 de los elementos length de inArray, empezando en la posición offset.
- Atributos
Excepciones
inArray es null.
offset o length es negativo.
O bien
offset más length es mayor que la longitud de inArray.
options no es un valor Base64FormattingOptions válido.
Ejemplos
En el siguiente ejemplo se muestra el ToBase64String método. La entrada se divide en grupos de tres bytes (24 bits) cada uno. Por lo tanto, cada grupo consta de cuatro números de 6 bits en los que cada número oscila entre 0 y 63. En este ejemplo, hay 85 grupos de 3 bytes con un byte restante. El primer grupo consta de los valores hexadecimales 00, 01 y 02, que producen cuatro valores de 6 bits iguales a decimales 0, 0, 4 y 2. Estos cuatro valores corresponden a los dígitos base-64 "A", "A", "E" y "C" al principio de la salida.
Si no existe un número entero de grupos de 3 bytes, los bytes restantes se rellenan eficazmente con ceros para formar un grupo completo. En este ejemplo, el valor del último byte es FF hexadecimal. Los primeros 6 bits son iguales al decimal 63, que corresponde al dígito base-64 "/" al final de la salida, y los siguientes 2 bits se rellenan con ceros para producir el decimal 48, que corresponde al dígito base-64, "w". Los dos últimos valores de 6 bits se rellenan y corresponden al carácter de relleno sin 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
'
Comentarios
Los elementos del inArray parámetro se toman como un valor numérico y se convierten en una representación de cadena en base 64.
Los dígitos base-64 en orden ascendente de cero son los caracteres en mayúsculas "A" a "Z", los caracteres en minúsculas "a" a "z", los números "0" a "9", y los símbolos "+" y "/". El carácter sin valor "=" se usa para relleno final.
Los offset parámetros y length son números con signo de 32 bits. El offset parámetro está basado en cero.
Importante
El ToBase64String método está diseñado para procesar una única matriz de bytes que contiene todos los datos que se van a codificar. Para codificar datos de una secuencia, use la System.Security.Cryptography.ToBase64Transform clase .
Si el options parámetro se establece InsertLineBreaks en y la salida de la conversión tiene más de 76 caracteres, se inserta un salto de línea cada 76 caracteres. Un salto de línea se define como un carácter de retorno de carro (U+000D) seguido de un carácter de avance de línea (U+000A). Para obtener más información, vea RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.
Consulte también
Se aplica a
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de