Convert.FromBase64CharArray(Char[], Int32, Int32) Methode
Definitie
Belangrijk
Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.
Converteert een subset van een Unicode-tekenmatrix, die binaire gegevens codeert als base-64 cijfers, naar een equivalente 8-bits niet-ondertekende gehele getalmatrix. Parameters geven de subset op in de invoermatrix en het aantal elementen dat moet worden geconverteerd.
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()Parameters
- inArray
- Char[]
Een Unicode-tekenmatrix.
- offset
- Int32
Een positie binnen inArray.
- length
- Int32
Het aantal elementen dat inArray moet worden geconverteerd.
Retouren
Byte[]
Een matrix van 8-bits niet-ondertekende gehele getallen die gelijk zijn aan length elementen op positie offset in inArray.
Uitzonderingen
inArray is null.
offset of length kleiner is dan 0.
– of –
offset plus length geeft een positie aan die zich niet binnen inArraybevindt.
De lengte van inArray, waarbij spatietekens worden genegeerd, is niet nul of een veelvoud van 4.
– of –
De indeling inArray is ongeldig.
inArray bevat een niet-base-64-teken, meer dan twee opvullingstekens of een niet-witruimteteken tussen de opvullingstekens.
Voorbeelden
In het volgende voorbeeld ziet u hoe de methode wordt FromBase64CharArray(Char[], Int32, Int32) gebruikt om UUencoded -gegevens (base-64) te decoderen en op te slaan als binaire uitvoer.
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
In het volgende voorbeeld ziet u de ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) en FromBase64CharArray(Char[], Int32, Int32) methoden. De invoer is onderverdeeld in groepen van elk drie bytes (24 bits). Daarom bestaat elke groep uit vier 6-bits getallen waarbij elk getal varieert van decimaal 0 tot en met 63. In dit voorbeeld zijn er 85 3-bytegroepen met nog één byte. De eerste groep bestaat uit de hexadecimale waarden 00, 01 en 02, die vier 6-bits waarden opleveren die gelijk zijn aan decimale 0, 0, 4 en 2. Deze vier waarden komen overeen met de basis-64 cijfers, 'A', 'A', 'E' en 'C', aan het begin van de uitvoer.
Als er geen integraal aantal groepen van 3 bytes bestaat, worden de resterende bytes effectief opgevuld met nullen om een volledige groep te vormen. In dit voorbeeld is de waarde van de laatste byte hexadecimaal FF. De eerste 6 bits zijn gelijk aan decimaal 63, die overeenkomt met het grondtal-64 cijfer "/" aan het einde van de uitvoer en de volgende 2 bits worden opgevuld met nullen om decimale 48 te opleveren, wat overeenkomt met het grondtal-64 cijfer , "w". De laatste twee 6-bits waarden zijn opvulling en komen overeen met het opvullingsteken "=".
// 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
Opmerkingen
inArray bestaat uit basis-64 cijfers, spatietekens en volgtekens. De basis-64 cijfers in oplopende volgorde van nul zijn de hoofdletters 'A' tot 'Z', kleine letters 'a' tot 'z', cijfers '0' tot '9' en de symbolen '+' en '/'.
De spatietekens en de bijbehorende Unicode-namen en hexadecimale codepunten zijn tab (TEKENTABULATIE, U+0009), newline (LIJNFEED, U+000A), regelterugloop (REGELTERUGLOOP, U+000D) en leeg (SPATIE, U+0020). Een willekeurig aantal witruimtetekens kan worden inArray weergegeven omdat alle spatietekens worden genegeerd.
Het waardeloze teken , "=", wordt gebruikt voor opvulling van achtervolging. Het einde kan inArray bestaan uit nul, één of twee opvullingstekens.
Important
De FromBase64CharArray methode is ontworpen voor het verwerken van één tekenmatrix die alle gegevens bevat die moeten worden gedecodeerd. Als u base-64-tekengegevens uit een stroom wilt decoderen, gebruikt u de System.Security.Cryptography.FromBase64Transform klasse.
