Aynı nesneyi sararken sarmalayıcılar == operatörünü kullanarak eşit karşılaştırmalı mıdır?

Bir geliştiricinin XML'den öznitelikleri kolayca ayrıştırmasını sağlayan XML öğeleri için bir sarıcı yazıyorum. Sarıcı, sarılmakta olan nesneden başka bir duruma sahip değil.

Ben ==operatör için bir aşırı yük içeren aşağıdaki uygulamayı (bu örnek için basitleştirilmiş) düşünüyorum .

class XmlWrapper
{
    protected readonly XElement _element;

    public XmlWrapper(XElement element)
    {
        _element = element;
    }

    public string NameAttribute
    {
        get
        {
            //Get the value of the name attribute
        }
        set
        {
            //Set the value of the name attribute
        }
    }

    public override bool Equals(object other)
    {
        var o = other as XmlWrapper;
        if (o == null) return false;
        return _element.Equals(o._element);
    }

    public override int GetHashCode()
    {
        return _element.GetHashCode();
    }

    static public bool operator == (XmlWrapper lhs, XmlWrapper rhs)
    {
        if (ReferenceEquals(lhs, null) && ReferenceEquals(rhs, null)) return true;
        if (ReferenceEquals(lhs, null) || ReferenceEquals(rhs, null)) return false;

        return lhs._element == rhs._element;
    }

    static public bool operator != (XmlWrapper lhs, XmlWrapper rhs)
    {
        return !(lhs == rhs);
    }
}

İdiyomatik c # anladığım gibi ==, Equals()yöntem değer eşitliği için operatör referans eşitliği içindir. Ancak bu durumda, "değer" yalnızca kaydırılmakta olan nesneye bir referanstır. Bu yüzden ne geleneksel veya deyim c # için net değilim.

Örneğin, bu kodda ...

var underlyingElement = new XElement("Foo");
var a = new XmlWrapper(underlyingElement);
var b = new XmlWrapper(underlyingElement);

a.NameAttribute = "Hello";
b.NameAttribute = "World";

if (a == b)
{
    Console.WriteLine("The wrappers a and b are the same.");
}

.... "a ve b sarmalayıcıları aynı mı?" Yoksa bu garip, yani en az şaşkınlık ilkesini ihlal eder mi?

Sarılı referansın XElementdeğişmez olması XmlWrappernedeniyle, aynı öğeyi saran iki örneği arasında harici olarak gözlemlenebilir bir fark yoktur , bu nedenle ==bu gerçeği yansıtmak için aşırı yüklenmenin anlamı vardır .

İstemci kodu neredeyse her zaman mantıksal eşitliğe önem verir (varsayılan olarak referans türleri için referans eşitliği kullanılarak uygulanır). Öbek üzerinde iki örnek olması, istemcilerin umursamaması gereken bir uygulama detayıdır (ve Object.ReferenceEqualsdoğrudan kullananlar ).

En mantıklı olduğunu düşünüyorsanız

Soru ve cevap geliştirici beklentisi meselesidir , bu teknik bir gereklilik değildir.

EĞER Eğer bir kimliğe sahip ve onun içerikleriyle tamamen tanımlanabilir değil bir sarmalayıcı düşünün, sonra sorunun cevabı evet.

Ancak bu tekrar eden bir sorundur. İki sargı, farklı nesneleri sararken, ancak her iki nesne de aynı içeriğe sahipken eşitlik göstermeli mi?

Cevap kendini tekrarlıyor. EĞER içerik nesneleri hiçbir kişisel kimliğe sahip ve bunun yerine tamamen içeriklerine göre tanımlanır ise içeriklerin nesneleri etkin bir eşitlik sergileyecek sarıcıları. Daha sonra içerik nesnelerini başka bir paketleyiciye sararsanız, bu (ek) paketleyicinin de eşitlik göstermesi gerekir.

Tamamen kaplumbağalar .

Genel ipucu

Varsayılan davranıştan saptığınızda, açıkça belirtilmelidir. Bir geliştirici olarak, iki referans türünün içeriği eşit olsa bile eşitlik göstermeyeceğini umuyorum. Bu davranışı değiştirirseniz, tüm geliştiricilerin bu atipik davranışın farkında olması için açıkça belgelemenizi öneririm.

İdiyomatik c # anladığım gibi ==, Equals()yöntem değer eşitliği için operatör referans eşitliği içindir.

Bu onun varsayılan davranışıdır, ancak bu taşınmaz bir kural değildir. Bu bir konvansiyon meselesidir, ancak konvansiyonlar haklı olduğu yerde değiştirilebilir .

stringburada ==da bir değer eşitliği denetimi (dize stajyerliği olmasa bile!) harika bir örnektir . Neden? Basitçe söylemek gerekirse: dizelerin değer nesneleri gibi davranması çoğu geliştiriciye daha sezgisel geliyor.

Kod tabanınız (veya geliştiricilerinizin yaşamları), paketleyicilerinizin yönetim kurulu genelinde değer eşitliği göstermesini sağlayarak önemli ölçüde basitleştirilebiliyorsa, buna gidin (ancak belgeleyin ).

Asla referans eşitlik kontrollerine ihtiyacınız yoksa (veya işletme alanınız tarafından işe yaramazsa), referans eşitliği kontrolünü korumanın bir anlamı yoktur. Daha sonra geliştirici hatasını önlemek için bir değer eşitliği denetimi ile değiştirmek daha iyidir .
Bununla birlikte, daha sonra çizginin aşağısında referans eşitlik kontrollerine ihtiyaç duymanız gerektiğinin farkında olun, yeniden uygulamak kayda değer bir çaba gerektirebilir.

Temelde dizeleri karşılaştırıyorsunuz, bu yüzden aynı XML içeriğini içeren iki paket eşit olarak kabul edilmezse Şaşırırdım, Eşittir veya == kullanılarak kontrol edilir.

Deyimsel kural, genel olarak referans tipi nesneler için anlamlı olabilir, ancak dizeler deyimsel anlamda özeldir, teknik olarak referans türleri olmalarına rağmen bunları değer olarak kabul etmeniz gerekir.

Wrapper postfix'iniz yine de karışıklık yaratıyor. Temel olarak "XML öğesi değil" der. Sonuçta referans türü olarak mı davranmalıyım? Anlamsal olarak bu bir anlam ifade etmeyecektir. Sınıf XmlContent adlı olsaydı daha az kafam karışırdı. Bu, teknik uygulama ayrıntılarını değil içeriği önemsediğimizi gösterecektir.