BitConverter Sınıf

Tanım

Temel veri türlerini bir bayt dizisine ve bir bayt dizisini taban veri türlerine dönüştürür.Converts base data types to an array of bytes, and an array of bytes to base data types.

public ref class BitConverter abstract sealed
public ref class BitConverter sealed
public static class BitConverter
public sealed class BitConverter
type BitConverter = class
Public Class BitConverter
Public NotInheritable Class BitConverter
Devralma
BitConverter

Örnekler

Aşağıdaki kod örneği, birkaç sınıf yönteminin kullanımını gösterir BitConverter .The following code example illustrates the use of several BitConverter class methods.

// Example of BitConverter class methods.
using namespace System;
int main()
{
   String^ formatter = "{0,25}{1,30}";
   double aDoubl = 0.1111111111111111111;
   float aSingl = 0.1111111111111111111F;
   __int64 aLong = 1111111111111111111;
   int anInt = 1111111111;
   short aShort = 11111;
   __wchar_t aChar = L'*';
   bool aBool = true;
   Console::WriteLine( "This example of methods of the BitConverter class"
   "\ngenerates the following output.\n" );
   Console::WriteLine( formatter, "argument", "byte array" );
   Console::WriteLine( formatter, "--------", "----------" );
   
   // Convert values to Byte arrays and display them.
   Console::WriteLine( formatter, aDoubl, BitConverter::ToString( BitConverter::GetBytes( aDoubl ) ) );
   Console::WriteLine( formatter, aSingl, BitConverter::ToString( BitConverter::GetBytes( aSingl ) ) );
   Console::WriteLine( formatter, aLong, BitConverter::ToString( BitConverter::GetBytes( aLong ) ) );
   Console::WriteLine( formatter, anInt, BitConverter::ToString( BitConverter::GetBytes( anInt ) ) );
   Console::WriteLine( formatter, aShort, BitConverter::ToString( BitConverter::GetBytes( aShort ) ) );
   Console::WriteLine( formatter, aChar, BitConverter::ToString( BitConverter::GetBytes( aChar ) ) );
   Console::WriteLine( formatter, aBool, BitConverter::ToString( BitConverter::GetBytes( aBool ) ) );
}

/*
This example of methods of the BitConverter class
generates the following output.

                 argument                    byte array
                 --------                    ----------
        0.111111111111111       1C-C7-71-1C-C7-71-BC-3F
                0.1111111                   39-8E-E3-3D
      1111111111111111111       C7-71-C4-2B-AB-75-6B-0F
               1111111111                   C7-35-3A-42
                    11111                         67-2B
                        *                         2A-00
                     True                            01
*/
// Example of BitConverter class methods.
using System;

class BitConverterDemo
{
    public static void Main( )
    {
        const string formatter = "{0,25}{1,30}";

        double  aDoubl  = 0.1111111111111111111;
        float   aSingl  = 0.1111111111111111111F;
        long    aLong   = 1111111111111111111;
        int     anInt   = 1111111111;
        short   aShort  = 11111;
        char    aChar   = '*';
        bool    aBool   = true;

        Console.WriteLine(
            "This example of methods of the BitConverter class" +
            "\ngenerates the following output.\n" );
        Console.WriteLine( formatter, "argument", "byte array" );
        Console.WriteLine( formatter, "--------", "----------" );

        // Convert values to Byte arrays and display them.
        Console.WriteLine( formatter, aDoubl,
            BitConverter.ToString( BitConverter.GetBytes( aDoubl ) ) );
        Console.WriteLine( formatter, aSingl,
            BitConverter.ToString( BitConverter.GetBytes( aSingl ) ) );
        Console.WriteLine( formatter, aLong,
            BitConverter.ToString( BitConverter.GetBytes( aLong ) ) );
        Console.WriteLine( formatter, anInt,
            BitConverter.ToString( BitConverter.GetBytes( anInt ) ) );
        Console.WriteLine( formatter, aShort,
            BitConverter.ToString( BitConverter.GetBytes( aShort ) ) );
        Console.WriteLine( formatter, aChar,
            BitConverter.ToString( BitConverter.GetBytes( aChar ) ) );
        Console.WriteLine( formatter, aBool,
            BitConverter.ToString( BitConverter.GetBytes( aBool ) ) );
    }
}

