Single.Equals Metoda

Definicja

Przestrzeń nazw:: System

Zestawy:: mscorlib.dll, System.Runtime.dll

Zestawy:: netstandard.dll, System.Runtime.dll

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Zwraca wartość wskazującą, czy dwa wystąpienia Single reprezentują tę samą wartość.

Przeciążenia

Nazwa	Opis
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu obiektowi.
Equals(Single)	Zwraca wartość wskazującą, czy to wystąpienie i określony Single obiekt reprezentują tę samą wartość.

Equals(Object)

Źródło:: Single.cs

Źródło:: Single.cs

Źródło:: Single.cs

Źródło:: Single.cs

Źródło:: Single.cs

Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu obiektowi.

public:
 override bool Equals(System::Object ^ obj);

public override bool Equals(object obj);

public override bool Equals(object? obj);

override this.Equals : obj -> bool

Public Overrides Function Equals (obj As Object) As Boolean

Parametry

obj: Object

Obiekt do porównania z tym wystąpieniem.

Zwraca

Boolean

true jeśli obj jest wystąpieniem Single i równa wartości tego wystąpienia; w przeciwnym razie false.

Przykłady

Poniższy przykład kodu przedstawia metodę Equals .

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

let obj1 = single 500
if a.Equals obj1 then
    printfn "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

Uwagi

Metoda Equals powinna być używana z ostrożnością, ponieważ dwie pozornie równoważne wartości mogą być nierówne ze względu na różnicową precyzję tych dwóch wartości. Poniższy przykład informuje, że wartość Single .3333 oraz Single, która została zwrócona przez podzielenie 1 przez 3, są nierówne.

// 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 floats with apparently identical values
let float1 = 0.33333f
let float2 = box (1f / 3f)
// Compare them for equality
printfn $"{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

Zamiast porównywać równość, jedna zalecana technika polega na zdefiniowaniu dopuszczalnego marginesu różnicy między dwiema wartościami (takimi jak .01% jednej z wartości). Jeśli wartość bezwzględna różnicy między dwiema wartościami jest mniejsza lub równa temu marginesowi, różnica może być spowodowana różnicami w precyzji i dlatego wartości mogą być równe. W poniższym przykładzie użyto tej techniki do porównania wartości .33333 i 1/3, czyli dwóch Single wartości, których nierówność wykazał poprzedni przykład kodu.

// 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 floats with apparently identical values
let float1 = 0.33333f
let float2 = box (1f / 3f)
// Define the tolerance for variation in their values
let difference = abs (float1 * 0.0001f)

// Compare the values
// The output to the console indicates that the two values are equal
if abs (float1 - (float2 :?> float32)) <= difference then
    printfn "float1 and float2 are equal."
else
    printfn "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

W takim przypadku wartości są równe.

Note

Precyzja liczb zmiennoprzecinkowych poza udokumentowaną precyzją jest specyficzna dla implementacji i wersji platformy .NET Framework. W związku z tym porównanie dwóch konkretnych liczb może ulec zmianie między wersjami struktury .NET, ponieważ precyzja wewnętrznej reprezentacji liczb może ulec zmianie.

Notatki dotyczące wywoływania

Rozpoznawanie przeciążenia kompilatora może uwzględniać widoczną różnicę w zachowaniu dwóch Equals(Object) przeciążeń metody. Jeśli niejawna konwersja między argumentem obj a elementem Single jest zdefiniowana, a argument nie jest typowany jako Object, kompilatory mogą wykonać niejawną konwersję i wywołać metodę Equals(Single) . W przeciwnym razie wywołają metodę Equals(Object) , która zawsze zwraca false wartość, jeśli jej obj argument nie jest wartością Single . Poniższy przykład ilustruje różnicę w zachowaniu między dwoma przeciążeniami metody. W przypadku wszystkich typów liczb pierwotnych z wyjątkiem Double w Visual Basic i z wyjątkiem Decimal i Double w języku C#, pierwsze porównanie zwraca true, ponieważ kompilator automatycznie wykonuje konwersję rozszerzającą i wywołuje metodę Equals(Single), podczas gdy drugie porównanie zwraca false, ponieważ kompilator wywołuje metodę Equals(Object).

using System;

public class Example2
{
   static float value = 112;

