System.Byte 構造体

[アーティクル]
01/11/2024

この記事では、この API のリファレンスドキュメントへの補足的な解説を提供します。

Byte は、0 (定数で表される) から 255 (定数で Byte.MinValue 表される) までの範囲の値を持つ符号なし整数を Byte.MaxValue 表す不変の値型です。 .NET には、-128 から 127 までの範囲の値を表す符号 SByte付き 8 ビット整数値型も含まれています。

Byte 値をインスタンス化する

値は Byte 、いくつかの方法でインスタンス化できます。

変数を Byte 宣言し、データ型の範囲内にあるリテラル整数値を Byte 割り当てることができます。次の例では、2 つの Byte 変数を宣言し、この方法で値を割り当てます。
```
byte value1 = 64;
byte value2 = 255;
```
```
let value1 = 64uy
let value2 = 255uy
```
```
Dim value1 As Byte = 64
Dim value2 As Byte = 255
```

バイト以外の数値をバイトに割り当てることができます。これは縮小変換であるため、C# と F# のキャスト演算子、またはオンの場合 Option Strict は Visual Basic の変換メソッドが必要です。バイト以外の値が Single小数部を含む、 Doubleまたは Decimal 値である場合、その小数部の処理は、変換を実行するコンパイラによって異なります。次の例では、複数の数値を変数に Byte 割り当てます。

int int1 = 128;
try
{
    byte value1 = (byte)int1;
    Console.WriteLine(value1);
}
catch (OverflowException)
{
    Console.WriteLine("{0} is out of range of a byte.", int1);
}

double dbl2 = 3.997;
try
{
    byte value2 = (byte)dbl2;
    Console.WriteLine(value2);
}
catch (OverflowException)
{
    Console.WriteLine("{0} is out of range of a byte.", dbl2);
}
// The example displays the following output:
//       128
//       3

let int1 = 128
try
    let value1 = byte int1
    printfn $"{value1}"
with :? OverflowException ->
    printfn $"{int1} is out of range of a byte."

let dbl2 = 3.997
try
    let value2 = byte dbl2
    printfn $"{value2}"
with :? OverflowException ->
    printfn $"{dbl2} is out of range of a byte."

// The example displays the following output:
//       128
//       3

Dim int1 As Integer = 128
Try
    Dim value1 As Byte = CByte(int1)
    Console.WriteLine(value1)
Catch e As OverflowException
    Console.WriteLine("{0} is out of range of a byte.", int1)
End Try

Dim dbl2 As Double = 3.997
Try
    Dim value2 As Byte = CByte(dbl2)
    Console.WriteLine(value2)
Catch e As OverflowException
    Console.WriteLine("{0} is out of range of a byte.", dbl2)
End Try
' The example displays the following output:
'       128
'       4

クラスのメソッドを呼び出して、 Convert サポートされている任意の型を Byte 値に変換できます。これは、インターフェイスをサポートしているため Byte に IConvertible 可能です。次の例は、値の配列 Int32 から値への変換を Byte 示しています。

int[] numbers = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue };
byte result;
foreach (int number in numbers)
{
    try
    {
        result = Convert.ToByte(number);
        Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                          number.GetType().Name, number,
                          result.GetType().Name, result);
    }
    catch (OverflowException)
    {
        Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                          number.GetType().Name, number);
    }
}
// The example displays the following output:
//       The Int32 value -2147483648 is outside the range of the Byte type.
//       The Int32 value -1 is outside the range of the Byte type.
//       Converted the Int32 value 0 to the Byte value 0.
//       Converted the Int32 value 121 to the Byte value 121.
//       The Int32 value 340 is outside the range of the Byte type.
//       The Int32 value 2147483647 is outside the range of the Byte type.

let numbers = [| Int32.MinValue; -1; 0; 121; 340; Int32.MaxValue |]
for number in numbers do
    try
        let result = Convert.ToByte number
        printfn $"Converted the {number.GetType().Name} value {number} to the {result.GetType().Name} value {result}."
    with :? OverflowException ->
        printfn $"The {number.GetType().Name} value {number} is outside the range of the Byte type."
