Convert.ToBase64String Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Convierte el valor de una matriz de enteros sin signo de 8 bits en su representación de cadena equivalente codificada con dígitos base-64.

Sobrecargas

ToBase64String(Byte[])	Convierte una matriz de enteros sin signo de 8 bits en su representación de cadena equivalente codificada con dígitos base-64.
ToBase64String(Byte[], Base64FormattingOptions)	Convierte una matriz de enteros sin signo de 8 bits en su representación de cadena equivalente codificada con dígitos 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 dentro del intervalo de solo lectura especificado en su representación de cadena equivalente codificada con dígitos 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 sin signo de 8 bits en su representación de cadena equivalente codificada con dígitos base-64. Los parámetros especifican el subconjunto como un 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 sin signo de 8 bits en su representación de cadena equivalente codificada con dígitos base-64. Los parámetros especifican el subconjunto como un desplazamiento en la matriz de entrada, el número de elementos de la matriz que se va a convertir y si se van a insertar saltos de línea en el valor devuelto.

ToBase64String(Byte[])

Source:

Convert.cs

Convierte una matriz de enteros sin signo de 8 bits en su representación de cadena equivalente codificada con dígitos base-64.

C#

public static string ToBase64String (byte[] inArray);

Parámetros

inArray

Byte[]

Matriz de enteros sin signo de 8 bits.

Devoluciones

String

Representación de cadena, en base 64, del contenido de inArray.

Excepciones

ArgumentNullException

inArray es null.

Ejemplos

En el ejemplo siguiente se usa el método ToBase64String(Byte[]) para convertir una matriz de bytes en una cadena codificada en UUencoded (base-64) y, a continuación, se llama al método FromBase64String(String) para restaurar la matriz de bytes original.

C#

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

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 método BitConverter.GetBytes(Int32) para convertir cada elemento en una matriz de bytes, que almacena en la posición adecuada en un búfer llamando al método Array.Copy(Array, Int32, Array, Int32, Int32). A continuación, este búfer se pasa al método ToBase64String(Byte[]) para crear una cadena codificada en UUencoded (base-64). A continuación, llama al método FromBase64String(String) para descodificar la cadena codificada en UU y llama al método BitConverter.ToInt32 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.

C#

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 }

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 el relleno final.

Importante

El método ToBase64String está diseñado para procesar una sola matriz de bytes que contiene todos los datos que se van a codificar. Para codificar datos de una secuencia, use la clase System.Security.Cryptography.ToBase64Transform.

Normalmente, el método ToBase64String no se usa para recorrer de ida y vuelta una cadena UUEncoded (codificada en base 64). Es decir, si descodifica una cadena llamando al método FromBase64String, codifique la matriz de bytes devuelta llamando al método ToBase64String, 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

• FromBase64String(String)
• ToBase64Transform

ToBase64String(Byte[], Base64FormattingOptions)

Source:

Convert.cs

Convierte una matriz de enteros sin signo de 8 bits en su representación de cadena equivalente codificada con dígitos base-64. Puede especificar si se van a insertar saltos de línea en el valor devuelto.

C#

public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);

Parámetros

inArray

Byte[]

Matriz de enteros sin signo de 8 bits.

options

Base64FormattingOptions

InsertLineBreaks para insertar un salto de línea cada 76 caracteres o None para no insertar saltos de línea.

Devoluciones

String

Representación de cadena en base 64 de los elementos de inArray.

Excepciones

ArgumentNullException

inArray es null.

ArgumentException

options no es un valor de Base64FormattingOptions válido.

Ejemplos

En el ejemplo siguiente se llama al Convert.ToBase64String(Byte[], Base64FormattingOptions) con un argumento Base64FormattingOptions.InsertLineBreaks para insertar saltos de línea en la cadena que se genera mediante la codificación de una matriz de bytes de 100 elementos.

C#

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

Como se muestra en la salida del ejemplo, el Convert.FromBase64String se realiza correctamente en la restauración de la matriz de bytes original; los caracteres de salto de línea se omiten durante la conversión.

Comentarios