/*
This example of methods of the BitConverter class
generates the following output.

                 argument                    byte array
                 --------                    ----------
        0.111111111111111       1C-C7-71-1C-C7-71-BC-3F
                0.1111111                   39-8E-E3-3D
      1111111111111111111       C7-71-C4-2B-AB-75-6B-0F
               1111111111                   C7-35-3A-42
                    11111                         67-2B
                        *                         2A-00
                     True                            01
*/
' Example of BitConverter class methods.
Module BitConverterDemo

    Sub Main( )

        Const formatter As String = "{0,25}{1,30}"
 
        Dim aDoubl      As Double   = 0.1111111111111111111
        Dim aSingl      As Single   = 0.1111111111111111111
        Dim aLong       As Long     = 1111111111111111111
        Dim anInt       As Integer  = 1111111111
        Dim aShort      As Short    = 11111
        Dim aChar       As Char     = "*"c
        Dim aBool       As Boolean  = True

        Console.WriteLine( _
            "This example of methods of the BitConverter class" & _
            vbCrLf & "generates the following output." & vbCrLf )
        Console.WriteLine( formatter, "argument", "Byte array" )
        Console.WriteLine( formatter, "--------", "----------" )

        ' Convert values to Byte arrays and display them.
        Console.WriteLine( formatter, aDoubl, _
            BitConverter.ToString( BitConverter.GetBytes( aDoubl ) ) )
        Console.WriteLine( formatter, aSingl, _
            BitConverter.ToString( BitConverter.GetBytes( aSingl ) ) )
        Console.WriteLine( formatter, aLong, _
            BitConverter.ToString( BitConverter.GetBytes( aLong ) ) )
        Console.WriteLine( formatter, anInt, _
            BitConverter.ToString( BitConverter.GetBytes( anInt ) ) )
        Console.WriteLine( formatter, aShort, _
            BitConverter.ToString( BitConverter.GetBytes( aShort ) ) )
        Console.WriteLine( formatter, aChar, _
            BitConverter.ToString( BitConverter.GetBytes( aChar ) ) )
        Console.WriteLine( formatter, aBool, _
            BitConverter.ToString( BitConverter.GetBytes( aBool ) ) )
    End Sub
End Module

' This example of methods of the BitConverter class
' generates the following output.
' 
'                  argument                    Byte array
'                  --------                    ----------
'         0.111111111111111       1C-C7-71-1C-C7-71-BC-3F
'                 0.1111111                   39-8E-E3-3D
'       1111111111111111111       C7-71-C4-2B-AB-75-6B-0F
'                1111111111                   C7-35-3A-42
'                     11111                         67-2B
'                         *                         2A-00
'                      True                            01

Açıklamalar

BitConverterSınıfı, değer türlerini kendi temel biçimlerinde, bir dizi bayt olarak işlemenize yardımcı olur.The BitConverter class helps manipulate value types in their fundamental form, as a series of bytes. Bir bayt 8 bit işaretsiz tamsayı olarak tanımlanır.A byte is defined as an 8-bit unsigned integer. BitConverterSınıfı, aşağıdaki tabloda gösterildiği gibi, ilkel türlerin her birini bayt dizisine dönüştürmek için statik yöntemler içerir.The BitConverter class includes static methods to convert each of the primitive types to and from an array of bytes, as the following table illustrates.

TürType Bayttan bayta dönüştürmeTo byte conversion Bayt dönüşümdenFrom byte conversion
Boolean GetBytes(Boolean) ToBoolean
Char GetBytes(Char) ToChar
Double GetBytes(Double)

