BigInteger.ToByteArray Yöntem

Tanım

Ad Alanı:

System.Numerics

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.Numerics.dll

Aşırı Yüklemeler

Name	Description
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 sonraki sekiz biti yansıtır ve bu şekilde devam eder. Örneğin, 1024 veya 0x0400 değeri aşağıdaki iki baytlık dizi olarak depolanır:

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

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

İkinin tamamlayıcı gösterimi her zaman dizideki son baytın en yüksek sıralı bitini (konumdaki Array.Length- 1bayt) işaret biti olarak yorumladığı için, yöntemi değeri sıfır olan ve pozitif değerlerin işaret bitlerinin ayarlanmış olduğu olarak yorumlanabilecek pozitif değerlerin bölünebilmesi için sıfır olan ek bir öğe içeren 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 bayt BigInteger dizisine depolayıp oluşturucuyu kullanarak BigInteger(Byte[]) geri yükleyerek gidiş dönüş yapabilirsiniz.

Caution

Kodunuz, değeri geri yüklemeden önce bu yöntem tarafından döndürülen dizideki tek tek bayt 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 bayt dizisinin son öğesindeki en yüksek sıralı bitin ayarlanması için pozitif bir değeri artırırsa, 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 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

isUnsigned true Ve negatifseSign.

Açıklamalar

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

Properties	Result
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 }