Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Enum

Definice

Určuje, zda ToBase64CharArray se ToBase64String jedná o relevantní a metody vložení konců řádků ve výstupu.Specifies whether relevant ToBase64CharArray and ToBase64String methods insert line breaks in their output.

Tento výčet má atribut FlagsAttribute, který umožňuje bitové kombinace hodnot členů.

public enum class Base64FormattingOptions
[System.Flags]
public enum Base64FormattingOptions
type Base64FormattingOptions = 
Public Enum Base64FormattingOptions
Dědičnost
Base64FormattingOptionsBase64FormattingOptionsBase64FormattingOptionsBase64FormattingOptions
Atributy

Pole

InsertLineBreaks InsertLineBreaks InsertLineBreaks InsertLineBreaks 1

Vloží zalomení řádků za každých 76 znaků v řetězcové reprezentaci.Inserts line breaks after every 76 characters in the string representation.

None None None None 0

Nevloží zalomení řádků za každých 76 znaků v řetězcové reprezentaci.Does not insert line breaks after every 76 characters in the string representation.

Příklady

V následujícím příkladu je volána Convert.ToBase64String(Byte[], Base64FormattingOptions) argument with InsertLineBreaks pro vložení konců řádků v řetězci, který je vytvořen pomocí kódování bajtového pole 100-elementu.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

Jak výstup z příkladu ukazuje, Convert.FromBase64String úspěšné obnovení původního bajtového pole; znaky zalomení řádku se během převodu ignorují.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.

Poznámky

Metody Convert.ToBase64CharArray aConvert.ToBase64String převádějí hodnotu pole 8bitové celé číslo bez znaménka na ekvivalentní řetězcové vyjádření, které se skládá ze základních 64 číslic.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. Řetězcové vyjádření může obsahovat jeden nebo více konců řádků, přičemž zalomení řádku je definováno jako návratový znak (U + 000D) následovaný znakem kanálu čáry (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). Vzhledem k tomu, že se konce řádků považují za prázdné místo v kódování Base-64, jsou ignorovány při převodu řetězce kódovaného pomocí základního 64 zpět na pole bajtů.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. Konce řádků jsou jednoduše praktické při zobrazení kódovaného řetězce v ovládacím prvku nebo zařízení, jako je okno konzoly.The line breaks are simply convenient when displaying the encoded string to a control or a device such as a console window.

Hodnoty None a InsertLineBreaks se vzájemně vylučují.The None and InsertLineBreaks values are mutually exclusive. Proto i když Base64FormattingOptions.None je výčet označen FlagsAttribute atributem, neposkytuje žádné smysly k provedení bitové kombinace těchto dvou hodnot.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.

Platí pro