Convert.ToBase64CharArray Convert.ToBase64CharArray Convert.ToBase64CharArray Convert.ToBase64CharArray Method

정의

8비트 부호 없는 정수 배열의 하위 집합을 base-64 숫자로 인코딩된 유니코드 문자 배열의 해당하는 하위 집합으로 변환합니다.Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits.

오버로드

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)

8비트 부호 없는 정수 배열의 하위 집합을 base-64 숫자로 인코딩된 유니코드 문자 배열의 해당하는 하위 집합으로 변환합니다.Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. 매개 변수는 하위 집합을 입력 및 출력 배열의 오프셋으로 지정하고 변환할 입력 배열의 요소 수를 지정합니다.Parameters specify the subsets as offsets in the input and output arrays, and the number of elements in the input array to convert.

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)

8비트 부호 없는 정수 배열의 하위 집합을 base-64 숫자로 인코딩된 유니코드 문자 배열의 해당하는 하위 집합으로 변환합니다.Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. 매개 변수는 하위 집합을 입력 및 출력 배열의 오프셋으로 지정하고, 변환할 입력 배열의 요소 수를 지정하고, 출력 배열에 줄 바꿈을 삽입할지를 지정합니다.Parameters specify the subsets as offsets in the input and output arrays, the number of elements in the input array to convert, and whether line breaks are inserted in the output array.

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)

8비트 부호 없는 정수 배열의 하위 집합을 base-64 숫자로 인코딩된 유니코드 문자 배열의 해당하는 하위 집합으로 변환합니다.Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. 매개 변수는 하위 집합을 입력 및 출력 배열의 오프셋으로 지정하고 변환할 입력 배열의 요소 수를 지정합니다.Parameters specify the subsets as offsets in the input and output arrays, and the number of elements in the input array to convert.

public:
 static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut);
public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut);
static member ToBase64CharArray : byte[] * int * int * char[] * int -> int
Public Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer) As Integer

매개 변수

inArray
Byte[]

8비트 부호 없는 정수로 구성된 입력 배열입니다.An input array of 8-bit unsigned integers.

offsetIn
Int32 Int32 Int32 Int32

inArray 내의 위치입니다.A position within inArray.

length
Int32 Int32 Int32 Int32

inArray의 요소 중에서 변환할 요소의 수입니다.The number of elements of inArray to convert.

outArray
Char[]

유니코드 문자로 구성된 출력 배열입니다.An output array of Unicode characters.

offsetOut
Int32 Int32 Int32 Int32

outArray 내의 위치입니다.A position within outArray.

반환

outArray의 바이트 수를 포함하는 32비트 부호 있는 정수를 반환합니다.A 32-bit signed integer containing the number of bytes in outArray.

예외

inArray 또는 outArraynull인 경우inArray or outArray is null.

offsetIn, offsetOut 또는 length가 음수입니다.offsetIn, offsetOut, or length is negative.

또는-or- offsetIn + lengthinArray의 길이보다 큽니다.offsetIn plus length is greater than the length of inArray.

또는-or- offsetOut + 반환할 요소 수가 outArray의 길이보다 큽니다.offsetOut plus the number of elements to return is greater than the length of outArray.

예제

다음 예제에서는 ToBase64CharArray UUencode 방법 (base 64에서 인코딩)를 이진 스트림으로 인코딩 파일에 저장 합니다.The following example demonstrates using the ToBase64CharArray method to UUencode (encode in base 64) a binary stream, then save the encoding to a file.

