BitConverter Класс

Определение

Преобразует базовые типы данных в массив байтов, а массив байтов — в базовые типы данных.

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
Наследование
BitConverter

Примеры

В следующем примере кода показано использование нескольких BitConverter методов класса.

// 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Класс помогает манипулировать типами значений в их основной форме в виде последовательности байтов. Байт определяется как 8-битовое целое число без знака. BitConverterКласс содержит статические методы для преобразования всех типов-примитивов в массив байтов и из него, как показано в следующей таблице.

Type Преобразование в байтовый формат Преобразование из байта
Boolean GetBytes(Boolean) ToBoolean
Char GetBytes(Char) ToChar
Double GetBytes(Double)

-или-

DoubleToInt64Bits(Double)
ToDouble

-или-

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 метод типа задают один и тот же тип. Как показано в следующем примере, восстановление массива, представляющего целое число со знаком, путем вызова ToUInt32 метода может привести к появлению значения, отличного от исходного. Дополнительные сведения см. в разделе Работа с подписанными недесятичными и побитовыми значениями.

using System;

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

      // Convert bytes back to int.
      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[]) методом) зависит от того, является ли архитектура компьютера прямым или обратным порядком байтов. Аналогично, порядок байтов в массиве, возвращаемый To методами интежервалуе и, ToChar зависит от того, имеет ли архитектура компьютера прямой или обратный порядок байтов. Порядок следования байтов архитектуры определяется IsLittleEndian свойством, которое возвращается true в системах с прямым порядком байтов и false в системах с обратным порядком байтов. В системах с прямым порядком байтов более низкие порядки байтов предшествуют байтам более высокого порядка. В системе с обратным порядком байтов более высокий порядок байтов предшествует байтам более низкого порядка. В следующей таблице показано различие в массивах байтов, полученное в результате передачи целого числа 1 234 567 890 (0x499602D2) в GetBytes(Int32) метод. Байты перечислены в порядке от байта по индексу 0 до байта с индексом 3.

С прямым порядком байтов D2 – 02-96-49
С обратным порядком байтов 49-96-02-D2

Поскольку возвращаемое значение некоторых методов зависит от системной архитектуры, будьте внимательны при передаче данных в байтах за пределы компьютеров:

  • Если все системы, отправляющие и получающие данные, гарантированно имеют одинаковый порядок следования байтов, то данные не будут выполнены.

  • Если системы, отправляющие и получающие данные, могут иметь разные порядок следования байтов, всегда следует передавать данные в определенном порядке. Это означает, что порядок байтов в массиве может быть реверсирован перед их отправкой или после получения. Распространенным соглашением является передача данных в сетевом порядке байтов (порядок с обратным порядком байтов). В следующем примере показана реализация для отправки целочисленного значения в сетевом байтом порядке.

    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 метод для его преобразования в заказ, требуемый получателем.

Поля

IsLittleEndian

Указывает порядок байтов (порядок следования байтов), по которому данные сохраняются в архитектуре этого компьютера.

Методы

DoubleToInt64Bits(Double)

Преобразует указанное число двойной точности с плавающей запятой в 64-битовое целое число со знаком.

DoubleToUInt64Bits(Double)

Преобразует заданное число с плавающей запятой двойной точности в 64-разрядное целое число без знака.

GetBytes(Boolean)

Возвращает указанное логическое значение в виде массива байтов.

GetBytes(Char)

Возвращает указанное значение знака Юникода в виде массива байтов.

GetBytes(Double)

Возвращает указанное значение двойной точности с плавающей запятой в виде массива байтов.

GetBytes(Half)

Возвращает указанное значение половинной точности с плавающей запятой в виде массива байтов.

GetBytes(Int16)

Возвращает указанное значение 16-битового целого числа со знаком в виде массива байтов.

GetBytes(Int32)

Возвращает указанное 32-разрядное целое число со знаком в качестве массива байтов.

GetBytes(Int64)

Возвращает указанное 64-разрядные целые числа со знаком в качестве массива байтов.

GetBytes(Single)

Возвращает указанное значение с плавающей запятой с обычной точностью в виде массива байтов.

GetBytes(UInt16)

Возвращает указанное значение 16-битового целого числа без знака в виде массива байтов.

GetBytes(UInt32)

Возвращает указанное 32-разрядное целое число без знака в виде массива байтов.

GetBytes(UInt64)

Возвращает указанное 64-разрядное целое число без знака в виде массива байтов.

HalfToInt16Bits(Half)

Преобразует значение с плавающей запятой половинной точности в 16-разрядное целое число.

HalfToUInt16Bits(Half)

Преобразует заданное число с плавающей запятой половинной точности в 16-битовое целое число без знака.

Int16BitsToHalf(Int16)

Повторно интерпретирует указанное 16-разрядное целое число со знаком как значение с плавающей запятой половинной точности.

Int32BitsToSingle(Int32)

Повторно интерпретирует указанное 32-разрядное целое число как значение одиночной точности с плавающей запятой.

Int64BitsToDouble(Int64)

Повторно интерпретирует указанное 64-битовое целое число со знаком в число двойной точности с плавающей запятой.

SingleToInt32Bits(Single)

Преобразует значение одиночной точности с плавающей запятой в целое число.

SingleToUInt32Bits(Single)

Преобразует указанное число с плавающей запятой одиночной точности в 32-разрядное целое число без знака.

ToBoolean(Byte[], Int32)

