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 Single

 

Data di pubblicazione: ottobre 2016

Rappresenta un numero in virgola mobile e precisione singola.

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

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

NomeDescrizione
System_CAPS_pubmethodCompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore rispetto al valore dell'oggetto specificato.

System_CAPS_pubmethodCompareTo(Single)

Confronta questa istanza con un numero in virgola mobile a precisione singola specificato e restituisce un valore intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore del numero in virgola mobile a precisione singola specificato.

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_pubmethodEquals(Single)

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

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 Single.

System_CAPS_pubmethodSystem_CAPS_staticIsInfinity(Single)

Restituisce un valore che indica se il numero specificato corrisponde all'infinito negativo o positivo.

System_CAPS_pubmethodSystem_CAPS_staticIsNaN(Single)

Restituisce un valore che indica se il valore specificato non è un numero (NaN).

System_CAPS_pubmethodSystem_CAPS_staticIsNegativeInfinity(Single)

Restituisce un valore che indica se il numero specificato è valutato come infinito negativo.

System_CAPS_pubmethodSystem_CAPS_staticIsPositiveInfinity(Single)

Restituisce un valore che indica se il numero specificato è valutato come infinito positivo.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Converte la rappresentazione in forma di stringa di un numero nel suo equivalente numero in virgola mobile a precisione singola.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Converte la rappresentazione in forma di stringa di un numero in un determinato formato specifico delle impostazioni di cultura nel suo equivalente numero in virgola mobile a precisione singola.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Converte la rappresentazione in forma di stringa di un numero in uno stile specificato nel suo equivalente numero in virgola mobile a precisione singola.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Converte la rappresentazione in forma di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni di cultura nel suo equivalente numero in virgola mobile a precisione singola.

System_CAPS_pubmethodToString()

Converte il valore numerico di questa istanza nella sua equivalente rappresentazione in forma di stringa. (Esegue l'override di ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Converte il valore numerico di questa istanza nella sua equivalente rappresentazione in forma di stringa utilizzando le informazioni di formato specifiche delle impostazioni di cultura.

System_CAPS_pubmethodToString(String)

Converte il valore numerico di questa istanza nella sua equivalente rappresentazione in forma di stringa usando il formato specificato.

System_CAPS_pubmethodToString(String, IFormatProvider)

Converte il valore numerico di questa istanza nella sua equivalente rappresentazione in forma di stringa utilizzando il formato specificato e le informazioni di formattazione specifiche delle impostazioni di cultura.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, Single)

Converte la rappresentazione in forma di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni di cultura nel suo equivalente numero in virgola mobile a precisione singola. Un valore restituito indica se la conversione è riuscita o meno.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Single)

Converte la rappresentazione in forma di stringa di un numero nel suo equivalente numero in virgola mobile a precisione singola. Un valore restituito indica se la conversione è riuscita o meno.

NomeDescrizione
System_CAPS_pubfieldSystem_CAPS_staticEpsilon

Rappresenta il valore Single positivo più piccolo maggiore di zero. Questo campo è costante.

System_CAPS_pubfieldSystem_CAPS_staticMaxValue

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

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Rappresenta il valore più piccolo possibile di Single. Questo campo è costante.

System_CAPS_pubfieldSystem_CAPS_staticNaN

Rappresenta un valore non numerico (NaN). Questo campo è costante.

System_CAPS_pubfieldSystem_CAPS_staticNegativeInfinity

Rappresenta l'infinito negativo. Questo campo è costante.

System_CAPS_pubfieldSystem_CAPS_staticPositiveInfinity

Rappresenta l'infinito positivo. Questo campo è costante.

NomeDescrizione
System_CAPS_puboperatorSystem_CAPS_staticEquality(Single, Single)

Restituisce un valore che indica se due valori Single specificati sono uguali.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Single, Single)

Restituisce un valore che indica se un valore Singlespecificato è maggiore di un altro valore Single specificato.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Single, Single)

Restituisce un valore che indica se un valore Single specificato è maggiore o uguale a un altro valore Single specificato.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Single, Single)

Restituisce un valore che indica se due valori Single specificati non sono uguali.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Single, Single)

Restituisce un valore che indica se il valore Single specificato è minore o uguale a un altro valore Single specificato.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Single, Single)

