BitConverter BitConverter BitConverter BitConverter Class

定义

将基数据类型转换为一个字节数组以及将一个字节数组转换为基数据类型。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 static class BitConverter
type BitConverter = class
Public Class BitConverter
继承
BitConverterBitConverterBitConverterBitConverter

示例

下面的代码示例演示如何使用多个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

注解

BitConverter类可帮助作为一系列字节操作其基本窗体中的值类型。The BitConverter class helps manipulate value types in their fundamental form, as a series of bytes. 一个字节被定义为一个 8 位无符号整数。A byte is defined as an 8-bit unsigned integer. BitConverter类包括下表说明了用于与从字节数组转换每个基元类型的静态方法。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.

类型Type 转换为字节To byte conversion 从字节转换From byte conversion
Boolean GetBytes(Boolean) ToBoolean
Char GetBytes(Char) ToChar
Double GetBytes(Double)

-or-

DoubleToInt64Bits(Double)
ToDouble

-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

如果您使用BitConverter方法往返数据,请确保GetBytes重载并To类型方法指定相同的类型。If you use BitConverter methods to round-trip data, make sure that the GetBytes overload and the ToType method specify the same type. 如下面的示例所示,还原一个数组,表示有符号的整数,通过调用ToUInt32方法可能会导致不同于原始值。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. 有关详细信息,请参阅文章使用已签名的非十进制和按位值BCL 团队博客中。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

返回的数组中的字节顺序GetBytes方法重载 (以及中返回的整数位的顺序DoubleToInt64Bits方法,并返回的十六进制字符串的顺序ToString(Byte[])方法) 取决于是否计算机体系结构是 little-endian 还是 big endian。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. 同样,数组中的字节顺序和返回To IntegerValue方法和ToChar方法取决于计算机体系结构是 little-endian 还是 big endian。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. 体系结构的 endian 设置为由IsLittleEndian属性,它返回true小字节序系统上和falsebig endian 系统上。The endianness of an architecture is indicated by the IsLittleEndian property, which returns true on little-endian systems and false on big-endian systems. 小字节序在系统上,较低序位字节前加上更高序位字节。On little-endian systems, lower-order bytes precede higher-order bytes. Big endian 系统上更高序位字节先于较低序位字节。On big-endian system, higher-order bytes precede lower-order bytes. 下表说明从传递的整数 1234567890 (0x499602D2) 产生的字节数组中的差异为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. 将字节从索引 0 处的字节到索引 3 处的字节顺序列出。The bytes are listed in order from the byte at index 0 to the byte at index 3.

小字节序Little-endian D2-02-96-49D2-02-96-49
Big endianBig-endian 49-96-02-D249-96-02-D2

因为某些方法的返回值取决于系统体系结构,一定要小心,传输到计算机边界之外的字节数据时:Because the return value of some methods depends on system architecture, be careful when transmitting byte data beyond machine boundaries:

  • 如果所有系统发送和接收数据得到了都保证具有相同的字节顺序,执行任何操作已完成的数据。If all systems sending and receiving data are guaranteed to have the same endianness, nothing has be done to the data.

  • 如果发送和接收数据的系统可以具有不同字节序,始终将按特定顺序的数据传输。If systems sending and receiving data can have different endianness, always transmit data in a particular order. 这意味着数组中的字节顺序可能需要撤消之前将其发送或接收它们之后。This means that the order of bytes in the array may have to be reversed either before sending them or after receiving them. 通用约定是以网络字节顺序 (big endian 顺序) 中的数据传输。A common convention is to transmit data in network byte order (big-endian order). 下面的示例提供了一个实现,以网络字节顺序发送一个整数值。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
    
  • 如果发送和接收数据的系统可以具有不同字节排序方式,并要传输的数据包含有符号整数,调用IPAddress.HostToNetworkOrder方法将数据转换为网络字节顺序和IPAddress.NetworkToHostOrder方法以将其转换为所需的顺序接收方。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.

字段

IsLittleEndian IsLittleEndian IsLittleEndian IsLittleEndian

指示数据存储在此计算机体系结构中的字节顺序(“endianness”)。Indicates the byte order ("endianness") in which data is stored in this computer architecture.

方法

DoubleToInt64Bits(Double) DoubleToInt64Bits(Double) DoubleToInt64Bits(Double) DoubleToInt64Bits(Double)

将指定的双精度浮点数转换为 64 位有符号整数。Converts the specified double-precision floating point number to a 64-bit signed integer.

GetBytes(Boolean) GetBytes(Boolean) GetBytes(Boolean) GetBytes(Boolean)

以字节数组的形式返回指定的布尔值。Returns the specified Boolean value as a byte array.

GetBytes(Char) GetBytes(Char) GetBytes(Char) GetBytes(Char)

字节数组形式返回指定的 Unicode 字符值。Returns the specified Unicode character value as an array of bytes.

GetBytes(Double) GetBytes(Double) GetBytes(Double) GetBytes(Double)

字节数组形式返回指定的双精度浮点值。Returns the specified double-precision floating point value as an array of bytes.

