Convert.ToBase64String Método

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Converte o valor de uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64.

Sobrecargas

ToBase64String(Byte[])	Converte uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64.
ToBase64String(Byte[], Base64FormattingOptions)	Converte uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64. Você pode especificar se as quebras de linha devem ser inseridas no valor retornado.
ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)	Converte os inteiros sem sinal de 8 bits dentro do intervalo somente leitura especificado em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64. Opcionalmente, você pode especificar se as quebras de linha devem ser inseridas no valor retornado.
ToBase64String(Byte[], Int32, Int32)	Converte um subconjunto de uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64. Os parâmetros especificam o subconjunto como um deslocamento na matriz de entrada e o número de elementos na matriz a ser convertida.
ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)	Converte um subconjunto de uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64. Os parâmetros especificam o subconjunto como um deslocamento na matriz de entrada, o número de elementos na matriz a ser convertida e se as quebras de linha devem ser inseridas no valor retornado.

ToBase64String(Byte[])

Origem:

Convert.cs

Converte uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64.

C#

public static string ToBase64String (byte[] inArray);

Parâmetros

inArray

Byte[]

Uma matriz de inteiros sem sinal de 8 bits.

Retornos

String

A representação da cadeia de caracteres, na base 64, do conteúdo de inArray.

Exceções

ArgumentNullException

inArray é null.

Exemplos

O exemplo a seguir usa o método ToBase64String(Byte[]) para converter uma matriz de bytes em uma cadeia de caracteres UUencoded (base-64) e, em seguida, chama o método FromBase64String(String) para restaurar a 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

Veja a seguir um exemplo mais complexo que cria uma matriz de 20 elementos de inteiros de 32 bits. Em seguida, ele usa o método BitConverter.GetBytes(Int32) para converter cada elemento em uma matriz de bytes, que armazena na posição apropriada em um buffer chamando o método Array.Copy(Array, Int32, Array, Int32, Int32). Em seguida, esse buffer é passado para o método ToBase64String(Byte[]) para criar uma cadeia de caracteres UUencoded (base-64). Em seguida, ele chama o método FromBase64String(String) para decodificar a cadeia de caracteres UUencoded e chama o método BitConverter.ToInt32 para converter cada conjunto de quatro bytes (o tamanho de um inteiro de 32 bits) em um inteiro. A saída do exemplo mostra que a matriz original foi restaurada com êxito.

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 }

Comentários

Os elementos de inArray são tomados como um valor numérico e convertidos em uma representação de cadeia de caracteres codificada com dígitos base-64.

Os dígitos base-64 em ordem crescente de zero são os caracteres maiúsculos "A" a "Z", os caracteres minúsculos "a" a "z", os numerais "0" a "9" e os símbolos "+" e "/". O caractere sem valor, "=", é usado para preenchimento à direita.

Importante

O método ToBase64String foi projetado para processar uma única matriz de bytes que contém todos os dados a serem codificados. Para codificar dados de um fluxo, use a classe System.Security.Cryptography.ToBase64Transform.

Normalmente, o método ToBase64String não é usado para fazer uma viagem de ida e volta em uma cadeia de caracteres UUEncoded (codificada em base 64). Ou seja, se você decodificar uma cadeia de caracteres chamando o método FromBase64String, codificar a matriz de bytes retornada chamando o método ToBase64String, a cadeia de caracteres resultante não será necessariamente idêntica à cadeia de caracteres original. A cadeia de caracteres só será de ida e volta se a cadeia de caracteres original for uma cadeia de caracteres codificada em base 64 válida.

Confira também

• FromBase64String(String)
• ToBase64Transform

ToBase64String(Byte[], Base64FormattingOptions)

Origem:

Convert.cs

Converte uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64. Você pode especificar se as quebras de linha devem ser inseridas no valor retornado.

C#

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

Parâmetros

inArray

Byte[]

Uma matriz de inteiros sem sinal de 8 bits.

options

Base64FormattingOptions

InsertLineBreaks inserir uma quebra de linha a cada 76 caracteres ou None para não inserir quebras de linha.

