Как проверить равенство ссылок (идентичность) (руководство по программированию на C#)

Для поддержки сравнения на идентичность ссылок в ваших типах не требуется реализовать какую-либо пользовательскую логику. Эта функция предоставляется для всех типов статическим методом Object.ReferenceEquals.

В следующем примере показано, как определить, имеют ли две переменные равенство ссылок, что означает, что они ссылаются на один и тот же объект в памяти.

В примере также показано, почему Object.ReferenceEquals всегда возвращает false для типов значений. Это связано с упаковкой , которая создает отдельные экземпляры объектов для каждого аргумента типа значения. Кроме того, не следует использовать ReferenceEquals для определения равенства строк.

Пример

using System.Text;

namespace TestReferenceEquality
{
    struct TestStruct
    {
        public int Num { get; private set; }
        public string Name { get; private set; }

        public TestStruct(int i, string s) : this()
        {
            Num = i;
            Name = s;
        }
    }

    class TestClass
    {
        public int Num { get; set; }
        public string? Name { get; set; }
    }

    class Program
    {
        static void Main()
        {
            // Demonstrate reference equality with reference types.
            #region ReferenceTypes

            // Create two reference type instances that have identical values.
            TestClass tcA = new TestClass() { Num = 1, Name = "New TestClass" };
            TestClass tcB = new TestClass() { Num = 1, Name = "New TestClass" };

            Console.WriteLine($"ReferenceEquals(tcA, tcB) = {Object.ReferenceEquals(tcA, tcB)}"); // false

            // After assignment, tcB and tcA refer to the same object.
            // They now have reference equality.
            tcB = tcA;
            Console.WriteLine($"After assignment: ReferenceEquals(tcA, tcB) = {Object.ReferenceEquals(tcA, tcB)}"); // true

            // Changes made to tcA are reflected in tcB. Therefore, objects
            // that have reference equality also have value equality.
            tcA.Num = 42;
            tcA.Name = "TestClass 42";
            Console.WriteLine($"tcB.Name = {tcB.Name} tcB.Num: {tcB.Num}");
            #endregion

            // Demonstrate that two value type instances never have reference equality.
            #region ValueTypes

            TestStruct tsC = new TestStruct( 1, "TestStruct 1");

            // Value types are boxed into separate objects when passed to ReferenceEquals.
            // Even if the same variable is used twice, boxing ensures they are different instances.
            TestStruct tsD = tsC;
            Console.WriteLine($"After assignment: ReferenceEquals(tsC, tsD) = {Object.ReferenceEquals(tsC, tsD)}"); // false
            #endregion

            #region stringRefEquality
            // Constant strings within the same assembly are always interned by the runtime.
            // This means they are stored in the same location in memory. Therefore,
            // the two strings have reference equality although no assignment takes place.
            string strA = "Hello world!";
            string strB = "Hello world!";
            Console.WriteLine($"ReferenceEquals(strA, strB) = {Object.ReferenceEquals(strA, strB)}"); // true

            // After a new string is assigned to strA, strA and strB
            // are no longer interned and no longer have reference equality.
            strA = "Goodbye world!";
            Console.WriteLine($"strA = '{strA}' strB = '{strB}'");

            Console.WriteLine("After strA changes, ReferenceEquals(strA, strB) = {0}",
                            Object.ReferenceEquals(strA, strB)); // false

            // A string that is created at runtime cannot be interned.
            StringBuilder sb = new StringBuilder("Hello world!");
            string stringC = sb.ToString();
            // False:
            Console.WriteLine($"ReferenceEquals(stringC, strB) = {Object.ReferenceEquals(stringC, strB)}");

            // The string class overloads the == operator to perform an equality comparison.
            Console.WriteLine($"stringC == strB = {stringC == strB}"); // true

            #endregion

            // Keep the console open in debug mode.
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    }
}

/* Output:
    ReferenceEquals(tcA, tcB) = False
    After assignment: ReferenceEquals(tcA, tcB) = True
    tcB.Name = TestClass 42 tcB.Num: 42
    After assignment: ReferenceEquals(tsC, tsD) = False
    ReferenceEquals(strA, strB) = True
    strA = "Goodbye world!" strB = "Hello world!"
    After strA changes, ReferenceEquals(strA, strB) = False
    ReferenceEquals(stringC, strB) = False
    stringC == strB = True
*/

Реализация Equals в универсальном базовом классе System.Object также выполняет проверку равенства ссылок, но не стоит использовать это, так как, если класс случайно переопределит метод, результаты могут не соответствовать ожиданиям. То же самое верно для операторов == и !=. По умолчанию, при работе с ссылочными типами, == и != выполняют проверку равенства ссылок. Однако производные классы могут перегружать оператор для проверки равенства значений. Чтобы свести к минимуму потенциал ошибки, рекомендуется всегда использовать ReferenceEquals, когда необходимо определить, имеют ли два объекта равенство ссылок.

Строки констант в одной сборке всегда интернируются средой выполнения. То есть поддерживается только один экземпляр каждой уникальной литеральной строки. Однако среда выполнения не гарантирует, что строки, созданные во время выполнения, интернируются, и не гарантирует, что две одинаковые строковые константы в разных сборках интернируются.

Заметка

ReferenceEquals возвращает false для типов значений из-за упаковки , так как каждый аргумент независимо упаковывается в отдельный объект.

См. также

• сравнения равенства