GetBytes(Int16) GetBytes(Int16) GetBytes(Int16) GetBytes(Int16)

字节数组形式返回指定的 16 位有符号的整数值。Returns the specified 16-bit signed integer value as an array of bytes.

GetBytes(Int32) GetBytes(Int32) GetBytes(Int32) GetBytes(Int32)

以字节数组的形式返回指定 32 位有符号整数值。Returns the specified 32-bit signed integer value as an array of bytes.

GetBytes(Int64) GetBytes(Int64) GetBytes(Int64) GetBytes(Int64)

以字节数组的形式返回指定 64 位带符号整数值。Returns the specified 64-bit signed integer value as an array of bytes.

GetBytes(Single) GetBytes(Single) GetBytes(Single) GetBytes(Single)

字节数组形式返回指定的单精度浮点值。Returns the specified single-precision floating point value as an array of bytes.

GetBytes(UInt16) GetBytes(UInt16) GetBytes(UInt16) GetBytes(UInt16)

字节数组形式返回指定的 16 位无符号的整数值。Returns the specified 16-bit unsigned integer value as an array of bytes.

GetBytes(UInt32) GetBytes(UInt32) GetBytes(UInt32) GetBytes(UInt32)

以字节数组的形式返回指定的 32 位无符号整数值。Returns the specified 32-bit unsigned integer value as an array of bytes.

GetBytes(UInt64) GetBytes(UInt64) GetBytes(UInt64) GetBytes(UInt64)

以字节数组的形式返回指定的 64 位无符号整数值。Returns the specified 64-bit unsigned integer value as an array of bytes.

Int32BitsToSingle(Int32) Int32BitsToSingle(Int32) Int32BitsToSingle(Int32) Int32BitsToSingle(Int32)
Int64BitsToDouble(Int64) Int64BitsToDouble(Int64) Int64BitsToDouble(Int64) Int64BitsToDouble(Int64)

将指定的 64 位有符号的整数转换为双精度浮点数字。Converts the specified 64-bit signed integer to a double-precision floating point number.

SingleToInt32Bits(Single) SingleToInt32Bits(Single) SingleToInt32Bits(Single) SingleToInt32Bits(Single)
ToBoolean(ReadOnlySpan<Byte>) ToBoolean(ReadOnlySpan<Byte>) ToBoolean(ReadOnlySpan<Byte>) ToBoolean(ReadOnlySpan<Byte>)
ToBoolean(Byte[], Int32) ToBoolean(Byte[], Int32) ToBoolean(Byte[], Int32) ToBoolean(Byte[], Int32)

返回由字节数组中指定位置的一个字节转换来的布尔值。Returns a Boolean value converted from the byte at a specified position in a byte array.

ToChar(ReadOnlySpan<Byte>) ToChar(ReadOnlySpan<Byte>) ToChar(ReadOnlySpan<Byte>) ToChar(ReadOnlySpan<Byte>)
ToChar(Byte[], Int32) ToChar(Byte[], Int32) ToChar(Byte[], Int32) ToChar(Byte[], Int32)

返回两个字节转换的字节数组中指定位置处的 Unicode 字符。Returns a Unicode character converted from two bytes at a specified position in a byte array.

ToDouble(ReadOnlySpan<Byte>) ToDouble(ReadOnlySpan<Byte>) ToDouble(ReadOnlySpan<Byte>) ToDouble(ReadOnlySpan<Byte>)
ToDouble(Byte[], Int32) ToDouble(Byte[], Int32) ToDouble(Byte[], Int32) ToDouble(Byte[], Int32)

返回从字节数组中指定位置的八个字节转换来双精度浮点数。Returns a double-precision floating point number converted from eight bytes at a specified position in a byte array.

ToInt16(ReadOnlySpan<Byte>) ToInt16(ReadOnlySpan<Byte>) ToInt16(ReadOnlySpan<Byte>) ToInt16(ReadOnlySpan<Byte>)
ToInt16(Byte[], Int32) ToInt16(Byte[], Int32) ToInt16(Byte[], Int32) ToInt16(Byte[], Int32)

返回从字节数组中指定位置的两个字节转换来的 16 位有符号的整数。Returns a 16-bit signed integer converted from two bytes at a specified position in a byte array.

ToInt32(Byte[], Int32) ToInt32(Byte[], Int32) ToInt32(Byte[], Int32) ToInt32(Byte[], Int32)

返回从字节数组中指定位置的四个字节转换来的 32 位有符号的整数。Returns a 32-bit signed integer converted from four bytes at a specified position in a byte array.

ToInt32(ReadOnlySpan<Byte>) ToInt32(ReadOnlySpan<Byte>) ToInt32(ReadOnlySpan<Byte>) ToInt32(ReadOnlySpan<Byte>)
ToInt64(ReadOnlySpan<Byte>) ToInt64(ReadOnlySpan<Byte>) ToInt64(ReadOnlySpan<Byte>) ToInt64(ReadOnlySpan<Byte>)
ToInt64(Byte[], Int32) ToInt64(Byte[], Int32) ToInt64(Byte[], Int32) ToInt64(Byte[], Int32)