   public static void Main()
   {
      byte byte1= 112;
      Console.WriteLine("value = byte1: {0,16}", value.Equals(byte1));
      TestObjectForEquality(byte1);

      short short1 = 112;
      Console.WriteLine("value = short1: {0,16}", value.Equals(short1));
      TestObjectForEquality(short1);

      int int1 = 112;
      Console.WriteLine("value = int1: {0,18}", value.Equals(int1));
      TestObjectForEquality(int1);

      long long1 = 112;
      Console.WriteLine("value = long1: {0,17}", value.Equals(long1));
      TestObjectForEquality(long1);

      sbyte sbyte1 = 112;
      Console.WriteLine("value = sbyte1: {0,16}", value.Equals(sbyte1));
      TestObjectForEquality(sbyte1);

      ushort ushort1 = 112;
      Console.WriteLine("value = ushort1: {0,16}", value.Equals(ushort1));
      TestObjectForEquality(ushort1);

      uint uint1 = 112;
      Console.WriteLine("value = uint1: {0,18}", value.Equals(uint1));
      TestObjectForEquality(uint1);

      ulong ulong1 = 112;
      Console.WriteLine("value = ulong1: {0,17}", value.Equals(ulong1));
      TestObjectForEquality(ulong1);

      decimal dec1 = 112m;
      Console.WriteLine("value = dec1: {0,21}", value.Equals(dec1));
      TestObjectForEquality(dec1);

      double dbl1 = 112;
      Console.WriteLine("value = dbl1: {0,20}", value.Equals(dbl1));
      TestObjectForEquality(dbl1);
   }

   private static void TestObjectForEquality(Object obj)
   {
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}\n",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj));
   }
}
// The example displays the following output:
//       value = byte1:             True
//       112 (Single) = 112 (Byte): False
//
//       value = short1:             True
//       112 (Single) = 112 (Int16): False
//
//       value = int1:               True
//       112 (Single) = 112 (Int32): False
//
//       value = long1:              True
//       112 (Single) = 112 (Int64): False
//
//       value = sbyte1:             True
//       112 (Single) = 112 (SByte): False
//
//       value = ushort1:             True
//       112 (Single) = 112 (UInt16): False
//
//       value = uint1:               True
//       112 (Single) = 112 (UInt32): False
//
//       value = ulong1:              True
//       112 (Single) = 112 (UInt64): False
//
//       value = dec1:                 False
//       112 (Single) = 112 (Decimal): False
//
//       value = dbl1:                False
//       112 (Single) = 112 (Double): False

let value = 112f

let testObjectForEquality (obj: obj) =
    printfn $"{value} ({value.GetType().Name}) = {obj} ({obj.GetType().Name}): {value.Equals obj}\n"

[<EntryPoint>]
let main _ =
    let byte1= 112uy
    printfn $"value = byte1: {value.Equals byte1,16}"
    testObjectForEquality byte1

    let short1 = 112s
    printfn $"value = short1: {value.Equals short1,16}"
    testObjectForEquality short1

    let int1 = 112
    printfn $"value = int1: {value.Equals int1,18}"
    testObjectForEquality int1

    let long1 = 112L
    printfn $"value = long1: {value.Equals long1,17}"
    testObjectForEquality long1
    
    let sbyte1 = 112y
    printfn $"value = sbyte1: {value.Equals sbyte1,16}"
    testObjectForEquality sbyte1

    let ushort1 = 112us
    printfn $"value = ushort1: {value.Equals ushort1,16}"
    testObjectForEquality ushort1

    let uint1 = 112u
    printfn $"value = uint1: {value.Equals uint1,18}"
    testObjectForEquality uint1

    let ulong1 = 112uL
    printfn $"value = ulong1: {value.Equals ulong1,17}"
    testObjectForEquality ulong1
    
    let dec1 = 112m
    printfn $"value = dec1: {value.Equals dec1,21}"
    testObjectForEquality dec1

    let dbl1 = 112.
    printfn $"value = dbl1: {value.Equals dbl1,20}"
    testObjectForEquality dbl1
    0

// The example displays the following output:
//       value = byte1:             True
//       112 (Single) = 112 (Byte): False
//
//       value = short1:             True
//       112 (Single) = 112 (Int16): False
//
//       value = int1:               True
//       112 (Single) = 112 (Int32): False
//
//       value = long1:              True
//       112 (Single) = 112 (Int64): False
//
//       value = sbyte1:             True
//       112 (Single) = 112 (SByte): False
//
//       value = ushort1:             True
//       112 (Single) = 112 (UInt16): False
//
//       value = uint1:               True
//       112 (Single) = 112 (UInt32): False
//
//       value = ulong1:              True
//       112 (Single) = 112 (UInt64): False
//
//       value = dec1:                 False
//       112 (Single) = 112 (Decimal): False
//
//       value = dbl1:                False
//       112 (Single) = 112 (Double): False

Module Example2
   Dim value As Single = 112

   Public Sub Main()
      Dim byte1 As Byte = 112
      Console.WriteLine("value = byte1: {0,16}", value.Equals(byte1))
      TestObjectForEquality(byte1)

      Dim short1 As Short = 112
      Console.WriteLine("value = short1: {0,16}", value.Equals(short1))
      TestObjectForEquality(short1)

      Dim int1 As Integer = 112
      Console.WriteLine("value = int1: {0,18}", value.Equals(int1))
      TestObjectForEquality(int1)

      Dim long1 As Long = 112
      Console.WriteLine("value = long1: {0,17}", value.Equals(long1))
      TestObjectForEquality(long1)

      Dim sbyte1 As SByte = 112
      Console.WriteLine("value = sbyte1: {0,16}", value.Equals(sbyte1))
      TestObjectForEquality(sbyte1)

      Dim ushort1 As UShort = 112
      Console.WriteLine("value = ushort1: {0,16}", value.Equals(ushort1))
      TestObjectForEquality(ushort1)

      Dim uint1 As UInteger = 112
      Console.WriteLine("value = uint1: {0,18}", value.Equals(uint1))
      TestObjectForEquality(uint1)

      Dim ulong1 As ULong = 112
      Console.WriteLine("value = ulong1: {0,17}", value.Equals(ulong1))
      TestObjectForEquality(ulong1)

      Dim dec1 As Decimal = 112d
      Console.WriteLine("value = dec1: {0,20}", value.Equals(dec1))
      TestObjectForEquality(dec1)

      Dim dbl1 As Double = 112
      Console.WriteLine("value = dbl1: {0,20}", value.Equals(dbl1))
      TestObjectForEquality(dbl1)
   End Sub

   Private Sub TestObjectForEquality(obj As Object)
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj))
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       value = byte1:             True
'       112 (Single) = 112 (Byte): False
'
'       value = short1:             True
'       112 (Single) = 112 (Int16): False
'
'       value = int1:               True
'       112 (Single) = 112 (Int32): False
'
'       value = long1:              True
'       112 (Single) = 112 (Int64): False
'
'       value = sbyte1:             True
'       112 (Single) = 112 (SByte): False
'
'       value = ushort1:             True
'       112 (Single) = 112 (UInt16): False
'
'       value = uint1:               True
'       112 (Single) = 112 (UInt32): False
'
'       value = ulong1:              True
'       112 (Single) = 112 (UInt64): False
'
'       value = dec1:                 True
'       112 (Single) = 112 (Decimal): False
'
'       value = dbl1:                False
'       112 (Single) = 112 (Double): False

Zobacz też

CompareTo(Object)

Dotyczy

Equals(Single)

Źródło:: Single.cs

Źródło:: Single.cs

Źródło:: Single.cs

Źródło:: Single.cs

Źródło:: Single.cs

Zwraca wartość wskazującą, czy to wystąpienie i określony Single obiekt reprezentują tę samą wartość.

public:
 virtual bool Equals(float obj);

public bool Equals(float obj);

override this.Equals : single -> bool

Public Function Equals (obj As Single) As Boolean

Parametry

obj: Single

Obiekt do porównania z tym wystąpieniem.

Zwraca

Boolean

true jeśli obj jest równe temu wystąpieniu; w przeciwnym razie false.

Implementuje

Equals(T)

Uwagi

Metoda Single.Equals(Single) implementuje interfejs System.IEquatable<T> i działa nieco lepiej niż Single.Equals(Object), ponieważ nie musi konwertować parametru obj na obiekt.

Konwersje rozszerzające

W zależności od języka programowania można kodować metodę Equals, w której typ parametru ma mniej bitów (jest węższy) niż typ wystąpienia. Jest to możliwe, ponieważ niektóre języki programowania wykonują niejawną konwersję rozszerzającą, która reprezentuje parametr jako typ z tyloma bitami co wystąpienie.