Restituisce un valore che indica se un valore Single specificato è minore o uguale a un altro valore Single specificato.

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. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

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.

Il Single tipo di valore rappresenta un numero a 32 bit e precisione singola con valori compresi tra 3, 402823e38 negativo e 3, 402823e38 positivo, nonché zero positivo o negativo, PositiveInfinity, NegativeInfinity, e non un numero (NaN). Destinato per rappresentare i valori che sono molto elevata (ad esempio, le distanze tra i pianeti o galassie) o molto piccolo (ad esempio, la massa molecolare della materia in chilogrammi) e che sono spesso imprecise (ad esempio la distanza da terra in un altro sistema solare). Il Single tipo sia conforme a IEC 60559: 1989 (IEEE 754) per l'aritmetica binaria a virgola mobile.

Questo argomento include le sezioni seguenti:

System.Single fornisce metodi per confrontare istanze di questo tipo, convertire il valore di un'istanza nella relativa rappresentazione di stringa e convertire la rappresentazione di stringa di un numero in un'istanza di questo tipo. Per informazioni su come codici di specifica del formato controllano la rappresentazione di stringa dei tipi di valore, vedere Formattazione di tipi in .NET Framework, Stringhe di formato numerico standard, e Stringhe di formato numerico personalizzato.

Il Single tipo di dati archivia valori a virgola mobile e precisione singola in un formato binario a 32 bit, come illustrato nella tabella riportata di seguito:

Parte

Bit

Separatore o mantissa

0-22

Esponente

23-30

Sign (0 = positivi, 1 = negativo)

31

Come per le frazioni decimali sono in grado di rappresentare con precisione alcuni valori frazionari (ad esempio 1/3 o Math.PI), frazioni binarie non sono in grado di rappresentare alcuni valori frazionari. 2/10, che corrisponde esattamente a. 2 come frazione decimale, ad esempio, è rappresentato da.0011111001001100 come frazione binaria con il modello "1100" ripetuta all'infinito. In questo caso, il valore a virgola mobile e fornisce una rappresentazione imprecisa del numero che rappresenta. Eseguire altre operazioni matematiche sul valore a virgola mobile originale spesso aumenta la mancanza di precisione. Ad esempio, se si confrontano i risultati della moltiplicazione. 3 da 10 e aggiunta.. 3 di 3 nove volte, verrà visualizzato tale aggiunta produce risultati meno precisi, perché include otto ulteriori operazioni di moltiplicazione. Si noti che esiste questa differenza risulta evidente solo se si visualizzano i due Single valori mediante "R" stringa di formato numerico standard, che, se necessario, vengono visualizzati tutti 9 cifre di precisione supportato dal Single tipo.

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

Poiché alcuni numeri non possono essere rappresentato correttamente come valori frazionari binari, i numeri in virgola mobile possono solamente approssimare i numeri reali.

Tutti i numeri in virgola mobile dispongono di un numero di cifre significative limitato, che determina anche il grado di accuratezza con cui un valore in virgola mobile approssima un numero reale. Oggetto Single valore ha fino a 7 cifre decimali di precisione, anche se internamente viene gestito un massimo di 9 cifre. Ciò significa che alcune operazioni a virgola mobile potrebbero non essere la precisione per modificare un valore a virgola mobile. Nell'esempio seguente definisce un valore a virgola mobile a precisione singola elevato e quindi aggiunge il prodotto di Single.Epsilon e un milione di miliardi a esso. Tuttavia, il prodotto è troppo piccolo per modificare il valore a virgola mobile originale. Le cifre meno significativa sono millesimi, mentre la cifra più significativa del prodotto è 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 limitata precisione di un numero in virgola mobile comporta diverse conseguenze:

  • Due numeri in virgola mobile apparentemente equivalenti per una particolare precisione potrebbero non risultare uguali a causa di differenze nelle cifre meno significative. Nell'esempio seguente, una serie di numeri vengono sommati e il totale viene confrontato con il totale previsto. Anche se sembrano essere lo stesso, una chiamata a due valori di Equals metodo indica che non si trovano.

    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).   
    

    Se si modificano gli elementi di formato nel Console.WriteLine(String, Object, Object) istruzione {0} e {1} a {0:R} e {1:R} per visualizzare tutte le cifre significative dei due Single valori, è chiaro che i due valori sono uguali a causa di una perdita di precisione durante le operazioni di addizione. In questo caso, il problema può essere risolto tramite la chiamata di Math.Round(Double, Int32) metodo arrotondare il Single valori in base alla precisione desiderato prima di eseguire il confronto.

  • Un'operazione matematica o di confronto in cui si utilizza un numero in virgola mobile potrebbe non restituire lo stesso risultato se viene utilizzato un numero decimale, perché il numero in virgola mobile binario potrebbe non essere equivalente al numero decimale. Un esempio precedente è illustrato questo visualizzando il risultato della moltiplicazione. 3 da 10 e aggiunta di nove volte.. 3 di 3.

    Quando la precisione numerica operazioni con valori frazionari è importante, utilizzare il Decimal digitare anziché il Single tipo. Quando la precisione numerica operazioni con i valori integrali oltre l'intervallo della Int64 o UInt64 tipi è importante, utilizzare il BigInteger tipo.

  • Un valore potrebbe non completare la sequenza di andata e ritorno se è coinvolto un numero in virgola mobile. Se un'operazione converte un numero a virgola mobile originale in un altro formato, un'operazione inversa trasforma il formato convertito nuovamente in un numero a virgola mobile e il numero a virgola mobile finale è uguale al numero a virgola mobile originale, si ha un valore di andata e ritorno. Il round trip potrebbe non riuscire perché uno o più cifre meno significative vengono perse o modificate in una conversione. Nell'esempio seguente, tre Single valori vengono convertiti in stringhe e salvati in un file. Come illustrato nell'output, anche se i valori vengono visualizzati in modo identico, i valori ripristinati non sono uguali ai valori originali.

    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
    

    In questo caso, i valori possono essere correttamente andata utilizzando "R" stringa di formato numerico standard per mantenere la precisione completa del Single valori, come illustrato nell'esempio seguente.

    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 valori hanno una precisione inferiore rispetto a Double valori. Oggetto Single valore che viene convertito in un equivalente apparentemente Double spesso non è uguale al Double valore a causa delle differenze nella precisione. Nell'esempio seguente, il risultato di operazioni di divisione identici viene assegnato a un Double valore e un Single valore. Dopo il Single valore viene eseguito il cast a un Double, viene illustrato un confronto tra i due valori che non sono uguali.

    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
    

    Per evitare questo problema, utilizzare il Double del tipo di dati al posto di Single tipo di dati o utilizzare il Round metodo in modo che entrambi i valori hanno la stessa precisione.

Per essere considerati uguali, due Single i valori devono rappresentare valori identici. Tuttavia, a causa di differenze tra i valori di precisione o a causa di una perdita di precisione da uno o entrambi i valori, valori a virgola mobile che devono essere identici spesso risultano per essere uguali a causa delle differenze nelle cifre meno significative. Di conseguenza, le chiamate al Equals metodo per determinare se due valori sono uguali oppure chiamate al CompareTo metodo per determinare la relazione tra due Single valori, spesso restituire risultati imprevisti. Ciò è evidente nell'esempio seguente, in cui due apparentemente uguali Single valori risultano per essere uguali, in quanto il primo valore è 7 cifre di precisione, mentre il secondo valore è 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

I valori calcolati che seguire diversi percorsi di codice e in modi diversi che vengono modificati spesso rivelino non uguali. Nell'esempio seguente, una Single valore è al quadrato e quindi viene calcolata la radice quadrata per ripristinare il valore originale. Un secondo Single viene moltiplicato per 3.51 e quadratico prima che la radice quadrata del risultato viene diviso per 3.51 per ripristinare il valore originale. Sebbene i due valori sembrano identiche, una chiamata al Equals(Single) metodo indica che non sono uguali. La stringa di formato standard "R" per restituire una stringa di risultato che visualizza tutte le cifre significative di ogni Single valore indica che il secondo valore è.0000000000001 minore rispetto alla prima.

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

