Convert.FromBase64CharArray メソッドとは？ わかりやすく解説

Weblio 辞書 > コンピュータ > .NET Framework クラス ライブラリ リファレンス > Convert.FromBase64CharArray メソッドの意味・解説 
.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引 ランキング
日本マイクロソフト株式会社日本マイクロソフト株式会社

Convert.FromBase64CharArray メソッド

Unicode 文字配列のサブセットを変換します。これにより、バイナリ データは Base64 の数字として等価の 8 ビット符号なし整数配列にエンコードされます。パラメータは、入力配列のサブセットと変換する要素の数を指定します。

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

Visual Basic (宣言)
Public Shared Function FromBase64CharArray
 ( _
    inArray As Char(), _
    offset As Integer, _
    length As Integer _
) As Byte()
Visual Basic (使用法)
Dim inArray As Char()
Dim offset As Integer
Dim length As Integer
Dim returnValue As Byte()

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

パラメータ

inArray

Unicode 文字配列。

offset

inArray 内での位置。

length

変換する inArray の要素の数。

戻り値
inArray の offset の位置にある length 要素と等価の 8 ビット符号なし整数の配列。

例外例外
例外の種類条件

ArgumentNullException

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

ArgumentOutOfRangeException

offset または length が 0 未満です。

または

length に offset を足した数が、inArray 内に存在しない位置を示しています。

FormatException

空白文字を除いた inArray の長さが 0 ではないか、または 4 の倍数ではありません。

または

inArray の書式が無効です。inArray に Base64 形式以外の文字、2 つ以上の埋め込み文字、または埋め込み文字の間に空白以外の文字が含まれています。

解説解説

inArray は、Base64 形式の文字、空白文字、および後続の埋め込み文字で構成されます。Base64 形式の文字を 0 から昇順で並べると、大文字の "A" ～ "Z"、小文字の "a" ～ "z"、数字の "0" ～ "9"、および "+" と "/" の記号になります。

空白文字、およびそれらの Unicode 名と 16 進数のコード ポイントは、タブ (CHARACTER TABULATION、U+0009)、改行 (LINE FEED、U+000A)、復帰 (CARRIAGE RETURN、U+000D)、および空白 (SPACE、U+0020) です。空白文字はすべて無視されるため、任意の数の空白文字を inArray に含めることができます。

値として解釈されない文字 "=" は、文字列末尾の埋め込み用に使用されます。inArray の末尾は、1 つまたは 2 つの埋め込み文字で構成されます。

使用例使用例

FromBase64CharArray メソッドを使用して、uuencode されたデータ (Base64 形式のデータ) をデコードし、バイナリ出力として保存する方法を次のコード例に示します。