-veya--or-

DoubleToInt64Bits(Double)
ToDouble

-veya--or-

Int64BitsToDouble
Int16 GetBytes(Int16) ToInt16
Int32 GetBytes(Int32) ToInt32
Int64 GetBytes(Int64) ToInt64
Single GetBytes(Single) ToSingle
UInt16 GetBytes(UInt16) ToUInt16
UInt32 GetBytes(UInt32) ToUInt32
UInt64 GetBytes(UInt64) ToUInt64

BitConverterVerileri gidiş dönüş için kullanıyorsanız, GetBytes aşırı yükleme ve To tür yönteminin aynı türü belirtmesini sağlayın.If you use BitConverter methods to round-trip data, make sure that the GetBytes overload and the ToType method specify the same type. Aşağıdaki örnekte gösterildiği gibi, yöntemini çağırarak işaretli bir tamsayıyı temsil eden bir diziyi geri yüklemek, ToUInt32 orijinalden farklı bir değer oluşmasına neden olabilir.As the following example illustrates, restoring an array that represents a signed integer by calling the ToUInt32 method can result in a value that is different from the original. Daha fazla bilgi için, BCL ekip bloguna Işaretli ondalık olmayan ve bit düzeyinde değerler Ile çalışan girdiye bakın.For more information, see the entry Working with Signed Non-Decimal and Bitwise Values in the BCL Team Blog.

using System;

public class Example
{
   public static void Main()
   {
      int value = -16;
      Byte[] bytes = BitConverter.GetBytes(value);

      // Convert bytes back to Int32.
      int intValue = BitConverter.ToInt32(bytes, 0);
      Console.WriteLine("{0} = {1}: {2}",
                        value, intValue,
                        value.Equals(intValue) ? "Round-trips" : "Does not round-trip");
      // Convert bytes to UInt32.
      uint uintValue = BitConverter.ToUInt32(bytes, 0);
      Console.WriteLine("{0} = {1}: {2}", value, uintValue,
                        value.Equals(uintValue) ? "Round-trips" : "Does not round-trip");
   }
}
// The example displays the following output:
//       -16 = -16: Round-trips
//       -16 = 4294967280: Does not round-trip
Module Example
   Public Sub Main()
      Dim value As Integer = -16
      Dim bytes() As Byte = BitConverter.GetBytes(value) 
      
      ' Convert bytes back to Int32.
      Dim intValue As Integer = BitConverter.ToInt32(bytes, 0)
      Console.WriteLine("{0} = {1}: {2}", 
                        value, intValue, 
                        If(value.Equals(intValue), "Round-trips", "Does not round-trip"))
      ' Convert bytes to UInt32.
      Dim uintValue As UInteger = BitConverter.ToUInt32(bytes, 0)
      Console.WriteLine("{0} = {1}: {2}", value, uintValue, 
                        If(value.Equals(uintValue), "Round-trips", "Does not round-trip"))
   End Sub
End Module
' The example displays the following output:
'       -16 = -16: Round-trips
'       -16 = 4294967280: Does not round-trip

Yöntem aşırı yüklemeleri tarafından döndürülen dizideki baytların sırası (ve yöntemi tarafından döndürülen GetBytes tamsayının içindeki bitlerin sırası DoubleToInt64Bits ve yöntem tarafından döndürülen onaltılık dizelerin sırası ToString(Byte[]) ), bilgisayar mimarisinin az endian veya Big-endian olmasına bağlıdır.The order of bytes in the array returned by the GetBytes method overloads (as well as the order of bits in the integer returned by the DoubleToInt64Bits method and the order of hexadecimal strings returned by the ToString(Byte[]) method) depends on whether the computer architecture is little-endian or big-endian. Benzer şekilde, dizideki bayt sırası ve To ıntegervalue yöntemleri ile döndürülen ve ToChar yöntemi, bilgisayar mimarisinin az endian veya Big-endian olmasına bağlıdır.Similarly, the order of bytes in the array and returned by the ToIntegerValue methods and the ToChar method depends on whether the computer architecture is little-endian or big-endian. Bir mimarinin IsLittleEndian bitimliği, true küçük endian sistemleri ve büyük endian sistemlerinde döndürülen özelliği tarafından belirtilir false .The endianness of an architecture is indicated by the IsLittleEndian property, which returns true on little-endian systems and false on big-endian systems. Küçük endian sistemlerinde, düşük sıralı baytlar daha yüksek sıra baytından önce.On little-endian systems, lower-order bytes precede higher-order bytes. Büyük endian sisteminde, daha yüksek sıralı baytlar daha düşük sıra baytından önce.On big-endian system, higher-order bytes precede lower-order bytes. Aşağıdaki tabloda, 1.234.567.890 (0x499602D2) tamsayısının yöntemine geçirilmesiyle elde edilen bayt dizilerindeki fark gösterilmektedir GetBytes(Int32) .The following table illustrates the difference in the byte arrays that result from passing the integer 1,234,567,890 (0x499602D2) to the GetBytes(Int32) method. Baytlar 0 dizinindeki bayttan Dizin 3 ' teki bayta göre sıralanır.The bytes are listed in order from the byte at index 0 to the byte at index 3.

Küçük endianLittle-endian D2-02-96-49D2-02-96-49
Büyük endianBig-endian 49-96-02-D249-96-02-D2

Bazı yöntemlerin dönüş değeri sistem mimarisine bağlı olduğundan, bayt verilerini makine sınırlarının ötesinde iletirken dikkatli olun:Because the return value of some methods depends on system architecture, be careful when transmitting byte data beyond machine boundaries:

  • Veri gönderen ve alan tüm sistemlerin aynı bitime sahip olma garantisi varsa, verilere hiçbir şey yapılmaz.If all systems sending and receiving data are guaranteed to have the same endianness, nothing has be done to the data.

  • Veri gönderme ve alma sistemleri farklı bir sıraya sahip olabilir ve verileri her zaman belirli bir sırada iletir.If systems sending and receiving data can have different endianness, always transmit data in a particular order. Bu, dizideki bayt sırasının, gönderilmeden veya alındıktan sonra geri çevrilme olabileceği anlamına gelir.This means that the order of bytes in the array may have to be reversed either before sending them or after receiving them. Ortak bir kural, verileri ağ bayt düzeninde (Big-endian sıralaması) aktarmakdır.A common convention is to transmit data in network byte order (big-endian order). Aşağıdaki örnek, ağ bayt düzeninde tamsayı değeri göndermek için bir uygulama sağlar.The following example provides an implementation for sending an integer value in network byte order.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          int value = 12345678;
          byte[] bytes = BitConverter.GetBytes(value);
          Console.WriteLine(BitConverter.ToString(bytes));
    
          if (BitConverter.IsLittleEndian)
             Array.Reverse(bytes);
    
          Console.WriteLine(BitConverter.ToString(bytes));
          // Call method to send byte stream across machine boundaries.
    
          // Receive byte stream from beyond machine boundaries.
          Console.WriteLine(BitConverter.ToString(bytes));
          if (BitConverter.IsLittleEndian)
             Array.Reverse(bytes);
    
          Console.WriteLine(BitConverter.ToString(bytes));
          int result = BitConverter.ToInt32(bytes, 0);
          Console.WriteLine("Original value: {0}", value);
          Console.WriteLine("Returned value: {0}", result);
       }
    }
    // The example displays the following output on a little-endian system:
    //       4E-61-BC-00
    //       00-BC-61-4E
    //       00-BC-61-4E
    //       4E-61-BC-00
    //       Original value: 12345678
    //       Returned value: 12345678
    
    Module Example
       Public Sub Main()
          Dim value As Integer = 12345678
          Dim bytes() As Byte = BitConverter.GetBytes(value)
          Console.WriteLine(BitConverter.ToString(bytes))
          
          If BitConverter.IsLittleEndian Then
             Array.Reverse(bytes) 
          End If
          Console.WriteLine(BitConverter.ToString(bytes))
          ' Call method to send byte stream across machine boundaries.
          
          ' Receive byte stream from beyond machine boundaries.
          Console.WriteLine(BitConverter.ToString(bytes))
          If BitConverter.IsLittleEndian Then     
             Array.Reverse(bytes)
          End If   
          Console.WriteLine(BitConverter.ToString(bytes))
          Dim result As Integer = BitConverter.ToInt32(bytes, 0)
          Console.WriteLine("Original value: {0}", value)
          Console.WriteLine("Returned value: {0}", result)
       End Sub
    End Module
    ' The example displays the following output on a little-endian system:
    '       4E-61-BC-00
    '       00-BC-61-4E
    '       00-BC-61-4E
    '       4E-61-BC-00
    '       Original value: 12345678
    '       Returned value: 12345678
    
  • Veri gönderme ve alma sistemleri farklı bir bitime sahip olabilir ve iletilmek üzere veriler, imzalanmış tamsayılar içeriyorsa, IPAddress.HostToNetworkOrder verileri ağ baytı sırasına dönüştürmek için yöntemi ve IPAddress.NetworkToHostOrder alıcı tarafından istenen sıraya dönüştürme yöntemini çağırın.If systems sending and receiving data can have different endianness and the data to be transmitted consists of signed integers, call the IPAddress.HostToNetworkOrder method to convert the data to network byte order and the IPAddress.NetworkToHostOrder method to convert it to the order required by the recipient.