Retornos

String

A representação de cadeia de caracteres na base 64 dos elementos em inArray.

Exceções

ArgumentNullException

inArray é null.

ArgumentException

options não é um valor de Base64FormattingOptions válido.

Exemplos

O exemplo a seguir chama o Convert.ToBase64String(Byte[], Base64FormattingOptions) com um argumento Base64FormattingOptions.InsertLineBreaks para inserir quebras de linha na cadeia de caracteres produzida pela codificação de uma 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 mostra a saída do exemplo, o Convert.FromBase64String consegue restaurar a matriz de bytes original; os caracteres de quebra de linha são ignorados durante a conversão.

Comentários

Os elementos do parâmetro inArray são tomados como um valor numérico e convertidos em uma representação de cadeia de caracteres na base 64.

Os dígitos base-64 em ordem crescente de zero são os caracteres maiúsculos "A" a "Z", os caracteres minúsculos "a" a "z", os numerais "0" a "9" e os símbolos "+" e "/". O caractere sem valor "=" é usado para preenchimento à direita.

Importante

O método ToBase64String foi projetado para processar uma única matriz de bytes que contém todos os dados a serem codificados. Para codificar dados de um fluxo, use a classe System.Security.Cryptography.ToBase64Transform.

Se o parâmetro options for definido como InsertLineBreaks e a saída da conversão for maior que 76 caracteres, uma quebra de linha será inserida a cada 76 caracteres. Uma quebra de linha é definida como um caractere de retorno de carro (U+000D) seguido por um caractere de feed de linha (U+000A). Como as quebras de linha são consideradas caracteres de espaço em branco em uma codificação base-64, elas são ignoradas ao converter uma cadeia de caracteres codificada em base 64 de volta em uma matriz de bytes. As quebras de linha são simplesmente convenientes ao exibir a cadeia de caracteres codificada em um controle ou um dispositivo, como uma janela de console. Para obter mais informações, consulte RFC 2045, "Extensões de Email multiuso da Internet", em https://www.rfc-editor.org/.

Confira também

• FromBase64String(String)
• ToBase64Transform

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Origem:

Convert.cs

Converte os inteiros sem sinal de 8 bits dentro do intervalo somente leitura especificado em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64. Opcionalmente, você pode especificar se as quebras de linha devem ser inseridas no valor retornado.

C#

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

Parâmetros

bytes

ReadOnlySpan<Byte>

Um intervalo somente leitura de inteiros sem sinal de 8 bits.

options

Base64FormattingOptions

Um dos valores de enumeração que especificam se as quebras de linha devem ser inseridas no valor retornado. O valor padrão é None.

Retornos

String

A representação de cadeia de caracteres na base 64 dos elementos em bytes. Se o comprimento de bytes for 0, uma cadeia de caracteres vazia será retornada.

Exceções

ArgumentException

options não é um valor de Base64FormattingOptions válido.

OutOfMemoryException

O comprimento de saída foi maior que int32.MaxValue.

ToBase64String(Byte[], Int32, Int32)

Origem:

Convert.cs

Converte um subconjunto de uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64. Os parâmetros especificam o subconjunto como um deslocamento na matriz de entrada e o número de elementos na matriz a ser convertida.

C#

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

Parâmetros

inArray

Byte[]

Uma matriz de inteiros sem sinal de 8 bits.

offset

Int32

Um deslocamento em inArray.

length

Int32

O número de elementos de inArray a serem convertidos.

Retornos

String

A representação de cadeia de caracteres na base 64 de elementos length de inArray, começando na posição offset.

Exceções

ArgumentNullException

inArray é null.

ArgumentOutOfRangeException

offset ou length é negativo.

-ou-

offset mais length é maior que o comprimento de inArray.

Comentários

Os elementos de inArray são tomados como um valor numérico e convertidos em uma representação de cadeia de caracteres na base 64.

Os dígitos base-64 em ordem crescente de zero são os caracteres maiúsculos "A" a "Z", os caracteres minúsculos "a" a "z", os numerais "0" a "9" e os símbolos "+" e "/". O caractere sem valor, "=", é usado para preenchimento à direita.

Os parâmetros offset e length são números assinados de 32 bits. O parâmetro offset é baseado em zero.

Importante

O método ToBase64String foi projetado para processar uma única matriz de bytes que contém todos os dados a serem codificados. Para codificar dados de um fluxo, use a classe System.Security.Cryptography.ToBase64Transform.

Confira também

• FromBase64String(String)
• ToBase64Transform

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

Origem:

Convert.cs

Converte um subconjunto de uma matriz de inteiros sem sinal de 8 bits em sua representação de cadeia de caracteres equivalente codificada com dígitos base-64. Os parâmetros especificam o subconjunto como um deslocamento na matriz de entrada, o número de elementos na matriz a ser convertida e se as quebras de linha devem ser inseridas no valor retornado.

C#

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

Parâmetros

inArray

Byte[]

Uma matriz de inteiros sem sinal de 8 bits.

offset

Int32

Um deslocamento em inArray.

length

Int32

O número de elementos de inArray a serem convertidos.

options

Base64FormattingOptions

InsertLineBreaks inserir uma quebra de linha a cada 76 caracteres ou None para não inserir quebras de linha.

Retornos

String

A representação de cadeia de caracteres na base 64 de elementos length de inArray, começando na posição offset.

Exceções

ArgumentNullException

inArray é null.

ArgumentOutOfRangeException

offset ou length é negativo.

-ou-

offset mais length é maior que o comprimento de inArray.

ArgumentException

options não é um valor de Base64FormattingOptions válido.

Exemplos

O exemplo a seguir demonstra o método ToBase64String. A entrada é dividida em grupos de três bytes (24 bits) cada. Consequentemente, cada grupo consiste em quatro números de 6 bits em que cada número varia decimal 0 a 63. Neste exemplo, há 85 grupos de 3 bytes com um byte restante. O primeiro grupo consiste nos valores hexadecimal 00, 01 e 02, que produzem quatro valores de 6 bits iguais a 0, 0, 4 e 2 decimais. Esses quatro valores correspondem aos dígitos base-64 "A", "A", "E" e "C" no início da saída.

Se um número integral de grupos de 3 bytes não existir, os bytes restantes serão efetivamente acolchoados com zeros para formar um grupo completo. Neste exemplo, o valor do último byte é FF hexadecimal. Os primeiros 6 bits são iguais ao decimal 63, que corresponde ao dígito base-64 "/" no final da saída, e os próximos 2 bits são adicionados com zeros para produzir 48 decimais, o que corresponde ao dígito base-64, "w". Os dois últimos valores de 6 bits são preenchimento e correspondem ao caractere de preenchimento sem 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

*/

Comentários

Os elementos do parâmetro inArray são tomados como um valor numérico e convertidos em uma representação de cadeia de caracteres na base 64.

Os dígitos base-64 em ordem crescente de zero são os caracteres maiúsculos "A" a "Z", os caracteres minúsculos "a" a "z", os numerais "0" a "9" e os símbolos "+" e "/". O caractere sem valor "=" é usado para preenchimento à direita.

Os parâmetros offset e length são números assinados de 32 bits. O parâmetro offset é baseado em zero.

Importante

O método ToBase64String foi projetado para processar uma única matriz de bytes que contém todos os dados a serem codificados. Para codificar dados de um fluxo, use a classe System.Security.Cryptography.ToBase64Transform.

Se o parâmetro options for definido como InsertLineBreaks e a saída da conversão for maior que 76 caracteres, uma quebra de linha será inserida a cada 76 caracteres. Uma quebra de linha é definida como um caractere de retorno de carro (U+000D) seguido por um caractere de feed de linha (U+000A). Para obter mais informações, consulte RFC 2045, "Extensões de Email multiuso da Internet", em https://www.rfc-editor.org/.

Confira também

• FromBase64String(String)
• ToBase64Transform