Convert.ToBase64CharArray 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 un subconjunto de una matriz de enteros de 8 bits sin signo en un subconjunto equivalente de una matriz de caracteres Unicode codificada con dígitos de base 64.
Sobrecargas
| ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) |
Convierte un subconjunto de una matriz de enteros de 8 bits sin signo en un subconjunto equivalente de una matriz de caracteres Unicode codificada con dígitos de base 64. Los parámetros especifican los subconjuntos como posiciones de desplazamiento en las matrices de entrada y salida, el número de elementos de la matriz de entrada que se convierten y si se insertan saltos de línea en la matriz de salida. |
| ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) |
Convierte un subconjunto de una matriz de enteros de 8 bits sin signo en un subconjunto equivalente de una matriz de caracteres Unicode codificada con dígitos de base 64. Los parámetros especifican los subconjuntos como posiciones de desplazamiento en las matrices de entrada y salida, así como el número de elementos de la matriz de entrada que se van a convertir. |
ToBase64CharArray(Byte[], Int32, Int32, Char[], 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 un subconjunto equivalente de una matriz de caracteres Unicode codificada con dígitos de base 64. Los parámetros especifican los subconjuntos como posiciones de desplazamiento en las matrices de entrada y salida, el número de elementos de la matriz de entrada que se convierten y si se insertan saltos de línea en la matriz de salida.
public:
static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut, Base64FormattingOptions options);public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options);[System.Runtime.InteropServices.ComVisible(false)]
public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options);static member ToBase64CharArray : byte[] * int * int * char[] * int * Base64FormattingOptions -> int[<System.Runtime.InteropServices.ComVisible(false)>]
static member ToBase64CharArray : byte[] * int * int * char[] * int * Base64FormattingOptions -> intPublic Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer, options As Base64FormattingOptions) As IntegerParámetros
- inArray
- Byte[]
Matriz de entrada de enteros de 8 bits sin signo.
- offsetIn
- Int32
Posición en inArray.
- length
- Int32
Número de elementos de inArray que se van a convertir.
- outArray
- Char[]
Matriz de salida de caracteres Unicode.
- offsetOut
- Int32
Posición en outArray.
- options
- Base64FormattingOptions
InsertLineBreaks para insertar un salto de línea cada 76 caracteres o None para no insertar saltos de línea.
Devoluciones
Entero de 32 bits con signo que contiene el número de bytes de outArray.
- Atributos
Excepciones
inArray o outArray es null.
offsetIn, offsetOut o length es negativo.
O bien
offsetIn más length es mayor que la longitud de inArray.
O bien
offsetOut más el número de elementos a devolver es mayor que la longitud de outArray.
options no es un valor Base64FormattingOptions válido.
Ejemplos
En el siguiente ejemplo se muestra el ToBase64CharArray 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.ToBase64CharArray() and
// Convert.FromBase64CharArray methods
using namespace System;
bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 );
int main()
{
array<Byte>^byteArray1 = gcnew array<Byte>(256);
array<Byte>^byteArray2 = gcnew array<Byte>(256);
array<Char>^charArray = gcnew array<Char>(352);
int charArrayLength;
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 );
// 1) Initialize and display a Byte array of arbitrary data.
Console::WriteLine( "1) Input: A Byte array of arbitrary data.{0}", nl );
for ( int x = 0; x < byteArray1->Length; x++ )
{
byteArray1[ x ] = (Byte)x;
Console::Write( "{0:X2} ", byteArray1[ x ] );
if ( ((x + 1) % 20) == 0 )
Console::WriteLine();
}
Console::Write( "{0}{0}", nl );
// 2) Convert the input Byte array to a Char array, with newlines inserted.
charArrayLength = Convert::ToBase64CharArray( byteArray1, 0, byteArray1->Length,
charArray, 0,
Base64FormattingOptions::InsertLineBreaks );
Console::WriteLine( "2) Convert the input Byte array to a Char array with newlines." );
Console::Write( " Output: A Char array (length = {0}). ", charArrayLength );
Console::WriteLine( "The elements of the array are:{0}", nl );
Console::WriteLine( ruler );
Console::WriteLine( gcnew String( charArray ) );
Console::WriteLine();
// 3) Convert the Char array back to a Byte array.
Console::WriteLine( "3) Convert the Char array to an output Byte array." );
byteArray2 = Convert::FromBase64CharArray( charArray, 0, charArrayLength );
// 4) Are the input and output Byte arrays equivalent?
Console::WriteLine( "4) The output Byte array is equal to the input Byte array: {0}", ArraysAreEqual( byteArray1, byteArray2 ) );
}
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) Input: A Byte array 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 the input Byte array to a Char array with newlines.
Output: A Char array (length = 352). The elements of the array are:
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 Char array to an output Byte array.
4) The output Byte array is equal to the input Byte array: True
*/
// This example demonstrates the Convert.ToBase64CharArray() and
// Convert.FromBase64CharArray methods
using System;
class Sample
{
public static void Main()
{
byte[] byteArray1 = new byte[256];
byte[] byteArray2 = new byte[256];
char[] charArray = new char[352];
int charArrayLength;
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);
// 1) Initialize and display a Byte array of arbitrary data.
Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl);
for (int x = 0; x < byteArray1.Length; x++)
{
byteArray1[x] = (byte)x;
Console.Write("{0:X2} ", byteArray1[x]);
if (((x+1)%20) == 0) Console.WriteLine();
}
Console.Write("{0}{0}", nl);
// 2) Convert the input Byte array to a Char array, with newlines inserted.
charArrayLength =
Convert.ToBase64CharArray(byteArray1, 0, byteArray1.Length,
charArray, 0, Base64FormattingOptions.InsertLineBreaks);
Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.");
Console.Write(" Output: A Char array (length = {0}). ", charArrayLength);
Console.WriteLine("The elements of the array are:{0}", nl);
Console.WriteLine(ruler);
Console.WriteLine(new String(charArray));
Console.WriteLine();
// 3) Convert the Char array back to a Byte array.
Console.WriteLine("3) Convert the Char array to an output Byte array.");
byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength);
// 4) Are the input and output Byte arrays equivalent?
Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}",
ArraysAreEqual(byteArray1, byteArray2));
}
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) Input: A Byte array 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 the input Byte array to a Char array with newlines.
Output: A Char array (length = 352). The elements of the array are:
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 Char array to an output Byte array.
4) The output Byte array is equal to the input Byte array: True
*/
// This example demonstrates the Convert.ToBase64CharArray() and
// Convert.FromBase64CharArray methods
open System
let arraysAreEqual (a1: byte[]) (a2: byte[]) =
a1.Length = a2.Length &&
Array.forall2 (=) a2 a1
let byteArray1 = Array.zeroCreate<byte> 256
let charArray = Array.zeroCreate<char> 352
let nl = Environment.NewLine
let ruler =
$" 1 2 3 4 5 6 7 {nl}" +
$"1234567890123456789012345678901234567890123456789012345678901234567890123456{nl}" +
"----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-"
// 1) Initialize and display a Byte array of arbitrary data.
printfn $"1) Input: A Byte array of arbitrary data.{nl}"
for i = 0 to byteArray1.Length - 1 do
byteArray1[i] <- byte i
printf $"{byteArray1[i]:X2} "
if (i + 1) % 20 = 0 then
printfn ""
printf $"{nl}{nl}"
// 2) Convert the input Byte array to a Char array, with newlines inserted.
let charArrayLength =
Convert.ToBase64CharArray(byteArray1, 0, byteArray1.Length,
charArray, 0, Base64FormattingOptions.InsertLineBreaks)
printfn "2) Convert the input Byte array to a Char array with newlines."
printf $" Output: A Char array (length = {charArrayLength}). "
printfn $"The elements of the array are:{nl}"
printfn $"{ruler}"
printfn $"{String charArray}"
printfn ""
// 3) Convert the Char array back to a Byte array.
printfn "3) Convert the Char array to an output Byte array."
let byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength)
// 4) Are the input and output Byte arrays equivalent?
printfn $"4) The output Byte array is equal to the input Byte array: {arraysAreEqual byteArray1 byteArray2}"
// This example produces the following results:
// 1) Input: A Byte array 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 the input Byte array to a Char array with newlines.
// Output: A Char array (length = 352). The elements of the array are:
//
// 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 Char array to an output Byte array.
// 4) The output Byte array is equal to the input Byte array: True
' This example demonstrates the Convert.ToBase64CharArray() and
' Convert.FromBase64CharArray methods
Class Sample
Public Shared Sub Main()
Dim byteArray1(255) As Byte
Dim byteArray2(255) As Byte
Dim charArray(351) As Char
Dim charArrayLength 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)
' 1) Initialize and display a Byte array of arbitrary data.
Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl)
Dim x As Integer
For x = 0 To byteArray1.Length - 1
byteArray1(x) = CByte(x)
Console.Write("{0:X2} ", byteArray1(x))
If(x + 1) Mod 20 = 0 Then
Console.WriteLine()
End If
Next x
Console.Write("{0}{0}", nl)
' 2) Convert the input Byte array to a Char array, with newlines inserted.
charArrayLength = Convert.ToBase64CharArray( _
byteArray1, 0, byteArray1.Length, _
charArray, 0, _
Base64FormattingOptions.InsertLineBreaks)
Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.")
Console.Write(" Output: A Char array (length = {0}). ", charArrayLength)
Console.WriteLine("The elements of the array are:{0}", nl)
Console.WriteLine(ruler)
Console.WriteLine(New [String](charArray))
Console.WriteLine()
' 3) Convert the Char array back to a Byte array.
Console.WriteLine("3) Convert the Char array to an output Byte array.")
byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength)
' 4) Are the input and output Byte arrays equivalent?
Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}", _
ArraysAreEqual(byteArray1, byteArray2))
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) Input: A Byte array 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 the input Byte array to a Char array with newlines.
' Output: A Char array (length = 352). The elements of the array are:
'
' 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 Char array to an output Byte array.
'4) The output Byte array is equal to the input Byte array: True
Comentarios
El subconjunto de length elementos del inArray parámetro a partir de la posición offsetIn, se toman como un valor numérico y se convierten en un subconjunto de elementos del parámetro a partir de la outArray posición offsetOut. El valor devuelto indica el número de elementos convertidos en outArray. El subconjunto de outArray consta de dígitos de 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. Los offsetIn parámetros y offsetOut son posiciones de matriz de base cero.
Importante
El ToBase64CharArray método está diseñado para procesar una única matriz de bytes que contiene todos los datos que se van a codificar. Para crear una matriz de caracteres base-64 a partir de una secuencia de bytes, 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
ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Convierte un subconjunto de una matriz de enteros de 8 bits sin signo en un subconjunto equivalente de una matriz de caracteres Unicode codificada con dígitos de base 64. Los parámetros especifican los subconjuntos como posiciones de desplazamiento en las matrices de entrada y salida, así como el número de elementos de la matriz de entrada que se van a convertir.
public:
static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut);public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut);static member ToBase64CharArray : byte[] * int * int * char[] * int -> intPublic Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer) As IntegerParámetros
- inArray
- Byte[]
Matriz de entrada de enteros de 8 bits sin signo.
- offsetIn
- Int32
Posición en inArray.
- length
- Int32
Número de elementos de inArray que se van a convertir.
- outArray
- Char[]
Matriz de salida de caracteres Unicode.
- offsetOut
- Int32
Posición en outArray.
Devoluciones
Entero de 32 bits con signo que contiene el número de bytes de outArray.
Excepciones
inArray o outArray es null.
offsetIn, offsetOut o length es negativo.
O bien
offsetIn más length es mayor que la longitud de inArray.
O bien
offsetOut más el número de elementos a devolver es mayor que la longitud de outArray.
Ejemplos
En el ejemplo siguiente se muestra cómo usar el ToBase64CharArray método para codificar UUencode (codificar en base 64) una secuencia binaria y, a continuación, guardar la codificación en un archivo.
public:
void EncodeWithCharArray()
{
FileStream^ inFile;
array<Byte>^binaryData;
try
{
inFile = gcnew FileStream( inputFileName,
FileMode::Open,
FileAccess::Read );
binaryData = gcnew array<Byte>((int)(inFile->Length));
long bytesRead = inFile->Read( binaryData, 0,
(int)inFile->Length );
inFile->Close();
}
catch ( Exception^ exp )
{
// Error creating stream or reading from it.
Console::WriteLine( "{0}", exp->Message );
return;
}
// Convert the binary input into Base64 UUEncoded output.
// Each 3 Byte sequence in the source data becomes a 4 Byte
// sequence in the character array.
long arrayLength = (long)((4.0 / 3.0) * binaryData->Length);
// If array length is not divisible by 4, go up to the next
// multiple of 4.
if ( arrayLength % 4 != 0 )
{
arrayLength += 4 - arrayLength % 4;
}
array<Char>^ base64CharArray = gcnew array<Char>(arrayLength);
try
{
Convert::ToBase64CharArray( binaryData,
0,
binaryData->Length,
base64CharArray, 0 );
}
catch ( ArgumentNullException^ )
{
Console::WriteLine( "Binary data array is null." );
return;
}
catch ( ArgumentOutOfRangeException^ )
{
Console::WriteLine( "Char Array is not large enough." );
return;
}
// Write the UUEncoded version to the output file.
StreamWriter^ outFile;
try
{
outFile = gcnew StreamWriter( outputFileName,
false,
Text::Encoding::ASCII );
outFile->Write( base64CharArray );
outFile->Close();
}
catch ( Exception^ exp )
{
// Error creating stream or writing to it.
Console::WriteLine( " {0}", exp->Message );
}
}
public void EncodeWithCharArray() {
System.IO.FileStream inFile;
byte[] binaryData;
try {
inFile = new System.IO.FileStream(inputFileName,
System.IO.FileMode.Open,
System.IO.FileAccess.Read);
binaryData = new Byte[inFile.Length];
long bytesRead = inFile.Read(binaryData, 0,
(int) inFile.Length);
inFile.Close();
}
catch (System.Exception exp) {
// Error creating stream or reading from it.
System.Console.WriteLine("{0}", exp.Message);
return;
}
// Convert the binary input into Base64 UUEncoded output.
// Each 3 byte sequence in the source data becomes a 4 byte
// sequence in the character array.
long arrayLength = (long) ((4.0d/3.0d) * binaryData.Length);
// If array length is not divisible by 4, go up to the next
// multiple of 4.
if (arrayLength % 4 != 0) {
arrayLength += 4 - arrayLength % 4;
}
char[] base64CharArray = new char[arrayLength];
try {
System.Convert.ToBase64CharArray(binaryData,
0,
binaryData.Length,
base64CharArray,
0);
}
catch (System.ArgumentNullException) {
System.Console.WriteLine("Binary data array is null.");
return;
}
catch (System.ArgumentOutOfRangeException) {
System.Console.WriteLine("Char Array is not large enough.");
return;
}
// Write the UUEncoded version to the output file.
System.IO.StreamWriter outFile;
try {
outFile = new System.IO.StreamWriter(outputFileName,
false,
System.Text.Encoding.ASCII);
outFile.Write(base64CharArray);
outFile.Close();
}
catch (System.Exception exp) {
// Error creating stream or writing to it.
System.Console.WriteLine("{0}", exp.Message);
}
}
let encodeWithCharArray () =
try
use inFile =
new FileStream(inputFileName, FileMode.Open, FileAccess.Read)
let binaryData =
Array.zeroCreate<byte> (int inFile.Length)
inFile.Read(binaryData, 0, int inFile.Length)
|> ignore
// Convert the binary input into Base64 UUEncoded output.
// Each 3 byte sequence in the source data becomes a 4 byte
// sequence in the character array.
let arrayLength =
(4. / 3.) * float binaryData.Length |> int64
// If array length is not divisible by 4, shadow up to the next multiple of 4.
let arrayLength =
if arrayLength % 4L <> 0L then
arrayLength + (4L - arrayLength % 4L)
else
arrayLength
let base64CharArray = Array.zeroCreate<char> (int arrayLength)
Convert.ToBase64CharArray(binaryData, 0, binaryData.Length, base64CharArray, 0)
|> ignore
// Write the UUEncoded version to the output file.
use outFile =
new StreamWriter(outputFileName, false, Encoding.ASCII)
outFile.Write(base64CharArray)
outFile.Close()
with
| :? ArgumentNullException -> printfn "Binary data array is null."
| :? ArgumentOutOfRangeException -> printfn "Char Array is not large enough."
| e ->
// Error creating stream or writing to it.
printfn $"{e.Message}"
Public Sub EncodeWithCharArray()
Dim inFile As System.IO.FileStream
Dim binaryData() As Byte
Try
inFile = New System.IO.FileStream(inputFileName, _
System.IO.FileMode.Open, _
System.IO.FileAccess.Read)
ReDim binaryData(inFile.Length)
Dim bytesRead As Long = inFile.Read(binaryData, _
0, _
CInt(inFile.Length))
inFile.Close()
Catch exp As System.Exception
' Error creating stream or reading from it.
System.Console.WriteLine("{0}", exp.Message)
Return
End Try
' Convert the binary input into Base64 UUEncoded output.
' Each 3 byte sequence in the source data becomes a 4 byte
' sequence in the character array.
Dim arrayLength As Long
arrayLength = (4 / 3) * binaryData.Length
If arrayLength Mod 4 <> 0 Then
arrayLength = arrayLength + 4 - arrayLength Mod 4
End If
Dim base64CharArray(arrayLength - 1) As Char
Try
System.Convert.ToBase64CharArray(binaryData, _
0, _
binaryData.Length, _
base64CharArray, 0)
Catch exp As System.ArgumentNullException
System.Console.WriteLine("Binary data array is null.")
Return
Catch exp As System.ArgumentOutOfRangeException
System.Console.WriteLine("Char Array is not large enough.")
Return
End Try
' Write the UUEncoded version to the output file.
Dim outFile As System.IO.StreamWriter
Try
outFile = New System.IO.StreamWriter(outputFileName, _
False, _
System.Text.Encoding.ASCII)
outFile.Write(base64CharArray)
outFile.Close()
Catch exp As System.Exception
' Error creating stream or writing to it.
System.Console.WriteLine("{0}", exp.Message)
End Try
End Sub
Comentarios
El subconjunto de elementos de a partir de lengthinArray la posición offsetIn, se toman como un valor numérico y se convierten en un subconjunto de elementos a outArray partir de la posición offsetOut. El valor devuelto indica el número de elementos convertidos en outArray. El subconjunto de outArray consta de dígitos de 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. Los offsetIn parámetros y offsetOut son posiciones de matriz de base cero.
Importante
El ToBase64CharArray método está diseñado para procesar una única matriz de bytes que contiene todos los datos que se van a codificar. Para crear una matriz de caracteres base-64 a partir de una secuencia de bytes, use la System.Security.Cryptography.ToBase64Transform clase .