Załóżmy na przykład, że typ wystąpienia to Single , a typ parametru to Int32. Kompilator języka Microsoft C# generuje instrukcje reprezentujące wartość parametru jako obiekt Single, a następnie generuje metodę Single.Equals(Single), która porównuje wartości wystąpienia i poszerzone reprezentacje parametru.

Zapoznaj się z dokumentacją języka programowania, aby ustalić, czy kompilator wykonuje niejawne konwersje rozszerzające typy liczbowe. Aby uzyskać więcej informacji, zobacz tabele konwersji typów .

Precyzja w porównaniach

Metoda Equals powinna być używana ostrożnie, ponieważ dwie pozornie równoważne wartości mogą być nierówne ze względu na różnicową precyzję tych dwóch wartości. Poniższy przykład informuje, że wartość Single .3333 oraz Single, która została zwrócona przez podzielenie 1 przez 3, są nierówne.

// 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 floats with apparently identical values
let float1 = 0.33333f
let float2 = 1f / 3f
// Compare them for equality
printfn $"{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

Jedna technika porównania, która pozwala uniknąć problemów związanych z porównywaniem równości, polega na zdefiniowaniu dopuszczalnego marginesu różnicy między dwiema wartościami (takimi jak .01% jednej z wartości). Jeśli wartość bezwzględna różnicy między dwiema wartościami jest mniejsza lub równa temu marginesowi, różnica może być wynikiem różnic w precyzji i dlatego wartości mogą być równe. W poniższym przykładzie użyto tej techniki do porównania wartości 0.33333 i 1/3, które są dwiema wartościami Single, stwierdzonymi jako różne w poprzednim przykładzie kodu.

// 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 floats with apparently identical values
let float1 = 0.33333f
let float2 = 1f / 3f
// Define the tolerance for variation in their values
let difference = abs (float1 * 0.0001f)

// Compare the values
// The output to the console indicates that the two values are equal
if abs (float1 - float2) <= difference then
    printfn "float1 and float2 are equal."
else
    printfn "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

W takim przypadku wartości są równe.

Note

Ponieważ Epsilon definiuje minimalne wyrażenie wartości dodatniej, której zakres jest zbliżony do zera, margines różnicy musi być większy niż Epsilon. Zazwyczaj wartość jest wielokrotnie większa niż Epsilon. W związku z tym zalecamy, aby nie używać Epsilon podczas porównywania wartości Double pod kątem równości.

