Convert.ToBase64CharArrayとは？ わかりやすく解説

.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引 ランキング
日本マイクロソフト株式会社日本マイクロソフト株式会社

Convert.ToBase64CharArray メソッド (Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)

メモ : このメソッドは、.NET Framework version 2.0 で新しく追加されたものです。

8 ビット符号なし整数配列のサブセットを、Base64 の数字でエンコードされた Unicode 文字配列の等価のサブセットに変換します。各パラメータは、入力配列と出力配列のオフセットとしてのサブセット、変換する入力配列の要素の数、および出力配列で改行を挿入するかどうかを指定します。

名前空間: System
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

Visual Basic (宣言)
<ComVisibleAttribute(False)> _
Public Shared Function ToBase64CharArray
 ( _
    inArray As Byte(), _
    offsetIn As Integer, _
    length As Integer, _
    outArray As Char(), _
    offsetOut As Integer, _
    options As Base64FormattingOptions _
) As Integer
Visual Basic (使用法)
Dim inArray As Byte()
Dim offsetIn As Integer
Dim length As Integer
Dim outArray As Char()
Dim offsetOut As Integer
Dim options As Base64FormattingOptions
Dim returnValue As Integer

returnValue = Convert.ToBase64CharArray(inArray, offsetIn, length, outArray, offsetOut,
 options)
C#
[ComVisibleAttribute(false)] 
public static int ToBase64CharArray
 (
    byte[] inArray,
    int offsetIn,
    int length,
    char[] outArray,
    int offsetOut,
    Base64FormattingOptions options
)
C++
[ComVisibleAttribute(false)] 
public:
static int ToBase64CharArray (
    array<unsigned char>^ inArray, 
    int offsetIn, 
    int length, 
    array<wchar_t>^ outArray, 
    int offsetOut, 
    Base64FormattingOptions options
)
J#
/** @attribute ComVisibleAttribute(false) */ 
public static int ToBase64CharArray
 (
    byte[] inArray, 
    int offsetIn, 
    int length, 
    char[] outArray, 
    int offsetOut, 
    Base64FormattingOptions options
)
JScript
ComVisibleAttribute(false) 
public static function ToBase64CharArray
 (
    inArray : byte[], 
    offsetIn : int, 
    length : int, 
    outArray : char[], 
    offsetOut : int, 
    options : Base64FormattingOptions
) : int

パラメータ

inArray

8 ビット符号なし整数で構成される入力配列。

offsetIn

inArray 内での位置。

length

変換する inArray の要素の数。

outArray

Unicode 文字の出力配列。

offsetOut

outArray 内での位置。

options

76 文字ごとに改行を挿入する場合は InsertLineBreaks。改行を挿入しない場合は None。

戻り値
outArray のバイト数が格納された 32 ビット符号付き整数。

例外例外
例外の種類条件

ArgumentNullException

inArray または outArray が null 参照 (Visual Basic では Nothing) です。

ArgumentOutOfRangeException

offsetIn、offsetOut,、または length が負の値です。

または

offsetIn に length を加算した値が、inArray の長さを超えています。

または

offsetOut と、返される要素の数を合計した値が、outArray の長さを超えています。

ArgumentException

options が有効な Base64FormattingOptions 値ではありません。

解説解説

offsetIn の位置で開始する inArray パラメータの length 要素のサブセットは数値として解釈され、offsetOut の位置で開始する outArray パラメータの要素のサブセットに変換されます。戻り値は、outArray の変換後の要素数を示します。outArray のサブセットは Base 64 の数字で構成されます。

Base64 形式の文字を 0 から昇順で並べた場合、大文字の "A" ～ "Z"、小文字の "a" ～ "z"、数字の "0" ～ "9"、および "+" と "/" の記号の順になります。値として解釈されない文字 "=" は、文字列末尾の埋め込み用に使用されます。

offset パラメータと length パラメータは、32 ビット符号付き数値です。offsetIn パラメータと offsetOut パラメータは、インデックス番号が 0 から始まる配列位置です。

options パラメータに InsertLineBreaks が設定されており、変換の出力が 76 文字よりも長い場合、76 文字ごとに改行が挿入されます。改行は、復帰文字 (U+000D) とその後に続くライン フィード文字 (U+000A) として定義されます。詳細については、http://www.rfc-editor.org/ にある RFC 2045 (「Multipurpose Internet Mail Extensions」) を参照してください。

使用例使用例

ToBase64CharArray メソッドのコード例を次に示します。入力は、3 バイト (24 ビット) ごとのグループに分けられます。したがって、各グループは、10 進数の 0 ～ 63 の範囲の 4 つの 6 ビット数値で構成されます。この例では、85 個の 3 バイトのグループがあり、1 バイトが残されています。最初のグループは、16 進値 00、01、02 で構成されます。これらは、10 進数の 0、0、4、2 に相当する 4 つの 6 ビット値を生成します。この 4 つの値は、出力の最初にある Base64 形式の文字 "A"、"A"、"E"、"C" に対応します。

