Single.Equals Single.Equals Single.Equals Single.Equals Method

Definizione

Restituisce un valore che indica se due istanze di Single rappresentano lo stesso valore.Returns a value indicating whether two instances of Single represent the same value.

Overload

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.Returns a value indicating whether this instance is equal to a specified object.

Equals(Single) Equals(Single) Equals(Single) Equals(Single)

Restituisce un valore che indica se l'istanza e un oggetto Single specificato rappresentano lo stesso valore.Returns a value indicating whether this instance and a specified Single object represent the same value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.Returns a value indicating whether this instance is equal to a specified object.

public:
 override bool Equals(System::Object ^ obj);
public override bool Equals (object obj);
override this.Equals : obj -> bool
Public Overrides Function Equals (obj As Object) As Boolean

Parametri

obj
Object Object Object Object

Oggetto da confrontare con l'istanza.An object to compare with this instance.

Restituisce

true se obj è un'istanza di Single ed è uguale al valore dell'istanza; in caso contrario, false.true if obj is an instance of Single and equals the value of this instance; otherwise, false.

Esempi

Nell'esempio di codice riportato di Equals seguito viene illustrato il metodo.The following code example demonstrates the Equals method.

obj1 = (Single)500;

if ( a.Equals( obj1 ) )
{
   Console::WriteLine( "The value type and reference type values are equal." );
}
obj1 = (Single)500;
if (a.Equals(obj1)) {
    Console.WriteLine("The value type and reference type values are equal.");
}
Obj1 = CType(500, Single)

If A.Equals(Obj1) Then
    Console.WriteLine("The value type and reference type values are equal.")
End If

Commenti

Il Equals metodo deve essere usato con cautela, perché due valori apparentemente equivalenti possono essere diversi a causa della diversa precisione dei due valori.The Equals method should be used with caution, because two apparently equivalent values can be unequal due to the differing precision of the two values. Nell'esempio seguente viene segnalato che Single il valore. 3333 e Single l'oggetto restituito dalla divisione 1 per 3 sono diversi.The following example reports that the Single value .3333 and the Single returned by dividing 1 by 3 are unequal.

// Initialize two floats with apparently identical values
float float1 = .33333f;
object float2 = 1/3;
// Compare them for equality
Console.WriteLine(float1.Equals(float2));    // displays false
' Initialize two singles with apparently identical values
Dim single1 As Single = .33333
Dim single2 As Object = 1/3
' Compare them for equality
Console.WriteLine(single1.Equals(single2))    ' displays False

Anziché confrontarsi per verificarne l'uguaglianza, una tecnica consigliata prevede la definizione di un margine accettabile di differenza tra due valori, ad esempio .01% di uno dei valori.Rather than comparing for equality, one recommended technique involves defining an acceptable margin of difference between two values (such as .01% of one of the values). Se il valore assoluto della differenza tra i due valori è minore o uguale a tale margine, la differenza è probabilmente dovuta a differenze di precisione e, pertanto, è probabile che i valori siano uguali.If the absolute value of the difference between the two values is less than or equal to that margin, the difference is likely to be due to differences in precision and, therefore, the values are likely to be equal. Nell'esempio seguente viene usata questa tecnica per confrontare i valori. 33333 e 1/3 Single , i due valori trovati dall'esempio di codice precedente come diversi.The following example uses this technique to compare .33333 and 1/3, the two Single values that the previous code example found to be unequal.

// Initialize two floats with apparently identical values
float float1 = .33333f;
object float2 = (float) 1/3;
// Define the tolerance for variation in their values
float difference = Math.Abs(float1 * .0001f);

// Compare the values
// The output to the console indicates that the two values are equal
if (Math.Abs(float1 - (float) float2) <= difference)
   Console.WriteLine("float1 and float2 are equal.");
else
   Console.WriteLine("float1 and float2 are unequal.");