Возвращает логическое значение, преобразованное из байта в указанной позиции в массиве байтов.

ToBoolean(ReadOnlySpan<Byte>)

Преобразует доступный только для чтения диапазон в логическое значение.

ToChar(Byte[], Int32)

Возвращает знак Юникода, преобразованный из двух байтов с указанной позицией в массив байтов.

ToChar(ReadOnlySpan<Byte>)

Преобразует доступный только для чтения диапазон в символ.

ToDouble(Byte[], Int32)

Возвращает число двойной точности с плавающей запятой, преобразованное из восьми байтов с указанной позицией в массив байтов.

ToDouble(ReadOnlySpan<Byte>)

Преобразует доступный только для чтения диапазон байтов в значение двойной точности с плавающей запятой.

ToHalf(Byte[], Int32)

Возвращает число с плавающей запятой Лафт, преобразованное из двух байтов с указанной позицией в массиве байтов.

ToHalf(ReadOnlySpan<Byte>)

Преобразует диапазон байтов только для чтения в значение с плавающей запятой половинной точности.

ToInt16(Byte[], Int32)

Возвращает 16-битовое целое число со знаком, преобразованное из двух байтов с указанной позицией в массив байтов.

ToInt16(ReadOnlySpan<Byte>)

Преобразует доступный только для чтения диапазон байтов в 16-разрядное целое число со знаком.

ToInt32(Byte[], Int32)

Возвращает 32-битовое целое число со знаком, преобразованное из четырех байтов с указанной позицией в массив байтов.

ToInt32(ReadOnlySpan<Byte>)

Преобразует доступный только для чтения диапазон байтов в 32-разрядное целое число со знаком.

ToInt64(Byte[], Int32)

Возвращает 64-битовое целое число со знаком, преобразованное из восьми байт с указанной позицией в массив байтов.

ToInt64(ReadOnlySpan<Byte>)

Преобразует доступный только для чтения диапазон байтов в 64-разрядное целое число со знаком.

ToSingle(Byte[], Int32)

Возвращает число одинарной точности с плавающей запятой, преобразованное из четырех байтов с указанной позицией в массив байтов.

ToSingle(ReadOnlySpan<Byte>)

Преобразует диапазон байтов только для чтения в значение одиночной точности с плавающей запятой.

ToString(Byte[])

Преобразует числовое значение каждого элемента заданного массива байтов в эквивалентное ему шестнадцатеричное строковое представление.

ToString(Byte[], Int32)

Преобразует числовое значение каждого элемента заданного подмассива байтов в эквивалентное ему шестнадцатеричное строковое представление.

ToString(Byte[], Int32, Int32)

Преобразует числовое значение каждого элемента заданного подмассива байтов в эквивалентное ему шестнадцатеричное строковое представление.

ToUInt16(Byte[], Int32)

Возвращает 16-битовое целое число без знака, преобразованное из двух байтов с указанной позицией в массив байтов.

ToUInt16(ReadOnlySpan<Byte>)

Преобразует доступный только для чтения диапазон байтов в 16-разрядное целое число без знака.

ToUInt32(Byte[], Int32)

Возвращает 32-битовое целое число без знака, преобразованное из четырех байтов с указанной позицией в массив байтов.

ToUInt32(ReadOnlySpan<Byte>)

Преобразует доступный только для чтения диапазон байтов в 32-разрядное целое число без знака.

ToUInt64(Byte[], Int32)

Возвращает 64-битовое целое число без знака, преобразованное из восьми байтов с указанной позицией в массив байтов.

ToUInt64(ReadOnlySpan<Byte>)

Преобразует байты в длинное целое число без знака.

TryWriteBytes(Span<Byte>, Boolean)

Преобразует логическое значение в диапазон байтов.

TryWriteBytes(Span<Byte>, Char)

Преобразует символ в диапазон байтов.

TryWriteBytes(Span<Byte>, Double)

Преобразует значение двойной точности с плавающей запятой в диапазон байтов.

TryWriteBytes(Span<Byte>, Half)

Преобразует значение с плавающей запятой половинной точности в диапазон байтов.

TryWriteBytes(Span<Byte>, Int16)

Преобразует 16-разрядное целое число со знаком в диапазон байтов.

TryWriteBytes(Span<Byte>, Int32)

Преобразует 32-разрядное целое число со знаком в диапазон байтов.

TryWriteBytes(Span<Byte>, Int64)

Преобразует 64-разрядное целое число со знаком в диапазон байтов.

TryWriteBytes(Span<Byte>, Single)

Преобразует значение одинарной точности с плавающей запятой в диапазон байтов.

TryWriteBytes(Span<Byte>, UInt16)

Преобразует 16-разрядное целое число без знака в диапазон байтов.

TryWriteBytes(Span<Byte>, UInt32)

Преобразует 32-разрядное целое число без знака в диапазон байтов.

TryWriteBytes(Span<Byte>, UInt64)

Преобразует 64-разрядное целое число без знака в диапазон байтов.

UInt16BitsToHalf(UInt16)

Преобразует указанное 16-битовое целое число без знака в число с плавающей запятой половинной точности.

UInt32BitsToSingle(UInt32)

Преобразует заданное 32-разрядное целое число без знака в число с плавающей запятой одиночной точности.

UInt64BitsToDouble(UInt64)

Преобразует заданное 64-разрядное целое число без знака в число двойной точности с плавающей запятой.

Применяется к

См. также раздел