Byte 结构

2013/12/13

表示 8 位无符号整数。

Namespace:  System
程序集:  mscorlib(位于 mscorlib.dll 中)

public struct Byte : IComparable, IComparable<byte>, 
	IConvertible, IEquatable<byte>, IFormattable

Byte 类型公开以下成员。

  名称说明
公共方法CompareTo(Byte)将此实例与指定的 8 位无符号整数进行比较并返回对其相对值的指示。
公共方法CompareTo(Object)将此实例与指定对象进行比较并返回一个对二者的相对值的指示。
公共方法Equals(Byte)返回一个值,该值指示此实例和指定的 Byte 对象是否表示相同的值。
公共方法Equals(Object)返回一个值,该值指示此实例是否等于指定的对象。 (重写 ValueType.Equals(Object)。)
受保护的方法Finalize允许 Object 在垃圾回收器回收该对象之前尝试释放资源并执行其他清理操作。 (从 Object 继承。)
公共方法GetHashCode返回此实例的哈希代码。 (重写 ValueType.GetHashCode()。)
公共方法GetType获取当前实例的 Type (从 Object 继承。)
公共方法GetTypeCode返回值类型 ByteTypeCode
受保护的方法MemberwiseClone创建当前 Object 的浅表副本。 (从 Object 继承。)
公共方法静态成员Parse(String)将数字的字符串表示形式转换为它的等效 Byte 表示形式。
公共方法静态成员Parse(String, NumberStyles)将指定样式的数字的字符串表示形式转换为它的等效 Byte
公共方法静态成员Parse(String, IFormatProvider)将指定的区域性特定格式的数字字符串表示形式转换为它的等效 Byte
公共方法静态成员Parse(String, NumberStyles, IFormatProvider)将指定样式和区域性特定格式的数字的字符串表示形式转换为它的等效 Byte 值。
公共方法ToString()将当前 Byte 对象的值转换为其等效的字符串表示形式。 (重写 ValueType.ToString()。)
公共方法ToString(IFormatProvider)使用指定的区域性特定格式设置信息将当前 Byte 对象的数值转换为它的等效字符串表示形式。
公共方法ToString(String)使用指定的格式将当前 Byte 对象的值转换为它的等效字符串表示形式。
公共方法ToString(String, IFormatProvider)使用指定的格式和区域性特定的格式设置信息将当前 Byte 对象的值转换为它的等效字符串表示形式。
公共方法静态成员TryParse(String, Byte)尝试将数字的字符串表示形式转换为它的等效 Byte,并返回一个指示转换是否成功的值。
公共方法静态成员TryParse(String, NumberStyles, IFormatProvider, Byte)将指定样式和区域性特定格式的数字的字符串表示形式转换为它的等效 Byte 值。一个指示转换是否成功的返回值。
返回顶部

  名称说明
公共字段静态成员MaxValue表示 Byte 的最大可能值。此字段为常量。
公共字段静态成员MinValue表示 Byte 的最小可能值。此字段为常量。
返回顶部

  名称说明
显式接口实现私有方法IConvertible.ToBoolean基础结构。 有关此成员的说明,请参见 IConvertible.ToBoolean
显式接口实现私有方法IConvertible.ToByte基础结构。 有关此成员的说明,请参见 IConvertible.ToByte
显式接口实现私有方法IConvertible.ToChar基础结构。 有关此成员的说明,请参见 IConvertible.ToChar
显式接口实现私有方法IConvertible.ToDateTime基础结构。 不支持此转换。尝试使用此方法将引发 InvalidCastException
显式接口实现私有方法IConvertible.ToDecimal基础结构。 有关此成员的说明,请参见 IConvertible.ToDecimal
显式接口实现私有方法IConvertible.ToDouble基础结构。 有关此成员的说明,请参见 IConvertible.ToDouble
显式接口实现私有方法IConvertible.ToInt16基础结构。 有关此成员的说明,请参见 IConvertible.ToInt16
显式接口实现私有方法IConvertible.ToInt32基础结构。 有关此成员的说明,请参见 IConvertible.ToInt32
显式接口实现私有方法IConvertible.ToInt64基础结构。 有关此成员的说明,请参见 IConvertible.ToInt64
显式接口实现私有方法IConvertible.ToSByte基础结构。 有关此成员的说明,请参见 IConvertible.ToSByte
显式接口实现私有方法IConvertible.ToSingle基础结构。 有关此成员的说明,请参见 IConvertible.ToSingle
显式接口实现私有方法IConvertible.ToType基础结构。 有关此成员的说明,请参见 IConvertible.ToType
显式接口实现私有方法IConvertible.ToUInt16基础结构。 有关此成员的说明,请参见 IConvertible.ToUInt16
显式接口实现私有方法IConvertible.ToUInt32基础结构。 有关此成员的说明,请参见 IConvertible.ToUInt32
显式接口实现私有方法IConvertible.ToUInt64基础结构。 有关此成员的说明,请参见 IConvertible.ToUInt64
返回顶部

Byte 是不可变的值类型,它表示无符号整数,其范围从 0(用 Byte.MinValue 常数表示)到 255 的值(用 Byte.MaxValue 常数表示)。.NET 框架还包括一个 8 位有符号整数值类型,SByte 表示从 -128 到 127 的值。

实例化字节值

可通过多种方法实例化 Byte 值:

  • 您可以声明一个 Byte 变量,并将它设定为在 Byte 数据类型范围内的文本整数值。下面的示例声明两个 Byte 变量,并以这种方式为它们分配值。

    
    byte value1 = 64;
    byte value2 = 255;
    
    
    
  • 您可以将非字节数值分配给一个字节。这是一个收缩转换,因此,如果 OptionStrict 为打开状态,它在 C# 中需要一个强制转换运算符,在 Visual Basic 中需要转换方法。如果非字节值是 SingleDouble,或包括小数部分的 Decimal 值,其小数部分将被截尾取整。下面的示例将几个数值赋给 Byte 变量。

    
    int int1 = 128;
    try
    {
       byte value1 = (byte)int1;
       outputBlock.Text += value1 + Environment.NewLine;
    }
    catch (OverflowException)
    {
       outputBlock.Text += String.Format("{0} is out of range of a byte.", int1) + "\n";
    }
    
    double dbl2 = 3.997;
    try
    {
       byte value2 = (byte)dbl2;
       outputBlock.Text += value2 + "\n";
    }
    catch (OverflowException)
    {
       outputBlock.Text += String.Format("{0} is out of range of a byte.", dbl2) + "\n";
    }
    // The example displays the following output:
    //       128
    //       3      
    
    
    
  • 调用 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);
          outputBlock.Text += String.Format("Converted the {0} value {1} to the {2} value {3}.",
                            number.GetType().Name, number,
                            result.GetType().Name, result) + "\n";
       }
       catch (OverflowException)
       {
          outputBlock.Text += String.Format("The {0} value {1} is outside the range of the Byte type.",
                            number.GetType().Name, number) + "\n";
       }
    }
    // 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.      
    
    
    
  • 可以调用 ParseTryParse 方法,将 Byte 值的字符串表现形式转换成 Byte。该字符串可包含十进制或十六进制数字。下面的示例通过使用一个十进制和一个十六进制的字符串阐释了分析操作。

    
    string string1 = "244";
    try
    {
       byte byte1 = Byte.Parse(string1);
       outputBlock.Text += byte1 + "\n";
    }
    catch (OverflowException)
    {
       outputBlock.Text += String.Format("'{0}' is out of range of a byte.", string1) + "\n";
    }
    catch (FormatException)
    {
       outputBlock.Text += String.Format("'{0}' is out of range of a byte.", string1) + "\n";
    }
    
    string string2 = "F9";
    try
    {
       byte byte2 = Byte.Parse(string2,
                               System.Globalization.NumberStyles.HexNumber);
       outputBlock.Text += byte2 + "\n";
    }
    catch (OverflowException)
    {
       outputBlock.Text += String.Format("'{0}' is out of range of a byte.", string2) + "\n";
    }
    catch (FormatException)
    {
       outputBlock.Text += String.Format("'{0}' is out of range of a byte.", string2) + "\n";
    }
    // The example displays the following output:
    //       244
    //       249
    
    
    

对字节值执行操作

Byte 类型支持标准数学运算,如加法、减法、除法、乘法、减法、求反和一元求反。与其他该整型类型类似,Byte 类型还支持按位 ANDORXOR、左移位和右移位运算符。

您可以使用标准数值运算符对两个 Byte 值进行比较,或者,您可以调用 CompareToEquals 方法。

用字符串代表一个字节。

Byte 类型提供对标准和自定义数字格式字符串的完全支持。但是,通常字节值表示为一位到三个数字值不带任何其他格式或为两位数字的十六进制值。

若要将 Byte 值的格式设置为无前导零的整数字符串,您可以调用 ToString() 的无参数方法。通过使用“D”格式说明符,您还可以包括指定数量的字符串表示形式中的前导零。您可以使用“X”格式说明符来显示 Byte 值的字符串表示形式。下面的示例用以下三种方式将 Byte 值的数组中元素进行格式设置。


outputBlock.FontFamily = new System.Windows.Media.FontFamily("Courier New");

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


通过调用 ToString(Byte, Int32) 方法并将基作为第二个参数,您还可以将 Byte 值的格式设置为二进制、八进制、十进制或十六进制字符串。下面的示例调用此方法显示二进制、八进制和十六进制一组字节值组成的表示形式。


byte[] numbers = { 0, 16, 104, 213 };
outputBlock.Text += String.Format("{0}   {1,8}   {2,5}   {3,5}",
                  "Value", "Binary", "Octal", "Hex") + "\n";
foreach (byte number in numbers)
{
   outputBlock.Text += String.Format("{0,5}   {1,8}   {2,5}   {3,5}",
                     number, Convert.ToString(number, 2),
                     Convert.ToString(number, 8),
                     Convert.ToString(number, 16)) + "\n";
}
// 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      


使用非小数字节值

除了使用作为十进制值的各个字节,您可能需要执行的字节值的按位运算,或处理字节数组或字节值的二进制或十六进制表示法。例如对于 BitConverter.GetBytes 方法的重载可以转换为字节数组的每个基元数据类型。

Byte 值只能由不含符号位的 8 位量值表示。当您在 Byte 值上执行按位运算,或当您使用各个位时,记住这一点很重要。若要执行一个数值,布尔,或任何两个的十进制值的比较操作,这两个值都必须使用相同的表示形式。

当对两个 Byte 值执行操作时,两个值将共享同一个表示,因此其结果是准确的。下面的示例阐释了屏蔽 Byte 值以确保它为偶数的最低序位的位。


using System;
using System.Globalization;

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      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);
         outputBlock.Text += String.Format("{0} And {1} = {2}", byteValue, mask,
                           byteValue & mask) + "\n";
      }
   }
}
// The example displays the following output:
//       12 And 254 = 12
//       123 And 254 = 122
//       245 And 254 = 244


另一方面,当您处理的无符号和有符号位,按位运算是很复杂的,由于 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 Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      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);
         outputBlock.Text += String.Format("{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)) + "\n";
      }
   }

   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)


Windows Phone OS

受以下版本支持: 8.0, 7.1, 7.0

Windows Phone

此类型的所有成员都是线程安全的。看似修改了实例状态的成员实际上返回一个用新值初始化的新实例。正如对任何其他类型一样,对于包含此类型的实例的共享变量,也必须通过锁定来保护对其进行的读写,以保证实现线程安全。

显示:
© 2014 Microsoft