C# Wrappers – Should == Operator Compare Wrappers of the Same Object?

cnetoperators

I'm writing a wrapper for XML elements that allows a developer to easily parse attributes from the XML. The wrapper has no state other than the object being wrapped.

I am considering the following implementation (simplified for this example) which includes an overload for the == operator.

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);
    }
}

As I understand idiomatic c#, the == operator is for reference equality while the Equals() method is for value equality. But in this case, the "value" is just a reference to the object being wrapped. So I am not clear what is conventional or idiomatic for c#.

For example, in this code…

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.");
}

….should the program output "The wrappers a and b are the same" ? Or would that be odd, i.e. violate the principal of least astonishment?

Best Answer

Since the reference to the wrapped XElement is immutable, there is no externally observable difference between two instances of XmlWrapper that wrap the same element, so it makes sense to overload == to reflect this fact.

Client code almost always cares about logical equality (which, by default, is implemented using reference equality for reference types). The fact that there are two instances on the heap is an implementation detail that clients shouldn't care about (and those that do will use Object.ReferenceEquals directly).

PRESENTER

this class has no dependency on the used GUI library

public class Presenter 
{
    IView view;
    public Presenter(IView view)
    {
        this.view = view;
    }

    public void ValidateInPut(string value)
    {
        if (!String.IsEmptyOrNull(value) && value.Contains("9")) 
        {  
           view.ShowError("The value in the Text box is invalid");
        }
    }
}

ViewInterface

public inteface IView
{
    void ShowError(string message);
}

VIEW

public class Form1:Form, IView
{
    private Presenter presenter;
    public Form1()
    {
         this.presenter = new Presenter(this); // or have a Dependcy Injection Framework do this
    }

    private void txtACNo_Validating(object sender, CancelEventArgs e)
    {
        presenter.ValidateInPut(txtACNo); // validate
    }

    public void IView.ShowError(string message);
    {
        MessageBox.Show(mesage);
    }
}

Rationale

By utilizing your view and presenter the presenter (with all its (busines)logic) becomes easily testable or the view can be replaced by a WebPage without the need to adapt your presenter logic.

Test

public class Test:IView
{
    bool showErrorCalled = false;

    public void Test()
    {  
       var p = new Presenter(this);
       showErrorCalled = false;
       p.ValidateInput("8");
       Test.Assert(showErrrocalled);
    }

    public void IView.ShowError(string message);
    {
        showErrorCalled = true;
    }
}

WebPage

public Default:Page, IView
{
      private Presenter presenter;
      public Default()
      {
          this.presenter = new Presenter(this);
      }

      public Page_Load(object sender, EventArgs e)
      {
          if (IsPostBack)
          {
               presenter.ValidateInput(txtAcNo.Text);
          }
      }

      public void IView.ShowError(string message);
      {
          Error.Text = message;
      }

}

PS

Remember that the cast operator on an object may fail. Your code

var controller = (TextBox)sender;

will only work as long as sender is a TextBox. It is better to check if there is a more generalized type up the hierarchy that still provides you with the needed interface. In your case that could be Control that has a Text property as well. A more defensive approach would be:

var controller = sender as Control; // try to cast, if not return null
if (controller != null) 
{
     // do stuff with controller
}
else
{
    // logging
    Debug.WriteLine("controller is null");
}

Best Answer

Related Solutions

C# Event Programming – Should the ‘e’ Parameter Be Omitted in EventHandler?

C# WinForms – Presenter Accessing the Value in Text Box Using Sender Object