3 バイトのグループの整数が存在しない場合は、残りのバイトに 0 が効率的に埋め込まれ、完全なグループが形成されます。この例では、最後のバイト値は 16 進数の FF です。最初の 6 ビットは 10 進数の 63 に相当し、出力の末尾にある Base64 形式の文字 "/" に対応します。次の 2 ビットには 0 が埋め込まれ、10 進数の 48 が生成されます。これは、Base64 形式の文字 "w" に対応します。最後の 2 つの 6 ビット値が埋め込まれます。これらは値として解釈されない埋め込み文字 "=" に対応します。

Visual Basic
' This example demonstrates the Convert.ToBase64CharArray() and 
'                               Convert.FromBase64CharArray methods
Imports System

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
'
C#
// 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

*/
C++
// 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

*/
J#
// This example demonstrates the Convert.ToBase64CharArray() and
//                               Convert.FromBase64CharArray methods
import System.*;

class Sample
{
    public static void main(String[]
 args)
    {
        ubyte byteArray1[] = new ubyte[256];
        ubyte byteArray2[] = new ubyte[256];
        char charArray[] = new char[352];
        int charArrayLength;
        String nl = Environment.get_NewLine();

        String ruler1a = "         1         2         3         4";
        String ruler2a = "1234567890123456789012345678901234567890";
        String ruler3a = "----+----+----+----+----+----+----+----+";
        String ruler1b = "         5         6         7      ";
        String ruler2b = "123456789012345678901234567890123456";
        String ruler3b = "----+----+----+----+----+----+----+-";
        String sTemp[] = {
            ruler1a, ruler1b, nl, ruler2a, ruler2b, nl, ruler3a, ruler3b
        };
        String ruler = String.Concat(sTemp);
        // 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.get_Length();
 x++) {
            byteArray1[x] = (ubyte)x;
            Console.Write("{0:X2} ", byteArray1.get_Item(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.get_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}). ",
            System.Convert.ToString(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}",
            System.Convert.ToString(ArraysAreEqual(byteArray1, byteArray2)));
    } //main

    public static boolean ArraysAreEqual(ubyte
 a1[], ubyte a2[]) 
    {
        if (a1.get_Length() != a2.get_Length()) {
            return false;
        }
        for (int i = 0; i < a1.get_Length();
 i++) {
            if (!a1.get_Item(i).Equals(a2.get_Item(i))) {
                return false;
            }
        }
        return true;
    } //ArraysAreEqual
} //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

*/
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0
参照参照
関連項目
Convert クラス
Convert メンバ
System 名前空間

Convert.ToBase64CharArray メソッド (Byte[], Int32, Int32, Char[], Int32)

8 ビット符号なし整数配列のサブセットを、Base64 の数字でエンコードされた Unicode 文字配列の等価のサブセットに変換します。パラメータは、入力配列と出力配列のオフセットとしてのサブセット、および変換する入力配列の要素の数を指定します。

名前空間: System
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

Visual Basic (宣言)
Public Shared Function ToBase64CharArray
 ( _
    inArray As Byte(), _
    offsetIn As Integer, _
    length As Integer, _
    outArray As Char(), _
    offsetOut As Integer _
) As Integer
Visual Basic (使用法)
Dim inArray As Byte()
Dim offsetIn As Integer
Dim length As Integer
Dim outArray As Char()
Dim offsetOut As Integer
Dim returnValue As Integer

returnValue = Convert.ToBase64CharArray(inArray, offsetIn, length, outArray, offsetOut)
C#
public static int ToBase64CharArray
 (
    byte[] inArray,
    int offsetIn,
    int length,
    char[] outArray,
    int offsetOut
)
C++
public:
static int ToBase64CharArray (
    array<unsigned char>^ inArray, 
    int offsetIn, 
    int length, 
    array<wchar_t>^ outArray, 
    int offsetOut
)
J#
public static int ToBase64CharArray
 (
    byte[] inArray, 
    int offsetIn, 
    int length, 
    char[] outArray, 
    int offsetOut
)
JScript
public static function ToBase64CharArray
 (
    inArray : byte[], 
    offsetIn : int, 
    length : int, 
    outArray : char[], 
    offsetOut : int
) : int

パラメータ

inArray

8 ビット符号なし整数で構成される入力配列。

offsetIn

inArray 内での位置。

length

変換する inArray の要素の数。

outArray

Unicode 文字の出力配列。

offsetOut

outArray 内での位置。

戻り値
outArray のバイト数が格納された 32 ビット符号付き整数。

例外例外
例外の種類条件

ArgumentNullException

inArray または outArray が null 参照 (Visual Basic では Nothing) です。

ArgumentOutOfRangeException

offsetIn、offsetOut,、または length が負の値です。

または

offsetIn に length を加算した値が、inArray の長さを超えています。

または

offsetOut と、返される要素の数を合計した値が、outArray の長さを超えています。

解説解説

offsetIn の位置から開始する inArray の length 要素のサブセットが数値として解釈され、offsetOut の位置から開始する outArray の要素のサブセットへ変換されます。戻り値は、outArray の変換後の要素数を示します。outArray のサブセットは Base 64 の数字で構成されます。

Base64 形式の文字を 0 から昇順で並べた場合、大文字の "A" ～ "Z"、小文字の "a" ～ "z"、数字の "0" ～ "9"、および "+" と "/" の記号の順になります。値として解釈されない文字 '=' は、文字列末尾の埋め込み用に使用されます。

offset パラメータと length パラメータは、32 ビット符号付き数値です。offsetIn パラメータと offsetOut パラメータは、インデックス番号が 0 から始まる配列位置です。

使用例使用例

ToBase64CharArray メソッドを使用して、バイナリ ストリームを uuencode (Base64 形式にエンコード) し、そのエンコーディングをファイルに保存するコード例を次に示します。

Visual Basic
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
C#
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);
    }
}
C++
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 );
      }
   }
J#
public void EncodeWithCharArray()
{
    System.IO.FileStream inFile;
    ubyte binaryData[];

    try {
        inFile = new System.IO.FileStream(inputFileName, 
                                          System.IO.FileMode.Open,
                                          System.IO.FileAccess.Read );
        binaryData = new ubyte[(int)inFile.get_Length()];

        long bytesRead = inFile.Read(binaryData, 0,
                                     (int)(inFile.get_Length()));
        inFile.Close();
    }
    catch (System.Exception exp) {
        // Error creating stream or reading from it.
        System.Console.WriteLine("{0}", exp.get_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;
    }

    char base64CharArray[] = new char[(int)arrayLength];

    try {
        System.Convert.ToBase64CharArray(binaryData, 0, binaryData.length,
                                         base64CharArray, 0);
    }
    catch (System.ArgumentNullException exp) {
        System.Console.WriteLine("Binary data array is null.");
        return;
    }
    catch (System.ArgumentOutOfRangeException exp) {
        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.get_ASCII());
        outFile.Write(base64CharArray);
        outFile.Close();
    }
    catch (System.Exception exp) {
        // Error creating stream or writing to it.
        System.Console.WriteLine("{0}", exp.get_Message());
    }
} //EncodeWithCharArray
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0、1.0
参照参照
関連項目
Convert クラス
Convert メンバ
System 名前空間

Convert.ToBase64CharArray メソッド

8 ビット符号なし整数配列のサブセットを、Base64 の数字でエンコードされた Unicode 文字配列の等価のサブセットに変換します。
オーバーロードの一覧オーバーロードの一覧

名前 説明
Convert.ToBase64CharArray (Byte[], Int32, Int32, Char[], Int32) 8 ビット符号なし整数配列のサブセットを、Base64 の数字でエンコードされた Unicode 文字配列の等価のサブセットに変換します。パラメータは、入力配列と出力配列のオフセットとしてのサブセット、および変換する入力配列の要素の数を指定します。

.NET Compact Framework によってサポートされています。

Convert.ToBase64CharArray (Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) 8 ビット符号なし整数配列のサブセットを、Base64 の数字でエンコードされた Unicode 文字配列の等価のサブセットに変換します。各パラメータは、入力配列と出力配列のオフセットとしてのサブセット、変換する入力配列の要素の数、および出力配列で改行を挿入するかどうかを指定します。
参照参照

関連項目

Convert クラス
Convert メンバ
System 名前空間

英和和英テキスト翻訳

英語⇒日本語日本語⇒英語

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

「Convert.ToBase64CharArray」の関連用語

1
Convert.ToBase64CharArray メソッド
.NET Framework クラス ライブラリ リファレンス
100% |||||

2
Convert.FromBase64CharArray メソッド
.NET Framework クラス ライブラリ リファレンス
50% |||||

3
Base64FormattingOptions 列挙体
.NET Framework クラス ライブラリ リファレンス
16% |||||

4
System 名前空間
.NET Framework クラス ライブラリ リファレンス
12% |||||

Convert.ToBase64CharArrayのお隣キーワード

Convert.FromBase64CharArray メソッド

Convert.FromBase64String メソッド

Convert.GetTypeCode メソッド

Convert.IsBadIndex メソッド

Convert.IsDBNull メソッド

Convert.ThrowTypeMismatch メソッド

Convert.ToBase64CharArray

Convert.ToBase64CharArray メソッド

Convert.ToBase64String メソッド

Convert.ToBoolean メソッド

ConvertEventArgs クラス

ConvertEventArgs コンストラクタ

ConvertEventArgs プロパティ

検索ランキング

   

 英語⇒日本語
日本語⇒英語		    


Convert.ToBase64CharArrayのページの著作権

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2026 Microsoft.All rights reserved.

©2026 GRAS Group, Inc.RSS