Convert.ToBase64CharArray Convert.ToBase64CharArray Convert.ToBase64CharArray Convert.ToBase64CharArray Method

定义

将 8 位无符号整数数组的子集转换为用 Base64 数字编码的 Unicode 字符数组的等价子集。Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits.

重载

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)

将 8 位无符号整数数组的子集转换为用 Base64 数字编码的 Unicode 字符数组的等价子集。Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. 参数将子集指定为输入和输出数组中的偏移量和输入数组中要转换的元素数。Parameters specify the subsets as offsets in the input and output arrays, and the number of elements in the input array to convert.

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)

将 8 位无符号整数数组的子集转换为用 Base64 数字编码的 Unicode 字符数组的等价子集。Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. 参数指定作为输入和输出数组中偏移量的子集、输入数组中要转换的元素数以及是否在输出数组中插入分行符。Parameters specify the subsets as offsets in the input and output arrays, the number of elements in the input array to convert, and whether line breaks are inserted in the output array.

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)

将 8 位无符号整数数组的子集转换为用 Base64 数字编码的 Unicode 字符数组的等价子集。Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. 参数将子集指定为输入和输出数组中的偏移量和输入数组中要转换的元素数。Parameters specify the subsets as offsets in the input and output arrays, and the number of elements in the input array to convert.

public:
 static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut);
public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut);
static member ToBase64CharArray : byte[] * int * int * char[] * int -> int
Public Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer) As Integer

参数

inArray
Byte[]

8 位无符号整数的输入数组。An input array of 8-bit unsigned integers.

offsetIn
Int32 Int32 Int32 Int32

inArray 中的位置。A position within inArray.

length
Int32 Int32 Int32 Int32

要转换的 inArray 的元素数。The number of elements of inArray to convert.

outArray
Char[]

Unicode 字符的输出数组。An output array of Unicode characters.

offsetOut
Int32 Int32 Int32 Int32

outArray 中的位置。A position within outArray.

返回

包含 outArray 中的字节数的 32 位带符号整数。A 32-bit signed integer containing the number of bytes in outArray.

异常

inArrayoutArraynullinArray or outArray is null.

offsetInoffsetOutlength 为负数。offsetIn, offsetOut, or length is negative.

- 或 --or- offsetIn 加上 length 大于 inArray 的长度。offsetIn plus length is greater than the length of inArray.

- 或 --or- offsetOut 加上要返回的元素数,大于 outArray 的长度。offsetOut plus the number of elements to return is greater than the length of outArray.

示例

下面的示例演示了如何使用ToBase64CharArrayUUencode 方法 (以 base 64 编码的) 二进制流,然后保存到文件的编码。The following example demonstrates using the ToBase64CharArray method to UUencode (encode in base 64) a binary stream, then save the encoding to a file.

public:
   void EncodeWithCharArray()
   {
      FileStream^ inFile;
      array<Byte>^binaryData;

      try
      {
         inFile = gcnew FileStream( inputFileName,
                                    FileMode::Open,
                                    FileAccess::Read );
         binaryData = gcnew array<Byte>((int)(inFile->Length));
         long bytesRead = inFile->Read( binaryData, 0,
                                        (int)inFile->Length );
         inFile->Close();
      }
      catch ( Exception^ exp ) 
      {
         // Error creating stream or reading from it.
         Console::WriteLine( "{0}", exp->Message );
         return;
      }
      
      // Convert the binary input into Base64 UUEncoded output.
      // Each 3 Byte sequence in the source data becomes a 4 Byte
      // sequence in the character array. 
      long arrayLength = (long)((4.0 / 3.0) * binaryData->Length);
      
      // If array length is not divisible by 4, go up to the next
      // multiple of 4.
      if ( arrayLength % 4 != 0 )
      {
         arrayLength += 4 - arrayLength % 4;
      }

      array<Char>^ base64CharArray = gcnew array<Char>(arrayLength);
      try
      {
         Convert::ToBase64CharArray( binaryData,
                                     0,
                                     binaryData->Length,
                                     base64CharArray, 0 );
      }
      catch ( ArgumentNullException^ ) 
      {
         Console::WriteLine( "Binary data array is null." );
         return;
      }
      catch ( ArgumentOutOfRangeException^ ) 
      {
         Console::WriteLine( "Char Array is not large enough." );
         return;
      }
      
      // Write the UUEncoded version to the output file.
      StreamWriter^ outFile;
      try
      {
         outFile = gcnew StreamWriter( outputFileName,
                                       false,
                                       Text::Encoding::ASCII );
         outFile->Write( base64CharArray );
         outFile->Close();
      }
      catch ( Exception^ exp ) 
      {
         // Error creating stream or writing to it.
         Console::WriteLine( " {0}", exp->Message );
      }
   }
public void EncodeWithCharArray() {
   System.IO.FileStream inFile;    
   byte[]             binaryData;

   try {
      inFile = new System.IO.FileStream(inputFileName,
                                 System.IO.FileMode.Open,
                                System.IO.FileAccess.Read);
      binaryData = new Byte[inFile.Length];
      long bytesRead = inFile.Read(binaryData, 0,
                           (int) inFile.Length);
      inFile.Close();
   }
   catch (System.Exception exp) {
      // Error creating stream or reading from it.
      System.Console.WriteLine("{0}", exp.Message);
      return;
   }

   // Convert the binary input into Base64 UUEncoded output.
   // Each 3 byte sequence in the source data becomes a 4 byte
   // sequence in the character array. 
   long arrayLength = (long) ((4.0d/3.0d) * binaryData.Length);
   
   // If array length is not divisible by 4, go up to the next
   // multiple of 4.
   if (arrayLength % 4 != 0) {
      arrayLength += 4 - arrayLength % 4;
   }
   
   char[] base64CharArray = new char[arrayLength];
   try {
      System.Convert.ToBase64CharArray(binaryData, 
                               0,
                               binaryData.Length,
                               base64CharArray,
                               0);
   }
   catch (System.ArgumentNullException) {
      System.Console.WriteLine("Binary data array is null.");
      return;
   }
   catch (System.ArgumentOutOfRangeException) {
      System.Console.WriteLine("Char Array is not large enough.");
      return;
   }

   // Write the UUEncoded version to the output file.
   System.IO.StreamWriter outFile; 
   try {
      outFile = new System.IO.StreamWriter(outputFileName,
                              false,
                              System.Text.Encoding.ASCII);          
      outFile.Write(base64CharArray);
      outFile.Close();
   }
   catch (System.Exception exp) {
      // Error creating stream or writing to it.
      System.Console.WriteLine("{0}", exp.Message);
   }
}
Public Sub EncodeWithCharArray()
   Dim inFile As System.IO.FileStream
   Dim binaryData() As Byte

   Try
      inFile = New System.IO.FileStream(inputFileName, _
                                        System.IO.FileMode.Open, _
                                        System.IO.FileAccess.Read)
      ReDim binaryData(inFile.Length)
      Dim bytesRead As Long = inFile.Read(binaryData, _
                                          0, _
                                          CInt(inFile.Length))
      inFile.Close()
   Catch exp As System.Exception
      ' Error creating stream or reading from it.
      System.Console.WriteLine("{0}", exp.Message)
      Return
   End Try

   ' Convert the binary input into Base64 UUEncoded output.
   ' Each 3 byte sequence in the source data becomes a 4 byte
   ' sequence in the character array. 
   Dim arrayLength As Long 
   arrayLength = (4 / 3) * binaryData.Length
   If arrayLength Mod 4 <> 0 Then
      arrayLength = arrayLength + 4 - arrayLength Mod 4
   End If

   Dim base64CharArray(arrayLength - 1) As Char
   Try
      System.Convert.ToBase64CharArray(binaryData, _
                                       0, _
                                       binaryData.Length, _
                                       base64CharArray, 0)
   Catch exp As System.ArgumentNullException
      System.Console.WriteLine("Binary data array is null.")
      Return
   Catch exp As System.ArgumentOutOfRangeException
      System.Console.WriteLine("Char Array is not large enough.")
      Return
   End Try

   ' Write the UUEncoded version to the output file.
   Dim outFile As System.IO.StreamWriter
   Try
      outFile = New System.IO.StreamWriter(outputFileName, _
                                           False, _
                                           System.Text.Encoding.ASCII)
      outFile.Write(base64CharArray)
      outFile.Close()
   Catch exp As System.Exception
      ' Error creating stream or writing to it.
      System.Console.WriteLine("{0}", exp.Message)
   End Try
End Sub

注解

子集length的元素inArray位置开始offsetIn,为数字值,并且转换中的元素子集outArray位置开始offsetOutThe subset of length elements of inArray starting at position offsetIn, are taken as a numeric value and converted to a subset of elements in outArray starting at position offsetOut. 返回值指示在转换后的元素数outArrayThe return value indicates the number of converted elements in outArray. 子集outArraybase-64 位数字组成。The subset of outArray consists of base-64 digits.

按升序从零开始的 base-64 位为大写字符"A"到"Z"、 小写字符"a"到"z"、 数字"0"到"9"和符号"+"和"/"。The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". 无值的字符、"="用于尾随填充。The valueless character, "=", is used for trailing padding.

offsetlength参数都是 32 位有符号的数字。The offset and length parameters are 32-bit signed numbers. offsetInoffsetOut参数是从零开始的数组位置。The offsetIn and offsetOut parameters are zero-based array positions.

重要

ToBase64CharArray方法旨在处理单个字节数组,其中包含要编码的所有数据。The ToBase64CharArray method is designed to process a single byte array that contains all the data to be encoded. 若要创建一个 base-64 字符数组,从字节流,请使用System.Security.Cryptography.ToBase64Transform类。To create a base-64 character array from a byte stream, use the System.Security.Cryptography.ToBase64Transform class.

另请参阅

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)

将 8 位无符号整数数组的子集转换为用 Base64 数字编码的 Unicode 字符数组的等价子集。Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. 参数指定作为输入和输出数组中偏移量的子集、输入数组中要转换的元素数以及是否在输出数组中插入分行符。Parameters specify the subsets as offsets in the input and output arrays, the number of elements in the input array to convert, and whether line breaks are inserted in the output array.

public:
 static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut, Base64FormattingOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options);
static member ToBase64CharArray : byte[] * int * int * char[] * int * Base64FormattingOptions -> int
Public Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer, options As Base64FormattingOptions) As Integer

参数

inArray
Byte[]

8 位无符号整数的输入数组。An input array of 8-bit unsigned integers.

offsetIn
Int32 Int32 Int32 Int32

inArray 中的位置。A position within inArray.

length
Int32 Int32 Int32 Int32

要转换的 inArray 的元素数。The number of elements of inArray to convert.

outArray
Char[]

Unicode 字符的输出数组。An output array of Unicode characters.

offsetOut
Int32 Int32 Int32 Int32

outArray 中的位置。A position within outArray.

options
Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions

如果每 76 个字符插入一个分行符,则使用 InsertLineBreaks,如果不插入分行符,则使用 NoneInsertLineBreaks to insert a line break every 76 characters, or None to not insert line breaks.

返回

包含 outArray 中的字节数的 32 位带符号整数。A 32-bit signed integer containing the number of bytes in outArray.

异常

inArrayoutArraynullinArray or outArray is null.

offsetInoffsetOutlength 为负数。offsetIn, offsetOut, or length is negative.

- 或 --or- offsetIn 加上 length 大于 inArray 的长度。offsetIn plus length is greater than the length of inArray.

- 或 --or- offsetOut 加上要返回的元素数,大于 outArray 的长度。offsetOut plus the number of elements to return is greater than the length of outArray.

示例

下面的示例演示ToBase64CharArray方法。The following example demonstrates the ToBase64CharArray method. 输入分为三个字节数 (24 bits) 的组。The input is divided into groups of three bytes (24 bits) each. 因此,每个组包含四个 6 位数字,其中每个数字的范围从十进制 0 到 63 个。Consequently, each group consists of four 6-bit numbers where each number ranges from decimal 0 to 63. 在此示例中,有一个字节显示剩余的 85 3 字节组。In this example, there are 85 3-byte groups with one byte remaining. 第一个组包含的十六进制值 00、 01 和 02,生成四个 6 位值等于十进制 0、 0、 4 和 2。The first group consists of the hexadecimal values 00, 01, and 02, which yield four 6-bit values equal to decimal 0, 0, 4, and 2. 这四个值对应于 base 64 数字"A"、"A"、"E"和"C"开头的输出。Those four values correspond to the base-64 digits "A", "A", "E", and "C" at the beginning of the output.

如果整 3 字节组数不存在,实际上会用零以形成一个完整的组填充剩余的字节数。If an integral number of 3-byte groups does not exist, the remaining bytes are effectively padded with zeros to form a complete group. 在此示例中,最后一个字节的值为十六进制的 FF。In this example, the value of the last byte is hexadecimal FF. 第一个 6 位均为十进制的 63,对应的输出的末尾处为 base-64 位"/",并下一步的 2 位填充了零以生成对应于"w"base-64 位的十进制 48。The first 6 bits are equal to decimal 63, which corresponds to the base-64 digit "/" at the end of the output, and the next 2 bits are padded with zeros to yield decimal 48, which corresponds to the base-64 digit, "w". 最后两个 6 位值为空白,并对应于无值填充字符"="。The last two 6-bit values are padding and correspond to the valueless padding character, "=".

// This example demonstrates the Convert.ToBase64CharArray() and
//                               Convert.FromBase64CharArray methods
using namespace System;
bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 );
int main()
{
   array<Byte>^byteArray1 = gcnew array<Byte>(256);
   array<Byte>^byteArray2 = gcnew array<Byte>(256);
   array<Char>^charArray = gcnew array<Char>(352);
   int charArrayLength;
   String^ nl = Environment::NewLine;
   String^ ruler1a = "         1         2         3         4";
   String^ ruler2a = "1234567890123456789012345678901234567890";
   String^ ruler3a = "----+----+----+----+----+----+----+----+";
   String^ ruler1b = "         5         6         7      ";
   String^ ruler2b = "123456789012345678901234567890123456";
   String^ ruler3b = "----+----+----+----+----+----+----+-";
   String^ ruler = String::Concat( ruler1a, ruler1b, nl, ruler2a, ruler2b, nl, ruler3a, ruler3b );
   
   // 1) Initialize and display a Byte array of arbitrary data.
   Console::WriteLine( "1) Input: A Byte array of arbitrary data.{0}", nl );
   for ( int x = 0; x < byteArray1->Length; x++ )
   {
      byteArray1[ x ] = (Byte)x;
      Console::Write( "{0:X2} ", byteArray1[ x ] );
      if ( ((x + 1) % 20) == 0 )
            Console::WriteLine();

   }
   Console::Write( "{0}{0}", nl );
   
   // 2) Convert the input Byte array to a Char array, with newlines inserted.
   charArrayLength = Convert::ToBase64CharArray( byteArray1, 0, byteArray1->Length, 
                                                 charArray, 0, 
                                                 Base64FormattingOptions::InsertLineBreaks );
   Console::WriteLine( "2) Convert the input Byte array to a Char array with newlines." );
   Console::Write( "   Output: A Char array (length = {0}). ", charArrayLength );
   Console::WriteLine( "The elements of the array are:{0}", nl );
   Console::WriteLine( ruler );
   Console::WriteLine( gcnew String( charArray ) );
   Console::WriteLine();
   
   // 3) Convert the Char array back to a Byte array.
   Console::WriteLine( "3) Convert the Char array to an output Byte array." );
   byteArray2 = Convert::FromBase64CharArray( charArray, 0, charArrayLength );
   
   // 4) Are the input and output Byte arrays equivalent?
   Console::WriteLine( "4) The output Byte array is equal to the input Byte array: {0}", ArraysAreEqual( byteArray1, byteArray2 ) );
}

bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 )
{
   if ( a1->Length != a2->Length )
      return false;

   for ( int i = 0; i < a1->Length; i++ )
      if ( a1[ i ] != a2[ i ] )
            return false;

   return true;
}

/*
This example produces the following results:

1) Input: A Byte array of arbitrary data.

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

2) Convert the input Byte array to a Char array with newlines.
   Output: A Char array (length = 352). The elements of the array are:

         1         2         3         4         5         6         7
1234567890123456789012345678901234567890123456789012345678901234567890123456
----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==

3) Convert the Char array to an output Byte array.
4) The output Byte array is equal to the input Byte array: True

*/
// This example demonstrates the Convert.ToBase64CharArray() and
//                               Convert.FromBase64CharArray methods

using System;

class Sample 
{
    public static void Main() 
    {
    byte[] byteArray1 = new byte[256];
    byte[] byteArray2 = new byte[256];
    char[] charArray  = new char[352];
    int charArrayLength;
    string nl = Environment.NewLine;

    string ruler1a = "         1         2         3         4";
    string ruler2a = "1234567890123456789012345678901234567890";
    string ruler3a = "----+----+----+----+----+----+----+----+";
    string ruler1b = "         5         6         7      ";
    string ruler2b = "123456789012345678901234567890123456";
    string ruler3b = "----+----+----+----+----+----+----+-";
    string ruler   = String.Concat(ruler1a, ruler1b, nl, 
                                   ruler2a, ruler2b, nl,
                                   ruler3a, ruler3b);

// 1) Initialize and display a Byte array of arbitrary data.
    Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl);
    for (int x = 0; x < byteArray1.Length; x++)
    {
    byteArray1[x] = (byte)x;
    Console.Write("{0:X2} ", byteArray1[x]);
    if (((x+1)%20) == 0) Console.WriteLine();
    }
    Console.Write("{0}{0}", nl);

// 2) Convert the input Byte array to a Char array, with newlines inserted.
    charArrayLength = 
        Convert.ToBase64CharArray(byteArray1, 0, byteArray1.Length, 
                                   charArray, 0, Base64FormattingOptions.InsertLineBreaks);
    Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.");
    Console.Write("   Output: A Char array (length = {0}). ", charArrayLength);
    Console.WriteLine("The elements of the array are:{0}", nl);
    Console.WriteLine(ruler);
    Console.WriteLine(new String(charArray));
    Console.WriteLine();

// 3) Convert the Char array back to a Byte array.
    Console.WriteLine("3) Convert the Char array to an output Byte array.");
    byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength);

// 4) Are the input and output Byte arrays equivalent?
    Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}", 
                      ArraysAreEqual(byteArray1, byteArray2));
    }

    public static bool ArraysAreEqual(byte[] a1, byte[] a2)
    {
    if (a1.Length != a2.Length) return false;
    for (int i = 0; i < a1.Length; i++)
        if (a1[i] != a2[i]) return false;
    return true;
    }
}
/*
This example produces the following results:

1) Input: A Byte array of arbitrary data.

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

2) Convert the input Byte array to a Char array with newlines.
   Output: A Char array (length = 352). The elements of the array are:

         1         2         3         4         5         6         7
1234567890123456789012345678901234567890123456789012345678901234567890123456
----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==

3) Convert the Char array to an output Byte array.
4) The output Byte array is equal to the input Byte array: True

*/
' This example demonstrates the Convert.ToBase64CharArray() and 
'                               Convert.FromBase64CharArray methods
Class Sample
   Public Shared Sub Main()
      Dim byteArray1(255) As Byte
      Dim byteArray2(255) As Byte
      Dim charArray(351) As Char
      Dim charArrayLength As Integer
      Dim nl As String = Environment.NewLine
      
      Dim ruler1a As String = "         1         2         3         4"
      Dim ruler2a As String = "1234567890123456789012345678901234567890"
      Dim ruler3a As String = "----+----+----+----+----+----+----+----+"
      Dim ruler1b As String = "         5         6         7      "
      Dim ruler2b As String = "123456789012345678901234567890123456"
      Dim ruler3b As String = "----+----+----+----+----+----+----+-"
      Dim ruler As String = String.Concat(ruler1a, ruler1b, nl, _
                                          ruler2a, ruler2b, nl, _
                                          ruler3a, ruler3b)

      ' 1) Initialize and display a Byte array of arbitrary data.
      Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl)
      Dim x As Integer
      For x = 0 To byteArray1.Length - 1
         byteArray1(x) = CByte(x)
         Console.Write("{0:X2} ", byteArray1(x))
         If(x + 1) Mod 20 = 0 Then
            Console.WriteLine()
         End If
      Next x
      Console.Write("{0}{0}", nl)
      
      ' 2) Convert the input Byte array to a Char array, with newlines inserted.
      charArrayLength = Convert.ToBase64CharArray( _
                                byteArray1, 0, byteArray1.Length, _
                                charArray, 0, _
                                Base64FormattingOptions.InsertLineBreaks)
      Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.")
      Console.Write("   Output: A Char array (length = {0}). ", charArrayLength)
      Console.WriteLine("The elements of the array are:{0}", nl)
      Console.WriteLine(ruler)
      Console.WriteLine(New [String](charArray))
      Console.WriteLine()
      
      ' 3) Convert the Char array back to a Byte array.
      Console.WriteLine("3) Convert the Char array to an output Byte array.")
      byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength)
      
      ' 4) Are the input and output Byte arrays equivalent?
      Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}", _
                            ArraysAreEqual(byteArray1, byteArray2))
   End Sub 'Main
   
   Public Shared Function ArraysAreEqual(a1() As Byte, a2() As Byte) As Boolean
      If a1.Length <> a2.Length Then
         Return False
      End If
      Dim i As Integer
      For i = 0 To a1.Length - 1
         If a1(i) <> a2(i) Then
            Return False
         End If
      Next i
      Return True
   End Function 'ArraysAreEqual
End Class 'Sample
'
'This example produces the following results:
'
'1) Input: A Byte array of arbitrary data.
'
'00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
'14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
'28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
'3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
'50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
'64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
'78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
'8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
'A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
'B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
'C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
'DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
'F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF
'
'2) Convert the input Byte array to a Char array with newlines.
'   Output: A Char array (length = 352). The elements of the array are:
'
'         1         2         3         4         5         6         7
'1234567890123456789012345678901234567890123456789012345678901234567890123456
'----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
'OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
'cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
'q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
'5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==
'
'3) Convert the Char array to an output Byte array.
'4) The output Byte array is equal to the input Byte array: True

注解

子集length的元素inArray起始位置的参数offsetIn,为数字值,并且转换中的元素子集outArray起始位置参数offsetOutThe subset of length elements of the inArray parameter starting at position offsetIn, are taken as a numeric value and converted to a subset of elements in the outArray parameter starting at position offsetOut. 返回值指示在转换后的元素数outArrayThe return value indicates the number of converted elements in outArray. 子集outArraybase-64 位数字组成。The subset of outArray consists of base-64 digits.

按升序从零开始的 base-64 位为大写字符"A"到"Z"、 小写字符"a"到"z"、 数字"0"到"9"和符号"+"和"/"。The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". 无值的字符"="用于尾随填充。The valueless character "=" is used for trailing padding.

offsetlength参数都是 32 位有符号的数字。The offset and length parameters are 32-bit signed numbers. offsetInoffsetOut参数是从零开始的数组位置。The offsetIn and offsetOut parameters are zero-based array positions.

重要

ToBase64CharArray方法旨在处理单个字节数组,其中包含要编码的所有数据。The ToBase64CharArray method is designed to process a single byte array that contains all the data to be encoded. 若要创建一个 base-64 字符数组,从字节流,请使用System.Security.Cryptography.ToBase64Transform类。To create a base-64 character array from a byte stream, use the System.Security.Cryptography.ToBase64Transform class.

如果options参数设置为InsertLineBreaks和转换的输出的长度超过 76 个字符,插入一个分行符每隔 76 个字符。If the options parameter is set to InsertLineBreaks and the output of the conversion is longer than 76 characters, a line break is inserted every 76 characters. 作为一个回车符 (U+000D) 在行后跟源字符 (U + 000A) 定义一个分行符。A line break is defined as a carriage return character (U+000D) followed by a line feed character (U+000A). 详细信息,请参阅 RFC 2045,"多用途 Internet 邮件扩展",网址 https://www.rfc-editor.org/ For more information, see RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

另请参阅

适用于