Druga technika, która pozwala uniknąć problemów związanych z porównywaniem równości, polega na porównaniu różnicy między dwiema liczbami zmiennoprzecinkowami z pewną wartością bezwzględną. Jeśli różnica jest mniejsza lub równa tej wartości bezwzględnej, liczby są równe. Jeśli jest większa, liczby nie są równe. Jednym ze sposobów wykonania tej czynności jest arbitralne wybranie wartości bezwzględnej. Jest to jednak problematyczne, ponieważ akceptowalny margines różnicy zależy od wielkości wartości Single. Drugi sposób wykorzystuje funkcję projektową formatu zmiennoprzecinkowego: Różnica między składnikami mantissa w reprezentacjach liczb całkowitych dwóch wartości zmiennoprzecinkowych wskazuje liczbę możliwych wartości zmiennoprzecinkowych, które oddziela dwie wartości. Na przykład różnica między 0,0 a Epsilon wynosi 1, ponieważ Epsilon jest najmniejszą reprezentowalną wartością podczas pracy z Single, którego wartość jest zerowa. W poniższym przykładzie użyto tej techniki do porównania wartości 33333 i 1/3, które są dwiema wartościami Double, które zostały uznane za nierówne w poprzednim przykładzie kodu z metodą Equals(Single). Należy pamiętać, że w przykładzie użyto metod BitConverter.GetBytes i BitConverter.ToInt32 w celu przekonwertowania wartości zmiennoprzecinkowej o pojedynczej precyzji na reprezentację liczby całkowitej.

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($"{value1:R} = {value2:R}: {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

open System

let hasMinimalDifference (value1: float32) (value2: float32) units =
    let bytes = BitConverter.GetBytes value1
    let iValue1 = BitConverter.ToInt32(bytes, 0)
    let bytes = BitConverter.GetBytes(value2)
    let iValue2 = BitConverter.ToInt32(bytes, 0)
    
    // If the signs are different, return false except for +0 and -0.
    if (iValue1 >>> 31) <> (iValue2 >>> 31) then
        value1 = value2
    else
        let diff = abs (iValue1 - iValue2)
        diff <= units

let value1 = 0.1f * 10f
let value2 =
    List.replicate 10 0.1f
    |> List.sum
    
printfn $"{value1:R} = {value2:R}: {hasMinimalDifference value1 value2 1}"
// The example displays the following output:
//        1 = 1.0000001: True

Module Example1
   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

Precyzja liczb zmiennoprzecinkowych poza udokumentowaną precyzją jest specyficzna dla implementacji i wersji platformy .NET. W związku z tym porównanie dwóch liczb może generować różne wyniki w zależności od wersji platformy .NET, ponieważ precyzja wewnętrznej reprezentacji liczb może ulec zmianie.

Notatki dotyczące wywoływania

using System;

public class Example2
{
   static float value = 112;

   public static void Main()
   {
      byte byte1= 112;
      Console.WriteLine("value = byte1: {0,16}", value.Equals(byte1));
      TestObjectForEquality(byte1);

      short short1 = 112;
      Console.WriteLine("value = short1: {0,16}", value.Equals(short1));
      TestObjectForEquality(short1);

      int int1 = 112;
      Console.WriteLine("value = int1: {0,18}", value.Equals(int1));
      TestObjectForEquality(int1);

      long long1 = 112;
      Console.WriteLine("value = long1: {0,17}", value.Equals(long1));
      TestObjectForEquality(long1);

      sbyte sbyte1 = 112;
      Console.WriteLine("value = sbyte1: {0,16}", value.Equals(sbyte1));
      TestObjectForEquality(sbyte1);

      ushort ushort1 = 112;
      Console.WriteLine("value = ushort1: {0,16}", value.Equals(ushort1));
      TestObjectForEquality(ushort1);

      uint uint1 = 112;
      Console.WriteLine("value = uint1: {0,18}", value.Equals(uint1));
      TestObjectForEquality(uint1);

      ulong ulong1 = 112;
      Console.WriteLine("value = ulong1: {0,17}", value.Equals(ulong1));
      TestObjectForEquality(ulong1);

      decimal dec1 = 112m;
      Console.WriteLine("value = dec1: {0,21}", value.Equals(dec1));
      TestObjectForEquality(dec1);

      double dbl1 = 112;
      Console.WriteLine("value = dbl1: {0,20}", value.Equals(dbl1));
      TestObjectForEquality(dbl1);
   }

   private static void TestObjectForEquality(Object obj)
   {
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}\n",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj));
   }
}
// The example displays the following output:
//       value = byte1:             True
//       112 (Single) = 112 (Byte): False
//
//       value = short1:             True
//       112 (Single) = 112 (Int16): False
//
//       value = int1:               True
//       112 (Single) = 112 (Int32): False
//
//       value = long1:              True
//       112 (Single) = 112 (Int64): False
//
//       value = sbyte1:             True
//       112 (Single) = 112 (SByte): False
//
//       value = ushort1:             True
//       112 (Single) = 112 (UInt16): False
//
//       value = uint1:               True
//       112 (Single) = 112 (UInt32): False
//
//       value = ulong1:              True
//       112 (Single) = 112 (UInt64): False
//
//       value = dec1:                 False
//       112 (Single) = 112 (Decimal): False
//
//       value = dbl1:                False
//       112 (Single) = 112 (Double): False

let value = 112f

let testObjectForEquality (obj: obj) =
    printfn $"{value} ({value.GetType().Name}) = {obj} ({obj.GetType().Name}): {value.Equals obj}\n"

[<EntryPoint>]
let main _ =
    let byte1= 112uy
    printfn $"value = byte1: {value.Equals byte1,16}"
    testObjectForEquality byte1

    let short1 = 112s
    printfn $"value = short1: {value.Equals short1,16}"
    testObjectForEquality short1

    let int1 = 112
    printfn $"value = int1: {value.Equals int1,18}"
    testObjectForEquality int1

    let long1 = 112L
    printfn $"value = long1: {value.Equals long1,17}"
    testObjectForEquality long1
    
    let sbyte1 = 112y
    printfn $"value = sbyte1: {value.Equals sbyte1,16}"
    testObjectForEquality sbyte1

    let ushort1 = 112us
    printfn $"value = ushort1: {value.Equals ushort1,16}"
    testObjectForEquality ushort1

    let uint1 = 112u
    printfn $"value = uint1: {value.Equals uint1,18}"
    testObjectForEquality uint1

    let ulong1 = 112uL
    printfn $"value = ulong1: {value.Equals ulong1,17}"
    testObjectForEquality ulong1
    
    let dec1 = 112m
    printfn $"value = dec1: {value.Equals dec1,21}"
    testObjectForEquality dec1

    let dbl1 = 112.
    printfn $"value = dbl1: {value.Equals dbl1,20}"
    testObjectForEquality dbl1
    0

// The example displays the following output:
//       value = byte1:             True
//       112 (Single) = 112 (Byte): False
//
//       value = short1:             True
//       112 (Single) = 112 (Int16): False
//
//       value = int1:               True
//       112 (Single) = 112 (Int32): False
//
//       value = long1:              True
//       112 (Single) = 112 (Int64): False
//
//       value = sbyte1:             True
//       112 (Single) = 112 (SByte): False
//
//       value = ushort1:             True
//       112 (Single) = 112 (UInt16): False
//
//       value = uint1:               True
//       112 (Single) = 112 (UInt32): False
//
//       value = ulong1:              True
//       112 (Single) = 112 (UInt64): False
//
//       value = dec1:                 False
//       112 (Single) = 112 (Decimal): False
//
//       value = dbl1:                False
//       112 (Single) = 112 (Double): False

Module Example2
   Dim value As Single = 112

   Public Sub Main()
      Dim byte1 As Byte = 112
      Console.WriteLine("value = byte1: {0,16}", value.Equals(byte1))
      TestObjectForEquality(byte1)

      Dim short1 As Short = 112
      Console.WriteLine("value = short1: {0,16}", value.Equals(short1))
      TestObjectForEquality(short1)

      Dim int1 As Integer = 112
      Console.WriteLine("value = int1: {0,18}", value.Equals(int1))
      TestObjectForEquality(int1)

      Dim long1 As Long = 112
      Console.WriteLine("value = long1: {0,17}", value.Equals(long1))
      TestObjectForEquality(long1)

      Dim sbyte1 As SByte = 112
      Console.WriteLine("value = sbyte1: {0,16}", value.Equals(sbyte1))
      TestObjectForEquality(sbyte1)

      Dim ushort1 As UShort = 112
      Console.WriteLine("value = ushort1: {0,16}", value.Equals(ushort1))
      TestObjectForEquality(ushort1)

      Dim uint1 As UInteger = 112
      Console.WriteLine("value = uint1: {0,18}", value.Equals(uint1))
      TestObjectForEquality(uint1)

      Dim ulong1 As ULong = 112
      Console.WriteLine("value = ulong1: {0,17}", value.Equals(ulong1))
      TestObjectForEquality(ulong1)

      Dim dec1 As Decimal = 112d
      Console.WriteLine("value = dec1: {0,20}", value.Equals(dec1))
      TestObjectForEquality(dec1)

      Dim dbl1 As Double = 112
      Console.WriteLine("value = dbl1: {0,20}", value.Equals(dbl1))
      TestObjectForEquality(dbl1)
   End Sub

   Private Sub TestObjectForEquality(obj As Object)
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj))
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       value = byte1:             True
'       112 (Single) = 112 (Byte): False
'
'       value = short1:             True
'       112 (Single) = 112 (Int16): False
'
'       value = int1:               True
'       112 (Single) = 112 (Int32): False
'
'       value = long1:              True
'       112 (Single) = 112 (Int64): False
'
'       value = sbyte1:             True
'       112 (Single) = 112 (SByte): False
'
'       value = ushort1:             True
'       112 (Single) = 112 (UInt16): False
'
'       value = uint1:               True
'       112 (Single) = 112 (UInt32): False
'
'       value = ulong1:              True
'       112 (Single) = 112 (UInt64): False
'
'       value = dec1:                 True
'       112 (Single) = 112 (Decimal): False
'
'       value = dbl1:                False
'       112 (Single) = 112 (Double): False

Zobacz też

Dotyczy

Opinia

Czy ta strona była pomocna?