Nei casi in cui è probabile che influisca sul risultato di un confronto di una perdita di precisione, è possibile utilizzare le tecniche seguenti invece di chiamare il Equals o CompareTo metodo:

  • Chiamare il Math.Round metodo per assicurarsi che entrambi i valori hanno la stessa precisione. Nell'esempio seguente viene modificato un esempio precedente per utilizzare questo approccio in modo che due valori frazionari sono equivalenti.

    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
    

    Si noti che il problema di precisione è ancora valida per l'arrotondamento dei valori intermedi. Per altre informazioni, vedere il metodo Math.Round(Double, Int32, MidpointRounding).

  • Verificare l'uguaglianza approssimativo anziché l'uguaglianza. Questa tecnica che è necessario definire un assoluto quantità mediante il quale i due valori possono variare ma comunque essere uguale o che si definisce una quantità relativa mediante il quale il valore più piccolo possibile differente dal valore più grande.

    System_CAPS_warningAvviso

    Single.Epsilon Talvolta viene utilizzato come misura della distanza tra due assoluta Single i valori per la verifica dell'uguaglianza. Tuttavia, Single.Epsilon Calcola il valore più piccolo che può essere aggiunto o sottratto da un Single il cui valore è zero. Per la maggior parte delle positivi e negativi Single valori, il valore di Single.Epsilon è troppo piccolo per essere rilevato. Pertanto, ad eccezione dei valori che sono pari a zero, non è consigliabile l'utilizzo nei test per verificarne l'uguaglianza.

    Nell'esempio seguente viene utilizzato il secondo approccio per definire un IsApproximatelyEqual metodo che verifica la differenza relativa tra due valori. Vengono inoltre confrontati il risultato di chiamate per il IsApproximatelyEqual (metodo) e Equals(Single) metodo.

    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
    

Operazioni con valori a virgola mobile non generano eccezioni, a differenza delle operazioni con i tipi integrali, che generano eccezioni in caso di operazioni non valide, ad esempio divisione per zero o di overflow. Al contrario, in queste situazioni, il risultato di un'operazione a virgola mobile è zero, infinito positivo, infinito negativo o non è un numero (NaN):

  • Se il risultato di un'operazione in virgola mobile è troppo piccolo per il formato di destinazione, il risultato è zero. Ciò può verificarsi quando vengono moltiplicati due numeri a virgola mobile molto piccoli, come illustrato nell'esempio seguente.

    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
    
  • Se la grandezza del risultato dell'operazione a virgola mobile supera l'intervallo del formato di destinazione, il risultato dell'operazione è PositiveInfinity o NegativeInfinity, come appropriato per il segno del risultato. Il risultato di un'operazione che causa un overflow Single.MaxValue è PositiveInfinity, e il risultato di un'operazione che causa un overflow Single.MinValue è NegativeInfinity, come illustrato nell'esempio seguente.

    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 anche i risultati da una divisione per zero con dividendo positivo, e NegativeInfinity dà come risultato di una divisione per zero con dividendo negativo.

  • Se un'operazione a virgola mobile non è valida, il risultato dell'operazione è NaN. Ad esempio, NaN risultati delle operazioni seguenti:

    • Divisione per zero con una quota pari a zero. Si noti che gli altri casi di divisione per zero risultati in una PositiveInfinity o NegativeInfinity.

    • Qualsiasi operazione a virgola mobile con un input non valido. Ad esempio, il tentativo di trovare la radice quadrata di un valore negativo restituisce NaN.

    • Qualsiasi operazione con un argomento il cui valore è Single.NaN.

Il Single struttura non definisce alcun operatori di conversione esplicita o implicita, invece, le conversioni vengono implementate dal compilatore.

Nella tabella seguente sono elencate le conversioni possibili di un valore di altri tipi numerici primitivi per un Single valore, indica inoltre se la conversione è grande o più piccolo e se risultante Single dispone di precisione inferiore rispetto al valore originale.

Conversione da

Widening di restrizione

Possibile perdita di precisione

Byte

Widening

No

Decimal

Widening

Si noti che c# richiede un operatore cast.

Sì. Decimal supporta 29 cifre decimali di precisione; Single supporta 9.

Double

Restrizione; out-of-range vengono convertiti in Double.NegativeInfinity o Double.PositiveInfinity.

Sì. Double supporta 17 cifre decimali di precisione; Single supporta 9.

Int16

Widening

No

Int32

Widening

