Partage via


Object.ReferenceEquals(Object, Object) Méthode

Définition

Détermine si les instances de Object spécifiées sont identiques.

public:
 static bool ReferenceEquals(System::Object ^ objA, System::Object ^ objB);
public static bool ReferenceEquals (object objA, object objB);
public static bool ReferenceEquals (object? objA, object? objB);
static member ReferenceEquals : obj * obj -> bool
Public Shared Function ReferenceEquals (objA As Object, objB As Object) As Boolean

Paramètres

objA
Object

Premier objet à comparer.

objB
Object

Deuxième objet à comparer.

Retours

Boolean

true si objA est la même instance que objB ou si les deux ont la valeur null ; sinon, false.

Exemples

L’exemple suivant utilise ReferenceEquals pour déterminer si deux objets sont la même instance.

using namespace System;
int main()
{
   Object^ o = nullptr;
   Object^ p = nullptr;
   Object^ q = gcnew Object;
   Console::WriteLine( Object::ReferenceEquals( o, p ) );
   p = q;
   Console::WriteLine( Object::ReferenceEquals( p, q ) );
   Console::WriteLine( Object::ReferenceEquals( o, p ) );
}

/*

This code produces the following output.

True
True
False

*/
object o = null;
object p = null;
object q = new Object();

Console.WriteLine(Object.ReferenceEquals(o, p));
p = q;
Console.WriteLine(Object.ReferenceEquals(p, q));
Console.WriteLine(Object.ReferenceEquals(o, p));

// This code produces the following output:
//   True
//   True
//   False
let o: obj = null
let mutable p: obj = null
let q = obj ()

printfn $"{Object.ReferenceEquals(o, p)}"
p <- q
printfn $"{Object.ReferenceEquals(p, q)}"
printfn $"{Object.ReferenceEquals(o, p)}"

// This code produces the following output:
//   True
//   True
//   False
Public Class App
    Public Shared Sub Main() 
        Dim o As Object = Nothing
        Dim p As Object = Nothing
        Dim q As New Object
        Console.WriteLine(Object.ReferenceEquals(o, p))
        p = q
        Console.WriteLine(Object.ReferenceEquals(p, q))
        Console.WriteLine(Object.ReferenceEquals(o, p))
    End Sub 
End Class 
' This code produces the following output:
'
' True
' True
' False
'

Remarques

Contrairement à la Equals méthode et à l’opérateur d’égalité, la ReferenceEquals méthode ne peut pas être substituée. Pour cette raison, si vous souhaitez tester deux références d’objet pour l’égalité et que vous n’êtes pas sûr de l’implémentation de la Equals méthode, vous pouvez appeler la ReferenceEquals méthode.

Toutefois, la valeur de retour de la ReferenceEquals méthode peut sembler anormale dans ces deux scénarios :

  • Lors de la comparaison des types valeur. Si objA et objB sont des types valeur, ils sont boxés avant qu’ils ne soient passés à la ReferenceEquals méthode. Cela signifie que si les deux objA instances et objB représentent la même instance d’un type valeur, la ReferenceEquals méthode retourne falsenéanmoins , comme l’illustre l’exemple suivant.

    int int1 = 3;
    Console.WriteLine(Object.ReferenceEquals(int1, int1));
    Console.WriteLine(int1.GetType().IsValueType);
    
    // The example displays the following output:
    //       False
    //       True
    
    let int1 = 3
    printfn $"{Object.ReferenceEquals(int1, int1)}"
    printfn $"{int1.GetType().IsValueType}"
    
    // The example displays the following output:
    //       False
    //       True
    
    Public Module Example
       Public Sub Main
          Dim int1 As Integer = 3
          Console.WriteLine(Object.ReferenceEquals(int1, int1))
          Console.WriteLine(int1.GetType().IsValueType)
       End Sub
    End Module
    ' The example displays the following output:
    '       False
    '       True
    

    Pour plus d’informations sur les types de valeurs boxing, consultez Boxing et Unboxing.

  • Lors de la comparaison de chaînes. Si objA et objB sont des chaînes, la ReferenceEquals méthode retourne true si la chaîne est interne. Il n’effectue pas de test pour l’égalité des valeurs. Dans l’exemple suivant, s1 et s2 sont égaux, car il s’agit de deux instances d’une seule chaîne interne. Toutefois, s3 et s4 ne sont pas égaux, car bien qu’elles aient des valeurs de chaîne identiques, cette chaîne n’est pas interne.

    String s1 = "String1";
    String s2 = "String1";
    Console.WriteLine("s1 = s2: {0}", Object.ReferenceEquals(s1, s2));
    Console.WriteLine("{0} interned: {1}", s1,
                      String.IsNullOrEmpty(String.IsInterned(s1)) ? "No" : "Yes");
    
    String suffix = "A";
    String s3 = "String" + suffix;
    String s4 = "String" + suffix;
    Console.WriteLine("s3 = s4: {0}", Object.ReferenceEquals(s3, s4));
    Console.WriteLine("{0} interned: {1}", s3,
                      String.IsNullOrEmpty(String.IsInterned(s3)) ? "No" : "Yes");
    
    // The example displays the following output:
    //       s1 = s2: True
    //       String1 interned: Yes
    //       s3 = s4: False
    //       StringA interned: No
    
    open System
    
    let s1 = "String1"
    let s2 = "String1"
    printfn $"s1 = s2: {Object.ReferenceEquals(s1, s2)}"
    printfn $"""{s1} interned: {if String.IsNullOrEmpty(String.IsInterned s1) then "No" else "Yes"}"""
    
    let suffix = "A"
    let s3 = "String" + suffix
    let s4 = "String" + suffix
    printfn $"s3 = s4: {Object.ReferenceEquals(s3, s4)}"
    printfn $"""{s3} interned: {if String.IsNullOrEmpty(String.IsInterned s3) then "No" else "Yes"}"""
    
    // The example displays the following output:
    //       s1 = s2: True
    //       String1 interned: Yes
    //       s3 = s4: False
    //       StringA interned: No
    
    Module Example
       Public Sub Main()
          Dim s1 As String = "String1"
          Dim s2 As String = "String1"
          Console.WriteLine("s1 = s2: {0}", Object.ReferenceEquals(s1, s2))
          Console.WriteLine("{0} interned: {1}", s1, 
                            If(String.IsNullOrEmpty(String.IsInterned(s1)), "No", "Yes"))
    
          Dim suffix As String = "A"
          Dim s3 = "String" + suffix
          Dim s4 = "String" + suffix
          Console.WriteLine("s3 = s4: {0}", Object.ReferenceEquals(s3, s4))
          Console.WriteLine("{0} interned: {1}", s3, 
                            If(String.IsNullOrEmpty(String.IsInterned(s3)), "No", "Yes"))
       End Sub
    End Module
    ' The example displays the following output:
    '       s1 = s2: True
    '       String1 interned: Yes
    '       s3 = s4: False
    '       StringA interned: No
    

    Pour plus d’informations sur l’interne de chaînes, consultez String.IsInterned.

S’applique à

Voir aussi