BigInteger.ToByteArray Yöntem

Tanım

Ad Alanı:

System.Numerics

Bütünleştirilmiş Kod:

System.Runtime.Numerics.dll

Aşırı Yüklemeler

ToByteArray()	Bir BigInteger değeri bayt dizisine dönüştürür.
ToByteArray(Boolean, Boolean)	Bunun değerini BigInteger mümkün olan en az bayt sayısını kullanarak bayt dizisi olarak döndürür. Değer sıfırsa, öğesi 0x00 olan bir baytlık bir dizi döndürür.

ToByteArray()

Kaynak:

BigInteger.cs

Bir BigInteger değeri bayt dizisine dönüştürür.

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

public byte[] ToByteArray ();

member this.ToByteArray : unit -> byte[]

Public Function ToByteArray () As Byte()

Döndürülenler

Byte[]

Geçerli BigInteger nesnenin bayt dizisine dönüştürülen değeri.

Örnekler

Aşağıdaki örnekte, bazı BigInteger değerlerin bayt dizilerinde nasıl gösterildiği gösterilmektedir.

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

Açıklamalar

Bu yöntem tarafından döndürülen dizideki tek tek baytlar küçük endian sırada görünür. Başka bir ifadeyle, değerin alt sıralı baytları daha yüksek sıralı baytlardan öncedir. Dizinin ilk baytı değerin ilk sekiz bitini BigInteger , ikinci bayt ise sonraki sekiz biti yansıtır ve bu şekilde devam eder. Örneğin, 1024 veya 0x0400 değeri aşağıdaki iki bayt dizisi olarak depolanır:

Öğe	Bayt değeri
0	0x00
1	0x04

Negatif değerler, mümkün olan en küçük biçimde ikinin tamamlayıcı gösterimi kullanılarak diziye yazılır. Örneğin, -1 değeri , veya 0xFF0xFF0xFF0xFF, gibi birden çok öğe içeren bir dizi yerine tek bir bayt olarak 0xFF0xFFtemsil edilir.0xFF

İkinin tamamlayıcı gösterimi her zaman dizideki son baytın en yüksek sıralı bitini (konumundaki Array.Length- 1bayt) işaret biti olarak yorumladığı için, yöntemi değeri sıfır olan ve pozitif değerlerin belirsiz olmasını sağlamak için değeri sıfır olan ve işaret bitlerinin ayarlanmış olduğu şeklinde yorumlanacak bir bayt dizisi döndürür. Örneğin, 120 veya 0x78 değeri tek baytlık bir dizi olarak temsil edilir: 0x78. Ancak, 128 veya 0x80, iki baytlık bir dizi olarak temsil edilir: 0x80, 0x00.

Bir değeri bir BigInteger bayt dizisine depolayıp oluşturucuyu kullanarak BigInteger(Byte[]) geri yükleyerek gidiş dönüş yapabilirsiniz.

Dikkat

Kodunuz, değeri geri yüklemeden önce bu yöntem tarafından döndürülen dizideki tek tek baytların değerini değiştirirse, işaret bitini istemeden değiştirmediğinizden emin olmanız gerekir. Örneğin, yaptığınız değişiklikler pozitif bir değeri artırarak bayt dizisinin son öğesindeki en yüksek sıralı bitin ayarlanmasını sağlarsa, dizinin sonuna değeri sıfır olan yeni bir bayt ekleyebilirsiniz.

ToByteArray(Boolean, Boolean)

Kaynak:

BigInteger.cs

Bunun değerini BigInteger mümkün olan en az bayt sayısını kullanarak bayt dizisi olarak döndürür. Değer sıfırsa, öğesi 0x00 olan bir baytlık bir dizi döndürür.

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()

Parametreler

isUnsigned

Boolean

true imzalanmamış kodlama kullanmak için; aksi takdirde , false.

isBigEndian

Boolean

true baytları büyük endian bayt sırasına göre yazmak için; aksi takdirde , false.

Döndürülenler

Byte[]

Geçerli BigInteger nesnenin bayt dizisine dönüştürülen değeri.

Özel durumlar

OverflowException

true Sign Ve isUnsigned negatifse.

Açıklamalar

Tamsayı değeri 33022 dört farklı dizide dışarı aktarılabilir:

Özellikler	Sonuç
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 }