public:
   void EncodeWithCharArray()
   {
      FileStream^ inFile;
      array<Byte>^binaryData;

      try
      {
         inFile = gcnew FileStream( inputFileName,
                                    FileMode::Open,
                                    FileAccess::Read );
         binaryData = gcnew array<Byte>((int)(inFile->Length));
         long bytesRead = inFile->Read( binaryData, 0,
                                        (int)inFile->Length );
         inFile->Close();
      }
      catch ( Exception^ exp ) 
      {
         // Error creating stream or reading from it.
         Console::WriteLine( "{0}", exp->Message );
         return;
      }
      
      // Convert the binary input into Base64 UUEncoded output.
      // Each 3 Byte sequence in the source data becomes a 4 Byte
      // sequence in the character array. 
      long arrayLength = (long)((4.0 / 3.0) * binaryData->Length);
      
      // If array length is not divisible by 4, go up to the next
      // multiple of 4.
      if ( arrayLength % 4 != 0 )
      {
         arrayLength += 4 - arrayLength % 4;
      }

      array<Char>^ base64CharArray = gcnew array<Char>(arrayLength);
      try
      {
         Convert::ToBase64CharArray( binaryData,
                                     0,
                                     binaryData->Length,
                                     base64CharArray, 0 );
      }
      catch ( ArgumentNullException^ ) 
      {
         Console::WriteLine( "Binary data array is null." );
         return;
      }
      catch ( ArgumentOutOfRangeException^ ) 
      {
         Console::WriteLine( "Char Array is not large enough." );
         return;
      }
      
      // Write the UUEncoded version to the output file.
      StreamWriter^ outFile;
      try
      {
         outFile = gcnew StreamWriter( outputFileName,
                                       false,
                                       Text::Encoding::ASCII );
         outFile->Write( base64CharArray );
         outFile->Close();
      }
      catch ( Exception^ exp ) 
      {
         // Error creating stream or writing to it.
         Console::WriteLine( " {0}", exp->Message );
      }
   }
public void EncodeWithCharArray() {
   System.IO.FileStream inFile;    
   byte[]             binaryData;

   try {
      inFile = new System.IO.FileStream(inputFileName,
                                 System.IO.FileMode.Open,
                                System.IO.FileAccess.Read);
      binaryData = new Byte[inFile.Length];
      long bytesRead = inFile.Read(binaryData, 0,
                           (int) inFile.Length);
      inFile.Close();
   }
   catch (System.Exception exp) {
      // Error creating stream or reading from it.
      System.Console.WriteLine("{0}", exp.Message);
      return;
   }

   // Convert the binary input into Base64 UUEncoded output.
   // Each 3 byte sequence in the source data becomes a 4 byte
   // sequence in the character array. 
   long arrayLength = (long) ((4.0d/3.0d) * binaryData.Length);
   
   // If array length is not divisible by 4, go up to the next
   // multiple of 4.
   if (arrayLength % 4 != 0) {
      arrayLength += 4 - arrayLength % 4;
   }
   
   char[] base64CharArray = new char[arrayLength];
   try {
      System.Convert.ToBase64CharArray(binaryData, 
                               0,
                               binaryData.Length,
                               base64CharArray,
                               0);
   }
   catch (System.ArgumentNullException) {
      System.Console.WriteLine("Binary data array is null.");
      return;
   }
   catch (System.ArgumentOutOfRangeException) {
      System.Console.WriteLine("Char Array is not large enough.");
      return;
   }

   // Write the UUEncoded version to the output file.
   System.IO.StreamWriter outFile; 
   try {
      outFile = new System.IO.StreamWriter(outputFileName,
                              false,
                              System.Text.Encoding.ASCII);          
      outFile.Write(base64CharArray);
      outFile.Close();
   }
   catch (System.Exception exp) {
      // Error creating stream or writing to it.
      System.Console.WriteLine("{0}", exp.Message);
   }
}
Public Sub EncodeWithCharArray()
   Dim inFile As System.IO.FileStream
   Dim binaryData() As Byte

   Try
      inFile = New System.IO.FileStream(inputFileName, _
                                        System.IO.FileMode.Open, _
                                        System.IO.FileAccess.Read)
      ReDim binaryData(inFile.Length)
      Dim bytesRead As Long = inFile.Read(binaryData, _
                                          0, _
                                          CInt(inFile.Length))
      inFile.Close()
   Catch exp As System.Exception
      ' Error creating stream or reading from it.
      System.Console.WriteLine("{0}", exp.Message)
      Return
   End Try

   ' Convert the binary input into Base64 UUEncoded output.
   ' Each 3 byte sequence in the source data becomes a 4 byte
   ' sequence in the character array. 
   Dim arrayLength As Long 
   arrayLength = (4 / 3) * binaryData.Length
   If arrayLength Mod 4 <> 0 Then
      arrayLength = arrayLength + 4 - arrayLength Mod 4
   End If

   Dim base64CharArray(arrayLength - 1) As Char
   Try
      System.Convert.ToBase64CharArray(binaryData, _
                                       0, _
                                       binaryData.Length, _
                                       base64CharArray, 0)
   Catch exp As System.ArgumentNullException
      System.Console.WriteLine("Binary data array is null.")
      Return
   Catch exp As System.ArgumentOutOfRangeException
      System.Console.WriteLine("Char Array is not large enough.")
      Return
   End Try

   ' Write the UUEncoded version to the output file.
   Dim outFile As System.IO.StreamWriter
   Try
      outFile = New System.IO.StreamWriter(outputFileName, _
                                           False, _
                                           System.Text.Encoding.ASCII)
      outFile.Write(base64CharArray)
      outFile.Close()
   Catch exp As System.Exception
      ' Error creating stream or writing to it.
      System.Console.WriteLine("{0}", exp.Message)
   End Try
