Convert.ToBase64String Metoda

Definice

Převede hodnotu pole 8bitových celých čísel bez znaménka na ekvivalentní řetězcové vyjádření, které je kódováno číslicemi base-64.

Přetížení

ToBase64String(Byte[])

Převede pole 8bitových celých čísel bez znaménka na ekvivalentní řetězcové vyjádření, které je kódováno číslicemi base-64.

ToBase64String(Byte[], Base64FormattingOptions)

Převede pole 8bitových celých čísel bez znaménka na ekvivalentní řetězcové vyjádření, které je kódováno číslicemi base-64. Můžete určit, zda chcete vložit konce řádků do návratové hodnoty.

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Převede 8bitové celé číslo bez znaménka uvnitř zadaného rozsahu jen pro čtení na ekvivalentní řetězcové vyjádření, které je kódováno pomocí číslic base-64. Volitelně můžete určit, jestli chcete vložit konce řádků do návratové hodnoty.

ToBase64String(Byte[], Int32, Int32)

Převede podmnožinu pole 8bitových celých čísel bez znaménka na ekvivalentní řetězcovou reprezentaci, která je zakódovaná s číslicemi base-64. Parametry určují podmnožinu jako posun ve vstupním poli a počet prvků v poli, které se mají převést.

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

Převede podmnožinu pole 8bitových celých čísel bez znaménka na ekvivalentní řetězcovou reprezentaci, která je zakódovaná s číslicemi base-64. Parametry určují podmnožinu jako posun ve vstupním poli, počet prvků v matici, které se mají převést, a zda se mají vložit konce řádků do návratové hodnoty.

ToBase64String(Byte[])

Zdroj:
Convert.cs
Zdroj:
Convert.cs
Zdroj:
Convert.cs

Převede pole 8bitových celých čísel bez znaménka na ekvivalentní řetězcové vyjádření, které je kódováno číslicemi base-64.

public static string ToBase64String (byte[] inArray);

Parametry

inArray
Byte[]

Pole 8bitových celých čísel bez znaménka.

Návraty

Řetězcové vyjádření v základu 64 obsahu inArray.

Výjimky

inArray je null.

Příklady

Následující příklad používá metodu ToBase64String(Byte[]) k převodu bajtového pole na řetězec UUencoded (base-64) a potom volá metodu FromBase64String(String) pro obnovení původní bajtové pole.

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

Následuje složitější příklad, který vytvoří pole 20 prvků s 32bitovými celými čísly. Pak použije BitConverter.GetBytes(Int32) metodu k převodu každého prvku na bajtové pole, které ukládá do příslušné pozice ve vyrovnávací paměti voláním Array.Copy(Array, Int32, Array, Int32, Int32) metody. Tato vyrovnávací paměť se pak předá metodě ToBase64String(Byte[]) k vytvoření řetězce UUencoded (base-64). Potom volá FromBase64String(String) metodu dekódování řetězce UUencoded a volá metodu BitConverter.ToInt32, která převede každou sadu čtyř bajtů (velikost 32bitového celého čísla) na celé číslo. Výstup z příkladu ukazuje, že původní pole bylo úspěšně obnoveno.

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 }

Poznámky

Prvky inArray se považují za číselnou hodnotu a převedou se na řetězcovou reprezentaci, která je zakódovaná číslicemi base-64.

Číslice se základem 64 ve vzestupném pořadí od nuly jsou velká písmena "A" až "Z", malá písmena "a" až "z", číslice "0" až "9" a symboly "+" a "/". Pro koncové odsazení se používá bezhodnotný znak =.

Důležité

Metoda ToBase64String je navržena tak, aby zpracovávala jedno bajtové pole, které obsahuje všechna data, která mají být kódována. K kódování dat z datového proudu použijte třídu System.Security.Cryptography.ToBase64Transform.

Obvykle se metoda ToBase64String nepoužívá k zaokrouhlování řetězce kódování UUEncoded (kódování base-64). To znamená, že pokud dekódujete řetězec voláním FromBase64String metody, zakódujte vrácené bajtové pole voláním metody ToBase64String, výsledný řetězec nemusí být nutně stejný jako původní řetězec. Řetězec bude zaokrouhlovat pouze v případě, že je původní řetězec platným řetězcem zakódovaným v base-64.

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

ToBase64String(Byte[], Base64FormattingOptions)

Zdroj:
Convert.cs
Zdroj:
Convert.cs
Zdroj:
Convert.cs

