Convert.ToBase64CharArray Yöntem
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
8 bit işaretsiz tamsayı dizisinin alt kümesini, taban-64 basamaklı kodlanmış unicode karakter dizisinin eşdeğer bir alt kümesine dönüştürür.
Aşırı Yüklemeler
| Name | Description |
|---|---|
| ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) |
8 bit işaretsiz tamsayı dizisinin alt kümesini, taban-64 basamaklı kodlanmış unicode karakter dizisinin eşdeğer bir alt kümesine dönüştürür. Parametreler, alt kümeleri giriş ve çıkış dizilerinde uzaklıklar olarak, dönüştürülecek giriş dizisindeki öğelerin sayısını ve çıkış dizisine satır sonlarının eklenip eklenmeyeceğini belirtir. |
| ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) |
8 bit işaretsiz tamsayı dizisinin alt kümesini, taban-64 basamaklı kodlanmış unicode karakter dizisinin eşdeğer bir alt kümesine dönüştürür. Parametreler, giriş ve çıkış dizilerinde uzaklıklar olarak alt kümeleri ve dönüştürülecek giriş dizisindeki öğelerin sayısını belirtir. |
ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)
- Kaynak:
- Convert.cs
- Kaynak:
- Convert.cs
- Kaynak:
- Convert.cs
- Kaynak:
- Convert.cs
- Kaynak:
- Convert.cs
8 bit işaretsiz tamsayı dizisinin alt kümesini, taban-64 basamaklı kodlanmış unicode karakter dizisinin eşdeğer bir alt kümesine dönüştürür. Parametreler, alt kümeleri giriş ve çıkış dizilerinde uzaklıklar olarak, dönüştürülecek giriş dizisindeki öğelerin sayısını ve çıkış dizisine satır sonlarının eklenip eklenmeyeceğini belirtir.
public:
static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut, Base64FormattingOptions options);public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options);[System.Runtime.InteropServices.ComVisible(false)]
public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options);static member ToBase64CharArray : byte[] * int * int * char[] * int * Base64FormattingOptions -> int[<System.Runtime.InteropServices.ComVisible(false)>]
static member ToBase64CharArray : byte[] * int * int * char[] * int * Base64FormattingOptions -> intPublic Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer, options As Base64FormattingOptions) As IntegerParametreler
- inArray
- Byte[]
8 bit işaretsiz tamsayılardan oluşan bir giriş dizisi.
- offsetIn
- Int32
içinde inArraybir konum.
- length
- Int32
Dönüştürülecek öğelerinin inArray sayısı.
- outArray
- Char[]
Unicode karakterlerinden oluşan bir çıkış dizisi.
- offsetOut
- Int32
içinde outArraybir konum.
- options
- Base64FormattingOptions
InsertLineBreaks her 76 karakterde bir satır sonu eklemek veya None satır sonu eklememek için.
Döndürülenler
içindeki outArraybayt sayısını içeren 32 bit imzalı tamsayı.
- Öznitelikler
Özel durumlar
inArray veya outArray şeklindedir null.
offsetIn, offsetOutveya length negatiftir.
-veya-
offsetIn artı length , uzunluğundan inArraybüyüktür.
-veya-
offsetOut artı döndürülecek öğe sayısı uzunluğundan outArraybüyüktür.
options geçerli Base64FormattingOptions bir değer değil.
Örnekler
Aşağıdaki örnekte yöntemi gösterilmektedir ToBase64CharArray . Giriş, her biri üç baytlık (24 bit) gruplara ayrılır. Sonuç olarak, her grup, her sayının ondalık 0 ile 63 arasında olduğu dört 6 bitlik sayıdan oluşur. Bu örnekte, bir bayt kalan 85 adet 3 baytlık grup vardır. İlk grup, ondalık 0, 0, 4 ve 2'ye eşit dört 6 bit değer veren 00, 01 ve 02 onaltılık değerlerden oluşur. Bu dört değer çıkışın başındaki "A", "A", "E" ve "C" taban 64 basamağına karşılık gelir.
3 baytlık grupların tamsayı sayısı yoksa, kalan baytlar tam bir grup oluşturmak için sıfırlarla etkin bir şekilde doldurulur. Bu örnekte, son bayt değeri onaltılık FF'dir. İlk 6 bit, çıkışın sonundaki taban-64 basama "/" karşılık gelen ondalık 63'e eşittir ve sonraki 2 bit ondalık 48'i vermek için sıfırlarla doldurulur ve bu da "w" taban-64 basama karşılık gelir. Son iki 6 bit değer doldurmadır ve "=" değersiz doldurma karakterine karşılık gelir.
// 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
Açıklamalar
konumundan başlayarak parametresinin length öğelerinin inArray alt kümesi sayısal bir değer olarak alınır ve konumundan offsetInbaşlayarak parametresindeki öğelerin bir alt kümesine outArray dönüştürülür.offsetOut Dönüş değeri, içindeki outArraydönüştürülen öğelerin sayısını gösterir. alt kümesi outArray 64 tabanından oluşur.
Sıfırdan artan düzende 64 tabanındaki basamaklar büyük harf "A" ile "Z" arasında, küçük harfli "a" ile "z" arası karakterler, "0" ile "9" arasında sayılar ve "+" ve "/" simgeleridir. "=" değersiz karakteri sondaki doldurma için kullanılır.
offset ve length parametreleri 32 bit imzalı sayılardır.
offsetIn ve offsetOut parametreleri sıfır tabanlı dizi konumlarıdır.
Important
ToBase64CharArray yöntemi, kodlanacak tüm verileri içeren tek bir bayt dizisini işlemek için tasarlanmıştır. Bayt akışından bir base-64 karakter dizisi oluşturmak için sınıfını System.Security.Cryptography.ToBase64Transform kullanın.
options parametresi olarak ayarlanırsa InsertLineBreaks ve dönüştürmenin çıkışı 76 karakterden uzunsa, her 76 karakterde bir satır sonu eklenir. Satır sonu, satır başı karakteri (U+000D) ve ardından satır besleme karakteri (U+000A) olarak tanımlanır. Daha fazla bilgi için bkz. RFC 2045, "Çok Amaçlı İnternet Posta Uzantıları", adresinde https://www.rfc-editor.org/.
Ayrıca bkz.
Şunlara uygulanır
ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)
- Kaynak:
- Convert.cs
- Kaynak:
- Convert.cs
- Kaynak:
- Convert.cs
- Kaynak:
- Convert.cs
- Kaynak:
- Convert.cs
8 bit işaretsiz tamsayı dizisinin alt kümesini, taban-64 basamaklı kodlanmış unicode karakter dizisinin eşdeğer bir alt kümesine dönüştürür. Parametreler, giriş ve çıkış dizilerinde uzaklıklar olarak alt kümeleri ve dönüştürülecek giriş dizisindeki öğelerin sayısını belirtir.
public:
static int ToBase64CharArray(cli::array <System::Byte> ^ inArray, int offsetIn, int length, cli::array <char> ^ outArray, int offsetOut);public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut);static member ToBase64CharArray : byte[] * int * int * char[] * int -> intPublic Shared Function ToBase64CharArray (inArray As Byte(), offsetIn As Integer, length As Integer, outArray As Char(), offsetOut As Integer) As IntegerParametreler
- inArray
- Byte[]
8 bit işaretsiz tamsayılardan oluşan bir giriş dizisi.
- offsetIn
- Int32
içinde inArraybir konum.
- length
- Int32
Dönüştürülecek öğelerinin inArray sayısı.
- outArray
- Char[]
Unicode karakterlerinden oluşan bir çıkış dizisi.
- offsetOut
- Int32
içinde outArraybir konum.
Döndürülenler
içindeki outArraybayt sayısını içeren 32 bit imzalı tamsayı.
Özel durumlar
inArray veya outArray şeklindedir null.
offsetIn, offsetOutveya length negatiftir.
-veya-
offsetIn artı length , uzunluğundan inArraybüyüktür.
-veya-
offsetOut artı döndürülecek öğe sayısı uzunluğundan outArraybüyüktür.
Örnekler
Aşağıdaki örnek, bir ikili akışı UUencode (64 tabanında kodlar) ve ardından kodlamayı bir dosyaya kaydetmek için yönteminin kullanılmasını ToBase64CharArray gösterir.
public void EncodeWithCharArray() {
System.IO.FileStream inFile;
byte[] binaryData;
try {
inFile = new System.IO.FileStream(inputFileName,
System.IO.FileMode.Open,
System.IO.FileAccess.Read);
binaryData = new Byte[inFile.Length];
long bytesRead = inFile.Read(binaryData, 0,
(int) inFile.Length);
inFile.Close();
}
catch (System.Exception exp) {
// Error creating stream or reading from it.
System.Console.WriteLine("{0}", exp.Message);
return;
}
// Convert the binary input into Base64 UUEncoded output.
// Each 3 byte sequence in the source data becomes a 4 byte
// sequence in the character array.
long arrayLength = (long) ((4.0d/3.0d) * binaryData.Length);
// If array length is not divisible by 4, go up to the next
// multiple of 4.
if (arrayLength % 4 != 0) {
arrayLength += 4 - arrayLength % 4;
}
char[] base64CharArray = new char[arrayLength];
try {
System.Convert.ToBase64CharArray(binaryData,
0,
binaryData.Length,
base64CharArray,
0);
}
catch (System.ArgumentNullException) {
System.Console.WriteLine("Binary data array is null.");
return;
}
catch (System.ArgumentOutOfRangeException) {
System.Console.WriteLine("Char Array is not large enough.");
return;
}
// Write the UUEncoded version to the output file.
System.IO.StreamWriter outFile;
try {
outFile = new System.IO.StreamWriter(outputFileName,
false,
System.Text.Encoding.ASCII);
outFile.Write(base64CharArray);
outFile.Close();
}
catch (System.Exception exp) {
// Error creating stream or writing to it.
System.Console.WriteLine("{0}", exp.Message);
}
}
let encodeWithCharArray () =
try
use inFile =
new FileStream(inputFileName, FileMode.Open, FileAccess.Read)
let binaryData =
Array.zeroCreate<byte> (int inFile.Length)
inFile.Read(binaryData, 0, int inFile.Length)
|> ignore
// Convert the binary input into Base64 UUEncoded output.
// Each 3 byte sequence in the source data becomes a 4 byte
// sequence in the character array.
let arrayLength =
(4. / 3.) * float binaryData.Length |> int64
// If array length is not divisible by 4, shadow up to the next multiple of 4.
let arrayLength =
if arrayLength % 4L <> 0L then
arrayLength + (4L - arrayLength % 4L)
else
arrayLength
let base64CharArray = Array.zeroCreate<char> (int arrayLength)
Convert.ToBase64CharArray(binaryData, 0, binaryData.Length, base64CharArray, 0)
|> ignore
// Write the UUEncoded version to the output file.
use outFile =
new StreamWriter(outputFileName, false, Encoding.ASCII)
outFile.Write(base64CharArray)
outFile.Close()
with
| :? ArgumentNullException -> printfn "Binary data array is null."
| :? ArgumentOutOfRangeException -> printfn "Char Array is not large enough."
| e ->
// Error creating stream or writing to it.
printfn $"{e.Message}"
Public Sub EncodeWithCharArray()
Dim inFile As System.IO.FileStream
Dim binaryData() As Byte
Try
inFile = New System.IO.FileStream(inputFileName, _
System.IO.FileMode.Open, _
System.IO.FileAccess.Read)
ReDim binaryData(inFile.Length)
Dim bytesRead As Long = inFile.Read(binaryData, _
0, _
CInt(inFile.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 binary input into Base64 UUEncoded output.
' Each 3 byte sequence in the source data becomes a 4 byte
' sequence in the character array.
Dim arrayLength As Long
arrayLength = (4 / 3) * binaryData.Length
If arrayLength Mod 4 <> 0 Then
arrayLength = arrayLength + 4 - arrayLength Mod 4
End If
Dim base64CharArray(arrayLength - 1) As Char
Try
System.Convert.ToBase64CharArray(binaryData, _
0, _
binaryData.Length, _
base64CharArray, 0)
Catch exp As System.ArgumentNullException
System.Console.WriteLine("Binary data array is null.")
Return
Catch exp As System.ArgumentOutOfRangeException
System.Console.WriteLine("Char Array is not large enough.")
Return
End Try
' Write the UUEncoded version to the output file.
Dim outFile As System.IO.StreamWriter
Try
outFile = New System.IO.StreamWriter(outputFileName, _
False, _
System.Text.Encoding.ASCII)
outFile.Write(base64CharArray)
outFile.Close()
Catch exp As System.Exception
' Error creating stream or writing to it.
System.Console.WriteLine("{0}", exp.Message)
End Try
End Sub
Açıklamalar
konumundan lengthbaşlayarak öğelerinin inArrayoffsetIn alt kümesi sayısal bir değer olarak alınır ve konumundan outArraybaşlayarak öğelerin offsetOut bir alt kümesine dönüştürülür. Dönüş değeri, içindeki outArraydönüştürülen öğelerin sayısını gösterir. alt kümesi outArray 64 tabanından oluşur.
Sıfırdan artan düzende 64 tabanındaki basamaklar büyük harf "A" ile "Z" arasında, küçük harfli "a" ile "z" arası karakterler, "0" ile "9" arasında sayılar ve "+" ve "/" simgeleridir. "=" değeri olmayan karakter, sondaki doldurma için kullanılır.
offset ve length parametreleri 32 bit imzalı sayılardır.
offsetIn ve offsetOut parametreleri sıfır tabanlı dizi konumlarıdır.
Important
ToBase64CharArray yöntemi, kodlanacak tüm verileri içeren tek bir bayt dizisini işlemek için tasarlanmıştır. Bayt akışından bir base-64 karakter dizisi oluşturmak için sınıfını System.Security.Cryptography.ToBase64Transform kullanın.