// The example displays the following output:
//       The Int32 value -2147483648 is outside the range of the Byte type.
//       The Int32 value -1 is outside the range of the Byte type.
//       Converted the Int32 value 0 to the Byte value 0.
//       Converted the Int32 value 121 to the Byte value 121.
//       The Int32 value 340 is outside the range of the Byte type.
//       The Int32 value 2147483647 is outside the range of the Byte type.

Dim numbers() As Integer = {Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue}
Dim result As Byte
For Each number As Integer In numbers
    Try
        result = Convert.ToByte(number)
        Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                      number.GetType().Name, number,
                      result.GetType().Name, result)
    Catch e As OverflowException
        Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                      number.GetType().Name, number)
    End Try
Next
' The example displays the following output:
'       The Int32 value -2147483648 is outside the range of the Byte type.
'       The Int32 value -1 is outside the range of the Byte type.
'       Converted the Int32 value 0 to the Byte value 0.
'       Converted the Int32 value 121 to the Byte value 121.
'       The Int32 value 340 is outside the range of the Byte type.
'       The Int32 value 2147483647 is outside the range of the Byte type.

or メソッドをParse呼び出して、値Byteの文字列形式を Byte .TryParse 文字列には、10 進数または 16 進数を含めることができます。次の例は、10 進文字列と 16 進文字列の両方を使用した解析操作を示しています。

string string1 = "244";
try
{
    byte byte1 = Byte.Parse(string1);
    Console.WriteLine(byte1);
}
catch (OverflowException)
{
    Console.WriteLine("'{0}' is out of range of a byte.", string1);
}
catch (FormatException)
{
    Console.WriteLine("'{0}' is out of range of a byte.", string1);
}

string string2 = "F9";
try
{
    byte byte2 = Byte.Parse(string2,
                            System.Globalization.NumberStyles.HexNumber);
    Console.WriteLine(byte2);
}
catch (OverflowException)
{
    Console.WriteLine("'{0}' is out of range of a byte.", string2);
}
catch (FormatException)
{
    Console.WriteLine("'{0}' is out of range of a byte.", string2);
}
// The example displays the following output:
//       244
//       249

let string1 = "244"
try
    let byte1 = Byte.Parse string1
    printfn $"{byte1}" 
with
| :? OverflowException ->
    printfn $"'{string1}' is out of range of a byte."
| :? FormatException ->
    printfn $"'{string1}' is out of range of a byte."

let string2 = "F9"
try
    let byte2 = Byte.Parse(string2, System.Globalization.NumberStyles.HexNumber)
    printfn $"{byte2}"
with
| :? OverflowException ->
    printfn $"'{string2}' is out of range of a byte."
| :? FormatException ->
    printfn $"'{string2}' is out of range of a byte."

// The example displays the following output:
//       244
//       249

Dim string1 As String = "244"
Try
    Dim byte1 As Byte = Byte.Parse(string1)
    Console.WriteLine(byte1)
Catch e As OverflowException
    Console.WriteLine("'{0}' is out of range of a byte.", string1)
Catch e As FormatException
    Console.WriteLine("'{0}' is out of range of a byte.", string1)
End Try

Dim string2 As String = "F9"
Try
    Dim byte2 As Byte = Byte.Parse(string2,
                           System.Globalization.NumberStyles.HexNumber)
    Console.WriteLine(byte2)
Catch e As OverflowException
    Console.WriteLine("'{0}' is out of range of a byte.", string2)
Catch e As FormatException
    Console.WriteLine("'{0}' is out of range of a byte.", string2)
End Try
' The example displays the following output:
'       244
'       249

バイト値に対して操作を実行する

この型は Byte 、加算、減算、除算、乗算、減算、否定、単項否定などの標準的な数学演算をサポートします。他の整数型と同様に、このByte型はビット演算子AND、ORXOR左シフト演算子、左シフト演算子、右シフト演算子もサポートします。

標準の数値演算子を使用して 2 つのByte値を比較するか、またはEqualsメソッドをCompareTo呼び出すことができます。

クラスのMathメンバーを呼び出して、数値の絶対値の取得、商の計算、整数除算からの商と再メインダーの計算、2 つの整数の最大値または最小値の決定、数値の符号の取得、数値の丸めなど、幅広い数値演算を実行することもできます。