Převede pole 8bitových celých čísel bez znaménka na ekvivalentní řetězcové vyjádření, které je kódováno číslicemi base-64. Můžete určit, zda chcete vložit konce řádků do návratové hodnoty.

public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public static string ToBase64String (byte[] inArray, Base64FormattingOptions options);

Parametry

inArray
Byte[]

Pole 8bitových celých čísel bez znaménka.

options
Base64FormattingOptions

InsertLineBreaks vložit konec řádku každých 76 znaků nebo None vložit konce řádků.

Návraty

Řetězcová reprezentace v základu 64 prvků v inArray.

Atributy

Výjimky

inArray je null.

options není platná hodnota Base64FormattingOptions.

Příklady

Následující příklad volá Convert.ToBase64String(Byte[], Base64FormattingOptions) s argumentem Base64FormattingOptions.InsertLineBreaks pro vložení konců řádků do řetězce vytvořeného kódováním pole 100 bajtů.

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

Jak ukazuje výstup z příkladu, Convert.FromBase64String úspěšně obnoví původní bajtové pole; Znaky konce řádku se během převodu ignorují.

Poznámky

Prvky parametru inArray jsou převzaty jako číselná hodnota a převedeny na řetězcovou reprezentaci v základu 64.

Číslice se základem 64 ve vzestupném pořadí od nuly jsou velká písmena "A" až "Z", malá písmena "a" až "z", číslice "0" až "9" a symboly "+" a "/". Pro koncové odsazení se používá bezhodnotný znak =.

Důležité

Metoda ToBase64String je navržena tak, aby zpracovávala jedno bajtové pole, které obsahuje všechna data, která mají být kódována. K kódování dat z datového proudu použijte třídu System.Security.Cryptography.ToBase64Transform.

Pokud je parametr options nastaven na InsertLineBreaks a výstup převodu je delší než 76 znaků, vloží se konec řádku každých 76 znaků. Konec řádku je definován jako návratový znak řádku (U+000D) následovaný znakem odřádkování (U+000A). Vzhledem k tomu, že konce řádků se v kódování base-64 považují za prázdné znaky, při převodu řetězce s kódováním base-64 zpět na bajtové pole se ignorují. Konce řádků jsou jednoduše pohodlné při zobrazení zakódovaného řetězce ovládacímu prvku nebo zařízení, jako je okno konzoly. Další informace naleznete v dokumentu RFC 2045, "Multipurpose Internet Mail Extensions" v https://www.rfc-editor.org/.

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)

Zdroj:
Convert.cs
Zdroj:
Convert.cs
Zdroj:
Convert.cs

Převede 8bitové celé číslo bez znaménka uvnitř zadaného rozsahu jen pro čtení na ekvivalentní řetězcové vyjádření, které je kódováno pomocí číslic base-64. Volitelně můžete určit, jestli chcete vložit konce řádků do návratové hodnoty.

public static string ToBase64String (ReadOnlySpan<byte> bytes, Base64FormattingOptions options = System.Base64FormattingOptions.None);

Parametry

bytes
ReadOnlySpan<Byte>

Rozsah jen pro čtení 8bitových celých čísel bez znaménka.

options
Base64FormattingOptions

Jedna z hodnot výčtu, které určují, zda se mají vložit konce řádků do návratové hodnoty. Výchozí hodnota je None.

Návraty

Řetězcová reprezentace v základu 64 prvků v bytes. Pokud je délka bytes 0, vrátí se prázdný řetězec.

Výjimky

options není platná hodnota Base64FormattingOptions.

Délka výstupu byla větší než Int32.MaxValue.

Platí pro

.NET 9 a další verze
Produkt Verze
.NET Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Standard 2.1

ToBase64String(Byte[], Int32, Int32)

Zdroj:
Convert.cs
Zdroj:
Convert.cs
Zdroj:
Convert.cs

Převede podmnožinu pole 8bitových celých čísel bez znaménka na ekvivalentní řetězcovou reprezentaci, která je zakódovaná s číslicemi base-64. Parametry určují podmnožinu jako posun ve vstupním poli a počet prvků v poli, které se mají převést.

public static string ToBase64String (byte[] inArray, int offset, int length);

Parametry

inArray
Byte[]

Pole 8bitových celých čísel bez znaménka.

offset
Int32

Posun v inArray.

length
Int32

Počet prvků inArray k převodu.

Návraty

Řetězcová reprezentace v základu 64 length prvků inArraypočínaje umístěním offset.

Výjimky

inArray je null.

offset nebo length je záporné.

-nebo-

offset plus length je větší než délka inArray.

Poznámky

Prvky inArray se považují za číselnou hodnotu a převedou se na řetězcovou reprezentaci v základu 64.

Číslice se základem 64 ve vzestupném pořadí od nuly jsou velká písmena "A" až "Z", malá písmena "a" až "z", číslice "0" až "9" a symboly "+" a "/". Pro koncové odsazení se používá bezhodnotný znak =.

Parametry offset a length jsou 32bitová podepsaná čísla. Parametr offset je založený na nule.

Důležité

Metoda ToBase64String je navržena tak, aby zpracovávala jedno bajtové pole, které obsahuje všechna data, která mají být kódována. K kódování dat z datového proudu použijte třídu System.Security.Cryptography.ToBase64Transform.

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

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

Zdroj:
Convert.cs
Zdroj:
Convert.cs
Zdroj:
Convert.cs

Převede podmnožinu pole 8bitových celých čísel bez znaménka na ekvivalentní řetězcovou reprezentaci, která je zakódovaná s číslicemi base-64. Parametry určují podmnožinu jako posun ve vstupním poli, počet prvků v matici, které se mají převést, a zda se mají vložit konce řádků do návratové hodnoty.

public static string ToBase64String (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);

Parametry

inArray
Byte[]

Pole 8bitových celých čísel bez znaménka.

offset
Int32

Posun v inArray.

length
Int32

Počet prvků inArray k převodu.

options
Base64FormattingOptions

InsertLineBreaks vložit konec řádku každých 76 znaků nebo None vložit konce řádků.

Návraty

Řetězcová reprezentace v základu 64 length prvků inArraypočínaje umístěním offset.

Atributy

Výjimky

inArray je null.

offset nebo length je záporné.

-nebo-

offset plus length je větší než délka inArray.

options není platná hodnota Base64FormattingOptions.

Příklady

Následující příklad ukazuje ToBase64String metoda. Vstup je rozdělen do skupin tří bajtů (24 bitů). V důsledku toho se každá skupina skládá ze čtyř 6bitových čísel, kde se každé číslo pohybuje od desetinných míst od 0 do 63. V tomto příkladu zbývá 85 3bajtů skupin s jedním bajtem. První skupina se skládá z šestnáctkových hodnot 00, 01 a 02, které poskytují čtyři 6bitové hodnoty, které se rovnají desetinné 0, 0, 4 a 2. Tyto čtyři hodnoty odpovídají číslicům "A", "A", "E" a "C" na začátku výstupu.

Pokud neexistuje celočíselný počet 3bajtů skupin, zbývající bajty jsou efektivně vycpané nulami, aby se vytvořila úplná skupina. V tomto příkladu je hodnota posledního bajtu šestnáctková hodnota FF. Prvních 6 bitů se rovná desetinné číslo 63, které odpovídá číslici "/" base-64 na konci výstupu, a další 2 bity jsou vycpané nulami, aby se získalo desetinné číslo 48, které odpovídá číslici base-64 "w". Poslední dvě 6bitové hodnoty jsou odsazení a odpovídají znaku odsazení bez hodnot , "=".

// 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

*/

Poznámky

Prvky parametru inArray jsou převzaty jako číselná hodnota a převedeny na řetězcovou reprezentaci v základu 64.

Číslice se základem 64 ve vzestupném pořadí od nuly jsou velká písmena "A" až "Z", malá písmena "a" až "z", číslice "0" až "9" a symboly "+" a "/". Pro koncové odsazení se používá bezhodnotný znak =.

Parametry offset a length jsou 32bitová podepsaná čísla. Parametr offset je založený na nule.

Důležité

Metoda ToBase64String je navržena tak, aby zpracovávala jedno bajtové pole, které obsahuje všechna data, která mají být kódována. K kódování dat z datového proudu použijte třídu System.Security.Cryptography.ToBase64Transform.

Pokud je parametr options nastaven na InsertLineBreaks a výstup převodu je delší než 76 znaků, vloží se konec řádku každých 76 znaků. Konec řádku je definován jako návratový znak řádku (U+000D) následovaný znakem odřádkování (U+000A). Další informace naleznete v dokumentu RFC 2045, "Multipurpose Internet Mail Extensions" v https://www.rfc-editor.org/.

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1