Convert.FromBase64CharArray(Char[], Int32, Int32) Metoda
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Převede podmnožinu znakového pole Unicode, která zakóduje binární data jako číslice base-64, na ekvivalentní 8bitovou celočíselnou matici bez znaménka. Parametry určují podmnožinu ve vstupním poli a počet prvků, které se mají převést.
public:
static cli::array <System::Byte> ^ FromBase64CharArray(cli::array <char> ^ inArray, int offset, int length);public static byte[] FromBase64CharArray (char[] inArray, int offset, int length);static member FromBase64CharArray : char[] * int * int -> byte[]Public Shared Function FromBase64CharArray (inArray As Char(), offset As Integer, length As Integer) As Byte()Parametry
- inArray
- Char[]
Pole znaků Unicode.
- offset
- Int32
Pozice uvnitř inArray.
- length
- Int32
Počet prvků, které inArray se mají převést.
Návraty
- Byte[]
Pole 8bitových celých čísel bez znaménka ekvivalentní length prvkům na pozici offset v inArray.
Výjimky
inArray je null.
offset nebo length je menší než 0.
-nebo-
offset plus length označuje pozici, která není uvnitř inArray.
Délka znaků , ignorování prázdných inArrayznaků, není nula nebo násobek 4.
-nebo-
Formát inArray je neplatný. inArray obsahuje znak bez základu 64, více než dva znaky odsazení nebo prázdný znak mezi znaky odsazení.
Příklady
Následující příklad ukazuje použití FromBase64CharArray(Char[], Int32, Int32) metody dekódovat UUencoded (base-64) data a uložit je jako binární výstup.
public:
void DecodeWithCharArray()
{
StreamReader^ inFile;
array<Char>^base64CharArray;
try
{
inFile = gcnew StreamReader( inputFileName,
Text::Encoding::ASCII );
base64CharArray = gcnew array<Char>((int)(inFile->BaseStream->Length));
inFile->Read( base64CharArray, 0, (int)inFile->BaseStream->Length );
inFile->Close();
}
catch ( Exception^ exp )
{
// Error creating stream or reading from it.
Console::WriteLine( "{0}", exp->Message );
return;
}
// Convert the Base64 UUEncoded input into binary output.
array<Byte>^binaryData;
try
{
binaryData = Convert::FromBase64CharArray( base64CharArray,
0,
base64CharArray->Length );
}
catch ( ArgumentNullException^ )
{
Console::WriteLine( "Base 64 character array is null." );
return;
}
catch ( FormatException^ )
{
Console::WriteLine( "Base 64 Char Array length is not " +
"4 or is not an even multiple of 4." );
return;
}
// Write out the decoded data.
FileStream^ outFile;
try
{
outFile = gcnew FileStream( outputFileName,
FileMode::Create,
FileAccess::Write );
outFile->Write( binaryData, 0, binaryData->Length );
outFile->Close();
}
catch ( Exception^ exp )
{
// Error creating stream or writing to it.
Console::WriteLine( "{0}", exp->Message );
}
}
public void DecodeWithCharArray() {
System.IO.StreamReader inFile;
char[] base64CharArray;
try {
inFile = new System.IO.StreamReader(inputFileName,
System.Text.Encoding.ASCII);
base64CharArray = new char[inFile.BaseStream.Length];
inFile.Read(base64CharArray, 0, (int)inFile.BaseStream.Length);
inFile.Close();
}
catch (System.Exception exp) {
// Error creating stream or reading from it.
System.Console.WriteLine("{0}", exp.Message);
return;
}
// Convert the Base64 UUEncoded input into binary output.
byte[] binaryData;
try {
binaryData =
System.Convert.FromBase64CharArray(base64CharArray,
0,
base64CharArray.Length);
}
catch ( System.ArgumentNullException ) {
System.Console.WriteLine("Base 64 character array is null.");
return;
}
catch ( System.FormatException ) {
System.Console.WriteLine("Base 64 Char Array length is not " +
"4 or is not an even multiple of 4." );
return;
}
// Write out the decoded data.
System.IO.FileStream outFile;
try {
outFile = new System.IO.FileStream(outputFileName,
System.IO.FileMode.Create,
System.IO.FileAccess.Write);
outFile.Write(binaryData, 0, binaryData.Length);
outFile.Close();
}
catch (System.Exception exp) {
// Error creating stream or writing to it.
System.Console.WriteLine("{0}", exp.Message);
}
}
let decodeWithCharArray () =
try
let inFile =
new StreamReader(inputFileName, Encoding.ASCII)
let base64CharArray =
Array.zeroCreate<char> (int inFile.BaseStream.Length)
inFile.Read(base64CharArray, 0, (int) inFile.BaseStream.Length)
|> ignore
// Convert the Base64 UUEncoded input into binary output.
let binaryData =
Convert.FromBase64CharArray(base64CharArray, 0, base64CharArray.Length)
// Write out the decoded data.
use outFile =
new FileStream(outputFileName, FileMode.Create, FileAccess.Write)
outFile.Write(binaryData, 0, binaryData.Length)
with
| :? ArgumentNullException -> printfn "Base 64 character array is null."
| :? FormatException -> printfn "Base 64 Char Array length is not 4 or is not an even multiple of 4."
| e -> printfn $"{e.Message}"
Public Sub DecodeWithCharArray()
Dim inFile As System.IO.StreamReader
Dim base64CharArray() As Char
Try
inFile = New System.IO.StreamReader(inputFileName, _
System.Text.Encoding.ASCII)
ReDim base64CharArray(inFile.BaseStream.Length - 1)
inFile.Read(base64CharArray, 0, inFile.BaseStream.Length)
inFile.Close()
Catch exp As System.Exception
' Error creating stream or reading from it.
System.Console.WriteLine("{0}", exp.Message)
Return
End Try
' Convert the Base64 UUEncoded input into binary output.
Dim binaryData() As Byte
Try
binaryData = System.Convert.FromBase64CharArray(base64CharArray, 0, _
base64CharArray.Length)
Catch exp As System.ArgumentNullException
System.Console.WriteLine("Base 64 character array is null.")
Return
Catch exp As System.FormatException
System.Console.WriteLine("Base 64 Char Array length is not " + _
"4 or is not an even multiple of 4")
Return
End Try
' Write out the decoded data.
Dim outFile As System.IO.FileStream
Try
outFile = New System.IO.FileStream(outputFileName, _
System.IO.FileMode.Create, _
System.IO.FileAccess.Write)
outFile.Write(binaryData, 0, binaryData.Length - 1)
outFile.Close()
Catch exp As System.Exception
' Error creating stream or writing to it.
System.Console.WriteLine("{0}", exp.Message)
End Try
End Sub
Následující příklad ukazuje ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) a FromBase64CharArray(Char[], Int32, Int32) metody. Vstup je rozdělen na skupiny po třech bajtech (24 bitů). 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. V tomto příkladu je 85 3bajtových skupin s 1 přebývajícím bajtem. 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. Tyto čtyři hodnoty odpovídají číslicemi base-64, "A", "A", "E" a "C" na začátku výstupu.
Pokud neexistuje celočíselný počet 3bajtových skupin, zbývající bajty jsou účinně doplněny nulami, aby vytvořily úplnou skupinu. V tomto příkladu je hodnota posledního bajtu šestnáctkové 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". Poslední dvě 6bitové hodnoty odsazují a odpovídají znaku odsazení bez hodnoty "=".
// This example demonstrates the Convert.ToBase64CharArray() and
// Convert.FromBase64CharArray methods
using namespace System;
bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 );
int main()
{
array<Byte>^byteArray1 = gcnew array<Byte>(256);
array<Byte>^byteArray2 = gcnew array<Byte>(256);
array<Char>^charArray = gcnew array<Char>(352);
int charArrayLength;
String^ nl = Environment::NewLine;
String^ ruler1a = " 1 2 3 4";
String^ ruler2a = "1234567890123456789012345678901234567890";
String^ ruler3a = "----+----+----+----+----+----+----+----+";
String^ ruler1b = " 5 6 7 ";
String^ ruler2b = "123456789012345678901234567890123456";
String^ ruler3b = "----+----+----+----+----+----+----+-";
String^ ruler = String::Concat( ruler1a, ruler1b, nl, ruler2a, ruler2b, nl, ruler3a, ruler3b );
// 1) Initialize and display a Byte array of arbitrary data.
Console::WriteLine( "1) Input: A Byte array of arbitrary data.{0}", nl );
for ( int x = 0; x < byteArray1->Length; x++ )
{
byteArray1[ x ] = (Byte)x;
Console::Write( "{0:X2} ", byteArray1[ x ] );
if ( ((x + 1) % 20) == 0 )
Console::WriteLine();
}
Console::Write( "{0}{0}", nl );
// 2) Convert the input Byte array to a Char array, with newlines inserted.
charArrayLength = Convert::ToBase64CharArray( byteArray1, 0, byteArray1->Length,
charArray, 0,
Base64FormattingOptions::InsertLineBreaks );
Console::WriteLine( "2) Convert the input Byte array to a Char array with newlines." );
Console::Write( " Output: A Char array (length = {0}). ", charArrayLength );
Console::WriteLine( "The elements of the array are:{0}", nl );
Console::WriteLine( ruler );
Console::WriteLine( gcnew String( charArray ) );
Console::WriteLine();
// 3) Convert the Char array back to a Byte array.
Console::WriteLine( "3) Convert the Char array to an output Byte array." );
byteArray2 = Convert::FromBase64CharArray( charArray, 0, charArrayLength );
// 4) Are the input and output Byte arrays equivalent?
Console::WriteLine( "4) The output Byte array is equal to the input Byte array: {0}", ArraysAreEqual( byteArray1, byteArray2 ) );
}
bool ArraysAreEqual( array<Byte>^a1, array<Byte>^a2 )
{
if ( a1->Length != a2->Length )
return false;
for ( int i = 0; i < a1->Length; i++ )
if ( a1[ i ] != a2[ i ] )
return false;
return true;
}
/*
This example produces the following results:
1) Input: A Byte array of arbitrary data.
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF
2) Convert the input Byte array to a Char array with newlines.
Output: A Char array (length = 352). The elements of the array are:
1 2 3 4 5 6 7
1234567890123456789012345678901234567890123456789012345678901234567890123456
----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==
3) Convert the Char array to an output Byte array.
4) The output Byte array is equal to the input Byte array: True
*/
// This example demonstrates the Convert.ToBase64CharArray() and
// Convert.FromBase64CharArray methods
using System;
class Sample
{
public static void Main()
{
byte[] byteArray1 = new byte[256];
byte[] byteArray2 = new byte[256];
char[] charArray = new char[352];
int charArrayLength;
string nl = Environment.NewLine;
string ruler1a = " 1 2 3 4";
string ruler2a = "1234567890123456789012345678901234567890";
string ruler3a = "----+----+----+----+----+----+----+----+";
string ruler1b = " 5 6 7 ";
string ruler2b = "123456789012345678901234567890123456";
string ruler3b = "----+----+----+----+----+----+----+-";
string ruler = String.Concat(ruler1a, ruler1b, nl,
ruler2a, ruler2b, nl,
ruler3a, ruler3b);
// 1) Initialize and display a Byte array of arbitrary data.
Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl);
for (int x = 0; x < byteArray1.Length; x++)
{
byteArray1[x] = (byte)x;
Console.Write("{0:X2} ", byteArray1[x]);
if (((x+1)%20) == 0) Console.WriteLine();
}
Console.Write("{0}{0}", nl);
// 2) Convert the input Byte array to a Char array, with newlines inserted.
charArrayLength =
Convert.ToBase64CharArray(byteArray1, 0, byteArray1.Length,
charArray, 0, Base64FormattingOptions.InsertLineBreaks);
Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.");
Console.Write(" Output: A Char array (length = {0}). ", charArrayLength);
Console.WriteLine("The elements of the array are:{0}", nl);
Console.WriteLine(ruler);
Console.WriteLine(new String(charArray));
Console.WriteLine();
// 3) Convert the Char array back to a Byte array.
Console.WriteLine("3) Convert the Char array to an output Byte array.");
byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength);
// 4) Are the input and output Byte arrays equivalent?
Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}",
ArraysAreEqual(byteArray1, byteArray2));
}
public static bool ArraysAreEqual(byte[] a1, byte[] a2)
{
if (a1.Length != a2.Length) return false;
for (int i = 0; i < a1.Length; i++)
if (a1[i] != a2[i]) return false;
return true;
}
}
/*
This example produces the following results:
1) Input: A Byte array of arbitrary data.
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF
2) Convert the input Byte array to a Char array with newlines.
Output: A Char array (length = 352). The elements of the array are:
1 2 3 4 5 6 7
1234567890123456789012345678901234567890123456789012345678901234567890123456
----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==
3) Convert the Char array to an output Byte array.
4) The output Byte array is equal to the input Byte array: True
*/
// This example demonstrates the Convert.ToBase64CharArray() and
// Convert.FromBase64CharArray methods
open System
let arraysAreEqual (a1: byte[]) (a2: byte[]) =
a1.Length = a2.Length &&
Array.forall2 (=) a2 a1
let byteArray1 = Array.zeroCreate<byte> 256
let charArray = Array.zeroCreate<char> 352
let nl = Environment.NewLine
let ruler =
$" 1 2 3 4 5 6 7 {nl}" +
$"1234567890123456789012345678901234567890123456789012345678901234567890123456{nl}" +
"----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-"
// 1) Initialize and display a Byte array of arbitrary data.
printfn $"1) Input: A Byte array of arbitrary data.{nl}"
for i = 0 to byteArray1.Length - 1 do
byteArray1[i] <- byte i
printf $"{byteArray1[i]:X2} "
if (i + 1) % 20 = 0 then
printfn ""
printf $"{nl}{nl}"
// 2) Convert the input Byte array to a Char array, with newlines inserted.
let charArrayLength =
Convert.ToBase64CharArray(byteArray1, 0, byteArray1.Length,
charArray, 0, Base64FormattingOptions.InsertLineBreaks)
printfn "2) Convert the input Byte array to a Char array with newlines."
printf $" Output: A Char array (length = {charArrayLength}). "
printfn $"The elements of the array are:{nl}"
printfn $"{ruler}"
printfn $"{String charArray}"
printfn ""
// 3) Convert the Char array back to a Byte array.
printfn "3) Convert the Char array to an output Byte array."
let byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength)
// 4) Are the input and output Byte arrays equivalent?
printfn $"4) The output Byte array is equal to the input Byte array: {arraysAreEqual byteArray1 byteArray2}"
// This example produces the following results:
// 1) Input: A Byte array of arbitrary data.
//
// 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
// 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
// 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
// 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
// 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
// 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
// 78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
// 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
// A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
// B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
// C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
// DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
// F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF
//
// 2) Convert the input Byte array to a Char array with newlines.
// Output: A Char array (length = 352). The elements of the array are:
//
// 1 2 3 4 5 6 7
// 1234567890123456789012345678901234567890123456789012345678901234567890123456
// ----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
// AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
// OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
// cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
// q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
// 5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==
//
// 3) Convert the Char array to an output Byte array.
// 4) The output Byte array is equal to the input Byte array: True
' This example demonstrates the Convert.ToBase64CharArray() and
' Convert.FromBase64CharArray methods
Class Sample
Public Shared Sub Main()
Dim byteArray1(255) As Byte
Dim byteArray2(255) As Byte
Dim charArray(351) As Char
Dim charArrayLength As Integer
Dim nl As String = Environment.NewLine
Dim ruler1a As String = " 1 2 3 4"
Dim ruler2a As String = "1234567890123456789012345678901234567890"
Dim ruler3a As String = "----+----+----+----+----+----+----+----+"
Dim ruler1b As String = " 5 6 7 "
Dim ruler2b As String = "123456789012345678901234567890123456"
Dim ruler3b As String = "----+----+----+----+----+----+----+-"
Dim ruler As String = String.Concat(ruler1a, ruler1b, nl, _
ruler2a, ruler2b, nl, _
ruler3a, ruler3b)
' 1) Initialize and display a Byte array of arbitrary data.
Console.WriteLine("1) Input: A Byte array of arbitrary data.{0}", nl)
Dim x As Integer
For x = 0 To byteArray1.Length - 1
byteArray1(x) = CByte(x)
Console.Write("{0:X2} ", byteArray1(x))
If(x + 1) Mod 20 = 0 Then
Console.WriteLine()
End If
Next x
Console.Write("{0}{0}", nl)
' 2) Convert the input Byte array to a Char array, with newlines inserted.
charArrayLength = Convert.ToBase64CharArray( _
byteArray1, 0, byteArray1.Length, _
charArray, 0, _
Base64FormattingOptions.InsertLineBreaks)
Console.WriteLine("2) Convert the input Byte array to a Char array with newlines.")
Console.Write(" Output: A Char array (length = {0}). ", charArrayLength)
Console.WriteLine("The elements of the array are:{0}", nl)
Console.WriteLine(ruler)
Console.WriteLine(New [String](charArray))
Console.WriteLine()
' 3) Convert the Char array back to a Byte array.
Console.WriteLine("3) Convert the Char array to an output Byte array.")
byteArray2 = Convert.FromBase64CharArray(charArray, 0, charArrayLength)
' 4) Are the input and output Byte arrays equivalent?
Console.WriteLine("4) The output Byte array is equal to the input Byte array: {0}", _
ArraysAreEqual(byteArray1, byteArray2))
End Sub
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) Input: A Byte array of arbitrary data.
'
'00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13
'14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27
'28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B
'3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
'50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63
'64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77
'78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B
'8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
'A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3
'B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7
'C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB
'DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
'F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF
'
'2) Convert the input Byte array to a Char array with newlines.
' Output: A Char array (length = 352). The elements of the array are:
'
' 1 2 3 4 5 6 7
'1234567890123456789012345678901234567890123456789012345678901234567890123456
'----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-
'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4
'OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx
'cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq
'q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj
'5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==
'
'3) Convert the Char array to an output Byte array.
'4) The output Byte array is equal to the input Byte array: True
Poznámky
inArray se skládá ze základních 64 číslic, prázdných znaků a koncových znaků odsazení. Číslice base-64 ve vzestupném pořadí od nuly jsou velké znaky "A" až "Z", malé znaky "a" až "z", číslice "0" až "9" a symboly "+" a "/".
Prázdné znaky a jejich názvy a šestnáctkové body kódu Unicode jsou tabulátor (TABULACE ZNAKŮ, U+0009), nový řádek (INFORMAČNÍ KANÁL ŘÁDKU, U+000A), návrat na začátek řádku (ZNAK RETURN, U+000D) a prázdné (MEZERA, U+0020). Libovolný počet prázdných znaků se může zobrazit, inArray protože všechny prázdné znaky jsou ignorovány.
Znak "=" bez hodnoty se používá pro koncové odsazení. Konec inArray může obsahovat nula, jeden nebo dva odsazení znaků.
Důležité
Metoda FromBase64CharArray je navržená tak, aby zpracovávala jedno znakové pole, které obsahuje všechna data, která se mají dekódovat. Chcete-li dekódovat základní 64 znaková data ze streamu, použijte System.Security.Cryptography.FromBase64Transform třídu.