> A class inherits all interface implementations provided by its base
classes.
>
> Without explicitly re-implementing an interface, a derived class cannot in
> any way alter the interface mappings it inherits from its base classes.

For
> example, in the declarations
>
> interface IControl
> {
> void Paint();
> }
> class Control: IControl
> {
> public void Paint() {...}
> }
> class TextBox: Control
> {
> new public void Paint() {...}
> }
>
> the Paint method in TextBox hides the Paint method in Control, but it does
> not alter the mapping of Control.Paint onto IControl.Paint, and calls to
> Paint through class instances and interface instances will have the

following
> effects
>
> Control c = new Control();
> TextBox t = new TextBox();
> IControl ic = c;
> IControl it = t;
> c.Paint(); // invokes Control.Paint();
> t.Paint(); // invokes TextBox.Paint();
> ic.Paint(); // invokes Control.Paint();
> it.Paint(); // invokes Control.Paint();
>
> However, when an interface method is mapped onto a virtual method in a

class,
> it is possible for derived classes to override the virtual method and

alter
> the implementation of the interface. For example, rewriting the

declarations
> above to
>
> interface IControl
> {
> void Paint();
> }
> class Control: IControl
> {
> public virtual void Paint() {...}
> }
> class TextBox: Control
> {
> public override void Paint() {...}
> }
> the following effects will now be observed
>
> Control c = new Control();
> TextBox t = new TextBox();
> IControl ic = c;
> IControl it = t;
> c.Paint(); // invokes Control.Paint();
> t.Paint(); // invokes TextBox.Paint();
> ic.Paint(); // invokes Control.Paint();
> it.Paint(); // invokes TextBox.Paint();
>
> Since explicit interface member implementations cannot be declared

virtual,
> it is not possible to override an explicit interface member

implementation.
> It is however perfectly valid for an explicit interface member

implementation
> to call another method, and that other method can be declared virtual to
> allow derived classes to override it. For example
>
> interface IControl
> {
> void Paint();
> }
> class Control: IControl
> {
> void IControl.Paint() { PaintControl(); }
> protected virtual void PaintControl() {...}
> }
> class TextBox: Control
> {
> protected override void PaintControl() {...}
> }
>
>