Convert.FromBase64String(String) Metoda

Definicja

Konwertuje określony ciąg, który koduje dane binarne jako cyfry Base-64, do równoważnej 8-bitowej nieoznaczonej liczby całkowitej.Converts the specified string, which encodes binary data as base-64 digits, to an equivalent 8-bit unsigned integer array.

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

Parametry

s
String

Ciąg do konwersji.The string to convert.

Zwraca

Byte[]

Tablica 8-bitowych liczb całkowitych bez znaku, która jest równoważna z s .An array of 8-bit unsigned integers that is equivalent to s.

Wyjątki

s to null.s is null.

Długość s ignorowana białych znaków nie jest równa zero ani wielokrotność 4.The length of s, ignoring white-space characters, is not zero or a multiple of 4.

-lub--or-

Format s jest nieprawidłowy.The format of s is invalid. s zawiera znak inny niż Base-64, więcej niż dwa znaki uzupełniające lub znak niebędący odstępem między wypełnieniami.s contains a non-base-64 character, more than two padding characters, or a non-white space-character among the padding characters.

Przykłady

W poniższym przykładzie zastosowano ToBase64String(Byte[]) metodę, aby skonwertować tablicę bajtową na ciąg (Base-64), a następnie wywołuje metodę, FromBase64String(String) Aby przywrócić oryginalną tablicę bajtów.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

Poniżej znajduje się bardziej złożony przykład, który tworzy 20-elementową tablicę z 32-bitową liczbą całkowitą.The following is a more complex example that creates a 20-element array of 32-bit integers. Następnie używa BitConverter.GetBytes(Int32) metody do konwersji każdego elementu na tablicę bajtową, która przechowuje w odpowiedniej pozycji w buforze przez wywołanie Array.Copy(Array, Int32, Array, Int32, Int32) 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. Ten bufor jest następnie przesyłany do ToBase64String(Byte[]) metody w celu utworzenia ciągu z parametrem (Base-64).This buffer is then passed to the ToBase64String(Byte[]) method to create a UUencoded (base-64) string. Następnie wywołuje FromBase64String(String) metodę w celu zdekodowania ciągu UUENCODE i wywołuje BitConverter.ToInt32 metodę, aby skonwertować każdy zestaw czterech bajtów (rozmiar 32-bitową liczbą całkowitą) na liczbę całkowitą.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. Dane wyjściowe z przykładu pokazują, że oryginalna Tablica została pomyślnie przywrócona.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 }

Uwagi

s składa się z podstawowych-64 cyfr, znaków białych i końcowych znaków uzupełniania.s is composed of base-64 digits, white-space characters, and trailing padding characters. Cyfry Base-64 w kolejności rosnącej od zera to wielkie litery od "A" do "Z", małe litery od "a" do "z", cyfry "0" do "9" oraz symbole "+" i "/".The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", lowercase characters "a" to "z", numerals "0" to "9", and the symbols "+" and "/".

Znaki białych znaków, ich nazwy Unicode i szesnastkowe punkty kodu, są tabulacją (TABULACJa ZNAKowa, U + 0009), wierszem (wysuw wiersza, U + 000A), znak powrotu karetki (znak powrotu KARETKi, U + 000D) i puste (SPACJa, U + 0020).The white-space characters, and their Unicode names and hexadecimal code points, are tab (CHARACTER TABULATION, U+0009), newline (LINE FEED, U+000A), carriage return (CARRIAGE RETURN, U+000D), and blank (SPACE, U+0020). Może pojawić się dowolna liczba znaków odstępu, s ponieważ wszystkie znaki odstępu są ignorowane.An arbitrary number of white-space characters can appear in s because all white-space characters are ignored.

Bezwartościowy znak „=” jest używany w celu dopełniania na końcu.The valueless character, "=", is used for trailing padding. Koniec elementu s może składać się z zero, jeden lub dwa znaki uzupełniania.The end of s can consist of zero, one, or two padding characters.

Ważne

FromBase64StringMetoda jest przeznaczona do przetwarzania pojedynczego ciągu, który zawiera wszystkie dane, które mają zostać zdekodowane.The FromBase64String method is designed to process a single string that contains all the data to be decoded. Aby zdekodować dane znakowe Base-64 ze strumienia, użyj System.Security.Cryptography.FromBase64Transform klasy.To decode base-64 character data from a stream, use the System.Security.Cryptography.FromBase64Transform class.

Dotyczy

Zobacz też