Byte Struktura
Definicja
Ważne
Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.
Reprezentuje 8-bitową liczbę całkowitą bez znaku.
public value class System::Byte : IComparable, IComparable<System::Byte>, IConvertible, IEquatable<System::Byte>, IFormattable
public value class System::Byte : IComparable, IComparable<System::Byte>, IConvertible, IEquatable<System::Byte>, ISpanFormattable
public value class System::Byte : IAdditionOperators<System::Byte, System::Byte, System::Byte>, IAdditiveIdentity<System::Byte, System::Byte>, IBinaryInteger<System::Byte>, IBinaryNumber<System::Byte>, IBitwiseOperators<System::Byte, System::Byte, System::Byte>, IComparable<System::Byte>, IComparisonOperators<System::Byte, System::Byte>, IConvertible, IDecrementOperators<System::Byte>, IDivisionOperators<System::Byte, System::Byte, System::Byte>, IEqualityOperators<System::Byte, System::Byte>, IEquatable<System::Byte>, IIncrementOperators<System::Byte>, IMinMaxValue<System::Byte>, IModulusOperators<System::Byte, System::Byte, System::Byte>, IMultiplicativeIdentity<System::Byte, System::Byte>, IMultiplyOperators<System::Byte, System::Byte, System::Byte>, INumber<System::Byte>, IParseable<System::Byte>, IShiftOperators<System::Byte, System::Byte>, ISpanParseable<System::Byte>, ISubtractionOperators<System::Byte, System::Byte, System::Byte>, IUnaryNegationOperators<System::Byte, System::Byte>, IUnaryPlusOperators<System::Byte, System::Byte>, IUnsignedNumber<System::Byte>
public value class System::Byte : IComparable, IConvertible, IFormattable
public value class System::Byte : IComparable, IComparable<System::Byte>, IEquatable<System::Byte>, IFormattable
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
public readonly struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
public readonly struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, ISpanFormattable
public readonly struct Byte : IAdditionOperators<byte,byte,byte>, IAdditiveIdentity<byte,byte>, IBinaryInteger<byte>, IBinaryNumber<byte>, IBitwiseOperators<byte,byte,byte>, IComparable<byte>, IComparisonOperators<byte,byte>, IConvertible, IDecrementOperators<byte>, IDivisionOperators<byte,byte,byte>, IEqualityOperators<byte,byte>, IEquatable<byte>, IIncrementOperators<byte>, IMinMaxValue<byte>, IModulusOperators<byte,byte,byte>, IMultiplicativeIdentity<byte,byte>, IMultiplyOperators<byte,byte,byte>, INumber<byte>, IParseable<byte>, IShiftOperators<byte,byte>, ISpanParseable<byte>, ISubtractionOperators<byte,byte,byte>, IUnaryNegationOperators<byte,byte>, IUnaryPlusOperators<byte,byte>, IUnsignedNumber<byte>
[System.Serializable]
public struct Byte : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
public struct Byte : IComparable, IComparable<byte>, IEquatable<byte>, IFormattable
type byte = struct
interface IConvertible
interface IFormattable
type byte = struct
interface IConvertible
interface ISpanFormattable
interface IFormattable
type byte = struct
interface IConvertible
interface ISpanFormattable
interface IFormattable
interface IBinaryInteger<byte>
interface IBinaryNumber<byte>
interface IBitwiseOperators<byte, byte, byte>
interface INumber<byte>
interface IAdditionOperators<byte, byte, byte>
interface IAdditiveIdentity<byte, byte>
interface IComparisonOperators<byte, byte>
interface IEqualityOperators<byte, byte>
interface IDecrementOperators<byte>
interface IDivisionOperators<byte, byte, byte>
interface IIncrementOperators<byte>
interface IModulusOperators<byte, byte, byte>
interface IMultiplicativeIdentity<byte, byte>
interface IMultiplyOperators<byte, byte, byte>
interface IParseable<byte>
interface ISpanParseable<byte>
interface ISubtractionOperators<byte, byte, byte>
interface IUnaryNegationOperators<byte, byte>
interface IUnaryPlusOperators<byte, byte>
interface IShiftOperators<byte, byte>
interface IMinMaxValue<byte>
interface IUnsignedNumber<byte>
[<System.Serializable>]
type byte = struct
interface IFormattable
interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type byte = struct
interface IFormattable
interface IConvertible
type byte = struct
interface IFormattable
Public Structure Byte
Implements IComparable, IComparable(Of Byte), IConvertible, IEquatable(Of Byte), IFormattable
Public Structure Byte
Implements IComparable, IComparable(Of Byte), IConvertible, IEquatable(Of Byte), ISpanFormattable
Public Structure Byte
Implements IAdditionOperators(Of Byte, Byte, Byte), IAdditiveIdentity(Of Byte, Byte), IBinaryInteger(Of Byte), IBinaryNumber(Of Byte), IBitwiseOperators(Of Byte, Byte, Byte), IComparable(Of Byte), IComparisonOperators(Of Byte, Byte), IConvertible, IDecrementOperators(Of Byte), IDivisionOperators(Of Byte, Byte, Byte), IEqualityOperators(Of Byte, Byte), IEquatable(Of Byte), IIncrementOperators(Of Byte), IMinMaxValue(Of Byte), IModulusOperators(Of Byte, Byte, Byte), IMultiplicativeIdentity(Of Byte, Byte), IMultiplyOperators(Of Byte, Byte, Byte), INumber(Of Byte), IParseable(Of Byte), IShiftOperators(Of Byte, Byte), ISpanParseable(Of Byte), ISubtractionOperators(Of Byte, Byte, Byte), IUnaryNegationOperators(Of Byte, Byte), IUnaryPlusOperators(Of Byte, Byte), IUnsignedNumber(Of Byte)
Public Structure Byte
Implements IComparable, IConvertible, IFormattable
Public Structure Byte
Implements IComparable, IComparable(Of Byte), IEquatable(Of Byte), IFormattable
- Dziedziczenie
- Atrybuty
- Implementuje
-
IComparable IComparable<Byte> IConvertible IEquatable<Byte> IFormattable ISpanFormattable IAdditionOperators<Byte,Byte,Byte> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Byte,Byte> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<Byte> IBinaryNumber<Byte> IBinaryNumber<TSelf> IBitwiseOperators<Byte,Byte,Byte> IBitwiseOperators<TSelf,TSelf,TSelf> IComparable<TOther> IComparable<TSelf> IComparisonOperators<Byte,Byte> IComparisonOperators<TSelf,TSelf> IDecrementOperators<Byte> IDecrementOperators<TSelf> IDivisionOperators<Byte,Byte,Byte> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Byte,Byte> IEqualityOperators<TSelf,TOther> IEqualityOperators<TSelf,TSelf> IEquatable<TOther> IEquatable<TSelf> IIncrementOperators<Byte> IIncrementOperators<TSelf> IMinMaxValue<Byte> IModulusOperators<Byte,Byte,Byte> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Byte,Byte> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Byte,Byte,Byte> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Byte> INumber<TSelf> IParseable<Byte> IParseable<TSelf> IShiftOperators<Byte,Byte> IShiftOperators<TSelf,TSelf> ISpanParseable<Byte> ISpanParseable<TSelf> ISubtractionOperators<Byte,Byte,Byte> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Byte,Byte> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Byte,Byte> IUnaryPlusOperators<TSelf,TSelf> IUnsignedNumber<Byte>
Uwagi
Byte jest niezmiennym typem wartości, który reprezentuje niepodpisane liczby całkowite z wartościami z zakresu od 0 (reprezentowanego przez stałą Byte.MinValue ) do 255 (co jest reprezentowane przez stałą Byte.MaxValue ). Platforma .NET zawiera również podpisany 8-bitowy typ wartości całkowitej, SBytektóry reprezentuje wartości z zakresu od -128 do 127.
Utworzenie wystąpienia wartości bajtowej
Wystąpienie wartości można utworzyć Byte na kilka sposobów:
Możesz zadeklarować zmienną Byte i przypisać jej wartość całkowitą literału, która znajduje się w zakresie Byte typu danych. Poniższy przykład deklaruje dwie Byte zmienne i przypisuje im wartości w ten sposób.
byte value1 = 64; byte value2 = 255;
let value1 = 64uy let value2 = 255uy
Dim value1 As Byte = 64 Dim value2 As Byte = 255
Do bajtu można przypisać wartość liczbową inną niż bajt. Jest to konwersja zawężania, więc wymaga operatora rzutowania w językach C# i F# lub metody konwersji w Visual Basic, jeśli
Option Strict
jest włączona. Jeśli wartość nie bajtowa jest wartością Singletypu , Doublelub Decimal zawierającą składnik ułamkowy, obsługa jego części ułamkowej zależy od kompilatora wykonującego konwersję. Poniższy przykład przypisuje kilka wartości liczbowych do Byte zmiennych.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
Możesz wywołać metodę Convert klasy, aby przekonwertować dowolny obsługiwany typ na Byte wartość. Jest to możliwe, ponieważ Byte obsługuje IConvertible interfejs. Poniższy przykład ilustruje konwersję tablicy Int32 wartości na Byte wartości.
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.
open System 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.
Metodę Parse lub TryParse można wywołać, aby przekonwertować reprezentację Byte ciągu wartości na Bytewartość . Ciąg może zawierać cyfry dziesiętne lub szesnastkowe. Poniższy przykład ilustruje operację analizy przy użyciu zarówno dziesiętnego, jak i ciągu szesnastkowego.
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
Wykonywanie operacji na wartościach bajtowych
Typ Byte obsługuje standardowe operacje matematyczne, takie jak dodawanie, odejmowanie, dzielenie, mnożenie, odejmowanie, negacja i negacja jednoargumentowa. Podobnie jak w przypadku innych typów całkowitych, Byte typ obsługuje również operatory bitowe AND
, OR
, , XOR
shift w lewo i przesunięcia w prawo.
Możesz użyć standardowych operatorów liczbowych, aby porównać dwie Byte wartości lub wywołać metodę CompareTo lub Equals .
Można również wywołać elementy członkowskie Math klasy, aby wykonać szeroki zakres operacji liczbowych, w tym uzyskać wartość bezwzględną liczby, obliczyć iloraz i resztę z dzielenia całkowitego, określając maksymalną lub minimalną wartość dwóch liczb całkowitych, uzyskując znak liczby i zaokrąglając liczbę.
Reprezentowanie bajta jako ciągu
Typ Byte zapewnia pełną obsługę ciągów standardowych i niestandardowych formatów liczbowych. (Aby uzyskać więcej informacji, zobacz Typy formatowania, Standardowe ciągi formatu liczbowego i Niestandardowe ciągi formatu liczbowego). Najczęściej jednak wartości bajtów są reprezentowane jako wartości jednocyfrowe do trzech cyfr bez dodatkowego formatowania lub jako dwucyfrowe wartości szesnastkowe.
Aby sformatować Byte wartość jako ciąg całkowity bez zer wiodących, możesz wywołać metodę bez ToString() parametrów. Używając specyfikatora formatu "D", można również uwzględnić określoną liczbę zer wiodących w reprezentacji ciągu. Za pomocą specyfikatora formatu "X" można reprezentować Byte wartość jako ciąg szesnastkowy. Poniższy przykład formatuje elementy w tablicy Byte wartości na te trzy sposoby.
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
Wartość można również sformatować Byte jako ciąg binarny, ósemkowy, dziesiętny lub szesnastkowy, wywołując ToString(Byte, Int32) metodę i podając bazę jako drugi parametr metody. Poniższy przykład wywołuje tę metodę, aby wyświetlić binarne, ósemkowe i szesnastkowe reprezentacje tablicy wartości bajtowych.
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
Praca z niedziesiętnymi wartościami bajtowymi
Oprócz pracy z poszczególnymi bajtami jako wartości dziesiętnych, możesz chcieć wykonywać operacje bitowe z wartościami bajtów lub pracować z tablicami bajtów albo z reprezentacjami binarnymi lub szesnastkowymi wartościami bajtów. Na przykład przeciążenia BitConverter.GetBytes metody mogą konwertować poszczególne typy danych pierwotnych na tablicę bajtów, a BigInteger.ToByteArray metoda konwertuje BigInteger wartość na tablicę bajtów.
Byte wartości są reprezentowane tylko w 8 bitach o ich wielkość, bez bitu znaku. Ważne jest, aby pamiętać o wykonywaniu operacji bitowych na Byte wartościach lub podczas pracy z poszczególnymi bitami. Aby wykonać operację liczbową, logiczną lub porównawczą na dwóch wartościach innych niż dziesiętne, obie wartości muszą używać tej samej reprezentacji.
Gdy operacja jest wykonywana na dwóch Byte wartościach, wartości mają taką samą reprezentację, więc wynik jest dokładny. Przedstawiono to w poniższym przykładzie, który maskuje bit o najniższej Byte kolejności wartości, aby upewnić się, że jest równy.
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 Example
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
Z drugiej strony podczas pracy z bitami niepodpisanymi i podpisanymi operacje bitowe są skomplikowane przez fakt, że SByte wartości używają reprezentacji znaku i wielkości dla wartości dodatnich, a dwa uzupełniają reprezentację wartości ujemnych. Aby wykonać znaczącą operację bitową, wartości muszą zostać przekonwertowane na dwie równoważne reprezentacje, a informacje o bitie znaku muszą zostać zachowane. W poniższym przykładzie można zamaskować bity 2 i 4 tablicy 8-bitowych wartości podpisanych i niepodpisanych.
using System;
using System.Collections.Generic;
using System.Globalization;
public struct ByteString
{
public string Value;
public int Sign;
}
public class Example
{
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 Example
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)
Pola
MaxValue |
Reprezentuje największą możliwą wartość elementu Byte. To pole jest stałe. |
MinValue |
Reprezentuje najmniejszą możliwą wartość elementu Byte. To pole jest stałe. |
Metody
CompareTo(Byte) |
Porównuje to wystąpienie z określoną 8-bitową liczbą całkowitą bez znaku i zwraca wskazanie ich wartości względnych. |
CompareTo(Object) |
Porównuje to wystąpienie z określonym obiektem i zwraca wskazanie ich względnych wartości. |
Equals(Byte) |
Zwraca wartość wskazującą, czy to wystąpienie i określony Byte obiekt reprezentują tę samą wartość. |
Equals(Object) |
Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi. |
GetHashCode() |
Zwraca wartość skrótu dla tego wystąpienia. |
GetTypeCode() | |
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na Byte jego odpowiednik. |
Parse(String) |
Konwertuje reprezentację ciągu liczby na jej Byte odpowiednik. |
Parse(String, IFormatProvider) |
Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na Byte jego odpowiednik. |
Parse(String, NumberStyles) |
Konwertuje reprezentację ciągu liczby w określonym stylu na jego Byte odpowiednik. |
Parse(String, NumberStyles, IFormatProvider) |
Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na Byte jego odpowiednik. |
ToString() |
Konwertuje wartość bieżącego Byte obiektu na równoważną reprezentację ciągu. |
ToString(IFormatProvider) |
Konwertuje wartość liczbową bieżącego Byte obiektu na równoważną reprezentację ciągu przy użyciu określonych informacji o formatowaniu specyficznym dla kultury. |
ToString(String) |
Konwertuje wartość bieżącego Byte obiektu na równoważną reprezentację ciągu przy użyciu określonego formatu. |
ToString(String, IFormatProvider) |
Konwertuje wartość bieżącego Byte obiektu na równoważną reprezentację ciągu przy użyciu określonych formatów i informacji o formatowaniu specyficznym dla kultury. |
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Próbuje sformatować wartość bieżącego 8-bitowego wystąpienia liczby całkowitej bez znaku do podanego zakresu znaków. |
TryParse(ReadOnlySpan<Char>, Byte) |
Próbuje przekonwertować reprezentację zakresu liczby na równoważną Byte i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie. |
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte) |
Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na jego Byte odpowiednik. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie. |
TryParse(String, Byte) |
Próbuje przekonwertować reprezentację ciągu liczby na jej Byte odpowiednik i zwraca wartość wskazującą, czy konwersja powiodła się. |
TryParse(String, NumberStyles, IFormatProvider, Byte) |
Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na jego Byte odpowiednik. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie. |
Jawne implementacje interfejsu
Dotyczy
Bezpieczeństwo wątkowe
Wszystkie elementy członkowskie tego typu są bezpieczne wątkowo. Elementy członkowskie, które na pierwszy rzut oka modyfikują stan wystąpienia, w rzeczywistości zwracają nowe wystąpienie zainicjowane z nową wartością. Podobnie jak w przypadku innych typów odczytywanie i zapisywanie w udostępnionej zmiennej, która zawiera wystąpienie tego typu, musi być chronione przez blokadę w celu zagwarantowania bezpieczeństwa wątków.