Los elementos del parámetro 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 el relleno final.

Importante

El método ToBase64String está diseñado para procesar una sola matriz de bytes que contiene todos los datos que se van a codificar. Para codificar datos de una secuencia, use la clase System.Security.Cryptography.ToBase64Transform.

Si el parámetro options se establece en InsertLineBreaks 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 a 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", en https://www.rfc-editor.org/.

Consulte también

• FromBase64String(String)
• ToBase64Transform

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Source:

Convert.cs

Convierte los enteros sin signo de 8 bits dentro del intervalo de solo lectura especificado en su representación de cadena equivalente codificada con dígitos base-64. Opcionalmente, puede especificar si se van a insertar saltos de línea en el valor devuelto.

C#

public static string ToBase64String (ReadOnlySpan<byte> bytes, Base64FormattingOptions options = System.Base64FormattingOptions.None);

Parámetros

bytes

ReadOnlySpan<Byte>

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

String

Representación de cadena en base 64 de los elementos de bytes. Si la longitud de bytes es 0, se devuelve una cadena vacía.

Excepciones

ArgumentException

options no es un valor de Base64FormattingOptions válido.

OutOfMemoryException

La longitud de salida era mayor que Int32.MaxValue.

ToBase64String(Byte[], Int32, Int32)

Source:

Convert.cs

Convierte un subconjunto de una matriz de enteros sin signo de 8 bits en su representación de cadena equivalente codificada con dígitos base-64. Los parámetros especifican el subconjunto como un desplazamiento en la matriz de entrada y el número de elementos de la matriz que se van a convertir.

C#

public static string ToBase64String (byte[] inArray, int offset, int length);

Parámetros

inArray

Byte[]

Matriz de enteros sin signo de 8 bits.

offset

Int32

Desplazamiento en inArray.

length

Int32

Número de elementos de inArray que se van a convertir.

Devoluciones

String

Representación de cadena en la base 64 de length elementos de inArray, empezando por la posición offset.

Excepciones

ArgumentNullException

inArray es null.

ArgumentOutOfRangeException

offset o length es negativo.

-o-

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 el relleno final.

Los parámetros offset y length son números con signo de 32 bits. El parámetro offset está basado en cero.

Importante

El método ToBase64String está diseñado para procesar una sola matriz de bytes que contiene todos los datos que se van a codificar. Para codificar datos de una secuencia, use la clase System.Security.Cryptography.ToBase64Transform.

Consulte también

• FromBase64String(String)
• ToBase64Transform

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

Source:

Convert.cs

Convierte un subconjunto de una matriz de enteros sin signo de 8 bits en su representación de cadena equivalente codificada con dígitos base-64. Los parámetros especifican el subconjunto como un desplazamiento en la matriz de entrada, el número de elementos de la matriz que se va a convertir y si se van a insertar saltos de línea en el valor devuelto.

C#

public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options);

Parámetros

inArray

Byte[]

Matriz de enteros sin signo de 8 bits.

offset

Int32

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

String

Representación de cadena en la base 64 de length elementos de inArray, empezando por la posición offset.

Excepciones

ArgumentNullException

inArray es null.

ArgumentOutOfRangeException

offset o length es negativo.

-o-

offset más length es mayor que la longitud de inArray.

ArgumentException

options no es un valor de Base64FormattingOptions válido.

Ejemplos

En el ejemplo siguiente se muestra el método ToBase64String. 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 donde cada número oscila entre 0 y 63 decimales. 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 decimal 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 decimales 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 , "=".

C#

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

*/

Comentarios

Los elementos del parámetro 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 el relleno final.

Los parámetros offset y length son números con signo de 32 bits. El parámetro offset está basado en cero.

Importante

El método ToBase64String está diseñado para procesar una sola matriz de bytes que contiene todos los datos que se van a codificar. Para codificar datos de una secuencia, use la clase System.Security.Cryptography.ToBase64Transform.

Si el parámetro options se establece en InsertLineBreaks 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", en https://www.rfc-editor.org/.

Consulte también

• FromBase64String(String)
• ToBase64Transform