Alanlar

IsLittleEndian

Verilerin bu bilgisayar mimarisinde depolandığı bayt sırasını ("bitime") gösterir.Indicates the byte order ("endianness") in which data is stored in this computer architecture.

Yöntemler

DoubleToInt64Bits(Double)

Belirtilen çift duyarlıklı kayan noktalı sayıyı 64 bitlik işaretli bir tamsayıya dönüştürür.Converts the specified double-precision floating point number to a 64-bit signed integer.

GetBytes(Boolean)

Belirtilen Boolean değeri bir bayt dizisi olarak döndürür.Returns the specified Boolean value as a byte array.

GetBytes(Char)

Belirtilen Unicode karakter değerini bir bayt dizisi olarak döndürür.Returns the specified Unicode character value as an array of bytes.

GetBytes(Double)

Belirtilen çift duyarlıklı kayan nokta değerini bir bayt dizisi olarak döndürür.Returns the specified double-precision floating point value as an array of bytes.

GetBytes(Int16)

Belirtilen 16 bit işaretli tamsayı değerini bir bayt dizisi olarak döndürür.Returns the specified 16-bit signed integer value as an array of bytes.

GetBytes(Int32)

Belirtilen 32 bitlik işaretli tamsayı değerini bir bayt dizisi olarak döndürür.Returns the specified 32-bit signed integer value as an array of bytes.

GetBytes(Int64)

Belirtilen 64 bitlik işaretli tamsayı değerini bir bayt dizisi olarak döndürür.Returns the specified 64-bit signed integer value as an array of bytes.

GetBytes(Single)

Belirtilen tek duyarlıklı kayan nokta değerini bir bayt dizisi olarak döndürür.Returns the specified single-precision floating point value as an array of bytes.

GetBytes(UInt16)

Belirtilen 16 bit işaretsiz tamsayı değerini bir bayt dizisi olarak döndürür.Returns the specified 16-bit unsigned integer value as an array of bytes.

GetBytes(UInt32)

Belirtilen 32 bitlik işaretsiz tamsayı değerini bir bayt dizisi olarak döndürür.Returns the specified 32-bit unsigned integer value as an array of bytes.

