BitConverter.ToInt32 Metod

Definition

Namnområde:
System
Sammansättningar:
netstandard.dll, System.Runtime.dll
Sammansättning:
System.Runtime.Extensions.dll
Sammansättning:
netstandard.dll
Sammansättningar:
mscorlib.dll, System.Runtime.Extensions.dll
Sammansättning:
mscorlib.dll

Överlagringar

Name Description
ToInt32(ReadOnlySpan<Byte>)

Konverterar ett skrivskyddat byteintervall till ett 32-bitars signerat heltal.
ToInt32(Byte[], Int32)

Returnerar ett 32-bitars signerat heltal som konverterats från fyra byte vid en angiven position i en bytematris.

ToInt32(ReadOnlySpan<Byte>)

Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs

Konverterar ett skrivskyddat byteintervall till ett 32-bitars signerat heltal.

public:
 static int ToInt32(ReadOnlySpan<System::Byte> value);
public static int ToInt32(ReadOnlySpan<byte> value);
static member ToInt32 : ReadOnlySpan<byte> -> int
Public Shared Function ToInt32 (value As ReadOnlySpan(Of Byte)) As Integer

Parametrar

value
ReadOnlySpan<Byte>

Ett skrivskyddat intervall som innehåller de byte som ska konverteras.

Returer

Int32

Ett 32-bitars signerat heltal som representerar de konverterade byteen.

Undantag

ArgumentOutOfRangeException

Längden value på är mindre än 4.

Gäller för

ToInt32(Byte[], Int32)

Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs

Returnerar ett 32-bitars signerat heltal som konverterats från fyra byte vid en angiven position i en bytematris.

public:
 static int ToInt32(cli::array <System::Byte> ^ value, int startIndex);
public static int ToInt32(byte[] value, int startIndex);
static member ToInt32 : byte[] * int -> int
Public Shared Function ToInt32 (value As Byte(), startIndex As Integer) As Integer

Parametrar

value
Byte[]

En matris med byte som innehåller de fyra byte som ska konverteras.

startIndex
Int32

Startpositionen inom value.

Returer

Int32

Ett 32-bitars signerat heltal som består av fyra byte från och med startIndex.

Undantag

ArgumentException

startIndex är större än eller lika med längden value på minus 3 och är mindre än eller lika med längden value på minus 1.

ArgumentNullException

value är null.

ArgumentOutOfRangeException

startIndex är mindre än noll eller större än längden value på minus 1.

Exempel

I följande exempel används ToInt32 metoden för att skapa Int32 värden från en matris med fyra byte och från de fyra övre byteen i en matris med åtta byte. Den använder GetBytes(Int32) också metoderna och ToInt32 för att tura om ett Int32 värde.

using System;

public class Example
{
   public static void Main()
   {
      // Create an Integer from a 4-byte array.
      Byte[] bytes1 = { 0xEC, 0x00, 0x00, 0x00 };
      Console.WriteLine("{0}--> 0x{1:X4} ({1:N0})", FormatBytes(bytes1),
                                      BitConverter.ToInt32(bytes1, 0));
      // Create an Integer from the upper four bytes of a byte array.
      Byte[] bytes2 = BitConverter.GetBytes(Int64.MaxValue / 2);
      Console.WriteLine("{0}--> 0x{1:X4} ({1:N0})", FormatBytes(bytes2),
                                      BitConverter.ToInt32(bytes2, 4));

      // Round-trip an integer value.
      int original = (int) Math.Pow(16, 3);
      Byte[] bytes3 = BitConverter.GetBytes(original);
      int restored = BitConverter.ToInt32(bytes3, 0);
      Console.WriteLine("0x{0:X4} ({0:N0}) --> {1} --> 0x{2:X4} ({2:N0})", original,
                        FormatBytes(bytes3), restored);
   }

   private static string FormatBytes(Byte[] bytes)
   {
       string value = "";
       foreach (var byt in bytes)
          value += string.Format("{0:X2} ", byt);

       return value;
   }
}
// The example displays the following output:
//       EC 00 00 00 --> 0x00EC (236)
//       FF FF FF FF FF FF FF 3F --> 0x3FFFFFFF (1,073,741,823)
//       0x1000 (4,096) --> 00 10 00 00  --> 0x1000 (4,096)

open System

let formatBytes (bytes: byte []) =
    bytes
    |> Array.map (fun x -> $"{x:X2}")
    |> String.concat ""

// Create an Integer from a 4-byte array.
let bytes1 = [| 0xECuy; 0x00uy; 0x00uy; 0x00uy |]
let int1  = BitConverter.ToInt32(bytes1, 0)
printfn $"{formatBytes bytes1}--> 0x{int1:X4} ({int1:N0})"

// Create an Integer from the upper four bytes of a byte array.
let bytes2 = BitConverter.GetBytes(Int64.MaxValue / 2L)
let int2 = BitConverter.ToInt32(bytes2, 4)
printfn $"{formatBytes bytes2}--> 0x{int2:X4} ({int2:N0})"

// Round-trip an integer value.
let original = pown 16 3
let bytes3 = BitConverter.GetBytes original
let restored = BitConverter.ToInt32(bytes3, 0)
printfn $"0x{original:X4} ({original:N0}) --> {formatBytes bytes3} --> 0x{restored:X4} ({restored:N0})"


// The example displays the following output:
//       EC 00 00 00 --> 0x00EC (236)
//       FF FF FF FF FF FF FF 3F --> 0x3FFFFFFF (1,073,741,823)
//       0x1000 (4,096) --> 00 10 00 00  --> 0x1000 (4,096)

Module Example
   Public Sub Main()
      ' Create an Integer from a 4-byte array.
      Dim bytes1() As Byte = { &hEC, &h00, &h00, &h00 }
      Console.WriteLine("{0}--> 0x{1:X4} ({1:N0})", FormatBytes(bytes1),
                                      BitConverter.ToInt32(bytes1, 0))
      ' Create an Integer from the upper four bytes of a byte array.
      Dim bytes2() As Byte = BitConverter.GetBytes(Int64.MaxValue \ 2)
      Console.WriteLine("{0}--> 0x{1:X4} ({1:N0})", FormatBytes(bytes2),
                                      BitConverter.ToInt32(bytes2, 4))
      
      ' Round-trip an integer value.
      Dim original As Integer = CInt(16^3)
      Dim bytes3() As Byte = BitConverter.GetBytes(original)
      Dim restored As Integer = BitConverter.ToInt32(bytes3, 0)
      Console.WriteLine("0x{0:X4} ({0:N0}) --> {1} --> 0x{2:X4} ({2:N0})", original, 
                        FormatBytes(bytes3), restored)
   End Sub
   
   Private Function FormatBytes(bytes() As Byte) As String
       Dim value As String = ""
       For Each byt In bytes
          value += String.Format("{0:X2} ", byt)
       Next
       Return value
   End Function
End Module
' The example displays the following output:
'       EC 00 00 00 --> 0x00EC (236)
'       FF FF FF FF FF FF FF 3F --> 0x3FFFFFFF (1,073,741,823)
'       0x1000 (4,096) --> 00 10 00 00  --> 0x1000 (4,096)

Kommentarer

Metoden ToInt32 konverterar byte från index startIndex till startIndex + 3 till ett Int32 värde. Ordningen på byte i matrisen måste återspegla endianiteten i datorsystemets arkitektur. Mer information finns i avsnittet Anmärkningar i BitConverter.

Se även

Gäller för