' Initialize two singles with apparently identical values
Dim single1 As Single = .33333
Dim single2 As Object = 1/3
' Define the tolerance for variation in their values
Dim difference As Single = Math.Abs(single1 * .0001f)

' Compare the values
' The output to the console indicates that the two values are equal
If Math.Abs(single1 - CSng(single2)) <= difference Then
   Console.WriteLine("single1 and single2 are equal.")
Else
   Console.WriteLine("single1 and single2 are unequal.")
End If

In questo caso, i valori sono uguali.In this case, the values are equal.

Nota

Poiché Epsilon definisce l'espressione minima di un valore positivo il cui intervallo è vicino a zero, il margine di differenza deve essere Epsilonmaggiore di.Because Epsilon defines the minimum expression of a positive value whose range is near zero, the margin of difference must be greater than Epsilon. In genere, è spesso maggiore di Epsilon.Typically, it is many times greater than Epsilon.

La precisione dei numeri a virgola mobile oltre la precisione documentata è specifica dell'implementazione e della versione del .NET Framework.The precision of floating-point numbers beyond the documented precision is specific to the implementation and version of the .NET Framework. Di conseguenza, un confronto tra due numeri specifici potrebbe variare tra le versioni del .NET Framework perché la precisione della rappresentazione interna dei numeri potrebbe cambiare.Consequently, a comparison of two particular numbers might change between versions of the .NET Framework because the precision of the numbers' internal representation might change.

Note per i chiamanti

La risoluzione dell'overload del compilatore può tenere conto di una differenza evidente nel comportamento Equals(Object) dei due overload del metodo.Compiler overload resolution may account for an apparent difference in the behavior of the two Equals(Object) method overloads. Se viene definita una obj conversione implicita tra l' Single argomento e un oggetto e l'argomento non Objectè tipizzato come, i compilatori possono eseguire una conversione Equals(Single) implicita e chiamare il metodo.If an implicit conversion between the obj argument and a Single is defined and the argument is not typed as an Object, compilers may perform an implicit conversion and call the Equals(Single) method. In caso contrario, chiamano Equals(Object) il metodo, che restituisce false sempre se obj il relativo argomento non Single è un valore.Otherwise, they call the Equals(Object) method, which always returns false if its obj argument is not a Single value. Nell'esempio seguente viene illustrata la differenza di comportamento tra i due overload del metodo.The following example illustrates the difference in behavior between the two method overloads. Nel caso di tutti i tipi numerici primitivi Double tranne che in Visual Basic e Decimal ad Double eccezione C#di e in, il true primo confronto restituisce perché il compilatore esegue automaticamente una conversione verso un tipo di oggetto più ampio e chiama il Equals(Single) metodo, mentre il secondo confronto restituisce false perché il compilatore chiama il Equals(Object) metodo.In the case of all primitive numeric types except for Double in Visual Basic and except for Decimal and Double in C#, the first comparison returns true because the compiler automatically performs a widening conversion and calls the Equals(Single) method, whereas the second comparison returns false because the compiler calls the Equals(Object) method.