GetBytes(UInt64)

Belirtilen 64 bitlik işaretsiz tamsayı değerini bir bayt dizisi olarak döndürür.Returns the specified 64-bit unsigned integer value as an array of bytes.

Int32BitsToSingle(Int32)

Belirtilen 32 bitlik tamsayıyı tek duyarlıklı kayan noktalı bir değer olarak yeniden yorumlar.Reinterprets the specified 32-bit integer as a single-precision floating-point value.

Int64BitsToDouble(Int64)

Belirtilen 64 bitlik işaretli tamsayıyı bir çift duyarlıklı kayan noktalı sayı olarak yeniden yorumlar.Reinterprets the specified 64-bit signed integer to a double-precision floating point number.

SingleToInt32Bits(Single)

Tek duyarlıklı kayan noktalı değeri tamsayıya dönüştürür.Converts a single-precision floating-point value into an integer.

ToBoolean(Byte[], Int32)

Bayt dizisindeki belirtilen konumdaki bayttan dönüştürülmüş bir Boole değeri döndürür.Returns a Boolean value converted from the byte at a specified position in a byte array.

ToBoolean(ReadOnlySpan<Byte>)

Salt okunurdur bayt yayılımını Boole değerine dönüştürür.Converts a read-only byte span to a Boolean value.

ToChar(Byte[], Int32)

Bayt dizisindeki belirtilen konumdaki iki bayttan dönüştürülmüş bir Unicode karakteri döndürür.Returns a Unicode character converted from two bytes at a specified position in a byte array.

ToChar(ReadOnlySpan<Byte>)

Salt okunurdur bayt yayılımını bir karaktere dönüştürür.Converts a read-only byte span into a character.

ToDouble(Byte[], Int32)

Bir bayt dizisindeki belirtilen konumdaki sekiz bayttan dönüştürülmüş bir çift duyarlıklı kayan noktalı sayı döndürür.Returns a double-precision floating point number converted from eight bytes at a specified position in a byte array.

ToDouble(ReadOnlySpan<Byte>)

Salt okunurdur bir bayt yayılımını çift duyarlıklı kayan noktalı değere dönüştürür.Converts a read-only byte span into a double-precision floating-point value.

ToInt16(Byte[], Int32)

Bayt dizisindeki belirtilen konumdaki iki bayttan dönüştürülen 16 bitlik işaretli bir tamsayı döndürür.Returns a 16-bit signed integer converted from two bytes at a specified position in a byte array.

ToInt16(ReadOnlySpan<Byte>)

Salt okunurdur bayt yayılımını 16 bit işaretli tamsayıya dönüştürür.Converts a read-only byte span into a 16-bit signed integer.

ToInt32(Byte[], Int32)

Bayt dizisindeki belirtilen konumda dört bayttan dönüştürülen 32 bitlik işaretli bir tamsayı döndürür.Returns a 32-bit signed integer converted from four bytes at a specified position in a byte array.

ToInt32(ReadOnlySpan<Byte>)

Salt okunurdur bir bayt aralığını 32 bitlik işaretli tamsayıya dönüştürür.Converts a read-only byte span into a 32-bit signed integer.

ToInt64(Byte[], Int32)

Bir bayt dizisindeki belirtilen konumdaki sekiz bayttan dönüştürülen 64 bitlik işaretli bir tamsayı döndürür.Returns a 64-bit signed integer converted from eight bytes at a specified position in a byte array.

ToInt64(ReadOnlySpan<Byte>)

Salt okunurdur bir bayt aralığını 64 bitlik işaretli tamsayıya dönüştürür.Converts a read-only byte span into a 64-bit signed integer.

ToSingle(Byte[], Int32)

Bayt dizisindeki belirtilen konumda dört bayttan dönüştürülen tek duyarlıklı kayan noktalı sayı döndürür.Returns a single-precision floating point number converted from four bytes at a specified position in a byte array.

