Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Byte, structure

Représente un entier non signé 8 bits.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

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

Le type Byte expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompareTo(Byte)Compare cette instance à un entier non signé 8 bits et retourne une indication de leurs valeurs relatives.
Méthode publiquePris en charge par XNA FrameworkCompareTo(Object)Compare cette instance à un objet spécifié et retourne une indication de leurs valeurs relatives.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Byte)Retourne une valeur indiquant si cette instance et un objet Byte spécifié représentent la même valeur.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Renvoie une valeur indiquant si cette instance équivaut à un objet spécifié. (Substitue ValueType.Equals(Object).)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeRetourne le code de hachage de cette instance. (Substitue ValueType.GetHashCode().)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkGetTypeCodeRetourne le TypeCode du type valeur Byte.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(String)Convertit la représentation sous forme de chaîne d'un nombre en sa représentation Byte équivalente.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(String, NumberStyles)Convertit la représentation d'un nombre sous forme de chaîne dans un style spécifié en Byte équivalent.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(String, IFormatProvider)Convertit la représentation sous forme de chaîne d'un nombre, ayant un format spécifique à la culture spécifié, en sa représentation Byte équivalente.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(String, NumberStyles, IFormatProvider)Convertit la représentation sous forme de chaîne d'un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation Byte équivalente.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString()Convertit la valeur de l'objet Byte en cours en sa représentation équivalente sous forme de chaîne. (Substitue ValueType.ToString().)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(IFormatProvider)Convertit la valeur numérique de l'objet Byte en cours en sa représentation sous forme de chaîne équivalente à l'aide des informations de mise en forme spécifiques à la culture spécifiées.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(String)Convertit la valeur de l'objet Byte actuel en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(String, IFormatProvider)Convertit la valeur de l'objet Byte actuel en sa représentation sous forme de chaîne équivalente à l'aide du format et des informations de mise en forme spécifiques à la culture spécifiés.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTryParse(String, Byte)Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent Byte et retourne une valeur indiquant si la conversion a réussi.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTryParse(String, NumberStyles, IFormatProvider, Byte)Convertit la représentation sous forme de chaîne d'un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation Byte équivalente. Une valeur de retour indique si la conversion a réussi ou a échoué.
Début

  NomDescription
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMaxValueReprésente la plus grande valeur possible d'un Byte. Ce champ est constant.
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMinValueReprésente la plus petite valeur possible de Byte. Ce champ est constant.
Début

  NomDescription
Implémentation d'interface expliciteMéthode privéePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIComparable.CompareToCompare l'instance actuelle avec un autre objet du même type et retourne un entier qui indique si l'instance actuelle précède ou suit un autre objet ou se trouve à la même position dans l'ordre de tri.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToBooleanInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToBoolean.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToByteInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToByte.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToCharInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToChar.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDateTimeInfrastructure. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève un InvalidCastException.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDecimalInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDecimal.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDoubleInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDouble.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt16Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToInt16.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt32Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToInt32.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt64Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToInt64.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSByteInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToSByte.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSingleInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToSingle.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToTypeInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToType.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt16Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt16.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt32Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt32.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt64Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt64.
Début

Byte est un type immuable qui représente un entier non signé avec des valeurs comprises entre 0 (qui est représenté par la constante Byte.MinValue) et 255 (qui est représenté par la constante Byte.MaxValue). Le .NET Framework inclut également un type de valeur d'entier 8 bits signé, SByte, qui représente des valeurs comprises entre - 128 et 127.

Instanciation d'une valeur d'octet

Vous pouvez instancier une valeur Byte de plusieurs façons :

  • Vous pouvez déclarer une variable Byte et l'assigner à une valeur d'entier littérale comprise dans la plage du type de données Byte. L'exemple suivant déclare deux variables Byte et leur assigne des valeurs de cette manière.

    
    byte value1 = 64;
    byte value2 = 255;
    
    
    
  • Vous pouvez assigner une valeur numérique différente d'un octet à un octet. Il s'agit d'une conversion restrictive ; cela requiert donc un opérateur de cast en C# et une méthode de conversion en Visual Basic si OptionStrict est activé. Si la valeur différente d'un octet est une valeur Single, Double ou Decimal qui inclut un composant fractionnaire, la gestion de sa partie fractionnaire dépend du compilateur qui effectue la conversion. L'exemple suivant assigne plusieurs valeurs numériques aux variables 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
    //       4      
    
    
    
  • Vous pouvez appeler une méthode de la classe Convert pour convertir n'importe quel type pris en charge en valeur Byte. C'est possible parce que Byte prend en charge l'interface IConvertible. L'exemple suivant illustre la conversion d'un tableau de valeurs Int32 en valeurs 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.      
    
    
    
  • Vous pouvez appeler la méthode Parse ou TryParse pour convertir la représentation sous forme de chaîne d'une valeur Byte en un Byte. La chaîne peut contenir des chiffres décimaux ou hexadécimaux. L'exemple suivant illustre l'opération d'analyse à l'aide d'une chaîne décimale et d'une chaîne hexadécimale.

    
    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
    
    
    

