Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Enum

Definición

Especifica si los métodos ToBase64CharArray y ToBase64String relevantes insertan saltos de línea en su salida.Specifies whether relevant ToBase64CharArray and ToBase64String methods insert line breaks in their output.

Esta enumeración tiene el atributo FlagsAttribute, que permite una combinación bit a bit de sus valores de miembro.

public enum class Base64FormattingOptions
[System.Flags]
public enum Base64FormattingOptions
type Base64FormattingOptions = 
Public Enum Base64FormattingOptions
Herencia
Base64FormattingOptionsBase64FormattingOptionsBase64FormattingOptionsBase64FormattingOptions
Atributos

Campos

InsertLineBreaks InsertLineBreaks InsertLineBreaks InsertLineBreaks 1

Inserta saltos de línea después de cada 76 caracteres en la representación de cadena.Inserts line breaks after every 76 characters in the string representation.

None None None None 0

No inserta saltos de línea después de cada 76 caracteres en la representación de cadena.Does not insert line breaks after every 76 characters in the string representation.

Ejemplos

El ejemplo siguiente se llama el Convert.ToBase64String(Byte[], Base64FormattingOptions) con un InsertLineBreaks argumento para Insertar línea se interrumpe en la cadena que se genera al codificar una matriz de bytes de 100 elementos.The following example calls the Convert.ToBase64String(Byte[], Base64FormattingOptions) with a InsertLineBreaks argument to insert line breaks in the string that is produced by encoding a 100-element byte array.

using System;

public class Example
{
   public static void Main()
   {
       // Define a byte array.
       Byte[] 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 sring.
       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
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 sring.
       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 la salida muestra el ejemplo, el Convert.FromBase64String se realiza correctamente en la restauración de la matriz de bytes original; se omiten los caracteres de salto de línea durante la conversión.As the output from the example shows, the Convert.FromBase64String succeeds in restoring the original byte array; the line break characters are ignored during the conversion.

Comentarios

El Convert.ToBase64CharArray y Convert.ToBase64String métodos convierten el valor de una matriz de enteros de 8 bits sin signo en una representación de cadena equivalente que consta de dígitos en base 64.The Convert.ToBase64CharArray and Convert.ToBase64String methods convert the value of an array of 8-bit unsigned integers to an equivalent string representation that consists of base 64 digits. La representación de cadena puede contener uno o varios saltos de línea, donde un salto de línea se define como un carro devuelven el carácter (U+000D) seguido por un carácter (000A) de avance de línea.The string representation can contain one or more line breaks, where a line break is defined as a carriage return character (U+000D) followed by a line feed character (U+000A). Dado que los saltos de línea se consideran caracteres de espacio en blanco en una codificación en base 64, se pasan por alto cuando la conversión de base 64 de cadena a una matriz de bytes codificada.Because line breaks are considered white-space characters in a base-64 encoding, they are ignored when converting a base-64 encoded string back to a byte array. Los saltos de línea resultan prácticos simplemente al mostrar la cadena codificada a un control o un dispositivo como una ventana de consola.The line breaks are simply convenient when displaying the encoded string to a control or a device such as a console window.

Ningún y InsertLineBreaks valores son mutuamente excluyentes.The None and InsertLineBreaks values are mutually exclusive. Por lo tanto, aunque el Base64FormattingOptions.None enumeración está marcada con el FlagsAttribute atributo, no tiene sentido realizar una combinación bit a bit de estos dos valores.Therefore, although the Base64FormattingOptions.None enumeration is marked with the FlagsAttribute attribute, it makes no sense to perform a bitwise combination of these two values.

Se aplica a