Testen op referentie gelijkheid (identiteit) (C#-programmeerhandleiding)

U hoeft geen aangepaste logica te implementeren ter ondersteuning van gelijkheidsvergelijkingen in uw typen. Deze functionaliteit wordt geleverd voor alle typen door de statische Object.ReferenceEquals methode.

In het volgende voorbeeld ziet u hoe u kunt bepalen of twee variabelen verwijzen naar gelijkheid, wat betekent dat ze verwijzen naar hetzelfde object in het geheugen.

In het voorbeeld ziet u ook waarom Object.ReferenceEquals altijd wordt geretourneerd false voor waardetypen en waarom u niet moet gebruiken ReferenceEquals om de gelijkheid van tekenreeksen te bepalen.

Opmerking

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) = {0}",
                                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) = {0}",
                                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 = {0} tcB.Num: {1}", tcB.Name, 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 copied on assignment. tsD and tsC have
            // the same values but are not the same object.
            TestStruct tsD = tsC;
            Console.WriteLine("After assignment: ReferenceEquals(tsC, tsD) = {0}",
                                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) = {0}",
                             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 = \"{0}\" strB = \"{1}\"", strA, 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) = {0}",
                            Object.ReferenceEquals(stringC, strB));

            // The string class overloads the == operator to perform an equality comparison.
            Console.WriteLine("stringC == strB = {0}", 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
*/

De implementatie van Equals de System.Object universele basisklasse voert ook een referentie gelijkheidscontrole uit, maar het is het beste om dit niet te gebruiken omdat, als een klasse de methode overschrijft, de resultaten mogelijk niet zijn wat u verwacht. Hetzelfde geldt voor de == en != operators. Wanneer ze werken op referentietypen, is het standaardgedrag van en != het uitvoeren van == een referentie gelijkheidscontrole. Afgeleide klassen kunnen de operator echter overbelasten om een waarde gelijkheidscontrole uit te voeren. Als u het risico op fouten wilt minimaliseren, kunt u het beste altijd gebruiken ReferenceEquals wanneer u moet bepalen of twee objecten verwijzen naar gelijkheid.

Constante tekenreeksen binnen dezelfde assembly worden altijd door de runtime geïnterneerd. Dat wil gezegd, er wordt slechts één exemplaar van elke unieke letterlijke tekenreeks bijgehouden. De runtime garandeert echter niet dat tekenreeksen die tijdens de runtime zijn gemaakt, worden geïnterneerd, en ook niet dat twee gelijke constante tekenreeksen in verschillende assembly's worden geïnterneerd.

Zie ook

• Gelijkheidsvergelijkingen