End Sub

설명

하위 집합 length 요소의 inArray 위치부터 offsetIn, 숫자 값으로 간주 됩니다 및 요소의 하위 집합으로 변환할 outArray 위치부터 offsetOut합니다.The subset of length elements of inArray starting at position offsetIn, are taken as a numeric value and converted to a subset of elements in outArray starting at position offsetOut. 반환 값에서 변환 된 요소의 수를 나타냅니다 outArray합니다.The return value indicates the number of converted elements in outArray. 하위 집합 outArray base-64 숫자 이루어져 있습니다.The subset of outArray consists of base-64 digits.

Base-64 숫자 0에서 오름차순 "z", 소문자 대문자 "A"는 "z", "9" 숫자 "0"을 "a" 및 기호 "+" 및 "/"입니다.The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". 값이 없는 문자, "=" 뒤쪽 안쪽 여백에 사용 됩니다.The valueless character, "=", is used for trailing padding.

합니다 offsetlength 매개 변수는 32 비트 부호 있는 숫자입니다.The offset and length parameters are 32-bit signed numbers. 합니다 offsetInoffsetOut 매개 변수는 0부터 시작 하는 배열의 위치입니다.The offsetIn and offsetOut parameters are zero-based array positions.

중요

ToBase64CharArray 메서드는 모든 데이터를 인코딩할 수를 포함 하는 단일 바이트 배열을 처리 하도록 설계 되었습니다.The ToBase64CharArray method is designed to process a single byte array that contains all the data to be encoded. Base-64 문자 배열 바이트 스트림에서 만들려면 사용 합니다 System.Security.Cryptography.ToBase64Transform 클래스입니다.To create a base-64 character array from a byte stream, use the System.Security.Cryptography.ToBase64Transform class.

추가 정보

ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)

8비트 부호 없는 정수 배열의 하위 집합을 base-64 숫자로 인코딩된 유니코드 문자 배열의 해당하는 하위 집합으로 변환합니다.Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. 매개 변수는 하위 집합을 입력 및 출력 배열의 오프셋으로 지정하고, 변환할 입력 배열의 요소 수를 지정하고, 출력 배열에 줄 바꿈을 삽입할지를 지정합니다.Parameters specify the subsets as offsets in the input and output arrays, the number of elements in the input array to convert, and whether line breaks are inserted in the output array.

public:
 static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut, Base64FormattingOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options);
static member ToBase64CharArray : byte[] * int * int * char[] * int * Base64FormattingOptions -> int
Public Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer, options As Base64FormattingOptions) As Integer

매개 변수

inArray
Byte[]

8비트 부호 없는 정수로 구성된 입력 배열입니다.An input array of 8-bit unsigned integers.

offsetIn
Int32 Int32 Int32 Int32

inArray 내의 위치입니다.A position within inArray.

length
Int32 Int32 Int32 Int32

inArray의 요소 중에서 변환할 요소의 수입니다.The number of elements of inArray to convert.

outArray
Char[]

유니코드 문자로 구성된 출력 배열입니다.An output array of Unicode characters.

offsetOut
Int32 Int32 Int32 Int32

outArray 내의 위치입니다.A position within outArray.

options
Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions

InsertLineBreaks는 76자마다 줄 바꿈을 삽입하며 None은 줄 바꿈을 삽입하지 않습니다.InsertLineBreaks to insert a line break every 76 characters, or None to not insert line breaks.

반환

outArray의 바이트 수를 포함하는 32비트 부호 있는 정수를 반환합니다.A 32-bit signed integer containing the number of bytes in outArray.

예외

inArray 또는 outArraynull인 경우inArray or outArray is null.

offsetIn, offsetOut 또는 length가 음수입니다.offsetIn, offsetOut, or length is negative.

또는-or- offsetIn + lengthinArray의 길이보다 큽니다.offsetIn plus length is greater than the length of inArray.

또는-or- offsetOut + 반환할 요소 수가 outArray의 길이보다 큽니다.offsetOut plus the number of elements to return is greater than the length of outArray.

options는 유효한 Base64FormattingOptions 값이 아닙니다.options is not a valid Base64FormattingOptions value.

예제

다음 예제는 ToBase64CharArray 메서드.The following example demonstrates the ToBase64CharArray method. 입력 각 3 바이트 (24 비트)의 그룹으로 나뉩니다.The input is divided into groups of three bytes (24 bits) each. 따라서 각 그룹에서 10 진수 0 ~ 63 개의 범위가 여기서 4 6 비트 숫자 이루어져 있습니다.Consequently, each group consists of four 6-bit numbers where each number ranges from decimal 0 to 63. 이 예에는 1 바이트 나머지 85 3 바이트 그룹이 있습니다.In this example, there are 85 3-byte groups with one byte remaining. 16 진수 값 00, 01, 02, 10 진수 0, 0, 4 및 2 같은 네 가지 6 비트 값을 생성 하는 첫 번째 그룹 구성 됩니다.The first group consists of the hexadecimal values 00, 01, and 02, which yield four 6-bit values equal to decimal 0, 0, 4, and 2. 이러한 네 가지 값은 base-64 숫자 "A", "A", "E" 및 "C" 부분을 출력에 해당합니다.Those four values correspond to the base-64 digits "A", "A", "E", and "C" at the beginning of the output.

3 바이트 그룹의 정수가 존재 하지 않는 경우 나머지 바이트는 효과적으로 전체 그룹으로 0으로 채워집니다.If an integral number of 3-byte groups does not exist, the remaining bytes are effectively padded with zeros to form a complete group. 이 예제에서는 마지막 바이트의 값은 16 진수 FF입니다.In this example, the value of the last byte is hexadecimal FF. 출력의 끝에 "/" base-64 숫자에 해당 하는 10 진수 63 처음 6 비트 같은지 및 다음 2 비트는 "w" base-64 숫자에 해당 하는 10 진수 48 0으로 채워집니다.The first 6 bits are equal to decimal 63, which corresponds to the base-64 digit "/" at the end of the output, and the next 2 bits are padded with zeros to yield decimal 48, which corresponds to the base-64 digit, "w". 마지막 두 6 비트 값은 패딩 되며 해당 하는 값이 없는 채움 문자를 "="입니다.The last two 6-bit values are padding and correspond to the valueless padding character, "=".

// This example demonstrates the Convert.ToBase64CharArray() and
//                               Convert.FromBase64CharArray methods
using namespace System;
bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 );
int main()
{
   array<Byte>^byteArray1 = gcnew array<Byte>(256);
   array<Byte>^byteArray2 = gcnew array<Byte>(256);
   array<Char>^charArray = gcnew array<Char>(352);
   int charArrayLength;
   String^ nl = Environment::NewLine;
   String^ ruler1a = "         1         2         3         4";
   String^ ruler2a = "1234567890123456789012345678901234567890";
   String^ ruler3a = "----+----+----+----+----+----+----+----+";
   String^ ruler1b = "         5         6         7      ";
   String^ ruler2b = "123456789012345678901234567890123456";
   String^ ruler3b = "----+----+----+----+----+----+----+-";
   String^ ruler = String::Concat( ruler1a, ruler1b, nl, ruler2a, ruler2b, nl, ruler3a, ruler3b );
   
   // 1) Initialize and display a Byte array of arbitrary data.
   Console::WriteLine( "1) Input: A Byte array of arbitrary data.{0}", nl );
   for ( int x = 0; x < byteArray1->Length; x++ )
   {
      byteArray1[ x ] = (Byte)x;
      Console::Write( "{0:X2} ", byteArray1[ x ] );
      if ( ((x + 1) % 20) == 0 )
            Console::WriteLine();

   }
   Console::Write( "{0}{0}", nl );
   
   // 2) Convert the input Byte array to a Char array, with newlines inserted.
   charArrayLength = Convert::ToBase64CharArray( byteArray1, 0, byteArray1->Length, 
                                                 charArray, 0, 
                                                 Base64FormattingOptions::InsertLineBreaks );
   Console::WriteLine( "2) Convert the input Byte array to a Char array with newlines." );
   Console::Write( "   Output: A Char array (length = {0}). ", charArrayLength );
   Console::WriteLine( "The elements of the array are:{0}", nl );
   Console::WriteLine( ruler );
   Console::WriteLine( gcnew String( charArray ) );
   Console::WriteLine();
   
   // 3) Convert the Char array back to a Byte array.
   Console::WriteLine( "3) Convert the Char array to an output Byte array." );
   byteArray2 = Convert::FromBase64CharArray( charArray, 0, charArrayLength );
   
   // 4) Are the input and output Byte arrays equivalent?
   Console::WriteLine( "4) The output Byte array is equal to the input Byte array: {0}", ArraysAreEqual( byteArray1, byteArray2 ) );
}

bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 )
{
   if ( a1->Length != a2->Length )
      return false;

   for ( int i = 0; i < a1->Length; i++ )
      if ( a1[ i ] != a2[ i ] )
            return false;

   return true;
}

/*
This example produces the following results:

1) Input: A Byte array of arbitrary data.

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

2) Convert the input Byte array to a Char array with newlines.
   Output: A Char array (length = 352). The elements of the array are:

         1         2         3         4         5         6         7
1234567890123456789012345678901234567890123456789012345678901234567890123456
----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==

3) Convert the Char array to an output Byte array.
4) The output Byte array is equal to the input Byte array: True

*/
// This example demonstrates the Convert.ToBase64CharArray() and
//                               Convert.FromBase64CharArray methods

using System;

