BigInteger.ToByteArray Metode

Definisi

Ruang nama:

System.Numerics

Rakitan:

System.Runtime.Numerics.dll

Overload

ToByteArray()	BigInteger Mengonversi nilai menjadi array byte.
ToByteArray(Boolean, Boolean)	Mengembalikan nilai ini BigInteger sebagai array byte menggunakan jumlah byte sekecil mungkin. Jika nilainya nol, mengembalikan array dari satu byte yang elemennya 0x00.

ToByteArray()

Sumber:

BigInteger.cs

BigInteger Mengonversi nilai menjadi array byte.

public:
 cli::array <System::Byte> ^ ToByteArray();

public byte[] ToByteArray ();

member this.ToByteArray : unit -> byte[]

Public Function ToByteArray () As Byte()

Mengembalikan

Byte[]

Nilai objek saat ini BigInteger dikonversi ke array byte.

Contoh

Contoh berikut menggambarkan bagaimana beberapa BigInteger nilai diwakili dalam array byte.

using System;
using System.Numerics;

public class Example
{
   static byte[] bytes;

   public static void Main()
   {
      BigInteger[] numbers = { BigInteger.MinusOne, BigInteger.One,
                               BigInteger.Zero, 120, 128, 255, 1024,
                               Int64.MinValue, Int64.MaxValue,
                               BigInteger.Parse("90123123981293054321") };
      foreach (BigInteger number in numbers)
      {
         bytes = number.ToByteArray();
         Console.Write("{0} ({1}) -> ", number, number.ToString(GetSpecifier()));
         Console.Write("{0} bytes: ", bytes.Length);
         foreach (byte byteValue in bytes)
            Console.Write("{0:X2} ", byteValue);

         Console.WriteLine();
      }
   }

   private static string GetSpecifier()
   {
      return "X" + (bytes.Length * 2).ToString();
   }
}
// The example displays the following output:
//    -1 (FF) -> 1 bytes: FF
//    1 (01) -> 1 bytes: 01
//    0 (00) -> 1 bytes: 00
//    120 (78) -> 1 bytes: 78
//    128 (0080) -> 2 bytes: 80 00
//    255 (00FF) -> 2 bytes: FF 00
//    1024 (0400) -> 2 bytes: 00 04
//    -9223372036854775808 (8000000000000000) -> 8 bytes: 00 00 00 00 00 00 00 80
//    9223372036854775807 (7FFFFFFFFFFFFFFF) -> 8 bytes: FF FF FF FF FF FF FF 7F
//    90123123981293054321 (04E2B5A7C4A975E971) -> 9 bytes: 71 E9 75 A9 C4 A7 B5 E2 04

open System
open System.Numerics

let numbers =
    [| BigInteger.MinusOne
       BigInteger.One
       BigInteger.Zero
       120
       128
       255
       1024
       Int64.MinValue
       Int64.MaxValue
       BigInteger.Parse("90123123981293054321") |]

for number in numbers do
    let bytes = number.ToByteArray()
    printf $"""{number} ({number.ToString("X" + (bytes.Length * 2).ToString())}) -> """
    printf $"{bytes.Length} bytes: "

    for byteValue in bytes do
        printf $"{byteValue:X2} "

    printfn ""

// The example displays the following output:
//    -1 (FF) -> 1 bytes: FF
//    1 (01) -> 1 bytes: 01
//    0 (00) -> 1 bytes: 00
//    120 (78) -> 1 bytes: 78
//    128 (0080) -> 2 bytes: 80 00
//    255 (00FF) -> 2 bytes: FF 00
//    1024 (0400) -> 2 bytes: 00 04
//    -9223372036854775808 (8000000000000000) -> 8 bytes: 00 00 00 00 00 00 00 80
//    9223372036854775807 (7FFFFFFFFFFFFFFF) -> 8 bytes: FF FF FF FF FF FF FF 7F
//    90123123981293054321 (04E2B5A7C4A975E971) -> 9 bytes: 71 E9 75 A9 C4 A7 B5 E2 04

Imports System.Numerics

Module Example
   Dim bytes() As Byte
      
   Public Sub Main()
      Dim numbers() As BigInteger = { BigInteger.MinusOne, BigInteger.One, 
                                      BigInteger.Zero, 120, 128, 255, 1024, 
                                      Int64.MinValue, Int64.MaxValue, 
                                      BigInteger.Parse("90123123981293054321") }
      For Each number As BigInteger In numbers
         bytes = number.ToByteArray()
         Console.Write("{0} ({1}) -> ", number, number.ToString(GetSpecifier()))
         Console.Write("{0} bytes: ", bytes.Length)
         For Each byteValue As Byte In bytes
            Console.Write("{0:X2} ", byteValue)
         Next
         Console.WriteLine()
      Next   
   End Sub
   
   Private Function GetSpecifier() As String
      Return "X" + CStr(bytes.Length * 2)
   End Function
