Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Enum

Definizione

Specifica se i metodi rilevanti ToBase64CharArray e ToBase64String inseriscono un'interruzione di riga nell'output.Specifies whether relevant ToBase64CharArray and ToBase64String methods insert line breaks in their output.

Questa enumerazione ha un attributo FlagsAttribute che consente una combinazione bit per bit dei valori del relativo membro.

public enum class Base64FormattingOptions
[System.Flags]
public enum Base64FormattingOptions
type Base64FormattingOptions = 
Public Enum Base64FormattingOptions
Ereditarietà
Base64FormattingOptionsBase64FormattingOptionsBase64FormattingOptionsBase64FormattingOptions
Attributi

Campi

InsertLineBreaks InsertLineBreaks InsertLineBreaks InsertLineBreaks 1

Inserisce interruzioni di riga ogni 76 caratteri nella rappresentazione di stringa.Inserts line breaks after every 76 characters in the string representation.

None None None None 0

Non inserisce interruzioni di riga ogni 76 caratteri nella rappresentazione di stringa.Does not insert line breaks after every 76 characters in the string representation.

Esempi

L'esempio seguente chiama il Convert.ToBase64String(Byte[], Base64FormattingOptions) con un InsertLineBreaks interruzioni di argomento per inserire una riga nella stringa di prodotti dalla codifica una matrice di byte di 100-elemento.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.
       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
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

Come illustrato nell'esempio, l'output di Convert.FromBase64String ha esito positivo per il ripristino della matrice di byte originale; i caratteri di interruzione di riga vengono ignorati durante la conversione.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.

Commenti

Il Convert.ToBase64CharArray e Convert.ToBase64String metodi convertono il valore di una matrice di interi senza segno a 8 bit in una rappresentazione di stringa equivalente che è costituito da cifre 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 rappresentazione di stringa può contenere uno o più interruzioni di riga, in cui un'interruzione di riga è definita come un ritorno a capo restituiscano il carattere (U+000D) seguito da un carattere (U + 000A) di avanzamento riga.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). Poiché le interruzioni di riga sono considerate caratteri di spazio in base 64 di codifica, vengono ignorati quando la conversione di una base 64 in una stringa in una matrice di byte codificata.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. Le interruzioni di riga sono semplicemente utile quando si visualizza la stringa codificata a un controllo o un dispositivo, ad esempio una finestra della console.The line breaks are simply convenient when displaying the encoded string to a control or a device such as a console window.

None e InsertLineBreaks valori si escludono a vicenda.The None and InsertLineBreaks values are mutually exclusive. Pertanto, sebbene l'enumerazione Base64FormattingOptions.None sia contrassegnata con l'attributo FlagsAttribute, non ha senso eseguire una combinazione bit per bit di questi due valori.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.

Si applica a