Visual Basic
Public Sub DecodeWithCharArray()
   Dim inFile As System.IO.StreamReader
   Dim base64CharArray() As Char

   Try
      inFile = New System.IO.StreamReader(inputFileName, _
                                          System.Text.Encoding.ASCII)

      ReDim base64CharArray(inFile.BaseStream.Length - 1)
      inFile.Read(base64CharArray, 0, inFile.BaseStream.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 Base64 UUEncoded input into binary output.
   Dim binaryData() As Byte
   Try
      binaryData = System.Convert.FromBase64CharArray(base64CharArray, 0, _
                                                base64CharArray.Length)
   Catch exp As System.ArgumentNullException
      System.Console.WriteLine("Base 64 character array is null.")
      Return
   Catch exp As System.FormatException
      System.Console.WriteLine("Base 64 Char Array length is not
 " + _
               "4 or is not an even multiple of 4")
      Return
   End Try

   ' Write out the decoded data.
   Dim outFile As System.IO.FileStream
   Try
      outFile = New System.IO.FileStream(outputFileName, _
                                         System.IO.FileMode.Create, _
                                         System.IO.FileAccess.Write)
      outFile.Write(binaryData, 0, binaryData.Length - 1)
      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 DecodeWithCharArray() {
    System.IO.StreamReader inFile;     
    char[] base64CharArray;

    try {
        inFile = new System.IO.StreamReader(inputFileName,
                                        System.Text.Encoding.ASCII);
        base64CharArray = new char[inFile.BaseStream.Length];
        inFile.Read(base64CharArray, 0, (int)inFile.BaseStream.Length);
        inFile.Close();
    }
    catch (System.Exception exp) {
        // Error creating stream or reading from it.
        System.Console.WriteLine("{0}", exp.Message);
        return;
    }

    // Convert the Base64 UUEncoded input into binary output.
    byte[] binaryData;
    try {
        binaryData = 
            System.Convert.FromBase64CharArray(base64CharArray,
                                               0,
                                               base64CharArray.Length);
    }
    catch ( System.ArgumentNullException ) {
        System.Console.WriteLine("Base 64 character array is null.");
        return;
    }
    catch ( System.FormatException ) {
        System.Console.WriteLine("Base 64 Char Array length is not " +
            "4 or is not an even multiple of 4." );
        return;
    }

    // Write out the decoded data.
    System.IO.FileStream outFile;
    try {
        outFile = new System.IO.FileStream(outputFileName,
                                           System.IO.FileMode.Create,
                                           System.IO.FileAccess.Write);
        outFile.Write(binaryData, 0, binaryData.Length);
        outFile.Close();
    }
    catch (System.Exception exp) {
        // Error creating stream or writing to it.
        System.Console.WriteLine("{0}", exp.Message);
    }
}
C++
public:
   void DecodeWithCharArray()
   {
      StreamReader^ inFile;
      array<Char>^base64CharArray;
      try
      {
         inFile = gcnew StreamReader( inputFileName,
                                      Text::Encoding::ASCII );
         base64CharArray = gcnew array<Char>((int)(inFile->BaseStream->Length));
         inFile->Read( base64CharArray, 0, (int)inFile->BaseStream->Length
 );
         inFile->Close();
      }
      catch ( Exception^ exp ) 
      {
         
         // Error creating stream or reading from it.
         Console::WriteLine( "{0}", exp->Message );
         return;
      }
      
      // Convert the Base64 UUEncoded input into binary output.
      array<Byte>^binaryData;
      try
      {
         binaryData = Convert::FromBase64CharArray( base64CharArray,
                                                    0,
                                                    base64CharArray->Length );
      }
      catch ( ArgumentNullException^ ) 
      {
         Console::WriteLine( "Base 64 character array is null."
 );
         return;
      }
      catch ( FormatException^ ) 
      {
         Console::WriteLine( "Base 64 Char Array length is not " +
            "4 or is not an even multiple of 4." );
         return;
      }
      
      // Write out the decoded data.
      FileStream^ outFile;
      try
      {
         outFile = gcnew FileStream( outputFileName,
                                     FileMode::Create,
                                     FileAccess::Write );
         outFile->Write( binaryData, 0, binaryData->Length );
         outFile->Close();
      }
      catch ( Exception^ exp ) 
      {
         // Error creating stream or writing to it.
         Console::WriteLine( "{0}", exp->Message );
      }
   }
J#
public void DecodeWithCharArray()
{
    System.IO.StreamReader inFile;
    char base64CharArray[];

    try {
        inFile = new System.IO.StreamReader(inputFileName,
                System.Text.Encoding.get_ASCII());
        base64CharArray = new char[
                        (int)inFile.get_BaseStream().get_Length()];
        inFile.Read(base64CharArray, 0,    
            (int)(inFile.get_BaseStream().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 Base64 UUEncoded input into binary output.
    ubyte binaryData[];

    try {
        binaryData = System.Convert.FromBase64CharArray(base64CharArray,
                    0, base64CharArray.length);
    }
    catch (System.ArgumentNullException exp) {
        System.Console.WriteLine("Base 64 character array is null.");
        return;
    }
    catch (System.FormatException exp) {
        System.Console.WriteLine(("Base 64 Char Array length is not " 
            + "4 or is not an even multiple of 4."));
        return;
    }

    // Write out the decoded data.
    System.IO.FileStream outFile;

    try {
        outFile = new System.IO.FileStream(outputFileName, 
                System.IO.FileMode.Create, System.IO.FileAccess.Write );
        outFile.Write(binaryData, 0, binaryData.length);
        outFile.Close();
    }
    catch (System.Exception exp) {
        // Error creating stream or writing to it.
        System.Console.WriteLine("{0}", exp.get_Message());
    }
} //DecodeWithCharArray

ToBase64CharArray メソッドおよび FromBase64CharArray メソッドのコード例を次に示します。入力は、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 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 名前空間

急上昇のことば

琥珀色の雨にぬれて
爆サイ
語彙
カスタマイズ
ブレイズメス1990
英和和英テキスト翻訳>> Weblio翻訳
英語⇒日本語日本語⇒英語
  

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

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

Weblioのサービス

「Convert.FromBase64CharArray メソッド」の関連用語

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

Convert.FromBase64CharArray メソッドのお隣キーワード

Convert.CheckIfDoubleIsInteger メソッド

Convert.CheckIfSingleIsInteger メソッド

Convert.Coerce メソッド

Convert.Coerce2 メソッド

Convert.CoerceT メソッド

Convert.DBNull フィールド

Convert.FromBase64CharArray メソッド

Convert.FromBase64String メソッド

Convert.GetTypeCode メソッド

Convert.IsBadIndex メソッド

Convert.IsDBNull メソッド

Convert.ThrowTypeMismatch メソッド

Convert.ToBase64CharArray メソッド

検索ランキング

   

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


Convert.FromBase64CharArray メソッドのページの著作権
Weblio 辞書 情報提供元は 参加元一覧 にて確認できます。

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

©2024 GRAS Group, Inc.RSS