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

辞書 類語・対義語辞典 英和・和英辞典 日中中日辞典 日韓韓日辞典 古語辞典

その他の辞書▼
- フランス語辞典
- インドネシア語辞典
- タイ語辞典
- ベトナム語辞典

Weblio 辞書ヘルプ

556の専門辞書や国語辞典百科事典から一度に検索!

無料の翻訳ならWeblio翻訳！

初めての方へ参加元一覧

Weblio 辞書 > コンピュータ > .NET Framework クラスライブラリリファレンス > 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)

[ComVisibleAttribute(false)] 
public static int ToBase64CharArray
 (
    byte[] inArray,
    int offsetIn,
    int length,
    char[] outArray,
    int offsetOut,
    Base64FormattingOptions options
)

[ComVisibleAttribute(false)] 
public:
static int ToBase64CharArray (
    array<unsigned char>^ inArray, 
    int offsetIn, 
    int length, 
    array<wchar_t>^ outArray, 
    int offsetOut, 
    Base64FormattingOptions options
)

/** @attribute ComVisibleAttribute(false) */ 
public static int ToBase64CharArray
 (
    byte[] inArray, 
    int offsetIn, 
    int length, 
    char[] outArray, 
    int offsetOut, 
    Base64FormattingOptions options
)

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 ビット値が埋め込まれます。これらは値として解釈されない埋め込み文字 "=" に対応します。

' 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
'

// 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
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
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

*/

プラットフォーム

プラットフォーム

バージョン情報

バージョン情報

.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)

public static int ToBase64CharArray
 (
    byte[] inArray,
    int offsetIn,
    int length,
    char[] outArray,
    int offsetOut
)

public:
static int ToBase64CharArray (
    array<unsigned char>^ inArray, 
    int offsetIn, 
    int length, 
    array<wchar_t>^ outArray, 
    int offsetOut
)

public static int ToBase64CharArray
 (
    byte[] inArray, 
    int offsetIn, 
    int length, 
    char[] outArray, 
    int offsetOut
)

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 形式にエンコード) し、そのエンコーディングをファイルに保存するコード例を次に示します。

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

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:
   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;
    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 名前空間

四宮ありす

このページでは「.NET Framework クラスライブラリリファレンス」からConvert.ToBase64CharArrayを検索した結果を表示しています。
Weblioに収録されているすべての辞書からConvert.ToBase64CharArrayを検索する場合は、下記のリンクをクリックしてください。

全ての辞書からConvert.ToBase64CharArray を検索

>> 「Convert.ToBase64CharArray」を含む用語の索引
Convert.ToBase64CharArrayのページへのリンク

辞書ショートカット

1 .NET Framework クラスライブラリリファレンス

カテゴリ一覧

＋ビジネス

＋業界用語

＋コンピュータ

＋自動車・バイク

＋船

＋建築・不動産

＋ヘルスケア

＋スポーツ

＋辞書・百科事典

すべての辞書の索引

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のページの著作権
Weblio 辞書情報提供元は参加元一覧にて確認できます。


	© 2025 Microsoft.All rights reserved.

ビジネス｜業界用語｜コンピュータ｜電車｜自動車・バイク｜船｜工学｜建築・不動産｜学問
 文化｜生活｜ヘルスケア｜趣味｜スポーツ｜生物｜食品｜人名｜方言｜辞書・百科事典

ご利用にあたって

・Weblio辞書とは

・検索の仕方

・利用規約

・プライバシーポリシー

・サイトマップ

便利な機能

・ウェブリオのアプリ

・画像から探す

お問合せ・ご要望

・お問い合わせ

会社概要

・公式企業ページ

・会社情報

・採用情報

ウェブリオのサービス

・Weblio 辞書

・類語・対義語辞典

・英和辞典・和英辞典

・Weblio翻訳

・日中中日辞典

・日韓韓日辞典

・フランス語辞典

・インドネシア語辞典

・タイ語辞典

・ベトナム語辞典

・古語辞典

・おすすめのプログラミングスクール情報「Livifun」

©2025 GRAS Group, Inc.RSS