バイトを文字列として表す

この型は Byte 、標準およびカスタムの数値書式指定文字列を完全にサポートします。 (詳細については、書式設定の種類、標準の数値書式指定文字列、およびユーザー設定の数値書式指定文字列。ただし、最も一般的に、バイト値は 1 桁から 3 桁の値で表され、書式設定は追加されず、2 桁の 16 進数の値として表されます。

先頭に Byte ゼロがない整数文字列として値を書式設定するには、パラメーターなしの ToString() メソッドを呼び出します。 "D" 書式指定子を使用すると、文字列形式に指定した数の先行ゼロを含めることもできます。 "X" 書式指定子を使用すると、値を Byte 16 進文字列として表すことができます。次の例では、これらの 3 つの方法で値の配列内の Byte 要素を書式設定します。

byte[] numbers = { 0, 16, 104, 213 };
foreach (byte number in numbers)
{
    // Display value using default formatting.
    Console.Write("{0,-3}  -->   ", number.ToString());
    // Display value with 3 digits and leading zeros.
    Console.Write(number.ToString("D3") + "   ");
    // Display value with hexadecimal.
    Console.Write(number.ToString("X2") + "   ");
    // Display value with four hexadecimal digits.
    Console.WriteLine(number.ToString("X4"));
}
// The example displays the following output:
//       0    -->   000   00   0000
//       16   -->   016   10   0010
//       104  -->   104   68   0068
//       213  -->   213   D5   00D5

let numbers = [| 0; 16; 104; 213 |]
for number in numbers do
    // Display value using default formatting.
    number.ToString()
    |> printf "%-3s  -->   "

    // Display value with 3 digits and leading zeros.
    number.ToString "D3"
    |> printf "%s   "
    
    // Display value with hexadecimal.
    number.ToString "X2"
    |> printf "%s   "
    
    // Display value with four hexadecimal digits.
    number.ToString "X4"
    |> printfn "%s"

// The example displays the following output:
//       0    -->   000   00   0000
//       16   -->   016   10   0010
//       104  -->   104   68   0068
//       213  -->   213   D5   00D5

Dim numbers() As Byte = {0, 16, 104, 213}
For Each number As Byte In numbers
    ' Display value using default formatting.
    Console.Write("{0,-3}  -->   ", number.ToString())
    ' Display value with 3 digits and leading zeros.
    Console.Write(number.ToString("D3") + "   ")
    ' Display value with hexadecimal.
    Console.Write(number.ToString("X2") + "   ")
    ' Display value with four hexadecimal digits.
    Console.WriteLine(number.ToString("X4"))
Next
' The example displays the following output:
'       0    -->   000   00   0000
'       16   -->   016   10   0010
'       104  -->   104   68   0068
'       213  -->   213   D5   00D5

メソッドを Byte 呼び出し ToString(Byte, Int32) 、メソッドの 2 番目のパラメーターとしてベースを指定することで、値をバイナリ、8 進数、10 進数、または 16 進数の文字列として書式設定することもできます。次の例では、このメソッドを呼び出して、バイト値の配列のバイナリ、8 進数、および 16 進数の表現を表示します。

byte[] numbers = { 0, 16, 104, 213 };
Console.WriteLine("{0}   {1,8}   {2,5}   {3,5}",
                  "Value", "Binary", "Octal", "Hex");
foreach (byte number in numbers)
{
    Console.WriteLine("{0,5}   {1,8}   {2,5}   {3,5}",
                      number, Convert.ToString(number, 2),
                      Convert.ToString(number, 8),
                      Convert.ToString(number, 16));
}
// The example displays the following output:
//       Value     Binary   Octal     Hex
//           0          0       0       0
//          16      10000      20      10
//         104    1101000     150      68
//         213   11010101     325      d5

let numbers = [| 0; 16; 104; 213 |]
printfn "%s   %8s   %5s   %5s" "Value" "Binary" "Octal" "Hex"
for number in numbers do
    printfn $"%5i{number}   %8s{Convert.ToString(number, 2)}   %5s{Convert.ToString(number, 8)}   %5s{Convert.ToString(number, 16)}"
                    
// The example displays the following output:
//       Value     Binary   Octal     Hex
//           0          0       0       0
//          16      10000      20      10
//         104    1101000     150      68
//         213   11010101     325      d5

Dim numbers() As Byte = {0, 16, 104, 213}
Console.WriteLine("{0}   {1,8}   {2,5}   {3,5}",
                "Value", "Binary", "Octal", "Hex")
For Each number As Byte In numbers
    Console.WriteLine("{0,5}   {1,8}   {2,5}   {3,5}",
                   number, Convert.ToString(number, 2),
                   Convert.ToString(number, 8),
                   Convert.ToString(number, 16))
Next
' The example displays the following output:
'       Value     Binary   Octal     Hex
'           0          0       0       0
'          16      10000      20      10
'         104    1101000     150      68
'         213   11010101     325      d5

10 進数以外のバイト値を操作する

個々のバイトを 10 進値として処理するだけでなく、バイト値を使用してビットごとの演算を実行したり、バイト配列を操作したり、バイト値のバイナリ表現または 16 進数表現を使用したりできます。たとえば、メソッドのBitConverter.GetBytesオーバーロードは、各プリミティブデータ型をバイト配列に変換でき、メソッドは値をBigInteger.ToByteArray BigIntegerバイト配列に変換します。

Byte 値は、符号ビットなしで、その大きさでのみ 8 ビットで表されます。これは、値に対してビットごとの演算を実行する場合や、個々のビットを Byte 操作する場合に注意することが重要です。 2 つの 10 進数以外の値に対して数値、ブール値、または比較演算を実行するには、両方の値で同じ表現を使用する必要があります。

2 つの Byte 値に対して操作を実行すると、値は同じ表現を共有するため、結果は正確です。これは、値の最下位ビットをマスクして偶数になるようにする次の Byte 例に示します。

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { Convert.ToString(12, 16),
                          Convert.ToString(123, 16),
                          Convert.ToString(245, 16) };

      byte mask = 0xFE;
      foreach (string value in values) {
         Byte byteValue = Byte.Parse(value, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("{0} And {1} = {2}", byteValue, mask,
                           byteValue & mask);
      }
   }
}
// The example displays the following output:
//       12 And 254 = 12
//       123 And 254 = 122
//       245 And 254 = 244