class Sample 
{
    public static void Main() 
    {
    byte[] byteArray1 = new byte[256];
    byte[] byteArray2 = new byte[256];
    char[] charArray  = new char[352];
    int charArrayLength;
    string nl = Environment.NewLine;

    string ruler1a = "         1         2         3         4";
    string ruler2a = "1234567890123456789012345678901234567890";
    string ruler3a = "----+----+----+----+----+----+----+----+";
    string ruler1b = "         5         6         7      ";
    string ruler2b = "123456789012345678901234567890123456";
    string ruler3b = "----+----+----+----+----+----+----+-";
    string ruler   = String.Concat(ruler1a, ruler1b, nl, 
                                   ruler2a, ruler2b, nl,
                                   ruler3a, ruler3b);

// 1) Initialize and display a Byte array of arbitrary data.
    Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl);
    for (int x = 0; x < byteArray1.Length; x++)
    {
    byteArray1[x] = (byte)x;
    Console.Write("{0:X2} ", byteArray1[x]);
    if (((x+1)%20) == 0) Console.WriteLine();
    }
    Console.Write("{0}{0}", nl);

// 2) Convert the input Byte array to a Char array, with newlines inserted.
    charArrayLength = 
        Convert.ToBase64CharArray(byteArray1, 0, byteArray1.Length, 
                                   charArray, 0, Base64FormattingOptions.InsertLineBreaks);
    Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.");
    Console.Write("   Output: A Char array (length = {0}). ", charArrayLength);
    Console.WriteLine("The elements of the array are:{0}", nl);
    Console.WriteLine(ruler);
    Console.WriteLine(new String(charArray));
    Console.WriteLine();

// 3) Convert the Char array back to a Byte array.
    Console.WriteLine("3) Convert the Char array to an output Byte array.");
    byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength);

// 4) Are the input and output Byte arrays equivalent?
    Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}", 
                      ArraysAreEqual(byteArray1, byteArray2));
    }

    public static bool ArraysAreEqual(byte[] a1, byte[] a2)
    {
    if (a1.Length != a2.Length) return false;
    for (int i = 0; i < a1.Length; i++)
        if (a1[i] != a2[i]) return false;
    return true;
    }
}
/*
This example produces the following results:

1) Input: A Byte array of arbitrary data.

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

2) Convert the input Byte array to a Char array with newlines.
   Output: A Char array (length = 352). The elements of the array are:

         1         2         3         4         5         6         7
1234567890123456789012345678901234567890123456789012345678901234567890123456
----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==

3) Convert the Char array to an output Byte array.
4) The output Byte array is equal to the input Byte array: True

*/
' This example demonstrates the Convert.ToBase64CharArray() and 
'                               Convert.FromBase64CharArray methods
Class Sample
   Public Shared Sub Main()
      Dim byteArray1(255) As Byte
      Dim byteArray2(255) As Byte
      Dim charArray(351) As Char
      Dim charArrayLength As Integer
      Dim nl As String = Environment.NewLine
      
      Dim ruler1a As String = "         1         2         3         4"
      Dim ruler2a As String = "1234567890123456789012345678901234567890"
      Dim ruler3a As String = "----+----+----+----+----+----+----+----+"
      Dim ruler1b As String = "         5         6         7      "
      Dim ruler2b As String = "123456789012345678901234567890123456"
      Dim ruler3b As String = "----+----+----+----+----+----+----+-"
      Dim ruler As String = String.Concat(ruler1a, ruler1b, nl, _
                                          ruler2a, ruler2b, nl, _
                                          ruler3a, ruler3b)

      ' 1) Initialize and display a Byte array of arbitrary data.
      Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl)
      Dim x As Integer
      For x = 0 To byteArray1.Length - 1
         byteArray1(x) = CByte(x)
         Console.Write("{0:X2} ", byteArray1(x))
         If(x + 1) Mod 20 = 0 Then
            Console.WriteLine()
         End If
      Next x
      Console.Write("{0}{0}", nl)
      
      ' 2) Convert the input Byte array to a Char array, with newlines inserted.
      charArrayLength = Convert.ToBase64CharArray( _
                                byteArray1, 0, byteArray1.Length, _
                                charArray, 0, _
                                Base64FormattingOptions.InsertLineBreaks)
      Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.")
      Console.Write("   Output: A Char array (length = {0}). ", charArrayLength)
      Console.WriteLine("The elements of the array are:{0}", nl)
      Console.WriteLine(ruler)
      Console.WriteLine(New [String](charArray))
      Console.WriteLine()
      
      ' 3) Convert the Char array back to a Byte array.
      Console.WriteLine("3) Convert the Char array to an output Byte array.")
      byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength)
      
      ' 4) Are the input and output Byte arrays equivalent?
      Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}", _
                            ArraysAreEqual(byteArray1, byteArray2))
   End Sub 'Main
   
   Public Shared Function ArraysAreEqual(a1() As Byte, a2() As Byte) As Boolean
      If a1.Length <> a2.Length Then
         Return False
      End If
      Dim i As Integer
      For i = 0 To a1.Length - 1
         If a1(i) <> a2(i) Then
            Return False
         End If
      Next i
      Return True
   End Function 'ArraysAreEqual
End Class 'Sample
'
'This example produces the following results:
'
'1) Input: A Byte array of arbitrary data.
'
'00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
'14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
'28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
'3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
'50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
'64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
'78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
'8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
'A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
'B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
'C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
'DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
'F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF
'
'2) Convert the input Byte array to a Char array with newlines.
'   Output: A Char array (length = 352). The elements of the array are:
'
'         1         2         3         4         5         6         7
'1234567890123456789012345678901234567890123456789012345678901234567890123456
'----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
'OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
'cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
'q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
'5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==
'
'3) Convert the Char array to an output Byte array.
'4) The output Byte array is equal to the input Byte array: True

설명

하위 집합 length 의 요소를 inArray 위치에서 시작 하는 매개 변수 offsetIn, 숫자 값으로 간주 됩니다 및 요소의 하위 집합으로 변환 합니다 outArray 위치에서 시작 하는 매개 변수 offsetOut.The subset of length elements of the inArray parameter starting at position offsetIn, are taken as a numeric value and converted to a subset of elements in the outArray parameter starting at position offsetOut. 반환 값에서 변환 된 요소의 수를 나타냅니다 outArray합니다.The return value indicates the number of converted elements in outArray. 하위 집합 outArray base-64 숫자 이루어져 있습니다.The subset of outArray consists of base-64 digits.

Base-64 숫자 0에서 오름차순 "z", 소문자 대문자 "A"는 "z", "9" 숫자 "0"을 "a" 및 기호 "+" 및 "/"입니다.The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". 값이 없는 문자 "=" 후행 안쪽 여백에 사용 됩니다.The valueless character "=" is used for trailing padding.

합니다 offsetlength 매개 변수는 32 비트 부호 있는 숫자입니다.The offset and length parameters are 32-bit signed numbers. 합니다 offsetInoffsetOut 매개 변수는 0부터 시작 하는 배열의 위치입니다.The offsetIn and offsetOut parameters are zero-based array positions.

중요

ToBase64CharArray 메서드는 모든 데이터를 인코딩할 수를 포함 하는 단일 바이트 배열을 처리 하도록 설계 되었습니다.The ToBase64CharArray method is designed to process a single byte array that contains all the data to be encoded. Base-64 문자 배열 바이트 스트림에서 만들려면 사용 합니다 System.Security.Cryptography.ToBase64Transform 클래스입니다.To create a base-64 character array from a byte stream, use the System.Security.Cryptography.ToBase64Transform class.

경우는 options 매개 변수는 설정 InsertLineBreaks 및 변환의 출력은 76 자, 줄 바꿈을 삽입은 76 자 마다.If the options parameter is set to InsertLineBreaks and the output of the conversion is longer than 76 characters, a line break is inserted every 76 characters. 줄 바꿈은 캐리지 리턴 문자 (U+000d) 뒤에 줄 바꿈 문자 (U + 000A)으로 정의 됩니다.A line break is defined as a carriage return character (U+000D) followed by a line feed character (U+000A). 자세한 내용은에서 RFC 2045, "Multipurpose Internet Mail Extensions"를 참조 https://www.rfc-editor.org/ 합니다.For more information, see RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

추가 정보

적용 대상