End Module
' The example displays the following output:
'    -1 (FF) -> 1 bytes: FF
'    1 (01) -> 1 bytes: 01
'    0 (00) -> 1 bytes: 00
'    120 (78) -> 1 bytes: 78
'    128 (0080) -> 2 bytes: 80 00
'    255 (00FF) -> 2 bytes: FF 00
'    1024 (0400) -> 2 bytes: 00 04
'    -9223372036854775808 (8000000000000000) -> 8 bytes: 00 00 00 00 00 00 00 80
'    9223372036854775807 (7FFFFFFFFFFFFFFF) -> 8 bytes: FF FF FF FF FF FF FF 7F
'    90123123981293054321 (04E2B5A7C4A975E971) -> 9 bytes: 71 E9 75 A9 C4 A7 B5 E2 04

Keterangan

Byte individual dalam array yang dikembalikan oleh metode ini muncul dalam urutan little-endian. Artinya, byte urutan yang lebih rendah dari nilai mendahului byte dengan urutan yang lebih tinggi. Byte pertama dari array mencerminkan delapan bit pertama dari BigInteger nilai, byte kedua mencerminkan delapan bit berikutnya, dan sebagainya. Misalnya, nilai 1024, atau 0x0400, disimpan sebagai array dua byte berikut:

Elemen	Nilai byte
0	0x00
1	0x04

Nilai negatif ditulis ke array menggunakan representasi pelengkap dua dalam bentuk yang paling ringkas. Misalnya, -1 direpresentasikan sebagai byte tunggal yang nilainya 0xFF bukan sebagai array dengan beberapa elemen, seperti 0xFF, 0xFF atau 0xFF, 0xFF, 0xFF, 0xFF.

Karena representasi pelengkap dua selalu menafsirkan bit urutan tertinggi dari byte terakhir dalam array (byte pada posisi Array.Length- 1) sebagai bit tanda, metode mengembalikan array byte dengan elemen tambahan yang nilainya nol untuk membedakan nilai positif yang dapat ditafsirkan sebagai memiliki bit tanda yang ditetapkan. Misalnya, nilai 120 atau 0x78 direpresentasikan sebagai array byte tunggal: 0x78. Namun, 128, atau 0x80, direpresentasikan sebagai array dua byte: 0x80, 0x00.

Anda dapat melakukan round-trip BigInteger nilai dengan menyimpannya ke array byte lalu memulihkannya menggunakan BigInteger(Byte[]) konstruktor.

Perhatian

Jika kode Anda memodifikasi nilai byte individual dalam array yang dikembalikan oleh metode ini sebelum memulihkan nilai, Anda harus memastikan bahwa Anda tidak secara tidak sengaja mengubah bit tanda. Misalnya, jika modifikasi Anda meningkatkan nilai positif sehingga bit urutan tertinggi di elemen terakhir array byte menjadi diatur, Anda dapat menambahkan byte baru yang nilainya nol ke akhir array.

ToByteArray(Boolean, Boolean)

Sumber:

BigInteger.cs

Mengembalikan nilai ini BigInteger sebagai array byte menggunakan jumlah byte sekecil mungkin. Jika nilainya nol, mengembalikan array dari satu byte yang elemennya 0x00.

public byte[] ToByteArray (bool isUnsigned = false, bool isBigEndian = false);

member this.ToByteArray : bool * bool -> byte[]

Public Function ToByteArray (Optional isUnsigned As Boolean = false, Optional isBigEndian As Boolean = false) As Byte()

Parameter

isUnsigned

Boolean

true untuk menggunakan pengodean yang tidak ditandatangani; jika tidak, false.

isBigEndian

Boolean

true untuk menulis byte dalam urutan byte big-endian; jika tidak, false.

Mengembalikan

Byte[]

Nilai objek saat ini BigInteger dikonversi ke array byte.

Pengecualian

OverflowException

Jika isUnsigned adalah true dan Sign negatif.

Keterangan

Nilai bilangan bulat 33022 dapat diekspor dalam empat array yang berbeda:

Properti	Hasil
isUnsigned: false, isBigEndian: false	new byte[] { 0xFE, 0x80, 0x00 }
isUnsigned: false, isBigEndian: true	new byte[] { 0x00, 0x80, 0xFE }
isUnsigned: true, isBigEndian: false	new byte[] { 0xFE, 0x80 }
isUnsigned: true, isBigEndian: true	new byte[] { 0x80, 0xFE }