[!code-csharpSystem.Single.Equals#2] [!code-vbSystem.Single.Equals#2][!code-csharpSystem.Single.Equals#2] [!code-vbSystem.Single.Equals#2]

Vedi anche

Equals(Single) Equals(Single) Equals(Single) Equals(Single)

Restituisce un valore che indica se l'istanza e un oggetto Single specificato rappresentano lo stesso valore.Returns a value indicating whether this instance and a specified Single object represent the same value.

public:
 virtual bool Equals(float obj);
public bool Equals (float obj);
override this.Equals : single -> bool
Public Function Equals (obj As Single) As Boolean

Parametri

obj
Single Single Single Single

Oggetto da confrontare con l'istanza.An object to compare with this instance.

Restituisce

true se obj è uguale all'istanza; in caso contrario, false.true if obj is equal to this instance; otherwise, false.

Implementazioni

Commenti

Questo metodo implementa l' System.IEquatable<T> interfaccia ed esegue una leggermente migliore rispetto Equals a perché non è necessario convertire il obj parametro in un oggetto.This method implements the System.IEquatable<T> interface, and performs slightly better than Equals because it does not have to convert the obj parameter to an object.

conversioni verso un tipo di dati più grandeWidening Conversions

A seconda del linguaggio di programmazione, potrebbe essere possibile codificare un Equals metodo in cui il tipo di parametro ha un minor numero di bit (è più piccolo) rispetto al tipo di istanza.Depending on your programming language, it might be possible to code an Equals method where the parameter type has fewer bits (is narrower) than the instance type. Questo è possibile perché alcuni linguaggi di programmazione eseguono una conversione implicita verso un tipo di ampliamento che rappresenta il parametro come un tipo con un numero di bit pari all'istanza.This is possible because some programming languages perform an implicit widening conversion that represents the parameter as a type with as many bits as the instance.

Si supponga, ad esempio, che il Single tipo di istanza sia e Int32che il tipo di parametro sia.For example, suppose the instance type is Single and the parameter type is Int32. Il compilatore C# Microsoft genera istruzioni per rappresentare il valore del parametro come Single oggetto e quindi genera un Single.Equals(Single) metodo che confronta i valori dell'istanza e la rappresentazione ampliata del parametro.The Microsoft C# compiler generates instructions to represent the value of the parameter as a Single object, and then generates a Single.Equals(Single) method that compares the values of the instance and the widened representation of the parameter.

Consultare la documentazione del linguaggio di programmazione per determinare se il compilatore esegue conversioni implicite verso un tipo di caratteri più ampio.Consult your programming language's documentation to determine if its compiler performs implicit widening conversions of numeric types. Per ulteriori informazioni, vedere l'argomento relativo alle tabelle di conversione dei tipi .For more information, see the Type Conversion Tables topic.

Precisione nei confrontiPrecision in Comparisons

Il Equals metodo deve essere utilizzato con cautela, perché due valori apparentemente equivalenti possono essere diversi a causa della diversa precisione dei due valori.The Equals method should be used with caution, because two apparently equivalent values can be unequal because of the differing precision of the two values. Nell'esempio seguente viene segnalato che Single il valore. 3333 e Single l'oggetto restituito dalla divisione 1 per 3 sono diversi.The following example reports that the Single value .3333 and the Single returned by dividing 1 by 3 are unequal.

// Initialize two floats with apparently identical values
float float1 = .33333f;
float float2 = 1/3;
// Compare them for equality
Console.WriteLine(float1.Equals(float2));    // displays false
' Initialize two singles with apparently identical values
Dim single1 As Single = .33333
Dim single2 As Single = 1/3
' Compare them for equality
Console.WriteLine(single1.Equals(single2))    ' displays False

Una tecnica di confronto che evita i problemi associati al confronto per l'uguaglianza comporta la definizione di un margine accettabile di differenza tra due valori, ad esempio il .01% di uno dei valori.One comparison technique that avoids the problems associated with comparing for equality involves defining an acceptable margin of difference between two values (such as .01% of one of the values). Se il valore assoluto della differenza tra i due valori è minore o uguale a tale margine, la differenza è probabilmente un risultato di differenze nella precisione e, pertanto, i valori sono probabilmente uguali.If the absolute value of the difference between the two values is less than or equal to that margin, the difference is likely to be an outcome of differences in precision and, therefore, the values are likely to be equal. Nell'esempio seguente viene usata questa tecnica per confrontare i valori. 33333 e 1/3, che Single corrispondono ai due valori che l'esempio di codice precedente risulta diverso.The following example uses this technique to compare .33333 and 1/3, which are the two Single values that the previous code example found to be unequal.

// Initialize two floats with apparently identical values
float float1 = .33333f;
float float2 = (float) 1/3;
// Define the tolerance for variation in their values
float difference = Math.Abs(float1 * .0001f);

// Compare the values
// The output to the console indicates that the two values are equal
if (Math.Abs(float1 - float2) <= difference)
   Console.WriteLine("float1 and float2 are equal.");
else
   Console.WriteLine("float1 and float2 are unequal.");
' Initialize two singles with apparently identical values
Dim single1 As Single = .33333
Dim single2 As Single = 1/3
' Define the tolerance for variation in their values
Dim difference As Single = Math.Abs(single1 * .0001f)

' Compare the values
' The output to the console indicates that the two values are equal
If Math.Abs(single1 - single2) <= difference Then
   Console.WriteLine("single1 and single2 are equal.")
Else
   Console.WriteLine("single1 and single2 are unequal.")
End If

In questo caso, i valori sono uguali.In this case, the values are equal.

Nota

Poiché Epsilon definisce l'espressione minima di un valore positivo il cui intervallo è vicino a zero, il margine di differenza deve essere Epsilonmaggiore di.Because Epsilon defines the minimum expression of a positive value whose range is near zero, the margin of difference must be greater than Epsilon. In genere, è spesso maggiore di Epsilon.Typically, it is many times greater than Epsilon. Per questo motivo, è consigliabile non usare Epsilon quando si confrontano Double i valori per verificarne l'uguaglianza.Because of this, we recommend that you do not use Epsilon when comparing Double values for equality.

Una seconda tecnica che evita i problemi associati al confronto per l'uguaglianza comporta il confronto tra due numeri a virgola mobile e un valore assoluto.A second technique that avoids the problems associated with comparing for equality involves comparing the difference between two floating-point numbers with some absolute value. Se la differenza è minore o uguale al valore assoluto, i numeri sono uguali.If the difference is less than or equal to that absolute value, the numbers are equal. Se è maggiore, i numeri non sono uguali.If it is greater, the numbers are not equal. Un modo per eseguire questa operazione consiste nel selezionare arbitrariamente un valore assoluto.One way to do this is to arbitrarily select an absolute value. Tuttavia, ciò è problematico, perché un margine accettabile di differenza dipende dalla grandezza dei Single valori.However, this is problematic, because an acceptable margin of difference depends on the magnitude of the Single values. Un secondo modo sfrutta la funzionalità di progettazione del formato a virgola mobile: La differenza tra i componenti mantissa nelle rappresentazioni Integer di due valori a virgola mobile indica il numero di possibili valori a virgola mobile che separano i due valori.A second way takes advantage of a design feature of the floating-point format: The difference between the mantissa components in the integer representations of two floating-point values indicates the number of possible floating-point values that separates the two values. Ad esempio, la differenza tra 0,0 e Epsilon è 1, poiché Epsilon è il più piccolo valore rappresentabile quando si utilizza un oggetto Single il cui valore è zero.For example, the difference between 0.0 and Epsilon is 1, because Epsilon is the smallest representable value when working with a Single whose value is zero. L'esempio seguente usa questa tecnica per confrontare i valori. 33333 e 1/3, che corrispondono Double ai due valori che l'esempio di codice Equals(Single) precedente con il metodo risulta diverso.The following example uses this technique to compare .33333 and 1/3, which are the two Double values that the previous code example with the Equals(Single) method found to be unequal. Si noti che nell'esempio vengono BitConverter.GetBytes usati BitConverter.ToInt32 i metodi e per convertire un valore a virgola mobile a precisione singola nella relativa rappresentazione di Integer.Note that the example uses the BitConverter.GetBytes and BitConverter.ToInt32 methods to convert a single-precision floating-point value to its integer representation.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .1f * 10f;
      float value2 = 0f;
      for (int ctr = 0; ctr < 10; ctr++)
         value2 += .1f;
         
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2,
                        HasMinimalDifference(value1, value2, 1));
   }

   public static bool HasMinimalDifference(float value1, float value2, int units)
   {
      byte[] bytes = BitConverter.GetBytes(value1);
      int iValue1 = BitConverter.ToInt32(bytes, 0);
      
      bytes = BitConverter.GetBytes(value2);
      int iValue2 = BitConverter.ToInt32(bytes, 0);
      
      // If the signs are different, return false except for +0 and -0.
      if ((iValue1 >> 31) != (iValue2 >> 31))
      {
         if (value1 == value2)
            return true;
          
         return false;
      }

      int diff = Math.Abs(iValue1 - iValue2);

      if (diff <= units)
         return true;

      return false;
   }
}
// The example displays the following output:
//        1 = 1.00000012: True
Module Example
   Public Sub Main()
      Dim value1 As Single = .1 * 10
      Dim value2 As Single = 0
      For ctr As Integer =  0 To 9
         value2 += CSng(.1)
      Next
               
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2,
                        HasMinimalDifference(value1, value2, 1))
   End Sub

   Public Function HasMinimalDifference(value1 As Single, value2 As Single, units As Integer) As Boolean
      Dim bytes() As Byte = BitConverter.GetBytes(value1)
      Dim iValue1 As Integer =  BitConverter.ToInt32(bytes, 0)
      
      bytes = BitConverter.GetBytes(value2)
      Dim iValue2 As Integer =  BitConverter.ToInt32(bytes, 0)
      
      ' If the signs are different, Return False except for +0 and -0.
      If ((iValue1 >> 31) <> (iValue2 >> 31)) Then
         If value1 = value2 Then
            Return True
         End If           
         Return False
      End If

      Dim diff As Integer =  Math.Abs(iValue1 - iValue2)

      If diff <= units Then
         Return True
      End If

      Return False
   End Function