ToSingle(ReadOnlySpan<Byte>)

Salt okunurdur bir bayt yayılımını çift duyarlıklı kayan noktalı değere dönüştürür.Converts a read-only byte span into a double-precision floating-point value.

ToString(Byte[])

Belirtilen bayt dizisinin her öğesinin sayısal değerini eşdeğer onaltılık dize gösterimine dönüştürür.Converts the numeric value of each element of a specified array of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32)

Belirtilen bir alt dizinin her bir öğesinin sayısal değerini eşdeğer onaltılı dize gösterimine dönüştürür.Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32, Int32)

Belirtilen bir alt dizinin her bir öğesinin sayısal değerini eşdeğer onaltılı dize gösterimine dönüştürür.Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToUInt16(Byte[], Int32)

Bayt dizisindeki belirtilen konumdaki iki bayttan dönüştürülen 16 bit işaretsiz bir tamsayı döndürür.Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.

ToUInt16(ReadOnlySpan<Byte>)

Salt okunurdur bir bayt yayılımını 16 bit işaretsiz tamsayıya dönüştürür.Converts a read-only byte-span into a 16-bit unsigned integer.

ToUInt32(Byte[], Int32)

Bayt dizisindeki belirtilen konumda dört bayttan dönüştürülen 32 bitlik işaretsiz bir tamsayı döndürür.Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.

ToUInt32(ReadOnlySpan<Byte>)

Salt okunurdur bir bayt aralığını 32 bitlik işaretsiz tamsayıya dönüştürür.Converts a read-only byte span into a 32-bit unsigned integer.

ToUInt64(Byte[], Int32)

Bir bayt dizisindeki belirtilen konumdaki sekiz bayttan dönüştürülen 64 bitlik işaretsiz bir tamsayı döndürür.Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.

ToUInt64(ReadOnlySpan<Byte>)

Baytları işaretsiz bir Long değerine dönüştürür.Converts bytes into an unsigned long.

TryWriteBytes(Span<Byte>, Boolean)

Boole değeri bayt aralığına dönüştürür.Converts a Boolean into a span of bytes.

TryWriteBytes(Span<Byte>, Char)

Bir karakteri bayt aralığına dönüştürür.Converts a character into a span of bytes.

TryWriteBytes(Span<Byte>, Double)

Çift duyarlıklı kayan nokta değerini bayt aralığına dönüştürür.Converts a double-precision floating-point value into a span of bytes.

TryWriteBytes(Span<Byte>, Int16)

16 bit işaretli tamsayıyı bayt aralığına dönüştürür.Converts a 16-bit signed integer into a span of bytes.

TryWriteBytes(Span<Byte>, Int32)

32 bitlik işaretli bir tamsayıyı bayt aralığına dönüştürür.Converts a 32-bit signed integer into a span of bytes.

TryWriteBytes(Span<Byte>, Int64)

64 bitlik işaretli bir tamsayıyı bayt aralığına dönüştürür.Converts a 64-bit signed integer into a span of bytes.

TryWriteBytes(Span<Byte>, Single)

Çift duyarlıklı kayan nokta değerini bayt aralığına dönüştürür.Converts a double-precision floating-point value into a span of bytes.

TryWriteBytes(Span<Byte>, UInt16)

İşaretsiz 16 bit tamsayıyı bayt aralığına dönüştürür.Converts an unsigned 16-bit integer into a span of bytes.

TryWriteBytes(Span<Byte>, UInt32)

32 bitlik işaretsiz bir tamsayıyı bayt aralığına dönüştürür.Converts a 32-bit unsigned integer into a span of bytes.

TryWriteBytes(Span<Byte>, UInt64)

İşaretsiz 64 bitlik bir tamsayıyı bayt aralığına dönüştürür.Converts an unsigned 64-bit integer into a span of bytes.

Şunlara uygulanır

Ayrıca bkz.