Convert.ToBase64CharArray Метод
Определение
Важно!
Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Преобразует подмножество массива 8-разрядных целых чисел без знака в эквивалентное подмножество массива знаков Юникода, состоящее из цифр в кодировке Base64.
Перегрузки
| ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions) |
Преобразует подмножество массива 8-разрядных целых чисел без знака в эквивалентное подмножество массива знаков Юникода, состоящее из цифр в кодировке Base64. В параметрах задаются подмножества как смещение во входном и выходном массивах и количество преобразуемых элементов входного массива, а также значение, указывающее, следует ли вставлять в выходной массив разрывы строки. |
| ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32) |
Преобразует подмножество массива 8-разрядных целых чисел без знака в эквивалентное подмножество массива знаков Юникода, состоящее из цифр в кодировке Base64. Подмножества задаются с помощью параметров как смещение во входном и выходном массивах и количество преобразуемых элементов входного массива. |
ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)
- Исходный код:
- Convert.cs
- Исходный код:
- Convert.cs
- Исходный код:
- Convert.cs
Преобразует подмножество массива 8-разрядных целых чисел без знака в эквивалентное подмножество массива знаков Юникода, состоящее из цифр в кодировке Base64. В параметрах задаются подмножества как смещение во входном и выходном массивах и количество преобразуемых элементов входного массива, а также значение, указывающее, следует ли вставлять в выходной массив разрывы строки.
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 IntegerПараметры
- inArray
- Byte[]
Входной массив 8-битовых целых чисел без знака.
- offsetIn
- Int32
Позиция в массиве inArray.
- length
- Int32
Число преобразуемых элементов inArray.
- outArray
- Char[]
Выходной массив знаков Юникода.
- offsetOut
- Int32
Позиция в массиве outArray.
- options
- Base64FormattingOptions
InsertLineBreaks для вставки разрыва строки после каждых 76 знаков или None, чтобы разрывы строки не вставлялись.
Возвращаемое значение
32-битовое целое число со знаком, представляющее число байтов в массиве outArray.
- Атрибуты
Исключения
Параметр inArray или outArray имеет значение null.
offsetIn, offsetOut или length является отрицательным значением.
-или-
Сумма значений offsetIn и length превышает длину массива inArray.
-или-
offsetOut плюс количество возвращаемых элементов превышает длину массива outArray.
options не является допустимым значением Base64FormattingOptions.
Примеры
В следующем примере демонстрируется ToBase64CharArray метод. Входные данные делятся на группы по три байта (по 24 бита). Следовательно, каждая группа состоит из четырех 6-разрядных чисел, в которых каждое число имеет диапазон от десятичных разрядов от 0 до 63. В этом примере существует 85 3-байтовых групп с одним оставшимся байтом. Первая группа состоит из шестнадцатеричных значений 00, 01 и 02, которые дают четыре 6-разрядных значения, равные десятичным 0, 0, 4 и 2. Эти четыре значения соответствуют 64-разрядным цифрам "A", "A", "E" и "C" в начале выходных данных.
Если целое число 3-байтовых групп не существует, оставшиеся байты фактически заполняются нулями, чтобы сформировать полную группу. В этом примере значение последнего байта — шестнадцатеричное значение FF. Первые 6 бит равны десятичному разряду 63, что соответствует цифре "/" в конце выходных данных, а следующие 2 бита заполняются нулями, чтобы получить десятичное число 48, соответствующее цифре base-64, "w". Последние два 6-разрядных значения являются заполнением и соответствуют символу заполнения без значений "=".
// 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
Комментарии
Подмножество элементов параметра, начиная с позиции offsetIn, принимается как числовое значение и преобразуется в подмножество элементов в параметре outArray , начиная с позиции offsetOut.inArraylength Возвращаемое значение указывает количество преобразованных элементов в outArray. Подмножество outArray состоит из 64 цифр.
Цифры base-64 в порядке возрастания от нуля — это символы верхнего регистра от "A" до "Z", символы нижнего регистра от "a" до "z", числа от "0" до "9", а также символы "+" и "/". Для отбивки в конце используется бесценный символ "=".
Параметры offset и length представляют собой 32-разрядные цифры со знаком. Параметры offsetIn и offsetOut представляют собой отсчитываемые от нуля позиции массива.
Важно!
Метод ToBase64CharArray предназначен для обработки одного массива байтов, содержащего все кодируемые данные. Чтобы создать массив символов base-64 из потока байтов, используйте System.Security.Cryptography.ToBase64Transform класс .
options Если параметр имеет значение InsertLineBreaks , а выходные данные преобразования длиннее 76 символов, разрыв строки вставляется каждые 76 символов. Разрыв строки определяется как символ возврата каретки (U+000D), за которым следует символ перевода строки (U+000A). Дополнительные сведения см. в статье RFC 2045, "Многоцелевые расширения почты Интернета" на странице https://www.rfc-editor.org/.
См. также раздел
Применяется к
ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)
- Исходный код:
- Convert.cs
- Исходный код:
- Convert.cs
- Исходный код:
- Convert.cs
Преобразует подмножество массива 8-разрядных целых чисел без знака в эквивалентное подмножество массива знаков Юникода, состоящее из цифр в кодировке Base64. Подмножества задаются с помощью параметров как смещение во входном и выходном массивах и количество преобразуемых элементов входного массива.
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 IntegerПараметры
- inArray
- Byte[]
Входной массив 8-битовых целых чисел без знака.
- offsetIn
- Int32
Позиция в массиве inArray.
- length
- Int32
Число преобразуемых элементов inArray.
- outArray
- Char[]
Выходной массив знаков Юникода.
- offsetOut
- Int32
Позиция в массиве outArray.
Возвращаемое значение
32-битовое целое число со знаком, представляющее число байтов в массиве outArray.
Исключения
Параметр inArray или outArray имеет значение null.
offsetIn, offsetOut или length является отрицательным значением.
-или-
Сумма значений offsetIn и length превышает длину массива inArray.
-или-
offsetOut плюс количество возвращаемых элементов превышает длину массива outArray.
Примеры
В следующем примере демонстрируется использование ToBase64CharArray метода UUencode (кодирование в base 64) двоичного потока, а затем сохранение кодировки в файл.
public:
void EncodeWithCharArray()
{
FileStream^ inFile;
array<Byte>^binaryData;
try
{
inFile = gcnew FileStream( inputFileName,
FileMode::Open,
FileAccess::Read );
binaryData = gcnew array<Byte>((int)(inFile->Length));
long bytesRead = inFile->Read( binaryData, 0,
(int)inFile->Length );
inFile->Close();
}
catch ( Exception^ exp )
{
// Error creating stream or reading from it.
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.0 / 3.0) * 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;
}
array<Char>^ base64CharArray = gcnew array<Char>(arrayLength);
try
{
Convert::ToBase64CharArray( binaryData,
0,
binaryData->Length,
base64CharArray, 0 );
}
catch ( ArgumentNullException^ )
{
Console::WriteLine( "Binary data array is null." );
return;
}
catch ( ArgumentOutOfRangeException^ )
{
Console::WriteLine( "Char Array is not large enough." );
return;
}
// Write the UUEncoded version to the output file.
StreamWriter^ outFile;
try
{
outFile = gcnew StreamWriter( outputFileName,
false,
Text::Encoding::ASCII );
outFile->Write( base64CharArray );
outFile->Close();
}
catch ( Exception^ exp )
{
// Error creating stream or writing to it.
Console::WriteLine( " {0}", exp->Message );
}
}
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
Комментарии
Подмножество length элементов inArray , начиная с позиции offsetIn, принимается как числовое значение и преобразуется в подмножество элементов, outArray начиная с позиции offsetOut. Возвращаемое значение указывает количество преобразованных элементов в outArray. Подмножество outArray состоит из 64 цифр.
Цифры base-64 в порядке возрастания от нуля — это символы верхнего регистра от "A" до "Z", символы нижнего регистра от "a" до "z", числа от "0" до "9", а также символы "+" и "/". Для отбивки в конце используется бесценный символ "=".
Параметры offset и length представляют собой 32-разрядные цифры со знаком. Параметры offsetIn и offsetOut представляют собой отсчитываемые от нуля позиции массива.
Важно!
Метод ToBase64CharArray предназначен для обработки одного массива байтов, содержащего все кодируемые данные. Чтобы создать массив символов base-64 из потока байтов, используйте System.Security.Cryptography.ToBase64Transform класс .
См. также раздел
Применяется к
Обратная связь
Ожидается в ближайшее время: в течение 2024 года мы постепенно откажемся от GitHub Issues как механизма обратной связи для контента и заменим его новой системой обратной связи. Дополнительные сведения см. в разделе https://aka.ms/ContentUserFeedback.
Отправить и просмотреть отзыв по