open System
open System.Globalization

let values = 
    [ Convert.ToString(12, 16)
      Convert.ToString(123, 16)
      Convert.ToString(245, 16) ]

let mask = 0xFEuy
for value in values do
    let byteValue = Byte.Parse(value, NumberStyles.AllowHexSpecifier)
    printfn $"{byteValue} And {mask} = {byteValue &&& mask}"
                    

// The example displays the following output:
//       12 And 254 = 12
//       123 And 254 = 122
//       245 And 254 = 244

Imports System.Globalization

Module Example1
    Public Sub Main()
        Dim values() As String = {Convert.ToString(12, 16),
                                 Convert.ToString(123, 16),
                                 Convert.ToString(245, 16)}

        Dim mask As Byte = &HFE
        For Each value As String In values
            Dim byteValue As Byte = Byte.Parse(value, NumberStyles.AllowHexSpecifier)
            Console.WriteLine("{0} And {1} = {2}", byteValue, mask,
                           byteValue And mask)
        Next
    End Sub
End Module
' The example displays the following output:
'       12 And 254 = 12
'       123 And 254 = 122
'       245 And 254 = 244

一方、符号なしビットと符号付きビットの両方を使用する場合、ビットごとの演算は、値が正の値に符号と大きさの表現を使用し、負の値に対して 2 の補数表現が使用されるため、複雑 SByte になります。意味のあるビットごとの演算を実行するには、値を 2 つの同等の表現に変換する必要があり、符号ビットに関する情報を保持する必要があります。次の例では、8 ビット符号付き値と符号なし値の配列のビット 2 と 4 をマスクします。

using System;
using System.Collections.Generic;
using System.Globalization;

public struct ByteString
{
    public string Value;
    public int Sign;
}

