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

Definice

Převede hodnotu pole 8bitové celé číslo bez znaménka na odpovídající řetězcovou reprezentaci, která je kódována pomocí číslic 64.Converts the value of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits.

Přetížení

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

Převede podmnožinu pole 8bitových celých čísel bez znaménka na odpovídající řetězcovou reprezentaci, která je kódována pomocí číslic 64.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parametry určují podmnožinu jako posun ve vstupním poli, počet prvků v poli, které se mají převést, a zda mají být do návratové hodnoty vloženy zalomení řádků.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)

Převede podmnožinu pole 8bitových celých čísel bez znaménka na odpovídající řetězcovou reprezentaci, která je kódována pomocí číslic 64.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parametry určují podmnožinu jako posun ve vstupním poli a počet prvků v poli, které chcete převést.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)

Převede pole 8bitových celých čísel bez znaménka na odpovídající řetězcovou reprezentaci, která je zakódována s použitím číslic-Base-64.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parametr určuje, zda mají být do návratové hodnoty vloženy zalomení řádků.A parameter specifies whether to insert line breaks in the return value.

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

Převede pole 8bitových celých čísel bez znaménka na odpovídající řetězcovou reprezentaci, která je zakódována s použitím číslic-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)

Převede podmnožinu pole 8bitových celých čísel bez znaménka na odpovídající řetězcovou reprezentaci, která je kódována pomocí číslic 64.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parametry určují podmnožinu jako posun ve vstupním poli, počet prvků v poli, které se mají převést, a zda mají být do návratové hodnoty vloženy zalomení řádků.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

Parametry

inArray
Byte[]

Pole 8bitových celých čísel bez znaménka.An array of 8-bit unsigned integers.

offset
Int32 Int32 Int32 Int32

Posun v inArray.An offset in inArray.

length
Int32 Int32 Int32 Int32

Počet prvků inArray , které mají být převedeny.The number of elements of inArray to convert.

options
Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions

InsertLineBreakspro vložení konce řádku každé 76 znaků nebo None pro vložení konců řádků.InsertLineBreaks to insert a line break every 76 characters, or None to not insert line breaks.

Návraty

Řetězcové vyjádření v základní 64 length prvky z inArray, počínaje pozicí offset.The string representation in base 64 of length elements of inArray, starting at position offset.

Výjimky

offsetnebo length je negativní.offset or length is negative.

-nebo--or- offsetznaménko plus length je větší než inArraydélka.offset plus length is greater than the length of inArray.

Příklady

Následující příklad ukazuje ToBase64String metodu.The following example demonstrates the ToBase64String method. Vstup je rozdělen na skupiny po třech bajtech (24 bitů).The input is divided into groups of three bytes (24 bits) each. Proto se každá skupina skládá ze čtyř 6bitových čísel, kde má každé číslo rozsah desítkového čísla 0 až 63.Consequently, each group consists of four 6-bit numbers where each number ranges from decimal 0 to 63. V tomto příkladu je 85 3bajtových skupin s 1 přebývajícím bajtem.In this example, there are 85 3-byte groups with one byte remaining. První skupina se skládá z šestnáctkových hodnot 00, 01 a 02, které získávají čtyři 6bitové hodnoty rovné desítkovým hodnotám 0, 0, 4 a 2.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. Tyto čtyři hodnoty 64 odpovídají číslicím "A", "A", "E" a "C" na začátku výstupu.Those four values correspond to the base-64 digits "A", "A", "E", and "C" at the beginning of the output.

Pokud neexistuje celočíselný počet 3bajtových skupin, zbývající bajty jsou účinně doplněny nulami, aby vytvořily úplnou skupinu.If an integral number of 3-byte groups does not exist, the remaining bytes are effectively padded with zeros to form a complete group. V tomto příkladu je hodnota posledního bajtu šestnáctkové FF.In this example, the value of the last byte is hexadecimal FF. Prvních šest bitů se rovná desítkovému číslu 63, které odpovídá číslici "/" v kódování base-64 na konci výstupu, a další dva bity jsou doplněny nulami na desítkové číslo 48, které v kódování base-64 odpovídá číslici "w".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". Poslední dvě 6bitové hodnoty odsazují a odpovídají znaku odsazení bez hodnoty "=".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
   
   
   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
'
'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
'

Poznámky

Prvky inArray parametru jsou pořízeny jako číselná hodnota a převedené na řetězcovou reprezentaci v základní 64.The elements of the inArray parameter are taken as a numeric value and converted to a string representation in base 64.

Číslice kódování base-64 ve vzestupném pořadí od nuly jsou velká písmena od "A" do "Z", malá písmena od "a" do "z", číslice "0" až "9" a symboly "+" 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 "/". Pro koncové odsazení se používá znak s hodnotou "=".The valueless character "=" is used for trailing padding.

