Force subclasses of an interface to implement ToString [C#]

Question

Say I have an interface IFoo, and I want all subclasses of IFoo to override Object's ToString method. Is this possible?

Simply adding the method signature to IFoo as such doesn't work:

interface IFoo
{
    String ToString();
}

...since all the subclasses extend Object and provide an implementation that way, so the compiler doesn't complain about it. Any suggestions?

Edit: fixed title

Answer 1

I don't believe you can do it with an interface. You can use an abstract base class though:

public abstract class Base
{
    public abstract override string ToString(); 
}

Answer 2

abstract class Foo
{
    public override abstract string ToString();
}

class Bar : Foo
{
    // need to override ToString()
}

Answer 3

I don't think you can force any sub-class to override any of the base-class's virtual methods unless those methods are abstract.

Answer 4

Implementing an interface method implicitly seals the method (as well as overriding it). So, unless you tell it otherwise, the first implementation of an interface ends the override chain in C#.

Essential .NET

Abstract class = your friend

Check this question

Answer 5

You can override in a subclass but there are some gotchas.

    
interface IFoo
{
    void Bar();
}

class Foo : IFoo
{
    public void Bar()
    {
        //Do some stuff
    }
}

class SubFoo : Foo, IFoo
{
    void IFoo.Bar()
    {
        //Do some other stuff
    }
}

class UseFoo
{
    Foo foo;
    SubFoo subFoo;
    IFoo iFoo;

    UseFoo()
    {
        foo.Bar();
        subFoo.Bar(); //CAUTION: Actually calls foo.Bar();
        iFoo = subFoo;
        iFoo.Bar(); //Calls the overridden version of Bar();
    }
}

credit goes to this guy:

http://www.williamcaputo.com/archives/000138.html

good luck!

Answer 6

Jon & Andrew: That abstract trick is really useful; I had no idea you could end the chain by declaring it as abstract. Cheers :)

In the past when I've required that ToString() be overriden in derived classes, I've always used a pattern like the following:

public abstract class BaseClass
{
    public abstract string ToStringImpl();

    public override string ToString()
    {
        return ToStringImpl();
    }    
}