# Object.ReferenceEquals(Object, Object) Método

## Definição

Determina se as instâncias de Object especificadas são a mesma instância.

``````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``

#### Parâmetros

objA
Object

O primeiro objeto a ser comparado.

objB
Object

O segundo objeto a ser comparado.

#### Retornos

Boolean

`true` se `objA` for a mesma instância que `objB` ou se ambos forem null; caso contrário, `false`.

## Exemplos

O exemplo a seguir usa ReferenceEquals para determinar se dois objetos são da mesma instância.

``````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
'
``````

## Comentários

Ao contrário do Equals método e do operador de igualdade, o ReferenceEquals método não pode ser substituído. Por isso, se você quiser testar duas referências de objeto quanto à igualdade e não tiver certeza sobre a implementação do `Equals` método, poderá chamar o ReferenceEquals método.

No entanto, o valor retornado do ReferenceEquals método pode parecer anômômal nestes dois cenários:

• Ao comparar tipos de valor. Se `objA` e `objB` são tipos de valor, eles são em caixa antes de serem passados para o ReferenceEquals método. Isso significa que, se ambos `objA` e `objB` representarem a mesma instância de um tipo de valor, o ReferenceEquals método, no entanto, retornará `false`, como mostra o exemplo a seguir.

``````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
``````

Para obter informações sobre tipos de valores de boxe, consulte Boxing e Unboxing.

• Ao comparar cadeias de caracteres. Se `objA` e `objB` forem cadeias de caracteres, o ReferenceEquals método retornará `true` se a cadeia de caracteres for internada. Ele não executa um teste para igualdade de valor. No exemplo a seguir, `s1` e `s2` são iguais porque são duas instâncias de uma única cadeia de caracteres internada. No entanto, `s3` e `s4` não são iguais, pois embora tenham valores de cadeia de caracteres idênticos, essa cadeia de caracteres não está internada.

``````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
``````

Para obter mais informações sobre a internação de cadeia de caracteres, consulte String.IsInterned.