Sì. Int32 supporta 10 cifre decimali di precisione; Single supporta 9.

Int64

Widening

Sì. Int64 supporta 19 cifre decimali di precisione; Single supporta 9.

SByte

Widening

No

UInt16

Widening

No

UInt32

Widening

Sì. UInt32 supporta 10 cifre decimali di precisione; Single supporta 9.

UInt64

Widening

Sì. Int64 supporta 20 cifre decimali di precisione; Single supporta 9.

Nell'esempio seguente converte il valore minimo o massimo di altri tipi numerici primitivi in un Single valore.

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)

Inoltre, il Double valori Double.NaN, Double.PositiveInfinity, e Double.NegativeInfinity convertire a Single.NaN, Single.PositiveInfinity, e Single.NegativeInfinity, rispettivamente.

Si noti che la conversione del valore di alcuni tipi numerici a una Single valore può comportare una perdita di precisione. Come illustrato nell'esempio, una perdita di precisione è possibile durante la conversione Decimal, Double, Int32, Int64, UInt32, e UInt64 valori Single valori.

La conversione di un Single valore a un Double è una conversione di ampliamento. La conversione può comportare una perdita di precisione se il Double tipo non dispone di una rappresentazione precisa per il Single valore.

La conversione di un Single valore su un valore di qualsiasi tipo di dati numerico primitivo diverso da un Double è una conversione di narrowing e richiede un operatore di cast (in c#) o un metodo di conversione (in Visual Basic). I valori che non rientrano nell'intervallo del tipo di dati di destinazione, che sono definiti in base al tipo di destinazione MinValue e MaxValue si comportano come illustrato nella tabella seguente.

Tipo di destinazione

Risultato

Qualsiasi tipo integrale

Un OverflowException eccezione se la conversione viene eseguita in un contesto controllato.

Se la conversione viene eseguita in un contesto non verificato (impostazione predefinita in c#), l'operazione di conversione ha esito positivo ma il valore causa l'overflow.

Decimal

Un OverflowException eccezione,

Inoltre, Single.NaN, Single.PositiveInfinity, e Single.NegativeInfinity generano un OverflowException per le conversioni dei valori integer in un contesto controllato, ma questi overflow di valori quando convertiti in valori interi in un contesto non verificato. Per le conversioni Decimal, generano sempre un OverflowException. Per le conversioni Double, la conversione in Double.NaN, Double.PositiveInfinity, e Double.NegativeInfinity, rispettivamente.

Si noti che potrebbe comportare una perdita di precisione tramite la conversione di un Single valore a un altro tipo numerico. Nel caso di conversione non integrali Double valori, come illustrato nell'output dell'esempio, il componente frazionario viene perso quando il Single valore viene arrotondato per (come in Visual Basic) o troncati (come in c#). Per le conversioni Decimal e Single valori, il Double valore potrebbe non essere una rappresentazione precisa nel tipo di dati di destinazione.

Nell'esempio seguente converte un numero di Single valori a diversi altri tipi numerici. Le conversioni si verificano in un contesto controllato in Visual Basic (predefinito) e in c# (perché il selezionata parola chiave). L'output dell'esempio viene illustrato il risultato per le conversioni in entrambi un selezionato un contesto non verificato. È possibile eseguire conversioni in un contesto non controllato in Visual Basic mediante la compilazione con il /removeintchecks+ opzione del compilatore e in c#, impostando come commento il checked istruzione.

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)

Per ulteriori informazioni sulla conversione dei tipi numerici, vedere Conversione di tipi in .NET Framework e Tabelle di conversione dei tipi in .NET Framework.

Il Single struttura e i tipi correlati forniscono metodi per eseguire le seguenti categorie di operazioni:

  • Il confronto tra valori. È possibile chiamare il Equals metodo per determinare se due Single valori sono uguali, o CompareTo metodo per determinare la relazione tra due valori.

    Il Single struttura supporta inoltre un set completo di operatori di confronto. Ad esempio, è possibile testare l'uguaglianza o disuguaglianza, o determinare se un valore è maggiore o uguale a un altro valore. Se uno degli operandi è un Double, Single valore viene convertito in un Double prima di eseguire il confronto. Se uno degli operandi è un tipo integrale, viene convertito in un Single prima di eseguire il confronto. Anche se questi sono conversioni di ampliamento, si può comportare una perdita di precisione.

    System_CAPS_warningAvviso

    A causa delle differenze nella precisione, due Single valori che devono essere uguali potrebbero rivelarsi uguali, che influisce sul risultato del confronto. Vedere il la verifica dell'uguaglianza sezione per ulteriori informazioni sul confronto tra due Single valori.

    È inoltre possibile chiamare il IsNaN, IsInfinity, IsPositiveInfinity, e IsNegativeInfinity i metodi di test per questi valori speciali.

  • Operazioni matematiche. Operazioni aritmetiche comuni quali addizione, sottrazione, moltiplicazione e divisione vengono implementate da compilatori di linguaggio e istruzioni Common Intermediate Language (CIL) anziché da Single metodi. Se l'altro operando in un'operazione matematica è una Double, Single viene convertito in un Double prima di eseguire l'operazione e il risultato dell'operazione è anche un Double valore. Se l'altro operando è un tipo integrale, viene convertito in un Single prima di eseguire l'operazione e il risultato dell'operazione è anche un Single valore.

    È possibile eseguire altre operazioni matematiche chiamando static (Shared in Visual Basic) in metodi di System.Math classe. Sono inclusi altri metodi comunemente utilizzati per le operazioni aritmetiche (ad esempio Math.Abs, Math.Sign, e Math.Sqrt), geometry (come Math.Cos e Math.Sin) e calcolo (ad esempio Math.Log). In tutti i casi, il Single valore viene convertito in un Double.

    È inoltre possibile modificare i singoli bit in un Single valore. Il BitConverter.GetBytes(Single) metodo restituisce il relativo schema di bit in una matrice di byte. Passando la matrice di byte di BitConverter.ToInt32 (metodo), è inoltre possibile mantenere il Single modello di valore del bit in un intero a 32 bit.

  • Arrotondamento. Arrotondamento viene spesso utilizzato come una tecnica per ridurre l'impatto delle differenze tra i valori causati da problemi di rappresentazione a virgola mobile e precisione. È possibile arrotondare un Single valore tramite la chiamata di Math.Round metodo. Tuttavia, si noti che il Single valore viene convertito in un Double prima il metodo viene chiamato, la conversione può comportare una perdita di precisione.

  • Formattazione. È possibile convertire un Single valore nella relativa rappresentazione di stringa chiamando il ToString metodo o utilizzando il formattazione composita funzionalità. Per informazioni su come stringhe di formato controllano la rappresentazione di stringa di valori a virgola mobile, vedere il Stringhe di formato numerico standard e Stringhe di formato numerico personalizzato argomenti.

  • Analisi di stringhe. È possibile convertire la rappresentazione di stringa di un valore a virgola mobile a un Single chiamando il Parse o TryParse (metodo). Se l'operazione di analisi ha esito negativo, il Parse metodo genera un'eccezione, mentre il TryParse restituisce false.

  • Conversione del tipo. Il Single struttura fornisce un'implementazione esplicita dell'interfaccia per il IConvertible interfaccia, che supporta la conversione tra le due tipi di dati .NET Framework standard. I compilatori di linguaggio supportano anche la conversione implicita di valori per tutti gli altri tipi numerici standard, ad eccezione di conversione di Double a Single valori. Conversione di un valore di qualsiasi tipo numerico standard diverso da un Double a un Single è una conversione di ampliamento e non richiede l'utilizzo di un metodo di conversione o operatore di cast.

    Tuttavia, la conversione di valori integer a 32 bit e 64 bit può comportare una perdita di precisione. Nella tabella seguente sono elencate le differenze nella precisione per 32 bit, 64 bit, e Double tipi:

    Tipo

    Precisione massima (in cifre decimali)

    Precisione interna (in cifre decimali)

    Double

    15

    17

    Int32 e UInt32

    10

    10

    Int64 e UInt64

    19

    19

    Single

    7

    9

    Il problema di precisione più di frequente riguarda Single valori che vengono convertiti in Double valori. Nell'esempio seguente, due valori prodotti da operazioni di divisione identici sono diversi, perché uno dei valori è un valore di virgola mobile e precisione singola convertito in 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
    

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, la lettura e scrittura a 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: