Base64FormattingOptions Énumération

Définition

Spécifie si les méthodes ToBase64CharArray et ToBase64String pertinentes insèrent des sauts de ligne dans leur résultat.Specifies whether relevant ToBase64CharArray and ToBase64String methods insert line breaks in their output.

Cette énumération a un attribut FlagsAttribute qui permet une combinaison au niveau du bit de ses valeurs membres.

public enum class Base64FormattingOptions
[System.Flags]
public enum Base64FormattingOptions
[<System.Flags>]
type Base64FormattingOptions = 
Public Enum Base64FormattingOptions
Héritage
Base64FormattingOptions
Attributs

Champs

InsertLineBreaks 1

Insère des sauts de ligne tous les 76 caractères dans la représentation sous forme de chaîne.Inserts line breaks after every 76 characters in the string representation.

None 0

N’insère pas de sauts de ligne tous les 76 caractères dans la représentation sous forme de chaîne.Does not insert line breaks after every 76 characters in the string representation.

Exemples

L’exemple suivant appelle la Convert.ToBase64String(Byte[], Base64FormattingOptions) méthode avec un InsertLineBreaks argument pour insérer des sauts de ligne dans la chaîne produite par l’encodage d’un tableau d’octets de 100 éléments :The following example calls the Convert.ToBase64String(Byte[], Base64FormattingOptions) method 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

Comme le montre la sortie de l’exemple, le Convert.FromBase64String parvient à restaurer le tableau d’octets d’origine ; les caractères de saut de ligne sont ignorés pendant la conversion.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.

Remarques

Les Convert.ToBase64CharArray Convert.ToBase64String méthodes et convertissent la valeur d’un tableau d’entiers non signés 8 bits en une représentation sous forme de chaîne équivalente qui se compose de chiffres de 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 représentation sous forme de chaîne peut contenir un ou plusieurs sauts de ligne, où un saut de ligne est défini comme un caractère de retour chariot (U + 000D) suivi d’un caractère de saut de ligne (U + 000A).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). Étant donné que les sauts de ligne sont considérés comme des caractères d’espace blanc dans un encodage de base 64, ils sont ignorés lors de la conversion d’une chaîne encodée en base 64 en tableau d’octets.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. Les sauts de ligne sont simplement pratiques lors de l’affichage de la chaîne encodée dans un contrôle ou un appareil tel qu’une fenêtre de console.The line breaks are simply convenient when displaying the encoded string to a control or a device such as a console window.

Les None valeurs et s’excluent InsertLineBreaks mutuellement.The None and InsertLineBreaks values are mutually exclusive. Par conséquent, bien que l' Base64FormattingOptions énumération soit marquée avec l' FlagsAttribute attribut, il n’est pas judicieux d’effectuer une combinaison d’opérations de bits de ces deux valeurs.Therefore, although the Base64FormattingOptions enumeration is marked with the FlagsAttribute attribute, it makes no sense to perform a bitwise combination of these two values.

S’applique à