Convert.FromBase64CharArray 메서드
64자리 기수의 이진 데이터를 동등한 8비트 부호 없는 정수 배열로 인코딩하는 방법으로 유니코드 문자 배열의 하위 집합을 변환합니다. 매개 변수에는 입력 배열의 하위 집합과 변환할 요소 수를 지정합니다.
네임스페이스: System
어셈블리: mscorlib(mscorlib.dll)
구문
‘선언
Public Shared Function FromBase64CharArray ( _
inArray As Char(), _
offset As Integer, _
length As Integer _
) As Byte()
‘사용 방법
Dim inArray As Char()
Dim offset As Integer
Dim length As Integer
Dim returnValue As Byte()
returnValue = Convert.FromBase64CharArray(inArray, offset, length)
public static byte[] FromBase64CharArray (
char[] inArray,
int offset,
int length
)
public:
static array<unsigned char>^ FromBase64CharArray (
array<wchar_t>^ inArray,
int offset,
int length
)
public static byte[] FromBase64CharArray (
char[] inArray,
int offset,
int length
)
public static function FromBase64CharArray (
inArray : char[],
offset : int,
length : int
) : byte[]
매개 변수
- inArray
유니코드 문자 배열입니다.
- offset
inArray 내의 위치입니다.
- length
inArray의 요소 중에서 변환할 요소의 수입니다.
반환 값
inArray의 offset 위치에 있는 length 요소에 해당하는 8비트 부호 없는 정수를 반환합니다.
예외
| 예외 형식 | 조건 |
|---|---|
inArray가 Null 참조(Visual Basic의 경우 Nothing)인 경우 |
|
offset 또는 length가 0 미만인 경우 - 또는 - offset과 length의 합이 inArray 내에 있지 않은 위치를 나타내는 경우 |
|
공백 문자를 제외한 inArray의 길이가 0이 아니거나 4의 배수가 아닌 경우 - 또는 - inArray의 형식이 잘못된 경우. inArray의 채움 문자에 64자리 기수가 아닌 문자, 세 개 이상의 채움 문자 또는 공백이 아닌 문자가 포함되어 있습니다. |
설명
inArray는 64자리 기수, 공백 문자 및 뒤쪽 여백 문자로 구성됩니다. 0부터 오름차순으로 정렬한 64자리 기수는 'A'에서 'Z'까지의 대문자, 'a'에서 'z'까지의 소문자, '0'에서 '9'까지의 숫자, 그리고 '+' 및 '/' 기호입니다.
공백 문자, 해당 유니코드 이름 및 16진수 코드 포인트는 탭(CHARACTER TABULATION, U+0009), 줄바꿈(LINE FEED, U+000A), 캐리지 리턴(CARRIAGE RETURN, U+000D) 및 공백(SPACE, U+0020)입니다. 모든 공백 문자는 무시되기 때문에 여러 개의 공백 문자가 inArray에 나타날 수 있습니다.
값이 없는 '=' 문자는 뒤쪽 여백에 사용됩니다. inArray의 끝에는 여백 문자가 없거나 한 개 또는 두 개가 있을 수 있습니다.
예제
다음 코드 예제에서는 FromBase64CharArray 메서드를 사용하여 UUencode(64 기수) 형식의 데이터를 디코딩하고 이 데이터를 이진 출력으로 저장하는 방법을 보여 줍니다.
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
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);
}
}
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 );
}
}
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까지인 6비트 수 네 개로 구성됩니다. 이 예제에는 3바이트 그룹 85개와 나머지 한 바이트가 있습니다. 첫 번째 그룹은 16진수 값 00, 01 및 02로 구성되어 있습니다. 이것은 10진수 0, 0, 4 및 2와 동일한 6비트 값 4개입니다. 네 값은 출력의 시작 부분에 있는 64자리 기수 'A', 'A', 'E' 및 'C'에 해당합니다.
3바이트 그룹의 정수가 없으면 나머지 바이트가 0으로 채워져 완전한 그룹을 형성합니다. 이 예제에서 마지막 바이트의 값은 16진수 FF입니다. 처음 6비트는 출력의 끝 부분에 있는 64자리 기수 '/'에 해당하는 10진수 63과 같으며 다음 2비트는 0으로 채워져 64자리 기수 'w'에 해당하는 10진수 48이 됩니다. 마지막 두 개의 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
*/
플랫폼
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에서 지원