BitConverter Třída

Definice

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

Dědičnost

Object

BitConverter

Příklady

Následující příklad kódu ukazuje použití několika BitConverter metod třídy.

// 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
*/

open System

let print: obj -> obj -> unit = printfn "%25O%30O"

let aDoubl = 0.1111111111111111111
let aSingl = 0.1111111111111111111f
let aLong = 1111111111111111111L
let anInt = 1111111111
let aShort = 11111s
let aChar = '*'
let aBool = true

printfn "This example of methods of the BitConverter class\ngenerates the following output.\n"
print "argument" "byte array"
print "--------" "----------"

// Convert values to Byte arrays and display them.
print aDoubl (BitConverter.ToString(BitConverter.GetBytes aDoubl))

print aSingl (BitConverter.ToString(BitConverter.GetBytes aSingl))

print aLong (BitConverter.ToString(BitConverter.GetBytes aLong))

print anInt (BitConverter.ToString(BitConverter.GetBytes anInt))

print aShort (BitConverter.ToString(BitConverter.GetBytes aShort))

print aChar (BitConverter.ToString(BitConverter.GetBytes aChar))

print 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

Poznámky

Třída BitConverter pomáhá manipulovat s typy hodnot v jejich základní podobě jako řada bajtů. Bajt je definován jako 8bitové celé číslo bez znaménka. Třída BitConverter obsahuje statické metody pro převod jednotlivých primitivních typů na pole bajtů a z pole bajtů, jak je znázorněno v následující tabulce.

Pokud používáte metody BitConverter k datům odezvy, ujistěte se, že přetížení GetBytes a ToTyp metody určují stejný typ. Jak ukazuje následující příklad, obnovení pole, které představuje podepsané celé číslo voláním ToUInt32 metoda může mít za následek hodnotu, která se liší od původního. Další informace naleznete v tématu Práce s hodnotami bez desetinných míst a bitových hodnot.

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

open System

let value = -16
let bytes = BitConverter.GetBytes value

// Convert bytes back to int.
let intValue = BitConverter.ToInt32(bytes, 0)
printfn $"""{value} = {intValue}: {if value.Equals intValue then "Round-trips" else "Does not round-trip"}"""

// Convert bytes to UInt32.
let uintValue = BitConverter.ToUInt32(bytes, 0)
printfn $"""{value} = {uintValue}: {if value.Equals uintValue then "Round-trips" else "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

Pořadí bajtů v poli vrácené přetížením metody GetBytes (stejně jako pořadí bitů v celé hodnotě vrácené metodou DoubleToInt64Bits) závisí na tom, zda je architektura počítače malá-endová nebo big-endian. Podobně pořadí bajtů v poli a vrácené ToIntegerValue metody a metoda ToChar závisí na tom, zda je architektura počítače malá-endian nebo big-endian. Koncovost architektury je označena vlastností IsLittleEndian, která vrací true v malých endových systémech a false v systémech big-endian. V malých endových systémech předchází bajty s nižším pořadím bajtů vyššího řádu. V systému big-endian předchází bajty vyššího řádu před bajty nižšího řádu. Následující tabulka ukazuje rozdíl v bajtových polích, které jsou výsledkem předání celého čísla 1 234 567 890 (0x499602D2) metodě GetBytes(Int32). Bajty jsou uvedené v pořadí od bajtu s indexem 0 až po bajt v indexu 3.

Vzhledem k tomu, že návratová hodnota některých metod závisí na systémové architektuře, buďte při přenosu bajtů dat mimo hranice počítače opatrní:

• Pokud je zaručeno, že všechny systémy odesílající a přijímající data budou mít stejnou endianitu, nemusíte s daty nic dělat.

• Pokud systémy odesílající a přijímající data můžou mít různou koncovost, vždy přenášet data v určitém pořadí. To znamená, že pořadí bajtů v poli může být před jejich odesláním nebo po přijetí nutné vrátit zpět. Běžnou konvencí je přenos dat v pořadí bajtů sítě (big-endian order). Následující příklad poskytuje implementaci pro odeslání celočíselné hodnoty v pořadí bajtů sítě.

  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
  

  open System
  
  let value = 12345678
  let bytes = BitConverter.GetBytes value
  printfn $"{BitConverter.ToString bytes}"
  
  if BitConverter.IsLittleEndian then
      Array.Reverse bytes
  
  printfn $"{BitConverter.ToString bytes}"
  // Call method to send byte stream across machine boundaries.
  
  // Receive byte stream from beyond machine boundaries.
  printfn $"{BitConverter.ToString bytes}"
  if BitConverter.IsLittleEndian then
      Array.Reverse bytes
  
  printfn $"{BitConverter.ToString bytes}"
  let result = BitConverter.ToInt32(bytes, 0)
  
  printfn $"Original value: {value}"
  printfn $"Returned value: {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
  

• Pokud systémy odesílající a přijímající data můžou mít různou endianitu a data, která se mají přenášet, se skládají z celých čísel, zavolejte metodu IPAddress.HostToNetworkOrder, která převede data na pořadí bajtů sítě a metodu IPAddress.NetworkToHostOrder pro převod na pořadí požadované příjemcem.

Pole

Metody

Platí pro

Viz také

• Byte