Struktur System.Byte
Artikel ini menyediakan keterangan tambahan untuk dokumentasi referensi untuk API ini.
Byte adalah tipe nilai yang tidak dapat diubah yang mewakili bilangan bulat yang tidak ditandatangani dengan nilai yang berkisar dari 0 (yang diwakili oleh Byte.MinValue konstanta) hingga 255 (yang diwakili oleh Byte.MaxValue konstanta). .NET juga menyertakan jenis nilai bilangan bulat 8-bit yang ditandatangani, SByte, yang mewakili nilai yang berkisar dari -128 hingga 127.
Membuat instans nilai Byte
Anda dapat membuat instans Byte nilai dengan beberapa cara:
Anda dapat mendeklarasikan Byte variabel dan menetapkannya nilai bilangan Byte bulat harfiah yang berada dalam rentang jenis data. Contoh berikut mendeklarasikan dua Byte variabel dan menetapkan nilainya dengan cara ini.
byte value1 = 64; byte value2 = 255;
let value1 = 64uy let value2 = 255uy
Dim value1 As Byte = 64 Dim value2 As Byte = 255
Anda dapat menetapkan nilai numerik non-byte ke byte. Ini adalah konversi yang mempersempit, sehingga memerlukan operator cast di C# dan F#, atau metode konversi di Visual Basic jika
Option Strict
aktif. Jika nilai non-byte adalah Singlenilai , , Doubleatau Decimal yang menyertakan komponen pecahan, penanganan bagian pecahannya tergantung pada kompilator yang melakukan konversi. Contoh berikut menetapkan beberapa nilai numerik ke Byte variabel.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
Anda dapat memanggil metode Convert kelas untuk mengonversi jenis yang didukung menjadi Byte nilai. Ini dimungkinkan IConvertible karena Byte mendukung antarmuka. Contoh berikut mengilustrasikan konversi array Int32 nilai ke Byte nilai.
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.
Anda dapat memanggil Parse metode atau TryParse untuk mengonversi representasi string dari Byte nilai menjadi Byte. String dapat berisi digit desimal atau heksadesimal. Contoh berikut mengilustrasikan operasi penguraian dengan menggunakan string desimal dan heksadesimal.
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
Melakukan operasi pada nilai Byte
Jenis ini Byte mendukung operasi matematika standar seperti penambahan, pengurangan, pembagian, perkalian, pengurangan, negasi, dan negasi unary. Seperti jenis integral lainnya, jenis ini Byte juga mendukung operator bitwise AND
, , OR
XOR
, shift kiri, dan shift kanan.
Anda dapat menggunakan operator numerik standar untuk membandingkan dua Byte nilai, atau Anda dapat memanggil CompareTo metode atau Equals .
Anda juga dapat memanggil anggota Math kelas untuk melakukan berbagai operasi numerik, termasuk mendapatkan nilai absolut angka, menghitung kuota dan sisanya dari pembagian integral, menentukan nilai maksimum atau minimum dua bilangan bulat, mendapatkan tanda angka, dan membulatkan angka.
Mewakili Byte sebagai String
Jenis ini Byte menyediakan dukungan penuh untuk string format numerik standar dan kustom. (Untuk informasi selengkapnya, lihat Tipe Pemformatan, String Format Numerik Standar, dan String Format Numerik Kustom.) Namun, yang paling umum, nilai byte direpresentasikan sebagai nilai satu digit ke tiga digit tanpa pemformatan tambahan, atau sebagai nilai heksadesimal dua digit.
Untuk memformat Byte nilai sebagai string integral tanpa nol di depan, Anda dapat memanggil metode tanpa ToString() parameter. Dengan menggunakan penentu format "D", Anda juga dapat menyertakan jumlah nol di depan tertentu dalam representasi string. Dengan menggunakan penentu format "X", Anda dapat mewakili Byte nilai sebagai string heksadesimal. Contoh berikut memformat elemen dalam array Byte nilai dengan tiga cara ini.
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
Anda juga dapat memformat Byte nilai sebagai string biner, oktal, desimal, atau heksadesimal dengan memanggil ToString(Byte, Int32) metode dan menyediakan basis sebagai parameter kedua metode. Contoh berikut memanggil metode ini untuk menampilkan representasi biner, oktal, dan heksadesimal dari array nilai byte.
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
Bekerja dengan nilai Byte non-desimal
Selain bekerja dengan byte individual sebagai nilai desimal, Anda mungkin ingin melakukan operasi bitwise dengan nilai byte, atau bekerja dengan array byte atau dengan representasi biner atau heksadesimal dari nilai byte. Misalnya, kelebihan beban BitConverter.GetBytes metode dapat mengonversi masing-masing jenis data primitif menjadi array byte, dan BigInteger.ToByteArray metode mengonversi BigInteger nilai menjadi array byte.
Byte nilai diwakili dalam 8 bit dengan besarnya saja, tanpa sedikit tanda. Ini penting untuk diingat ketika Anda melakukan operasi bitwise pada Byte nilai atau ketika Anda bekerja dengan bit individual. Untuk melakukan operasi numerik, Boolean, atau perbandingan pada dua nilai non-desimal, kedua nilai harus menggunakan representasi yang sama.
Saat operasi dilakukan pada dua Byte nilai, nilai berbagi representasi yang sama, sehingga hasilnya akurat. Ini diilustrasikan dalam contoh berikut, yang menutupi bit urutan terendah dari Byte nilai untuk memastikan bahwa nilainya merata.
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
Di sisi lain, ketika Anda bekerja dengan bit yang tidak ditandatangani dan ditandatangani, operasi bitwise rumit oleh fakta bahwa SByte nilai menggunakan representasi tanda dan besar untuk nilai positif, dan representasi pelengkap dua untuk nilai negatif. Untuk melakukan operasi bitwise yang bermakna, nilai harus dikonversi ke dua representasi yang setara, dan informasi tentang bit tanda harus dipertahankan. Contoh berikut melakukan ini untuk menutupi bit 2 dan 4 dari array nilai yang ditandatangani dan tidak ditandatangani 8-bit.
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)
Saran dan Komentar
https://aka.ms/ContentUserFeedback.
Segera hadir: Sepanjang tahun 2024 kami akan menghentikan penggunaan GitHub Issues sebagai mekanisme umpan balik untuk konten dan menggantinya dengan sistem umpan balik baru. Untuk mengetahui informasi selengkapnya, lihat:Kirim dan lihat umpan balik untuk