public class Example1
{
    public static void Main()
    {
        ByteString[] values = CreateArray(-15, 123, 245);

        byte mask = 0x14;        // Mask all bits but 2 and 4.

        foreach (ByteString strValue in values)
        {
            byte byteValue = Byte.Parse(strValue.Value, NumberStyles.AllowHexSpecifier);
            Console.WriteLine("{0} ({1}) And {2} ({3}) = {4} ({5})",
                              strValue.Sign * byteValue,
                              Convert.ToString(byteValue, 2),
                              mask, Convert.ToString(mask, 2),
                              (strValue.Sign & Math.Sign(mask)) * (byteValue & mask),
                              Convert.ToString(byteValue & mask, 2));
        }
    }

    private static ByteString[] CreateArray(params int[] values)
    {
        List<ByteString> byteStrings = new List<ByteString>();

        foreach (object value in values)
        {
            ByteString temp = new ByteString();
            int sign = Math.Sign((int)value);
            temp.Sign = sign;

            // Change two's complement to magnitude-only representation.
            temp.Value = Convert.ToString(((int)value) * sign, 16);

            byteStrings.Add(temp);
        }
        return byteStrings.ToArray();
    }
}
// The example displays the following output:
//       -15 (1111) And 20 (10100) = 4 (100)
//       123 (1111011) And 20 (10100) = 16 (10000)
//       245 (11110101) And 20 (10100) = 20 (10100)

open System
open System.Collections.Generic
open System.Globalization

[<Struct>]
type ByteString =
    { Sign: int
      Value: string }

let createArray values =
    [ for value in values do
        let sign = sign value
        { Sign = sign
         // Change two's complement to magnitude-only representation.
          Value = Convert.ToString(value * sign, 16)} ]


let values = createArray [ -15; 123; 245 ]

let mask = 0x14uy        // Mask all bits but 2 and 4.

for strValue in values do
    let byteValue = Byte.Parse(strValue.Value, NumberStyles.AllowHexSpecifier)
    printfn $"{strValue.Sign * int byteValue} ({Convert.ToString(byteValue, 2)}) And {mask} ({Convert.ToString(mask, 2)}) = {(strValue.Sign &&& (int mask |> sign)) * int (byteValue &&& mask)} ({Convert.ToString(byteValue &&& mask, 2)})"

// The example displays the following output:
//       -15 (1111) And 20 (10100) = 4 (100)
//       123 (1111011) And 20 (10100) = 16 (10000)
//       245 (11110101) And 20 (10100) = 20 (10100)

Imports System.Collections.Generic
Imports System.Globalization

Public Structure ByteString
   Public Value As String
   Public Sign As Integer
End Structure

Module Example2
    Public Sub Main()
        Dim values() As ByteString = CreateArray(-15, 123, 245)

        Dim mask As Byte = &H14        ' Mask all bits but 2 and 4.

        For Each strValue As ByteString In values
            Dim byteValue As Byte = Byte.Parse(strValue.Value, NumberStyles.AllowHexSpecifier)
            Console.WriteLine("{0} ({1}) And {2} ({3}) = {4} ({5})",
                           strValue.Sign * byteValue,
                           Convert.ToString(byteValue, 2),
                           mask, Convert.ToString(mask, 2),
                           (strValue.Sign And Math.Sign(mask)) * (byteValue And mask),
                           Convert.ToString(byteValue And mask, 2))
        Next
    End Sub

    Private Function CreateArray(ParamArray values() As Object) As ByteString()
        Dim byteStrings As New List(Of ByteString)
        For Each value As Object In values
            Dim temp As New ByteString()
            Dim sign As Integer = Math.Sign(value)
            temp.Sign = sign
            ' Change two's complement to magnitude-only representation.
            value = value * sign

            temp.Value = Convert.ToString(value, 16)
            byteStrings.Add(temp)
        Next
        Return byteStrings.ToArray()
    End Function
End Module
' The example displays the following output:
'       -15 (1111) And 20 (10100) = 4 (100)
'       123 (1111011) And 20 (10100) = 16 (10000)
'       245 (11110101) And 20 (10100) = 20 (10100)

次の方法で共有

System.Byte 構造体

Byte 値をインスタンス化する

バイト値に対して操作を実行する

バイトを文字列として表す

10 進数以外のバイト値を操作する

その他のリソース