Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Struttura Byte

 

Data di pubblicazione: ottobre 2016

Rappresenta un intero senza segno a 8 bit.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Byte : IComparable, IFormattable, IConvertible, 
	IComparable<byte>, IEquatable<byte>

NomeDescrizione
System_CAPS_pubmethodCompareTo(Byte)

Confronta questa istanza con un valore intero senza segno a 8 bit specificato e restituisce un'indicazione dei loro valori relativi.

System_CAPS_pubmethodCompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un'indicazione dei loro relativi valori.

System_CAPS_pubmethodEquals(Byte)

Restituisce un valore che indica se l'istanza e un oggetto Byte specificato rappresentano lo stesso valore.

System_CAPS_pubmethodEquals(Object)

Restituisce un valore che indica se questa istanza è uguale ad un oggetto specificato. (Esegue l'override di ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Restituisce il codice hash per questa istanza. (Esegue l'override di ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Ottiene l'oggetto Type dell'istanza corrente.(Ereditato da Object.)

System_CAPS_pubmethodGetTypeCode()

Restituisce l'oggetto TypeCode del tipo di valore Byte.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Converte la rappresentazione di stringa di un numero nell'oggetto Byte equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura indicato nell'oggetto Byte equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Converte la rappresentazione di stringa di un numero in uno stile specificato nell'oggetto Byte equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Converte la rappresentazione di stringa di un numero in uno stile specificato e un formato specifico delle impostazioni cultura indicato nell'oggetto Byte equivalente.

System_CAPS_pubmethodToString()

Converte il valore dell'oggetto Byte corrente nella rappresentazione di stringa equivalente.(Esegue l'override di ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Converte il valore numerico dell'oggetto Byte corrente nella rappresentazione di stringa equivalente, usando le informazioni specificate relative alla formattazione delle impostazioni cultura.

System_CAPS_pubmethodToString(String)

Converte il valore dell'oggetto Byte corrente nella rappresentazione di stringa equivalente, usando il formato specificato.

System_CAPS_pubmethodToString(String, IFormatProvider)

Converte il valore dell'oggetto Byte corrente nella rappresentazione di stringa equivalente, usando il formato specificato e le informazioni di formattazione specifiche delle impostazioni cultura.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Byte)

Prova a convertire la rappresentazione di stringa di un numero nell'oggetto Byte equivalente e restituisce un valore che indica se la conversione è stata eseguita correttamente.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, Byte)

Converte la rappresentazione di stringa di un numero in uno stile specificato e un formato specifico delle impostazioni cultura indicato nell'oggetto Byte equivalente. Un valore restituito indica se la conversione è riuscita o meno.

NomeDescrizione
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Rappresenta il valore massimo possibile di Byte. Questo campo è costante.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Rappresenta il valore minimo possibile di un oggetto Byte. Questo campo è costante.

NomeDescrizione
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToChar.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToUInt64.

Byteè un tipo di valore non modificabile che rappresenta interi senza segno con valori compresi tra 0 (rappresentata dal Byte.MinValue costante) a 255 (rappresentata dal Byte.MaxValue costante). .NET Framework include anche un tipo di valore intero con segno a 8 bit, SByte, che rappresenta i valori compresi tra -128 e 127.

È possibile creare un'istanza di un Byte valore in diversi modi:

  • È possibile dichiarare un Byte variabile e assegnarle un valore letterale integer che è compresa nell'intervallo di Byte tipo di dati. Nell'esempio seguente vengono dichiarati due Byte variabili e li assegna i valori in questo modo.

    byte value1 = 64;
    byte value2 = 255;
    
  • È possibile assegnare un valore numerico non byte per byte. Si tratta di una conversione di narrowing, pertanto richiede un operatore di cast in c# e un metodo di conversione in Visual Basic se OptionStrict si trova in. Se il valore di byte non è un Single, Double, o Decimal valore include un componente frazionario, la gestione della parte frazionaria dipende dal compilatore che esegue la conversione. L'esempio seguente assegna alcuni valori numerici per Byte variabili.

    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
    
  • È possibile chiamare un metodo di Convert classe per convertire qualsiasi tipo supportato in un Byte valore. Ciò è possibile perché Byte supporta il IConvertible interfaccia. Nell'esempio seguente viene illustrata la conversione di una matrice di Int32 valori Byte valori.

    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.      
    
  • È possibile chiamare il Parse o TryParse metodo per convertire la rappresentazione di stringa di un Byte valore un Byte. La stringa può contenere cifre decimale o esadecimale. Nell'esempio seguente viene illustrata l'operazione di analisi utilizzando un numero decimale sia una stringa esadecimale.

    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
    

Il Byte tipo supporta operazioni matematiche standard, ad esempio addizione, sottrazione, divisione, moltiplicazione, sottrazione, negazione e negazione unaria. Come altri tipi integrali di Byte tipo supporta anche il bit per bit AND, OR, XOR, left shift e right shift (operatori).

È possibile utilizzare gli operatori numerici standard per confrontare due Byte valori oppure è possibile chiamare il CompareTo o Equals metodo.

È inoltre possibile chiamare i membri del Math classe per eseguire un'ampia gamma di operazioni numeriche, tra cui ottenere il valore assoluto di un numero, calcolare il quoziente e il resto della divisione integrale, determinando il valore massimo o minimo di due interi, il segno di un numero di recupero e arrotondamento di un numero.

Il Byte tipo fornisce il supporto completo per le stringhe di formato numerico standard e personalizzate. (Per ulteriori informazioni, vedere Formattazione di tipi in .NET Framework, Stringhe di formato numerico standard, e Stringhe di formato numerico personalizzato.) Tuttavia, in genere, byte valori sono rappresentati come valori di una cifra a tre cifre senza formattazione aggiuntiva o come valori esadecimali a due cifre.

Per formattare un Byte valore come stringa integrale senza zeri iniziali, è possibile chiamare senza parametri ToString() metodo. Utilizzando l'identificatore di formato "D", è anche possibile includere un numero specificato di zeri iniziali nella rappresentazione di stringa. Utilizzando l'identificatore di formato "X", è possibile rappresentare un Byte valore come stringa esadecimale. Nell'esempio seguente formatta gli elementi in una matrice di Byte valori nei tre modi seguenti.

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      

È anche possibile formattare un Byte valore come binaria, ottale, esadecimale o decimale stringa chiamando il ToString(Byte, Int32) (metodo) e fornendo la base come secondo parametro del metodo. Nell'esempio seguente chiama questo metodo per visualizzare il file binario, ottale e rappresentazioni esadecimali di una matrice di valori di 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      

Oltre a utilizzare byte singoli come valori decimali, è necessario eseguire operazioni bit a bit con valori byte, oppure utilizzare matrici di byte con le rappresentazioni binarie o esadecimali di valori byte. Ad esempio, esegue l'overload del BitConverter.GetBytes metodo consente di convertire i tipi di dati primitivi in una matrice di byte e BigInteger.ToByteArray metodo converte un BigInteger valore da una matrice di byte.

Bytei valori sono rappresentati in 8 bit dalla grandezza solo, senza il bit di segno. Questo aspetto è importante da tenere presenti quando si eseguono operazioni bit per bit su Byte valori o quando si lavora con singoli bit. Per eseguire l'operazione di confronto tra qualsiasi due valori non decimali, booleano o numerico, entrambi i valori devono utilizzare la stessa rappresentazione.

Quando viene eseguita un'operazione su due Byte valori, i valori condividono la stessa rappresentazione, pertanto il risultato è accurato. Come illustrato nell'esempio seguente, che il bit di ordine più basso di una Byte valore per assicurarsi che sia anche.

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

D'altra parte, quando si lavora con bits con e senza segno, le operazioni bit per bit sono complicate dal fatto che il SByte valori utilizzano una rappresentazione di segno e grandezza per i valori positivi e rappresentazione in complemento a due per i valori negativi. Per eseguire un'operazione bit per bit significativa, i valori devono essere convertiti in due rappresentazioni equivalenti e informazioni sui bit di segno devono essere mantenute. Nell'esempio seguente viene eseguita l'operazione per escludere i bit 2 e 4 di una matrice di valori con e senza segno a 8 bit.

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)

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

Tutti i membri di questo tipo sono thread-safe. I membri che apparentemente modificano lo stato dell'istanza è in realtà restituiscono una nuova istanza inizializzata con il nuovo valore. Come con qualsiasi altro tipo, lettura e scrittura in una variabile condivisa che contiene un'istanza di questo tipo deve essere protetto da un blocco per garantire la thread safety.

Torna all'inizio
Mostra: