Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Single structure

 

Date de publication : novembre 2016

Représente un nombre à virgule flottante simple précision.

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

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

NomDescription
System_CAPS_pubmethodCompareTo(Object)

Compare cette instance à un objet spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié.

System_CAPS_pubmethodCompareTo(Single)

Compare cette instance à un nombre à virgule flottante simple précision spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à celle du nombre à virgule flottante simple précision spécifié.

System_CAPS_pubmethodEquals(Object)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.(Remplace ValueType.Equals(Object).)

System_CAPS_pubmethodEquals(Single)

Retourne une valeur indiquant si cette instance et un objet Single spécifié représentent la même valeur.

System_CAPS_pubmethodGetHashCode()

Retourne le code de hachage de cette instance.(Remplace ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodGetTypeCode()

Retourne le TypeCode du type valeur Single.

System_CAPS_pubmethodSystem_CAPS_staticIsInfinity(Single)

Retourne une valeur indiquant si la valeur du nombre spécifié est l'infini négatif ou positif.

System_CAPS_pubmethodSystem_CAPS_staticIsNaN(Single)

Retourne une valeur qui indique si la valeur spécifiée n'est pas un nombre (NaN).

System_CAPS_pubmethodSystem_CAPS_staticIsNegativeInfinity(Single)

Retourne une valeur indiquant si le nombre spécifié est équivalent à l'infini négatif.

System_CAPS_pubmethodSystem_CAPS_staticIsPositiveInfinity(Single)

Retourne une valeur indiquant si le nombre spécifié est équivalent à l'infini positif.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Convertit la chaîne d'un nombre en nombre à virgule flottante simple précision équivalent.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Convertit la chaîne d'un nombre dans un format propre à la culture spécifiée en nombre à virgule flottante simple précision équivalent.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Convertit la chaîne d'un nombre dans un style spécifié en nombre à virgule flottante simple précision équivalent.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Convertit la chaîne d'un nombre dans un style et un format propre à la culture spécifiés en nombre à virgule flottante simple précision équivalent.

System_CAPS_pubmethodToString()

Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.(Remplace ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide des informations de format spécifiques à la culture donnée.

System_CAPS_pubmethodToString(String)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.

System_CAPS_pubmethodToString(String, IFormatProvider)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié et des informations de format spécifiques à la culture.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, Single)

Convertit la chaîne d'un nombre dans un style et un format propre à la culture spécifiés en nombre à virgule flottante simple précision équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Single)

Convertit la chaîne d'un nombre en nombre à virgule flottante simple précision équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.

NomDescription
System_CAPS_pubfieldSystem_CAPS_staticEpsilon

Représente la valeur Single positive la plus petite qui est supérieure à zéro. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Représente la plus grande valeur possible de Single. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Représente la plus petite valeur possible de Single. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticNaN

Représente une valeur autre qu'un nombre (NaN). Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticNegativeInfinity

Représente l'infini négatif. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticPositiveInfinity

Représente l'infini positif. Ce champ est constant.

NomDescription
System_CAPS_puboperatorSystem_CAPS_staticEquality(Single, Single)

Retourne une valeur qui indique si deux valeurs Single spécifiées sont égales.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Single, Single)

Retourne une valeur qui indique si une valeur Single spécifique est supérieure à une autre valeur Single spécifique.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Single, Single)

Retourne une valeur qui indique si une valeur Single spécifique est supérieure ou égale à une autre valeur Single spécifique.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Single, Single)

Retourne une valeur qui indique si deux valeurs Single spécifiées sont différentes.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Single, Single)

Retourne une valeur qui indique si une valeur Single spécifique est inférieure à une autre valeur Single spécifique.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Single, Single)

Retourne une valeur qui indique si une valeur Single spécifique est inférieure ou égale à une autre valeur Single spécifique.

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt64.

Le Single type valeur représente un nombre de 32 bits simple précision dont les valeurs comprises entre moins 3, 402823E38 et plus 3, 402823E38, ainsi que zéro positif ou négatif, PositiveInfinity, NegativeInfinity, et non un nombre (NaN). Il est destiné à représenter des valeurs qui sont extrêmement volumineux (comme les distances entre les planètes ou galaxies) ou extrêmement petit (par exemple, la masse moléculaire d’une substance en kilogrammes) et qui sont souvent imprécises (par exemple la distance entre la terre et un autre système solaire). Le Single type est compatible avec l’IEC 60559 : 1989 (IEEE 754) standard pour l’arithmétique flottante binaire.

Cette rubrique contient les sections suivantes :

System.Single Fournit des méthodes permettant de comparer les instances de ce type, de convertir la valeur d’une instance en sa représentation sous forme de chaîne et de convertir la représentation sous forme de chaîne d’un nombre en une instance de ce type. Pour savoir comment les codes de spécification de format contrôlent la représentation sous forme de chaîne des types valeur, consultez la page Mise en forme des types dans .NET Framework, Chaînes de format numériques standard, et Chaînes de format numériques personnalisées.

Le Single type de données stocke les valeurs à virgule flottante simple précision dans un format binaire de 32 bits, comme indiqué dans le tableau suivant :

Élément

Bits

Mantisse ou mantisse

0-22

Exposant

23-30

Authentification (0 = positifs, 1 = négatif)

31

Tout comme les fractions décimales ne peuvent pas représenter précisément des valeurs décimales (par exemple 1/3 ou Math.PI), fractions binaires ne peuvent pas représenter des valeurs décimales. Par exemple, 2/10, qui est représentée avec précision par.2 comme une fraction décimale, est représenté par.0011111001001100 sous forme de fraction binaire avec le modèle « 1100 » extensible à l’infini. Dans ce cas, la valeur à virgule flottante fournit une représentation imprécise du nombre qu’il représente. Exécution d’autres opérations mathématiques sur la valeur à virgule flottante d’origine souvent augmente son manque de précision. Par exemple, si vous comparez les résultats de la multiplication.3 par 10 et ajout.3 à.3 neuf fois, vous verrez cet ajout produit le résultat moins précis, car elle comporte huit davantage d’opérations de multiplication. Notez que cet écart n’apparaît que si vous affichez les deux Single valeurs à l’aide de « R » chaîne de format numérique standard, qui, si nécessaire, affiche tous les 9 chiffres de précision pris en charge par le Single type.

using System;

public class Example
{
   public static void Main()
   {
      Single value = .2f;
      Single result1 = value * 10f;
      Single result2 = 0f;
      for (int ctr = 1; ctr <= 10; ctr++)
         result2 += value;

      Console.WriteLine(".2 * 10:           {0:R}", result1);
      Console.WriteLine(".2 Added 10 times: {0:R}", result2);
   }
}
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024

Étant donné que des nombres ne peut pas être représentées exactement comme des valeurs binaires fractionnaires, nombres à virgule flottante peuvent uniquement des nombres réels approximatifs.

Tous les nombres à virgule flottante ont un nombre limité de chiffres significatifs, lequel détermine également la façon dont une valeur à virgule flottante s’apparentent précisément un nombre réel. Un Single valeur a jusqu'à 7 chiffres décimaux de précision, bien qu’un maximum de 9 chiffres est géré en interne. Cela signifie que certaines opérations en virgule flottante n’ont peut-être pas la précision pour modifier une valeur à virgule flottante. L’exemple suivant définit une valeur à virgule flottante simple précision élevée, puis ajoute le produit de Single.Epsilon et quadrillion celui à celui-ci. Toutefois, le produit est trop petit pour modifier la valeur à virgule flottante d’origine. Son chiffre le moins significatif est millièmes, tandis que le chiffre le plus significatif dans le produit est 1-312.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 123456789e4f;
      Single additional = Single.Epsilon * 1e12f;
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional);
   }
}
// The example displays the following output:
//    1.234568E+12 + 1.401298E-33 = 1.234568E+12

La précision limitée d’un nombre à virgule flottante a plusieurs conséquences :

  • Deux nombres à virgule flottante qui apparaissent égaux à une précision particulière ne peuvent pas considérés comme égaux parce que leurs chiffres les moins significatifs sont différents. Dans l’exemple suivant, une série de nombres sont additionnés et leur total est comparé avec le total attendu. Bien que les deux valeurs semblent être identiques, un appel à la Equals méthode indique qu’ils ne le sont pas.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Single[] values = { 10.01f, 2.88f, 2.88f, 2.88f, 9.0f };
          Single result = 27.65f;
          Single total = 0f;
          foreach (var value in values)
             total += value;
    
          if (total.Equals(result))
             Console.WriteLine("The sum of the values equals the total.");
          else
             Console.WriteLine("The sum of the values ({0:R}) does not equal the total ({1:R}).",
                               total, result); 
       }
    }
    // The example displays the following output:
    //      The sum of the values (27.65) does not equal the total (27.65).   
    //
    // If the index items in the Console.WriteLine statement are changed to {0:R},
    // the example displays the following output:
    //       The sum of the values (27.6500015) does not equal the total (27.65).   
    

    Si vous modifiez les éléments de format dans la Console.WriteLine(String, Object, Object) instruction de {0} et {1} à {0:R} et {1:R} pour afficher tous les chiffres significatifs des deux Single valeurs, il est clair que les deux valeurs sont inégales en raison d’une perte de précision lors des opérations d’addition. Dans ce cas, le problème peut être résolu en appelant le Math.Round(Double, Int32) méthode pour arrondir le Single les valeurs de la précision de votre choix avant d’effectuer la comparaison.

  • Une opération mathématique ou de comparaison qui utilise un nombre à virgule flottante peut ne pas donne le même résultat si un nombre décimal est utilisé, car le nombre à virgule flottante binaire ne peut pas égal au nombre décimal. Un exemple précédent illustre cela en affichant le résultat de la multiplication.3 par 10 et en ajoutant.3 à.3 neuf fois.

    Lorsqu’il est importante de précision dans les opérations numériques avec les valeurs fractionnaires, utilisez la Decimal type au lieu du Single type. Lors de la précision dans les opérations numériques avec des valeurs intégrales au-delà de la plage de la Int64 ou UInt64 types est important, utilisez le BigInteger type.

  • Une valeur ne peut pas effectuer un aller-retour si un nombre à virgule flottante est impliqué. Une valeur est dite d’aller-retour si une opération convertit un nombre à virgule flottante d’origine vers un autre formulaire, l’opération inverse transforme la forme convertie en un nombre à virgule flottante et le nombre à virgule flottante final est égal au nombre à virgule flottante d’origine. L’aller-retour peut échouer car une ou plusieurs chiffres les moins significatifs sont perdus ou modifiés dans une conversion. Dans l’exemple suivant, trois Single valeurs sont converties en chaînes et enregistrés dans un fichier. Comme le montre la sortie, bien que les valeurs semblent être identiques, les valeurs restaurées ne sont pas égales aux valeurs d’origine.

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) {
             sw.Write(values[ctr].ToString());
             if (ctr != values.Length - 1)
                sw.Write("|");
          }      
          sw.Close();
    
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.882883 <> 2.882883
    //       0.3333333 <> 0.3333333
    //       3.141593 <> 3.141593
    

    Dans ce cas, les valeurs peuvent être le correctement un aller-retour à l’aide de « R » chaîne de format numérique standard pour conserver la précision de Single valeurs, comme le montre l’exemple suivant.

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:R}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
    
          sw.Close();
    
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.882883 = 2.882883
    //       0.3333333 = 0.3333333
    //       3.141593 = 3.141593
    
  • Single les valeurs ont moins de précision que Double valeurs. Un Single valeur est convertie en un équivalent apparemment Double souvent n’est pas égale à la Double valeur en raison de différences de précision. Dans l’exemple suivant, le résultat des opérations de division identique est attribué à un Double valeur et un Single valeur. Après le Single valeur est convertie en un Double, une comparaison des deux valeurs montre qu’ils sont inégaux.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1/3.0;
          Single sValue2 = 1/3.0f;
          Double value2 = (Double) sValue2;
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                              value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.33333333333333331 = 0.3333333432674408: False
    

    Pour éviter ce problème, soit utiliser le Double de type de données à la place de la Single type de données, ou utilisez le Round (méthode) afin que les deux valeurs ont le même degré de précision.

Pour être considérés comme égaux, deux Single valeurs doivent représenter des valeurs identiques. Toutefois, en raison de différences de précision entre les valeurs, ou en raison d’une perte de précision en un ou plusieurs valeurs, les valeurs à virgule flottante qui sont censés être identiques souvent s’avèrent inégales en raison de différences dans leurs chiffres les moins significatifs. Par conséquent, les appels à la Equals méthode pour déterminer si deux valeurs sont égales, ou des appels à la CompareTo méthode pour déterminer la relation entre deux Single valeurs, souvent donner des résultats inattendus. Ceci est évident dans l’exemple suivant, où deux apparemment égal Single valeurs semblent pour être égaux, car la première valeur a 7 chiffres de précision, alors que la deuxième valeur a 9.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .3333333f;
      float value2 = 1.0f/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.3333333 = 0.333333343: False

Les valeurs calculées qui suivent des chemins de code différents, et qui sont manipulés différemment souvent s’avérer inégaux. Dans l’exemple suivant, un Single carrée de la valeur, puis la racine carrée est calculée pour restaurer la valeur d’origine. Une seconde Single est multipliée par 3.51 et carré avant la racine carrée du résultat est divisée par 3.51 pour restaurer la valeur d’origine. Bien que les deux valeurs sont identiques, un appel à la Equals(Single) méthode indique qu’ils ne sont pas égales. À l’aide de la chaîne de format standard « R » pour retourner une chaîne de résultat qui affiche tous les chiffres significatifs de chaque Single valeur indique que la deuxième valeur est.0000000000001 inférieur à la première.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = 10.201438f;
      value1 = (float) Math.Sqrt((float) Math.Pow(value1, 2));
      float value2 = (float) Math.Pow((float) value1 * 3.51f, 2);
      value2 = ((float) Math.Sqrt(value2)) / 3.51f;
      Console.WriteLine("{0} = {1}: {2}\n", 
                        value1, value2, value1.Equals(value2)); 
      Console.WriteLine("{0:R} = {1:R}", value1, value2); 
   }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

Dans les cas où une perte de précision est susceptible d’affecter le résultat d’une comparaison, vous pouvez utiliser les techniques suivantes au lieu d’appeler le Equals ou CompareTo méthode :

  • Appelez le Math.Round pour s’assurer que les deux valeurs ont la même précision. L’exemple suivant modifie l’exemple précédent pour utiliser cette approche afin que les deux valeurs fractionnaires sont équivalentes.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = .3333333f;
          float value2 = 1.0f/3;
          int precision = 7;
          value1 = (float) Math.Round(value1, precision);
          value2 = (float) Math.Round(value2, precision);
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.3333333 = 0.3333333: True
    

    Notez que le problème de précision s’applique toujours à l’arrondi des valeurs du milieu. Pour plus d'informations, voir la méthode Math.Round(Double, Int32, MidpointRounding).

  • Tester l’égalité approximative au lieu de l’égalité. Cette technique exige que vous définissez soit absolu montant par lequel les deux valeurs peuvent différer mais toujours être égal ou que vous définissez une quantité relative par lequel la plus petite valeur peut différer de la plus grande valeur.

    System_CAPS_warningAvertissement

    Single.Epsilon est parfois utilisé comme mesure absolue de la distance entre deux Single lors du test d’égalité des valeurs. Toutefois, Single.Epsilon mesure la plus petite valeur possible pouvant être ajoutée à ou soustraite, une Single dont la valeur est égale à zéro. Pour la plupart des positif et négatif Single valeurs, la valeur de Single.Epsilon est trop petite pour être détecté. Par conséquent, à l’exception des valeurs qui sont égales à zéro, nous déconseillons son utilisation dans les tests d’égalité.

    L’exemple suivant utilise la dernière approche pour définir un IsApproximatelyEqual méthode qui teste la différence relative entre les deux valeurs. Il compare également le résultat d’appels à la IsApproximatelyEqual (méthode) et Equals(Single) (méthode).

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float one1 = .1f * 10;
          float one2 = 0f;
          for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1f;
    
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000001f));   
       }
    
       static bool IsApproximatelyEqual(float value1, float value2, float epsilon)
       {
          // If they are equal anyway, just return True.
          if (value1.Equals(value2))
             return true;
    
          // Handle NaN, Infinity.
          if (Double.IsInfinity(value1) | Double.IsNaN(value1))
             return value1.Equals(value2);
          else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
             return value1.Equals(value2);
    
          // Handle zero to avoid division by zero
          double divisor = Math.Max(value1, value2);
          if (divisor.Equals(0)) 
             divisor = Math.Min(value1, value2);
    
          return Math.Abs(value1 - value2)/divisor <= epsilon;           
       } 
    }
    // The example displays the following output:
    //       1 = 1.00000012: False
    //       1 is approximately equal to 1.00000012: True
    

Opérations avec des valeurs à virgule flottante ne lèvent pas d’exceptions, contrairement aux opérations avec les types intégraux, laquelle lever des exceptions en cas d’opérations illégales telles que la division par zéro ou de dépassement de capacité. En revanche, dans ce cas, le résultat d’une opération en virgule flottante est zéro, l’infini positif, l’infini négatif ou une valeur non numérique (NaN) :

  • Si le résultat d’une opération en virgule flottante est trop petit pour le format de destination, le résultat est zéro. Cela peut se produire lorsque deux nombres à virgule flottante très petite sont multipliés, comme le montre l’exemple suivant.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = 1.163287e-36f;
          float value2 = 9.164234e-25f;
          float result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0f));
       }
    }
    // The example displays the following output:
    //       1.163287E-36 * 9.164234E-25 = 0
    //       0 = 0: True
    
  • Si la grandeur du résultat d’une opération en virgule flottante dépasse la plage du format de destination, le résultat de l’opération est PositiveInfinity ou NegativeInfinity, en fonction du signe du résultat. Le résultat d’une opération qui déborde Single.MaxValue est PositiveInfinity, et le résultat d’une opération qui déborde Single.MinValue est NegativeInfinity, comme illustré dans l’exemple suivant.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = 3.065e35f;
          float value2 = 6.9375e32f;
          float result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n", 
                            Single.IsNegativeInfinity(result));
    
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result));
       }
    }                                                                 
    
    // The example displays the following output:
    //       PositiveInfinity: True
    //       NegativeInfinity: False
    //       
    //       PositiveInfinity: False
    //       NegativeInfinity: True
    

    PositiveInfinity également résulte d’une division par zéro avec un dividende positif, et NegativeInfinity résulte d’une division par zéro avec un dividende négatif.

  • Si une opération en virgule flottante n’est pas valide, le résultat de l’opération est NaN. Par exemple, NaN entraîne les opérations suivantes :

    • Division par zéro avec un dividende égale à zéro. Notez que les autres cas de division par zéro génère soit PositiveInfinity ou NegativeInfinity.

    • Toute opération en virgule flottante avec une entrée non valide. Par exemple, la tentative de recherche retourne la racine carrée d’une valeur négative NaN.

    • Toute opération avec un argument dont la valeur est Single.NaN.

Le Single structure ne définit pas d’opérateur de conversion explicite ou implicite, au lieu de cela, les conversions sont implémentées par le compilateur.

Le tableau suivant répertorie les conversions possibles d’une valeur pour les autres types numériques primitifs à un Single valeur, il indique également si la conversion est restrictive ou et si résultant Single peut avoir une précision inférieure à la valeur d’origine.

Conversion de

Les étendues/restrictives

Perte de précision

Byte

Widening

Non

Decimal

Widening

Notez que c# requiert un opérateur de conversion.

Oui. Decimal prend en charge de 29 chiffres décimaux de précision. Single prend en charge 9.

Double

Restrictives ; les valeurs hors limites sont converties en Double.NegativeInfinity ou Double.PositiveInfinity.

Oui. Double prend en charge de 17 chiffres décimaux de précision. Single prend en charge 9.

Int16

Widening

Non

Int32

Widening

Oui. Int32 prend en charge 10 chiffres décimaux de précision. Single prend en charge 9.

Int64

Widening

Oui. Int64 prend en charge de 19 chiffres décimaux de précision. Single prend en charge 9.

SByte

Widening

Non

UInt16

Widening

Non

UInt32

Widening

Oui. UInt32 prend en charge 10 chiffres décimaux de précision. Single prend en charge 9.

UInt64

Widening

Oui. Int64 prend en charge 20 chiffres décimaux de précision. Single prend en charge 9.

L’exemple suivant convertit la valeur minimale ou maximale d’autres types numériques primitifs à un Single valeur.

using System;

public class Example
{
   public static void Main()
   {
      dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                           Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                           Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                           SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
      float sngValue;
      foreach (var value in values) {
         if (value.GetType() == typeof(Decimal) ||
             value.GetType() == typeof(Double))
            sngValue = (float) value;
         else
            sngValue = value;
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name);
      }
   }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

En outre, le Double valeurs Double.NaN, Double.PositiveInfinity, et Double.NegativeInfinity convertir à Single.NaN, Single.PositiveInfinity, et Single.NegativeInfinity, respectivement.

Notez que la conversion de la valeur de certains types numériques à un Single valeur peut entraîner une perte de précision. Comme l’illustre l’exemple, une perte de précision est possible lors de la conversion Decimal, Double, Int32, Int64, UInt32, et UInt64 valeurs Single valeurs.

La conversion d’un Single de valeur pour un Double est une conversion étendue. La conversion peut entraîner une perte de précision si le Double type n’a pas une représentation précise de la Single valeur.

La conversion d’un Single valeur autre que pour une valeur de tout type numérique primitif un Double est une conversion restrictive et nécessite un opérateur de cast (en c#) ou une méthode de conversion (en Visual Basic). Les valeurs sont en dehors de la plage du type de données cible, qui sont définies par le type de cible MinValue et MaxValue se comportent des propriétés, comme indiqué dans le tableau suivant.

Type de cible

Résultat

N’importe quel type intégral

Un OverflowException exception si la conversion se produit dans un contexte vérifié.

Si la conversion se produit dans un contexte non vérifié (la valeur par défaut en c#), l’opération de conversion réussit mais que la valeur dépasse.

Decimal

Un OverflowException exception,

En outre, Single.NaN, Single.PositiveInfinity, et Single.NegativeInfinity lever un OverflowException pour les conversions de nombres entiers dans un contexte vérifié, mais ces dépassement des valeurs lorsque convertis en entiers dans un contexte non vérifié. Pour les conversions Decimal, ils lèvent toujours un OverflowException. Pour les conversions Double, elles convertissent vers Double.NaN, Double.PositiveInfinity, et Double.NegativeInfinity, respectivement.

Notez qu’une perte de précision peut-être résulter de la conversion d’un Single valeur à un autre type numérique. Dans le cas de conversion non intégral Double valeurs, comme le montre la sortie de l’exemple, le composant fractionnaire est perdu lorsque la Single valeur est arrondie (comme dans Visual Basic) ou tronqué (comme dans c#). Pour les conversions Decimal et Single des valeurs, la Double valeur ne peut pas avoir une représentation précise dans le type de données cible.

L’exemple suivant convertit un nombre de Single valeurs à plusieurs autres types numériques. Les conversions qui se produisent dans un contexte vérifié dans Visual Basic (la valeur par défaut) et en c# (raison de la activée mot clé). La sortie de l’exemple illustre le résultat pour les conversions a été archivé à la fois un contexte non vérifié. Vous pouvez effectuer des conversions dans un contexte non vérifié dans Visual Basic en compilant avec le /removeintchecks+ commutateur de compilateur et c# en commentant le checked instruction.

using System;

public class Example
{
   public static void Main()
   {
      float[] values = { Single.MinValue, -67890.1234f, -12345.6789f,
                         12345.6789f, 67890.1234f, Single.MaxValue,
                         Single.NaN, Single.PositiveInfinity,
                         Single.NegativeInfinity };
      checked {
         foreach (var value in values) {
            try {
                Int64 lValue = (long) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  lValue, lValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Int64.", value);
            }
            try {
                UInt64 ulValue = (ulong) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  ulValue, ulValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to UInt64.", value);
            }
            try {
                Decimal dValue = (decimal) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dValue, dValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Decimal.", value);
            }

            Double dblValue = value;
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                              value, value.GetType().Name,
                              dblValue, dblValue.GetType().Name);
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)

Pour plus d’informations sur la conversion des types numériques, consultez la page Conversion de type dans le .NET Framework et Tables de conversion de types dans .NET Framework.

Le Single structure et les types associés fournissent des méthodes pour effectuer les catégories des opérations suivantes :

  • Comparaison de valeurs. Vous pouvez appeler la Equals méthode pour déterminer si deux Single valeurs sont égales, ou la CompareTo méthode pour déterminer la relation entre deux valeurs.

    Le Single prend également en charge un ensemble complet des opérateurs de comparaison. Par exemple, vous pouvez tester l’égalité ou l’inégalité ou déterminer si une valeur est supérieure ou égale à une autre valeur. Si l’un des opérandes est une Double, la Single valeur est convertie en un Double avant d’effectuer la comparaison. Si l’un des opérandes est de type intégral, il est converti en un Single avant d’effectuer la comparaison. Bien que ceux-ci sont des conversions étendues, il peuvent impliquer une perte de précision.

    System_CAPS_warningAvertissement

    En raison de différences de précision, deux Single valeurs devant être égal peuvent s’avérer pour être égaux, ce qui affecte le résultat de la comparaison. Consultez le test d’égalité section pour plus d’informations sur la comparaison de deux Single valeurs.

    Vous pouvez également appeler le IsNaN, IsInfinity, IsPositiveInfinity, et IsNegativeInfinity méthodes pour tester ces valeurs spéciales.

  • Des opérations mathématiques. Les opérations arithmétiques courantes telles que l’addition, soustraction, multiplication et division sont implémentées par les compilateurs de langage et les instructions du langage CIL (Common Intermediate) plutôt que par Single méthodes. Si l’autre opérande dans une opération mathématique est un Double, le Single est converti en un Double avant d’effectuer l’opération et le résultat de l’opération est également un Double valeur. Si l’autre opérande est un type intégral, il est converti en un Single avant d’effectuer l’opération et le résultat de l’opération est également un Single valeur.

    Vous pouvez effectuer d’autres opérations mathématiques en appelant static (Shared en Visual Basic) les méthodes dans la System.Math classe. Ceux-ci incluent des méthodes supplémentaires utilisés pour les opérations arithmétiques (tel que Math.Abs, Math.Sign, et Math.Sqrt), géométrie (tels que Math.Cos et Math.Sin) et calcul (tels que Math.Log). Dans tous les cas, le Single valeur est convertie en un Double.

    Vous pouvez également manipuler les bits individuels d’un Single valeur. Le BitConverter.GetBytes(Single) méthode retourne son modèle de bits dans un tableau d’octets. En passant ce tableau d’octets à la BitConverter.ToInt32 (méthode), vous pouvez également conserver la Single modèle de valeur de bit dans un entier de 32 bits.

  • Arrondi. Arrondi est souvent utilisé comme une technique permettant de réduire l’impact des différences entre les valeurs provoquées par des problèmes de représentation à virgule flottante et de précision. Vous pouvez arrondir un Single valeur en appelant le Math.Round (méthode). Toutefois, notez que le Single valeur est convertie en un Double avant de la méthode est appelée, la conversion peut impliquer une perte de précision.

  • Mise en forme. Vous pouvez convertir un Single valeur en sa représentation chaîne en appelant le ToString méthode ou à l’aide de la mise en forme composite fonctionnalité. Pour plus d’informations sur la façon dont les chaînes de format contrôlent la représentation sous forme de chaîne de valeurs à virgule flottante, consultez le Chaînes de format numériques standard et Chaînes de format numériques personnalisées rubriques.

  • L’analyse de chaînes. Vous pouvez convertir la représentation sous forme de chaîne d’une valeur à virgule flottante en un Single valeur en appelant le Parse ou TryParse (méthode). Si l’opération d’analyse échoue, le Parse méthode lève une exception, tandis que la TryParse méthode renvoie false.

  • La conversion de type. Le Single structure fournit une implémentation d’interface explicite pour le IConvertible interface, qui prend en charge la conversion entre les deux types de données .NET Framework standards. Les compilateurs de langages prennent également en charge la conversion implicite des valeurs pour tous les autres types numériques standards, à l’exception de la conversion de Double à Single valeurs. Conversion d’une valeur de n’importe quel type numérique standard autres qu’un Double à un Single est une conversion étendue et ne nécessite pas l’utilisation d’une méthode de conversion opérateur ou de conversion.

    Toutefois, la conversion de valeurs entières 32 bits et 64 bits peut entraîner une perte de précision. Le tableau suivant répertorie les différences de précision de 32 bits, 64 bits, et Double types :

    Type

    Précision maximale (en chiffres)

    Précision interne (en chiffres)

    Double

    15

    17

    Int32 et UInt32

    10

    10

    Int64 et UInt64

    19

    19

    Single

    7

    9

    Le problème de précision plus fréquents Single valeurs sont converties en Double valeurs. Dans l’exemple suivant, deux valeurs produites par des opérations de division identiques sont inégales, car l’une des valeurs est une simple précision valeur à virgule flottante qui est convertie en un Double.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1/3.0;
          Single sValue2 = 1/3.0f;
          Double value2 = (Double) sValue2;
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                              value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.33333333333333331 = 0.3333333432674408: False
    

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Tous les membres de ce type sont thread-safe. En réalité, les membres qui semblent modifier l'état de l'instance renvoie 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 sécurité des threads.

Retour au début
Afficher: