Free-ebooks-library - Bahar Ali Khan

public class RichTextBox : TextBox, IUndoable
{
public new void Undo() { Console.WriteLine ("RichTextBox.Undo"); }
}
Calling the reimplemented member through the interface calls the subclass’s
implementation:
RichTextBox r = new RichTextBox();
r.Undo(); // RichTextBox.Undo Case 1
((IUndoable)r).Undo(); // RichTextBox.Undo Case 2
Assuming the same RichTextBox definition, suppose that TextBox implemented Undo
implicitly:
public class TextBox : IUndoable
{
public void Undo() { Console.WriteLine ("TextBox.Undo"); }
}
This would give us another way to call Undo, which would “break” the system, as
shown in Case 3:
RichTextBox r = new RichTextBox();
r.Undo(); // RichTextBox.Undo Case 1
((IUndoable)r).Undo(); // RichTextBox.Undo Case 2
((TextBox)r).Undo(); // TextBox.Undo Case 3
Case 3 shows that reimplementation hijacking is effective only when a member is
called through the interface and not through the base class. This is usually undesirable,
as it can mean inconsistent semantics. Reimplementation is most appropriate
as a strategy for overriding explicitly implemented interface members.
Alternatives to interface reimplementation
Even with explicit member implementation, interface reimplementation is problematic
for a couple of reasons:
• The subclass has no way to call the base class method.
• The base class author may not anticipate that a method be reimplemented and
may not allow for the potential consequences.
Reimplementation can be a good last resort when subclassing hasn’t been anticipated.
A better option, however, is to design a base class such that reimplementation
will never be required. There are two ways to achieve this:
• When implicitly implementing a member, mark it virtual if appropriate.
• When explicitly implementing a member, use the following pattern if you anticipate
that subclasses might need to override any logic:
public class TextBox : IUndoable
{
void IUndoable.Undo() { Undo(); } // Calls method below
protected virtual void Undo() { Console.WriteLine ("TextBox.Undo"); }
}
Interfaces | 95
Creating Types