Parametry offset alength jsou 32 číslice se znaménkem.The offset and length parameters are 32-bit signed numbers. offset Parametr je založený na nule.The offset parameter is zero-based.

Důležité

ToBase64String Metoda je navržena pro zpracování jednoho bajtového pole, které obsahuje všechna data, která mají být kódována.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. Chcete-li zakódovat data z datového proudu System.Security.Cryptography.ToBase64Transform , použijte třídu.To encode data from a stream, use the System.Security.Cryptography.ToBase64Transform class.

InsertLineBreaks Pokud je options parametr nastaven na hodnotu a výstup převodu je delší než 76 znaků, zalomení řádku je vloženo každých 76 znaků.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. Zalomení řádku je definováno jako návratový znak na řádku (U + 000D) následovaný znakem kanálu čáry (U + 000A).A line break is defined as a carriage return character (U+000D) followed by a line feed character (U+000A). Další informace najdete v dokumentu RFC 2045, "Multipurpose Internet Mail Extensions", https://www.rfc-editor.org/na adrese.For more information, see RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

Viz také

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

Převede podmnožinu pole 8bitových celých čísel bez znaménka na odpovídající řetězcovou reprezentaci, která je kódována pomocí číslic 64.Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parametry určují podmnožinu jako posun ve vstupním poli a počet prvků v poli, které chcete převést.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

Parametry

inArray
Byte[]

Pole 8bitových celých čísel bez znaménka.An array of 8-bit unsigned integers.

offset
Int32 Int32 Int32 Int32

Posun v inArray.An offset in inArray.

length
Int32 Int32 Int32 Int32

Počet prvků inArray , které mají být převedeny.The number of elements of inArray to convert.

Návraty

Řetězcové vyjádření v základní 64 length prvky z inArray, počínaje pozicí offset.The string representation in base 64 of length elements of inArray, starting at position offset.

Výjimky

offsetnebo length je negativní.offset or length is negative.

-nebo--or- offsetznaménko plus length je větší než inArraydélka.offset plus length is greater than the length of inArray.

Poznámky

Prvky třídy inArray jsou považovány za číselnou hodnotu a převedené na řetězcovou reprezentaci v základní 64.The elements of inArray are taken as a numeric value and converted to a string representation in base 64.

Číslice kódování base-64 ve vzestupném pořadí od nuly jsou velká písmena od "A" do "Z", malá písmena od "a" do "z", číslice "0" až "9" a symboly "+" 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 "/". Znak "=" bez hodnoty se používá pro koncové odsazení.The valueless character, "=", is used for trailing padding.

Parametry offset alength jsou 32 číslice se znaménkem.The offset and length parameters are 32-bit signed numbers. offset Parametr je založený na nule.The offset parameter is zero-based.

Důležité

ToBase64String Metoda je navržena pro zpracování jednoho bajtového pole, které obsahuje všechna data, která mají být kódována.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. Chcete-li zakódovat data z datového proudu System.Security.Cryptography.ToBase64Transform , použijte třídu.To encode data from a stream, use the System.Security.Cryptography.ToBase64Transform class.

Viz také

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

Převede pole 8bitových celých čísel bez znaménka na odpovídající řetězcovou reprezentaci, která je zakódována s použitím číslic-Base-64.Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parametr určuje, zda mají být do návratové hodnoty vloženy zalomení řádků.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

Parametry

inArray
Byte[]

Pole 8bitových celých čísel bez znaménka.An array of 8-bit unsigned integers.

options
Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions Base64FormattingOptions

InsertLineBreakspro vložení konce řádku každé 76 znaků nebo None pro vložení konců řádků.InsertLineBreaks to insert a line break every 76 characters, or None to not insert line breaks.

Návraty

Řetězcové vyjádření v základní 64 prvků v inArray.The string representation in base 64 of the elements in inArray.

Výjimky

Příklady

Následující příklad volá Convert.ToBase64String(Byte[], Base64FormattingOptions) Base64FormattingOptions.InsertLineBreaks s argumentem pro vložení konců řádků v řetězci, který je vytvořen pomocí kódování bajtového pole 100-elementu.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.
       var 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 string.
       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 string.
       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

Jak výstup z příkladu ukazuje, Convert.FromBase64String úspěšné obnovení původního bajtového pole; znaky zalomení řádku se během převodu ignorují.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.

Poznámky

Prvky inArray parametru jsou pořízeny jako číselná hodnota a převedené na řetězcovou reprezentaci v základní 64.The elements of the inArray parameter are taken as a numeric value and converted to a string representation in base 64.

Číslice kódování base-64 ve vzestupném pořadí od nuly jsou velká písmena od "A" do "Z", malá písmena od "a" do "z", číslice "0" až "9" a symboly "+" 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 "/". Pro koncové odsazení se používá znak s hodnotou "=".The valueless character "=" is used for trailing padding.

Důležité

ToBase64String Metoda je navržena pro zpracování jednoho bajtového pole, které obsahuje všechna data, která mají být kódována.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. Chcete-li zakódovat data z datového proudu System.Security.Cryptography.ToBase64Transform , použijte třídu.To encode data from a stream, use the System.Security.Cryptography.ToBase64Transform class.

InsertLineBreaks Pokud je options parametr nastaven na hodnotu a výstup převodu je delší než 76 znaků, zalomení řádku je vloženo každých 76 znaků.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. Zalomení řádku je definováno jako návratový znak na řádku (U + 000D) následovaný znakem kanálu čáry (U + 000A).A line break is defined as a carriage return character (U+000D) followed by a line feed character (U+000A). Vzhledem k tomu, že se konce řádků považují za prázdné místo v kódování Base-64, jsou ignorovány při převodu řetězce kódovaného pomocí základního 64 zpět na pole bajtů.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. Konce řádků jsou jednoduše praktické při zobrazení kódovaného řetězce v ovládacím prvku nebo zařízení, jako je okno konzoly.The line breaks are simply convenient when displaying the encoded string to a control or a device such as a console window. Další informace najdete v dokumentu RFC 2045, "Multipurpose Internet Mail Extensions", https://www.rfc-editor.org/na adrese.For more information, see RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

Viz také

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

Převede pole 8bitových celých čísel bez znaménka na odpovídající řetězcovou reprezentaci, která je zakódována s použitím číslic-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

Parametry

inArray
Byte[]

Pole 8bitových celých čísel bez znaménka.An array of 8-bit unsigned integers.

Návraty

Řetězcové vyjádření v základní 64 obsahu inArray.The string representation, in base 64, of the contents of inArray.

Výjimky

Příklady

Následující příklad používá ToBase64String(Byte[]) metodu pro převod pole bajtů na řetězec uuencode (Base-64) a poté FromBase64String(String) volá metodu pro obnovení původního bajtového pole.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 string.
       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 string.
       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

Následuje složitější příklad, který vytvoří pole 20 bitů s 32 čísly.The following is a more complex example that creates a 20-element array of 32-bit integers. Potom používá BitConverter.GetBytes(Int32) metodu pro převod každého prvku na bajtové pole, které je uloženo v příslušné pozici ve vyrovnávací paměti Array.Copy(Array, Int32, Array, Int32, Int32) voláním metody.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. Tato vyrovnávací paměť je pak předána ToBase64String(Byte[]) metodě pro vytvoření řetězce uuencode (Base-64).This buffer is then passed to the ToBase64String(Byte[]) method to create a UUencoded (base-64) string. Poté volá FromBase64String(String) metodu pro dekódování řetězce uuencode a BitConverter.ToInt32 volá metodu pro převod každé sady čtyř bajtů (velikost 32ého celého čísla) na celé číslo.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. Výstup z příkladu ukazuje, že původní pole bylo úspěšně obnoveno.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 }

Poznámky

Prvky třídy inArray jsou pořízeny jako číselná hodnota a převedené na řetězcovou reprezentaci, která je kódována pomocí číslic-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.

Číslice kódování base-64 ve vzestupném pořadí od nuly jsou velká písmena od "A" do "Z", malá písmena od "a" do "z", číslice "0" až "9" a symboly "+" 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 "/". Znak "=" bez hodnoty se používá pro koncové odsazení.The valueless character, "=", is used for trailing padding.

Důležité

ToBase64String Metoda je navržena pro zpracování jednoho bajtového pole, které obsahuje všechna data, která mají být kódována.The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. Chcete-li zakódovat data z datového proudu System.Security.Cryptography.ToBase64Transform , použijte třídu.To encode data from a stream, use the System.Security.Cryptography.ToBase64Transform class.

ToBase64String Metoda se běžně nepoužívá k přenosu řetězce uuencode (s kódováním Base-64).Ordinarily, the ToBase64String method is not used to round-trip a UUEncoded (base-64 encoded) string. To znamená, že pokud řetězec dekódujete voláním FromBase64String metody, ToBase64String výsledný řetězec nebude nutně totožný s původním řetězcem.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. Řetězec se přeloží pouze v případě, že je původní řetězec platným řetězcem zakódovaným v základní 64.The string will round-trip only if the original string is a valid base-64 encoded string.

Viz také

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

Parametry

Návraty

Platí pro