返回从字节数组中指定位置的八个字节转换来的 64 位有符号的整数。Returns a 64-bit signed integer converted from eight bytes at a specified position in a byte array.

ToSingle(ReadOnlySpan<Byte>) ToSingle(ReadOnlySpan<Byte>) ToSingle(ReadOnlySpan<Byte>) ToSingle(ReadOnlySpan<Byte>)
ToSingle(Byte[], Int32) ToSingle(Byte[], Int32) ToSingle(Byte[], Int32) ToSingle(Byte[], Int32)

返回从字节数组中指定位置的四个字节转换来单精度浮点数。Returns a single-precision floating point number converted from four bytes at a specified position in a byte array.

ToString(Byte[]) ToString(Byte[]) ToString(Byte[]) ToString(Byte[])

将指定的字节数组的每个元素的数值转换为其等效十六进制字符串表示形式。Converts the numeric value of each element of a specified array of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32) ToString(Byte[], Int32) ToString(Byte[], Int32) ToString(Byte[], Int32)

将指定的字节子数组的每个元素的数值转换为其等效十六进制字符串表示形式。Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32, Int32) ToString(Byte[], Int32, Int32) ToString(Byte[], Int32, Int32) ToString(Byte[], Int32, Int32)

将指定的字节子数组的每个元素的数值转换为其等效十六进制字符串表示形式。Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToUInt16(ReadOnlySpan<Byte>) ToUInt16(ReadOnlySpan<Byte>) ToUInt16(ReadOnlySpan<Byte>) ToUInt16(ReadOnlySpan<Byte>)
ToUInt16(Byte[], Int32) ToUInt16(Byte[], Int32) ToUInt16(Byte[], Int32) ToUInt16(Byte[], Int32)

返回从字节数组中指定位置的两个字节转换来的 16 位无符号的整数。Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.

ToUInt32(ReadOnlySpan<Byte>) ToUInt32(ReadOnlySpan<Byte>) ToUInt32(ReadOnlySpan<Byte>) ToUInt32(ReadOnlySpan<Byte>)
ToUInt32(Byte[], Int32) ToUInt32(Byte[], Int32) ToUInt32(Byte[], Int32) ToUInt32(Byte[], Int32)

返回从字节数组中指定位置的四个字节转换来的 32 位无符号的整数。Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.

ToUInt64(Byte[], Int32) ToUInt64(Byte[], Int32) ToUInt64(Byte[], Int32) ToUInt64(Byte[], Int32)

返回从字节数组中指定位置的八个字节转换来的 64 位无符号的整数。Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.

ToUInt64(ReadOnlySpan<Byte>) ToUInt64(ReadOnlySpan<Byte>) ToUInt64(ReadOnlySpan<Byte>) ToUInt64(ReadOnlySpan<Byte>)
TryWriteBytes(Span<Byte>, Boolean) TryWriteBytes(Span<Byte>, Boolean) TryWriteBytes(Span<Byte>, Boolean) TryWriteBytes(Span<Byte>, Boolean)
TryWriteBytes(Span<Byte>, Char) TryWriteBytes(Span<Byte>, Char) TryWriteBytes(Span<Byte>, Char) TryWriteBytes(Span<Byte>, Char)
TryWriteBytes(Span<Byte>, Double) TryWriteBytes(Span<Byte>, Double) TryWriteBytes(Span<Byte>, Double) TryWriteBytes(Span<Byte>, Double)
TryWriteBytes(Span<Byte>, Int16) TryWriteBytes(Span<Byte>, Int16) TryWriteBytes(Span<Byte>, Int16) TryWriteBytes(Span<Byte>, Int16)
TryWriteBytes(Span<Byte>, Int32) TryWriteBytes(Span<Byte>, Int32) TryWriteBytes(Span<Byte>, Int32) TryWriteBytes(Span<Byte>, Int32)
TryWriteBytes(Span<Byte>, Int64) TryWriteBytes(Span<Byte>, Int64) TryWriteBytes(Span<Byte>, Int64) TryWriteBytes(Span<Byte>, Int64)
TryWriteBytes(Span<Byte>, Single) TryWriteBytes(Span<Byte>, Single) TryWriteBytes(Span<Byte>, Single) TryWriteBytes(Span<Byte>, Single)
TryWriteBytes(Span<Byte>, UInt16) TryWriteBytes(Span<Byte>, UInt16) TryWriteBytes(Span<Byte>, UInt16) TryWriteBytes(Span<Byte>, UInt16)
TryWriteBytes(Span<Byte>, UInt32) TryWriteBytes(Span<Byte>, UInt32) TryWriteBytes(Span<Byte>, UInt32) TryWriteBytes(Span<Byte>, UInt32)
TryWriteBytes(Span<Byte>, UInt64) TryWriteBytes(Span<Byte>, UInt64) TryWriteBytes(Span<Byte>, UInt64) TryWriteBytes(Span<Byte>, UInt64)

适用于

另请参阅