Exécution d'opérations sur les valeurs d'octets

Le type Byte prend en charge les opérations mathématiques standard, telles que l'addition, la soustraction, la division, la multiplication, la soustraction, la négation et la négation unaire. Comme les autres types intégraux, le type Byte prend en charge également les opérateurs de bit, de décalage vers la droite et de décalage vers la gauche AND, OR et XOR.

Vous pouvez utiliser les opérateurs numériques standard pour comparer deux valeurs Byte, ou vous pouvez appeler la méthode CompareTo ou Equals.

Appelez également les membres de la classe Math pour exécuter une large gamme d'opérations numériques, y compris obtenir la valeur absolue d'un nombre, calculer le quotient et le reste de la division complète, déterminer le maximum ou la valeur minimale de deux entiers, obtenir le signe d'un nombre, et arrondir un nombre.

Représentant un octet en tant que chaîne.

Le type Byte prend complètement en charge les chaînes de format numériques standard et personnalisées. (Pour plus d'informations, consultez Mise en forme des types, Chaînes de format numériques standard et Chaînes de format numériques personnalisées.) Toutefois, plus couramment, les valeurs d'octets sont représentées sous forme de valeurs avec un à trois chiffres sans mise en forme supplémentaire, ou sous forme de valeurs hexadécimale à deux chiffres.

Pour mettre une valeur Byte sous forme de chaîne d'entier sans zéros non significatifs, vous pouvez appeler la méthode sans paramètre ToString(). En utilisant le spécificateur de format « D », vous pouvez également inclure un nombre spécifié de zéros non significatifs dans la représentation sous forme de chaîne. En utilisant le spécificateur de format « X », vous pouvez représenter une valeur Byte sous forme de chaîne hexadécimale. L'exemple suivant met en forme les éléments dans un tableau de valeurs Byte selon ces trois manières.


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      


Vous pouvez également mettre une valeur Byte sous forme de chaîne binaire, octale, décimale ou hexadécimale en appelant la méthode ToString(Byte, Int32) et en fournissant la base en tant que second paramètre de la méthode. L'exemple suivant appelle cette méthode pour afficher les représentations binaires, octales et hexadécimales d'un tableau de valeurs d'octets.


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      


Utilisation de valeurs d'octets non décimales

En plus d'utiliser des octets individuels comme valeurs décimales, vous pouvez souhaiter effectuer des opérations au niveau du bit avec des valeurs d'octets ou utiliser des tableaux d'octets ou les représentations binaires ou hexadécimales des valeurs d'octets. Par exemple, les surcharges de la méthode BitConverter.GetBytes peuvent convertir chacun des types de données primitifs en un tableau d'octets, et la méthode BigInteger.ToByteArray convertit une valeur BigInteger en un tableau d'octets.

Les valeurs Byte sont représentées en 8 bits uniquement par leur ordre de grandeur, sans bit de signe. Il est important de le retenir lorsque vous effectuez des opérations au niveau du bit sur des valeurs Byte ou lorsque vous travaillez avec des bits individuels. Pour effectuer une opération numérique, booléenne ou de comparaison sur deux valeurs non décimales, les deux valeurs doivent utiliser la même représentation.

Lorsqu'une opération est effectuée sur deux valeurs Byte, les valeurs partagent la même représentation, pour que le résultat soit précis. Cela est illustré dans l'exemple suivant, qui masque l'octet d'ordre le plus bas d'une valeur Byte pour s'assurer qu'elle est égale.


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'autre part, lorsque vous utilisez à la fois des octets signés et non signés, les opérations au niveau du bit sont compliquées par le fait que les valeurs SByte utilisent la représentation « signe et magnitude » pour les valeurs positives, et la représentation du complément à deux pour les valeurs négatives. Pour effectuer une opération au niveau du bit explicite, les valeurs doivent être converties en deux représentations équivalentes, en conservant les informations sur le bit de signe. L'exemple suivant fait cela pour masquer les octets 2 et 4 d'un tableau de valeurs 8 bits signées et non signées.


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)


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres de ce type sont thread-safe. Les membres qui semblent modifier l'instance d'état retournent, en réalité, une nouvelle instance initialisée avec la nouvelle valeur. Comme avec tout autre type, la lecture et l'écriture sur une variable partagée qui contient une instance de ce type doivent être protégées par un verrou pour garantir la cohérence de thread.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft