Convert.ToBase64String Convert.ToBase64String Convert.ToBase64String Convert.ToBase64String Method

정의

8비트 부호 없는 정수로 구성된 배열의 값을 base-64 숫자로 인코딩된 해당하는 문자열 표현으로 변환합니다.Converts the value of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits.

오버로드

ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions) ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions) ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions) ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)

8비트 부호 없는 정수로 구성된 배열의 하위 집합을 base-64 숫자로 인코딩된 해당하는 문자열 표현으로 변환합니다.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. 매개 변수는 하위 집합을 입력 배열의 오프셋으로 지정하고, 배열에서 변환할 요소의 수를 지정하고, 반환 값에 줄 바꿈을 삽입할지를 지정합니다.Parameters specify the subset as an offset in the input array, the number of elements in the array to convert, and whether to insert line breaks in the return value.

ToBase64String(Byte[], Int32, Int32) ToBase64String(Byte[], Int32, Int32) ToBase64String(Byte[], Int32, Int32) ToBase64String(Byte[], Int32, Int32)

8비트 부호 없는 정수로 구성된 배열의 하위 집합을 base-64 숫자로 인코딩된 해당하는 문자열 표현으로 변환합니다.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. 매개 변수는 하위 집합을 입력 배열의 오프셋으로 지정하고 변환할 배열의 요소 수를 지정합니다.Parameters specify the subset as an offset in the input array, and the number of elements in the array to convert.

ToBase64String(Byte[], Base64FormattingOptions) ToBase64String(Byte[], Base64FormattingOptions) ToBase64String(Byte[], Base64FormattingOptions) ToBase64String(Byte[], Base64FormattingOptions)

8비트 부호 없는 정수로 구성된 배열을 base-64 숫자로 인코딩된 해당하는 문자열 표현으로 변환합니다.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. 매개 변수는 반환 값에 줄 바꿈을 삽입할지를 지정합니다.A parameter specifies whether to insert line breaks in the return value.

ToBase64String(Byte[]) ToBase64String(Byte[]) ToBase64String(Byte[]) ToBase64String(Byte[])

8비트 부호 없는 정수로 구성된 배열을 base-64 숫자로 인코딩된 해당하는 문자열 표현으로 변환합니다.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits.

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions) ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions) ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions) ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions) ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions) ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)

8비트 부호 없는 정수로 구성된 배열의 하위 집합을 base-64 숫자로 인코딩된 해당하는 문자열 표현으로 변환합니다.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. 매개 변수는 하위 집합을 입력 배열의 오프셋으로 지정하고, 배열에서 변환할 요소의 수를 지정하고, 반환 값에 줄 바꿈을 삽입할지를 지정합니다.Parameters specify the subset as an offset in the input array, the number of elements in the array to convert, and whether to insert line breaks in the return value.

public:
 static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, int offset, int length, Base64FormattingOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options);
static member ToBase64String : byte[] * int * int * Base64FormattingOptions -> string
Public Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer, options As Base64FormattingOptions) As String

매개 변수

inArray
Byte[]

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

offset
Int32 Int32 Int32 Int32

inArray에 있는 오프셋입니다.An offset in inArray.

length
Int32 Int32 Int32 Int32

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

options
Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions

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

반환

length 위치에서 시작하는 inArrayoffset 요소에 대한 base 64 문자열 표현입니다.The string representation in base 64 of length elements of inArray, starting at position offset.

예외

offset 또는 length가 음수입니다.offset or length is negative.

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

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

예제

다음 예제는 ToBase64String 메서드.The following example demonstrates the ToBase64String 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.ToBase64String() and 
//                               Convert.FromBase64String() methods
using namespace System;
bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 );
int main()
{
   array<Byte>^inArray = gcnew array<Byte>(256);
   array<Byte>^outArray = gcnew array<Byte>(256);
   String^ s2;
   String^ s3;
   String^ step1 = "1) The input is a byte array (inArray) of arbitrary data.";
   String^ step2 = "2) Convert a subarray of the input data array to a base 64 string.";
   String^ step3 = "3) Convert the entire input data array to a base 64 string.";
   String^ step4 = "4) The two methods in steps 2 and 3 produce the same result: {0}";
   String^ step5 = "5) Convert the base 64 string to an output byte array (outArray).";
   String^ step6 = "6) The input and output arrays, inArray and outArray, are equal: {0}";
   int x;
   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, nl );
   
   // 1) Display an arbitrary array of input data (inArray). The data could be 
   //    derived from user input, a file, an algorithm, etc.
   Console::WriteLine( step1 );
   Console::WriteLine();
   for ( x = 0; x < inArray->Length; x++ )
   {
      inArray[ x ] = (Byte)x;
      Console::Write( "{0:X2} ", inArray[ x ] );
      if ( ((x + 1) % 20) == 0 )
            Console::WriteLine();

   }
   Console::Write( "{0}{0}", nl );
   
   // 2) Convert a subarray of the input data to a base64 string. In this case, 
   //    the subarray is the entire input data array. New lines (CRLF) are inserted.
   Console::WriteLine( step2 );
   s2 = Convert::ToBase64String( inArray, 0, inArray->Length, Base64FormattingOptions::InsertLineBreaks );
   Console::WriteLine( "{0}{1}{2}{3}", nl, ruler, s2, nl );
   
   // 3) Convert the input data to a base64 string. In this case, the entire 
   //    input data array is converted by default. New lines (CRLF) are inserted.
   Console::WriteLine( step3 );
   s3 = Convert::ToBase64String( inArray, Base64FormattingOptions::InsertLineBreaks );
   
   // 4) Test whether the methods in steps 2 and 3 produce the same result.
   Console::WriteLine( step4, s2->Equals( s3 ) );
   
   // 5) Convert the base 64 string to an output array (outArray).
   Console::WriteLine( step5 );
   outArray = Convert::FromBase64String( s2 );
   
   // 6) Is outArray equal to inArray?
   Console::WriteLine( step6, ArraysAreEqual( inArray, outArray ) );
}

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) The input is a byte array (inArray) 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 a subarray of the input data array to a base 64 string.

         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 entire input data array to a base 64 string.
4) The two methods in steps 2 and 3 produce the same result: True
5) Convert the base 64 string to an output byte array (outArray).
6) The input and output arrays, inArray and outArray, are equal: True

*/
// This example demonstrates the Convert.ToBase64String() and 
//                               Convert.FromBase64String() methods

using System;
class Sample 
{
    public static void Main() 
    {
    byte[] inArray  = new byte[256];
    byte[] outArray = new byte[256];
    string s2;
    string s3;
    string step1 = "1) The input is a byte array (inArray) of arbitrary data.";
    string step2 = "2) Convert a subarray of the input data array to a base 64 string.";
    string step3 = "3) Convert the entire input data array to a base 64 string.";
    string step4 = "4) The two methods in steps 2 and 3 produce the same result: {0}";
    string step5 = "5) Convert the base 64 string to an output byte array (outArray).";
    string step6 = "6) The input and output arrays, inArray and outArray, are equal: {0}";
    int x;
    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, nl);

// 1) Display an arbitrary array of input data (inArray). The data could be 
//    derived from user input, a file, an algorithm, etc.

    Console.WriteLine(step1);
    Console.WriteLine();
    for (x = 0; x < inArray.Length; x++)
        {
        inArray[x] = (byte)x;
        Console.Write("{0:X2} ", inArray[x]);
        if (((x+1)%20) == 0) Console.WriteLine();
        }
    Console.Write("{0}{0}", nl);

// 2) Convert a subarray of the input data to a base64 string. In this case, 
//    the subarray is the entire input data array. New lines (CRLF) are inserted.

    Console.WriteLine(step2);
    s2 = Convert.ToBase64String(inArray, 0, inArray.Length, 
                                Base64FormattingOptions.InsertLineBreaks);
    Console.WriteLine("{0}{1}{2}{3}", nl, ruler, s2, nl);

// 3) Convert the input data to a base64 string. In this case, the entire 
//    input data array is converted by default. New lines (CRLF) are inserted.

    Console.WriteLine(step3);
    s3 = Convert.ToBase64String(inArray, Base64FormattingOptions.InsertLineBreaks);

// 4) Test whether the methods in steps 2 and 3 produce the same result.
    Console.WriteLine(step4, s2.Equals(s3));

// 5) Convert the base 64 string to an output array (outArray).
    Console.WriteLine(step5);
    outArray = Convert.FromBase64String(s2);

// 6) Is outArray equal to inArray?
   Console.WriteLine(step6, ArraysAreEqual(inArray, outArray));
   }

    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) The input is a byte array (inArray) 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 a subarray of the input data array to a base 64 string.

         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 entire input data array to a base 64 string.
4) The two methods in steps 2 and 3 produce the same result: True
5) Convert the base 64 string to an output byte array (outArray).
6) The input and output arrays, inArray and outArray, are equal: True

*/
' This example demonstrates the Convert.ToBase64String() and 
'                               Convert.FromBase64String() methods
Class Sample
   Public Shared Sub Main()
      Dim inArray(255)  As Byte
      Dim outArray(255) As Byte
      Dim s2 As String
      Dim s3 As String
      Dim step1 As String = "1) The input is a byte array (inArray) of arbitrary data."
      Dim step2 As String = "2) Convert a subarray of the input data array to a base 64 string."
      Dim step3 As String = "3) Convert the entire input data array to a base 64 string."
      Dim step4 As String = "4) The two methods in steps 2 and 3 produce the same result: {0}"
      Dim step5 As String = "5) Convert the base 64 string to an output byte array (outArray)."
      Dim step6 As String = "6) The input and output arrays, inArray and outArray, are equal: {0}"
      Dim x 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, nl)
      
      ' 1) Display an arbitrary array of input data (inArray). The data could be 
      '    derived from user input, a file, an algorithm, etc.
      Console.WriteLine(step1)
      Console.WriteLine()
      For x = 0 To inArray.Length - 1
         inArray(x) = CByte(x)
         Console.Write("{0:X2} ", inArray(x))
         If (x + 1) Mod 20 = 0 Then
            Console.WriteLine()
         End If
      Next x
      Console.Write("{0}{0}", nl)
      
      ' 2) Convert a subarray of the input data to a base64 string. In this case, 
      '    the subarray is the entire input data array. New lines (CRLF) are inserted.
      Console.WriteLine(step2)
      s2 = Convert.ToBase64String(inArray, 0, inArray.Length, _
                                  Base64FormattingOptions.InsertLineBreaks)
      Console.WriteLine("{0}{1}{2}{3}", nl, ruler, s2, nl)
      
      ' 3) Convert the input data to a base64 string. In this case, the entire 
      '    input data array is converted by default. New lines (CRLF) are inserted.
      Console.WriteLine(step3)
      s3 = Convert.ToBase64String(inArray, Base64FormattingOptions.InsertLineBreaks)
      
      ' 4) Test whether the methods in steps 2 and 3 produce the same result.
      Console.WriteLine(step4, s2.Equals(s3))
      
      ' 5) Convert the base 64 string to an output array (outArray).
      Console.WriteLine(step5)
      outArray = Convert.FromBase64String(s2)
      
      ' 6) Is outArray equal to inArray?
      Console.WriteLine(step6, ArraysAreEqual(inArray, outArray))
   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) The input is a byte array (inArray) 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 a subarray of the input data array to a base 64 string.
'
'         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 entire input data array to a base 64 string.
'4) The two methods in steps 2 and 3 produce the same result: True
'5) Convert the base 64 string to an output byte array (outArray).
'6) The input and output arrays, inArray and outArray, are equal: True
'

설명

요소는 inArray 매개 변수는 숫자 값으로 간주 되며 base 64에서 문자열 표현으로 변환 합니다.The elements of the inArray parameter are taken as a numeric value and converted to a string representation in base 64.

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. offset 매개 변수는 0부터 시작 합니다.The offset parameter is zero-based.

중요

ToBase64String 메서드는 모든 데이터를 인코딩할 수를 포함 하는 단일 바이트 배열을 처리 하도록 설계 되었습니다.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. 스트림에서 데이터를 인코딩하려면는 System.Security.Cryptography.ToBase64Transform 클래스입니다.To encode data from a 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/.

추가 정보

ToBase64String(Byte[], Int32, Int32) ToBase64String(Byte[], Int32, Int32) ToBase64String(Byte[], Int32, Int32) ToBase64String(Byte[], Int32, Int32)

8비트 부호 없는 정수로 구성된 배열의 하위 집합을 base-64 숫자로 인코딩된 해당하는 문자열 표현으로 변환합니다.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. 매개 변수는 하위 집합을 입력 배열의 오프셋으로 지정하고 변환할 배열의 요소 수를 지정합니다.Parameters specify the subset as an offset in the input array, and the number of elements in the array to convert.

public:
 static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, int offset, int length);
public static string ToBase64String (byte[] inArray, int offset, int length);
static member ToBase64String : byte[] * int * int -> string
Public Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer) As String

매개 변수

inArray
Byte[]

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

offset
Int32 Int32 Int32 Int32

inArray에 있는 오프셋입니다.An offset in inArray.

length
Int32 Int32 Int32 Int32

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

반환

length 위치에서 시작하는 inArrayoffset 요소에 대한 base 64 문자열 표현입니다.The string representation in base 64 of length elements of inArray, starting at position offset.

예외

offset 또는 length가 음수입니다.offset or length is negative.

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

설명

요소의 inArray 숫자 값으로 가져오고 base 64에서 문자열 표현으로 변환 합니다.The elements of inArray are taken as a numeric value and converted to a string representation in base 64.

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. offset 매개 변수는 0부터 시작 합니다.The offset parameter is zero-based.

중요

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

추가 정보

ToBase64String(Byte[], Base64FormattingOptions) ToBase64String(Byte[], Base64FormattingOptions) ToBase64String(Byte[], Base64FormattingOptions) ToBase64String(Byte[], Base64FormattingOptions)

8비트 부호 없는 정수로 구성된 배열을 base-64 숫자로 인코딩된 해당하는 문자열 표현으로 변환합니다.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. 매개 변수는 반환 값에 줄 바꿈을 삽입할지를 지정합니다.A parameter specifies whether to insert line breaks in the return value.

public:
 static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray, Base64FormattingOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);
static member ToBase64String : byte[] * Base64FormattingOptions -> string
Public Shared Function ToBase64String (inArray As Byte(), options As Base64FormattingOptions) As String

매개 변수

inArray
Byte[]

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

options
Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions

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

반환

inArray의 요소에 대한 base 64 숫자의 문자열 표현입니다.The string representation in base 64 of the elements in inArray.

예외

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

예제

다음 예제에서는 합니다 Convert.ToBase64String(Byte[], Base64FormattingOptions) 사용 하 여를 Base64FormattingOptions.InsertLineBreaks 100 요소 바이트 배열을 인코딩하여 생성 되는 문자열의 줄을 삽입 하려면 인수를 중단 합니다.The following example calls the Convert.ToBase64String(Byte[], Base64FormattingOptions) with a Base64FormattingOptions.InsertLineBreaks argument to insert line breaks in the string that is produced by encoding a 100-element byte array.

using System;

public class Example
{
   public static void Main()
   {
       // Define a byte array.
       Byte[] bytes = new Byte[100];
       int originalTotal = 0;
       for (int ctr = 0; ctr <= bytes.GetUpperBound(0); ctr++) {
          bytes[ctr] = (byte)(ctr + 1);
          originalTotal += bytes[ctr];
       }
       // Display summary information about the array.
       Console.WriteLine("The original byte array:");
       Console.WriteLine("   Total elements: {0}", bytes.Length);
       Console.WriteLine("   Length of String Representation: {0}",
                         BitConverter.ToString(bytes).Length);
       Console.WriteLine("   Sum of elements: {0:N0}", originalTotal);                  
       Console.WriteLine();
       
       // Convert the array to a base 64 sring.
       String s = Convert.ToBase64String(bytes, 
                                         Base64FormattingOptions.InsertLineBreaks);
       Console.WriteLine("The base 64 string:\n   {0}\n", s);
       
       // Restore the byte array.
       Byte[] newBytes = Convert.FromBase64String(s);
       int newTotal = 0;
       foreach (var newByte in newBytes)
          newTotal += newByte;

       // Display summary information about the restored array.
       Console.WriteLine("   Total elements: {0}", newBytes.Length);
       Console.WriteLine("   Length of String Representation: {0}",
                         BitConverter.ToString(newBytes).Length);
       Console.WriteLine("   Sum of elements: {0:N0}", newTotal);                  
   }
}
// The example displays the following output:
//   The original byte array:
//      Total elements: 100
//      Length of String Representation: 299
//      Sum of elements: 5,050
//   
//   The base 64 string:
//      AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5
//   Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZA==
//   
//      Total elements: 100
//      Length of String Representation: 299
//      Sum of elements: 5,050
Module Example
   Public Sub Main()
       ' Define a byte array.
       Dim bytes(99) As Byte
       Dim originalTotal As Integer = 0
       For ctr As Integer = 0 To bytes.GetUpperBound(0)
          bytes(ctr) = CByte(ctr + 1)
          originalTotal += bytes(ctr)
       Next
       ' Display summary information about the array.
       Console.WriteLine("The original byte array:")
       Console.WriteLine("   Total elements: {0}", bytes.Length)
       Console.WriteLine("   Length of String Representation: {0}",
                         BitConverter.ToString(bytes).Length)
       Console.WriteLine("   Sum of elements: {0:N0}", originalTotal)                  
       Console.WriteLine()
       
       ' Convert the array to a base 64 sring.
       Dim s As String = Convert.ToBase64String(bytes, 
                                               Base64FormattingOptions.InsertLineBreaks)
       Console.WriteLine("The base 64 string:{1}   {0}{1}", 
                         s, vbCrLf)
       
       ' Restore the byte array.
       Dim newBytes() As Byte = Convert.FromBase64String(s)
       Dim newTotal As Integer = 0
       For Each newByte In newBytes
          newTotal += newByte
       Next
       ' Display summary information about the restored array.
       Console.WriteLine("   Total elements: {0}", newBytes.Length)
       Console.WriteLine("   Length of String Representation: {0}",
                         BitConverter.ToString(newBytes).Length)
       Console.WriteLine("   Sum of elements: {0:N0}", newTotal)                  
   End Sub
End Module
' The example displays the following output:
'   The original byte array:
'      Total elements: 100
'      Length of String Representation: 299
'      Sum of elements: 5,050
'   
'   The base 64 string:
'      AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5
'   Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZA==
'   
'      Total elements: 100
'      Length of String Representation: 299
'      Sum of elements: 5,050

예제에서 출력으로는 Convert.FromBase64String 원래 바이트 배열을; 복원에 성공 하면 줄 바꿈 문자로 변환 하는 동안 무시 됩니다.As the output from the example shows, the Convert.FromBase64String succeeds in restoring the original byte array; the line break characters are ignored during the conversion.

설명

요소는 inArray 매개 변수는 숫자 값으로 간주 되며 base 64에서 문자열 표현으로 변환 합니다.The elements of the inArray parameter are taken as a numeric value and converted to a string representation in base 64.

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.

중요

ToBase64String 메서드는 모든 데이터를 인코딩할 수를 포함 하는 단일 바이트 배열을 처리 하도록 설계 되었습니다.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. 스트림에서 데이터를 인코딩하려면는 System.Security.Cryptography.ToBase64Transform 클래스입니다.To encode data from a 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). 줄 바꿈에는 공백 문자는 base-64 인코딩 것으로 간주 되므로로 인코딩된 바이트 배열에 다시 문자열을 base-64로 변환 하는 경우 무시 됩니다.Because line breaks are considered white-space characters in a base-64 encoding, they are ignored when converting a base-64 encoded string back to a byte array. 줄 바꿈은 단순히 편리한 경우가 컨트롤 또는 콘솔 창과 같은 장치에 인코딩된 문자열을 표시 합니다.The line breaks are simply convenient when displaying the encoded string to a control or a device such as a console window. 자세한 내용은에서 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/.

추가 정보

ToBase64String(Byte[]) ToBase64String(Byte[]) ToBase64String(Byte[]) ToBase64String(Byte[])

8비트 부호 없는 정수로 구성된 배열을 base-64 숫자로 인코딩된 해당하는 문자열 표현으로 변환합니다.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits.

public:
 static System::String ^ ToBase64String(cli::array <System::Byte> ^ inArray);
public static string ToBase64String (byte[] inArray);
static member ToBase64String : byte[] -> string
Public Shared Function ToBase64String (inArray As Byte()) As String

매개 변수

inArray
Byte[]

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

반환

inArray의 내용에 대한 base 64 숫자의 문자열 표현입니다.The string representation, in base 64, of the contents of inArray.

예외

예제

다음 예제에서는 합니다 ToBase64String(Byte[]) (base-64) Uuencode 된 문자열을 설정한 다음 호출을 바이트 배열로 변환 하는 방법의 FromBase64String(String) 원래 바이트 배열을 복원 하는 방법입니다.The following example uses the ToBase64String(Byte[]) method to convert a byte array to a UUencoded (base-64) string, and then calls the FromBase64String(String) method to restore the original byte array.

using System;

public class Example
{
   public static void Main()
   {
       // Define a byte array.
       byte[] bytes = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
       Console.WriteLine("The byte array: ");
       Console.WriteLine("   {0}\n", BitConverter.ToString(bytes));
       
       // Convert the array to a base 64 sring.
       String s = Convert.ToBase64String(bytes);
       Console.WriteLine("The base 64 string:\n   {0}\n", s);
       
       // Restore the byte array.
       byte[] newBytes = Convert.FromBase64String(s);
       Console.WriteLine("The restored byte array: ");
       Console.WriteLine("   {0}\n", BitConverter.ToString(newBytes));
   }
}
// The example displays the following output:
//     The byte array:
//        02-04-06-08-0A-0C-0E-10-12-14
//     
//     The base 64 string:
//        AgQGCAoMDhASFA==
//     
//     The restored byte array:
//        02-04-06-08-0A-0C-0E-10-12-14
Module Example
   Public Sub Main()
       ' Define a byte array.
       Dim bytes() As Byte = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }
       Console.WriteLine("The byte array: ")
       Console.WriteLine("   {0}", BitConverter.ToString(bytes))
       Console.WriteLine()
       
       ' Convert the array to a base 64 sring.
       Dim s As String = Convert.ToBase64String(bytes)
       Console.WriteLine("The base 64 string:{1}   {0}{1}", 
                         s, vbCrLf)
       
       ' Restore the byte array.
       Dim newBytes() As Byte = Convert.FromBase64String(s)
       Console.WriteLine("The restored byte array: ")
       Console.WriteLine("   {0}", BitConverter.ToString(newBytes))
       Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'     The byte array:
'        02-04-06-08-0A-0C-0E-10-12-14
'     
'     The base 64 string:
'        AgQGCAoMDhASFA==
'     
'     The restored byte array:
'        02-04-06-08-0A-0C-0E-10-12-14

다음은 복잡 한 예는 32 비트 정수의 20 개의 요소 배열을 만듭니다.The following is a more complex example that creates a 20-element array of 32-bit integers. 사용 하 여는 BitConverter.GetBytes(Int32) 메서드를 호출 하 여 버퍼에서 적절 한 위치에 저장 되는 바이트 배열, 각 요소를 변환 하는 Array.Copy(Array, Int32, Array, Int32, Int32) 메서드.It then uses the BitConverter.GetBytes(Int32) method to convert each element into a byte array, which it stores in the appropriate position in a buffer by calling the Array.Copy(Array, Int32, Array, Int32, Int32) method. 이 버퍼에 전달 되는 ToBase64String(Byte[]) (base-64) Uuencode 된 문자열을 만드는 방법.This buffer is then passed to the ToBase64String(Byte[]) method to create a UUencoded (base-64) string. 그런 다음 호출 하는 FromBase64String(String) 호출와 UUencoded 문자열을 디코드 하는 방법의 BitConverter.ToInt32 각 집합이 4 바이트 (32 비트 정수 크기)을 정수로 변환 하는 방법.It then calls the FromBase64String(String) method to decode the UUencoded string, and calls the BitConverter.ToInt32 method to convert each set of four bytes (the size of a 32-bit integer) to an integer. 예제의 출력에 원본 배열을 성공적으로 복원 된 보여 줍니다.The output from the example shows that the original array has been successfully restored.

using System;

public class Example
{
   public static void Main()
   {
      // Define an array of 20 elements and display it.
      int[] arr = new int[20]; 
      int value = 1;
      for (int ctr = 0; ctr <= arr.GetUpperBound(0); ctr++) {
         arr[ctr] = value;
         value = value * 2 + 1;
      }
      DisplayArray(arr);

      // Convert the array of integers to a byte array.
      byte[] bytes = new byte[arr.Length * 4];
      for (int ctr = 0; ctr < arr.Length; ctr++) {
         Array.Copy(BitConverter.GetBytes(arr[ctr]), 0, 
                    bytes, ctr * 4, 4);
      }
         
      // Encode the byte array using Base64 encoding
      String base64 = Convert.ToBase64String(bytes);
      Console.WriteLine("The encoded string: ");
      for (int ctr = 0; ctr <= base64.Length / 50; ctr++) 
         Console.WriteLine(base64.Substring(ctr * 50, 
                                            ctr * 50 + 50 <= base64.Length 
                                               ? 50 : base64.Length - ctr * 50));
      Console.WriteLine();
      
      // Convert the string back to a byte array.
      byte[] newBytes = Convert.FromBase64String(base64);

      // Convert the byte array back to an integer array.
      int[] newArr = new int[newBytes.Length/4];
      for (int ctr = 0; ctr < newBytes.Length / 4; ctr ++)
         newArr[ctr] = BitConverter.ToInt32(newBytes, ctr * 4);
         
      DisplayArray(newArr);
   }

   private static void DisplayArray(Array arr)
   {
      Console.WriteLine("The array:");
      Console.Write("{ ");
      for (int ctr = 0; ctr < arr.GetUpperBound(0); ctr++) {
         Console.Write("{0}, ", arr.GetValue(ctr));
         if ((ctr + 1) % 10 == 0) 
            Console.Write("\n  ");
      }
      Console.WriteLine("{0} {1}", arr.GetValue(arr.GetUpperBound(0)), "}");
      Console.WriteLine();
   }
}
// The example displays the following output:
// The array:
// { 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023,
//   2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575 }
// 
// The encoded string:
// AQAAAAMAAAAHAAAADwAAAB8AAAA/AAAAfwAAAP8AAAD/AQAA/w
// MAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8H
// 
// The array:
// { 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023,
//   2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575 }
Module Example
   Public Sub Main()
      ' Define an array of 20 elements and display it.
      Dim arr(19) As Integer 
      Dim value As Integer = 1
      For ctr As Integer = 0 To arr.GetUpperBound(0)
         arr(ctr) = value
         value = value * 2 + 1
      Next
      DisplayArray(arr)

      ' Convert the array of integers to a byte array.
      Dim bytes(arr.Length * 4 - 1) As Byte 
      For ctr As Integer = 0 To arr.Length - 1
         Array.Copy(BitConverter.GetBytes(arr(ctr)), 0, 
                    bytes, ctr * 4, 4)
      Next
         
      ' Encode the byte array using Base64 encoding
      Dim base64 As String = Convert.ToBase64String(bytes)
      Console.WriteLine("The encoded string: ")
      For ctr As Integer = 0 To base64.Length \ 50 - 1 
         Console.WriteLine(base64.Substring(ctr * 50, 
                                            If(ctr * 50 + 50 <= base64.Length, 
                                               50, base64.Length - ctr * 50)))
      Next
      Console.WriteLine()
      
      ' Convert the string back to a byte array.
      Dim newBytes() As Byte = Convert.FromBase64String(base64)

      ' Convert the byte array back to an integer array.
      Dim newArr(newBytes.Length\4 - 1) As Integer
      For ctr As Integer = 0 To newBytes.Length \ 4 - 1
         newArr(ctr) = BitConverter.ToInt32(newBytes, ctr * 4)
      Next   
      DisplayArray(newArr)
   End Sub

   Private Sub DisplayArray(arr As Array)
      Console.WriteLine("The array:")
      Console.Write("{ ")
      For ctr As Integer = 0 To arr.GetUpperBound(0) - 1
         Console.Write("{0}, ", arr.GetValue(ctr))
         If (ctr + 1) Mod 10 = 0 Then Console.Write("{0}  ", vbCrLf)
      Next
      Console.WriteLine("{0} {1}", arr.GetValue(arr.GetUpperBound(0)), "}")
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'     The array:
'     { 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023,
'       2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575 }
'     
'     The encoded string:
'     AQAAAAMAAAAHAAAADwAAAB8AAAA/AAAAfwAAAP8AAAD/AQAA/w
'     MAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8H
'     
'     The array:
'     { 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023,
'       2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575 }

설명

요소의 inArray 숫자 값으로 가져오고 base-64 숫자로 인코딩된 문자열 표현으로 변환 합니다.The elements of inArray are taken as a numeric value and converted to a string representation that is encoded with 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.

중요

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

일반적으로 ToBase64String 메서드가 아닌 UUEncoded (base-64로 인코딩된)를 왕복 하는 데 사용 문자열입니다.Ordinarily, the ToBase64String method is not used to round-trip a UUEncoded (base-64 encoded) string. 즉, 호출 하 여 문자열을 디코드 하는 경우는 FromBase64String 메서드를 호출 하 여 반환된 된 바이트 배열 인코드는 ToBase64String 메서드를 결과 문자열은 반드시 동일 하지 원래 문자열입니다.That is, if you decode a string by calling the FromBase64String method, then encode the returned byte array by calling the ToBase64String method, the resulting string will not necessarily be identical to the original string. 문자열은 원래 문자열은 올바른 base-64로 인코딩된 문자열을 하는 경우에 왕복이 됩니다.The string will round-trip only if the original string is a valid base-64 encoded string.

추가 정보

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions) ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions) ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

public static string ToBase64String (ReadOnlySpan<byte> bytes, Base64FormattingOptions options = System.Base64FormattingOptions.None);
static member ToBase64String : ReadOnlySpan<byte> * Base64FormattingOptions -> string
Public Shared Function ToBase64String (bytes As ReadOnlySpan(Of Byte), Optional options As Base64FormattingOptions = System.Base64FormattingOptions.None) As String

매개 변수

반환

적용 대상