End Module
' The example displays the following output:
'       1 = 1.00000012: True

La precisione dei numeri a virgola mobile oltre la precisione documentata è specifica dell'implementazione e della versione del .NET Framework.The precision of floating-point numbers beyond the documented precision is specific to the implementation and version of the .NET Framework. Di conseguenza, un confronto tra due numeri può produrre risultati diversi a seconda della versione della .NET Framework, perché la precisione della rappresentazione interna dei numeri potrebbe cambiare.Consequently, a comparison of two numbers might produce different results depending on the version of the .NET Framework, because the precision of the numbers' internal representation might change.

Note per i chiamanti

La risoluzione dell'overload del compilatore può tenere conto di una differenza evidente nel comportamento Equals(Object) dei due overload del metodo.Compiler overload resolution may account for an apparent difference in the behavior of the two Equals(Object) method overloads. Se viene definita una obj conversione implicita tra l' Single argomento e un oggetto e l'argomento non Objectè tipizzato come, i compilatori possono eseguire una conversione Equals(Single) implicita e chiamare il metodo.If an implicit conversion between the obj argument and a Single is defined and the argument is not typed as an Object, compilers may perform an implicit conversion and call the Equals(Single) method. In caso contrario, chiamano Equals(Object) il metodo, che restituisce false sempre se obj il relativo argomento non Single è un valore.Otherwise, they call the Equals(Object) method, which always returns false if its obj argument is not a Single value. Nell'esempio seguente viene illustrata la differenza di comportamento tra i due overload del metodo.The following example illustrates the difference in behavior between the two method overloads. Nel caso di tutti i tipi numerici primitivi Double tranne che in Visual Basic e Decimal ad Double eccezione C#di e in, il true primo confronto restituisce perché il compilatore esegue automaticamente una conversione verso un tipo di oggetto più ampio e chiama il Equals(Single) metodo, mentre il secondo confronto restituisce false perché il compilatore chiama il Equals(Object) metodo.In the case of all primitive numeric types except for Double in Visual Basic and except for Decimal and Double in C#, the first comparison returns true because the compiler automatically performs a widening conversion and calls the Equals(Single) method, whereas the second comparison returns false because the compiler calls the Equals(Object) method.

[!code-csharpSystem.Single.Equals#2] [!code-vbSystem.Single.Equals#2][!code-csharpSystem.Single.Equals#2] [!code-vbSystem.Single.Equals#2]

Vedi anche

Si applica a