Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Enum

Definition

Gibt an, ob die relevante ToBase64CharArray-Methode und die relevante ToBase64String-Methode Zeilenumbrüche in die Ausgabe einfügen.Specifies whether relevant ToBase64CharArray and ToBase64String methods insert line breaks in their output.

Diese Enumeration weist ein FlagsAttribute-Attribut auf, die eine bitweise Kombination der Memberwerte zulässt.

public enum class Base64FormattingOptions
[System.Flags]
public enum Base64FormattingOptions
type Base64FormattingOptions = 
Public Enum Base64FormattingOptions
Vererbung
Base64FormattingOptionsBase64FormattingOptionsBase64FormattingOptionsBase64FormattingOptions
Attribute

Felder

InsertLineBreaks InsertLineBreaks InsertLineBreaks InsertLineBreaks 1

Fügt in der Zeichenfolgendarstellung nach je 76 Zeichen einen Zeilenumbruch ein.Inserts line breaks after every 76 characters in the string representation.

None None None None 0

Fügt in der Zeichenfolgendarstellung nach je 76 Zeichen keinen Zeilenumbruch ein.Does not insert line breaks after every 76 characters in the string representation.

Beispiele

Im folgenden Beispiel wird die Convert.ToBase64String(Byte[], Base64FormattingOptions) mit einem InsertLineBreaks Argument zum Einfügen der Zeile unterbrochen, in der Zeichenfolge, die erstellt werden, indem Sie die Codierung einer 100 Elementen bestehendes Bytearray.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

Wie die Ausgabe des Beispiels zeigt die Convert.FromBase64String erfolgreich ausgeführt wird, bei der Wiederherstellung des ursprüngliche Byte-Arrays, die Zeilenumbruchzeichen werden während der Konvertierung ignoriert.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.

Hinweise

Die Convert.ToBase64CharArray und Convert.ToBase64String Methoden konvertieren Sie den Wert eines Arrays von 8-Bit-Ganzzahlen ohne Vorzeichen in eine entsprechende Zeichenfolgendarstellung, die aus base-64-Ziffern besteht.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. Die Zeichenfolgendarstellung einer darf, oder weitere Zeilenumbrüche, wobei ein Zeilenumbruch als ein Wagenrücklaufzeichen definiert wird zurückgeben, Zeichen (U + 000D) gefolgt von einem Zeilenvorschubzeichen (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). Da Zeilenumbrüche Leerzeichen in eine Base64-Codierung betrachtet werden, werden sie ignoriert beim Konvertieren der Base-64-Zeichenfolge in ein Bytearray zurück codierten.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. Die Zeilenumbrüche sind einfach praktisch, wenn die codierte Zeichenfolge in ein Steuerelement oder ein Gerät wie z. B. ein Konsolenfenster angezeigt.The line breaks are simply convenient when displaying the encoded string to a control or a device such as a console window.

Die None und InsertLineBreaks Werte schließen sich gegenseitig.The None and InsertLineBreaks values are mutually exclusive. Aus diesem Grund zwar die Base64FormattingOptions.None Enumeration wird gekennzeichnet, mit der FlagsAttribute -Attribut, es nicht sinnvoll, eine bitweise Kombination von diesen beiden Werten führen.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.

Gilt für: