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.

例外

inArray または outArraynull です。inArray or outArray is null.

offsetInoffsetOut、または length が負の値です。offsetIn, offsetOut, or length is negative.

または-or- offsetInlength を加算した値が、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を UUencode メソッド (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位置からoffsetOutします。The 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. 戻り値が変換された要素の数を示すoutArrayします。The return value indicates the number of converted elements in outArray. サブセットoutArrayの base 64 桁で構成されます。The subset of outArray consists of base-64 digits.

0 から昇順に base 64 桁"Z"、文字の小文字を大文字の"A"である数字の「0」~「9」、"z"を"a"と記号「+」と「/」。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パラメーターは配列の 0 から始まる位置。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.

例外

inArray または outArraynull です。inArray or outArray is null.

offsetInoffsetOut、または length が負の値です。offsetIn, offsetOut, or length is negative.

または-or- offsetInlength を加算した値が、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.

options は有効な Base64FormattingOptions 値ではありません。options is not a valid Base64FormattingOptions value.

次の例で、ToBase64CharArrayメソッド。The following example demonstrates the ToBase64CharArray method. 入力は、3 バイト (24 ビット) ごとのグループに分けられます。The input is divided into groups of three bytes (24 bits) each. その結果、各グループは、各数 10 進数 0 ~ 63 の範囲で 6 ビット数値の 4 つで構成されます。Consequently, each group consists of four 6-bit numbers where each number ranges from decimal 0 to 63. この例では、残りの 1 バイトで 85 の 3 バイト グループがあります。In this example, there are 85 3-byte groups with one byte remaining. 最初のグループは、00、01、02 10 進数 0、0、4、および 2 と等しい 6 ビット値が 4 つの 16 進値で構成されます。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. これら 4 つの値は、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 の 16 進数が。In this example, the value of the last byte is hexadecimal FF. 最初の 6 ビットが出力の末尾で base 64 桁「/」に対応して、10 進数の 63 等しいと、次の 2 ビットには、base 64 桁では、"w"に対応する 10 進数の 48 を生成する 0 が埋め込まれます。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". 最後の 2 つの 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パラメーターの位置からoffsetOutします。The 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. 戻り値が変換された要素の数を示すoutArrayします。The return value indicates the number of converted elements in outArray. サブセットoutArrayの base 64 桁で構成されます。The subset of outArray consists of base-64 digits.

0 から昇順に base 64 桁"Z"、文字の小文字を大文字の"A"である数字の「0」~「9」、"z"を"a"と記号「+」と「/」。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パラメーターは配列の 0 から始まる位置。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+000 a) として定義されます。A line break is defined as a carriage return character (U+000D) followed by a line feed character (U+000A). 詳細についてを参照してください、RFC 2045"Multipurpose Internet Mail Extensions"、 https://www.rfc-editor.org/します。For more information, see RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

こちらもご覧ください

適用対象