Base64FormattingOptions Wyliczenie

Definicja

Określa, czy odpowiednie ToBase64CharArray i metody ToBase64String wstawiają podziały wierszy w danych wyjściowych.Specifies whether relevant ToBase64CharArray and ToBase64String methods insert line breaks in their output.

To wyliczenie ma atrybut FlagsAttribute zezwalający na bitową kombinację jego wartości składowych.

public enum class Base64FormattingOptions
[System.Flags]
public enum Base64FormattingOptions
type Base64FormattingOptions = 
Public Enum Base64FormattingOptions
Dziedziczenie
Base64FormattingOptions
Atrybuty

Pola

InsertLineBreaks 1

Wstawia podziały wierszy po każdym 76 znaków w reprezentacji w postaci ciągu.Inserts line breaks after every 76 characters in the string representation.

None 0

Nie wstawia podziałów wierszy po każdym 76 znaków w reprezentacji ciągu.Does not insert line breaks after every 76 characters in the string representation.

Przykłady

Poniższy przykład wywołuje metodę Convert.ToBase64String(Byte[], Base64FormattingOptions) z argumentem InsertLineBreaks, aby wstawić podziały wierszy w ciągu, który jest generowany przez kodowanie 100-elementowej tablicy bajtowej: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

Dane wyjściowe z przykładu pokazują, że Convert.FromBase64String pomyślnie przywraca oryginalną tablicę bajtów; znaki podziału wiersza są ignorowane podczas konwersji.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.

Uwagi

Metody Convert.ToBase64CharArray i Convert.ToBase64String konwertują wartość tablicy 8-bitowych liczb całkowitych bez znaku na równoważną reprezentację ciągu, która składa się z podstawowej 64 cyfr.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. Reprezentacja ciągu może zawierać jeden lub więcej podziałów wierszy, gdzie podział wiersza jest zdefiniowany jako znak powrotu karetki (U + 000D), po którym następuje znak wysuwu wiersza (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). Ponieważ podziały wierszy są uznawane za znaki odstępu w kodowaniu Base-64, są one ignorowane podczas konwertowania zakodowanego ciągu Base-64 z powrotem do tablicy bajtów.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. Podziały wierszy są po prostu wygodne podczas wyświetlania zakodowanego ciągu do kontrolki lub urządzenia, takiego jak okno konsoli.The line breaks are simply convenient when displaying the encoded string to a control or a device such as a console window.

Wartości None i InsertLineBreaks wzajemnie się wykluczają.The None and InsertLineBreaks values are mutually exclusive. W związku z tym, mimo że Wyliczenie Base64FormattingOptions jest oznaczone atrybutem FlagsAttribute, nie ma sensu, aby wykonać bitową kombinację tych dwóch wartości.Therefore, although the Base64FormattingOptions enumeration is marked with the FlagsAttribute attribute, it makes no sense to perform a bitwise combination of these two values.

Dotyczy