Can a base-class method return this, even in a derived class?

Question

I'd like to be able to have a method in a C# base class, callable on objects of several derived classes, that returns the object itself, and have the CLR know what type the object really is - i.e., the appropriate derived type. Can someone suggest a way to do it? Other, of course, than return type covariance, which C# doesn't have.

Something like this, except that Method()'s return type should be the type of the derived class, not the base:

public abstract class Base { 
    public Base Method() { return this; }
}

public class Derived1: Base { ... }

public class Derived2: Base { ... }

public class Main {
    public static int Main() {
        Derived1 d1 = new Derived1();
        Derived1 x = d1.Method();
        Derived2 d2 = new Derived2();
        Derived2 y = d2.Method();
    }
}

I can only think of two ways to make this work, and I don't like either of them:

1. Cast the result of Method() to the expected type (e.g., Derived1 x = (Derived) d1.Method();). But casts are the tool of the Devil, and besides, the intent of the method is to return a Derived1 or Derived2 or ..., not a Base.

2. Declare Method() as abstract in the base and implement it separately in each derived class. But that runs exactly counter to the idea of factoring out common methods. The Method() would be identical in each case except for its return type.

Answer 1

Okay, I misread the question. I'd thought the OP did want to override the method. Apparently not, so generics are the way forward:

public abstract class Base<T> where T : Base<T>
{
    public T Method()
    {
        return (T) (object) this;
    }
}

public class Derived1 : Base<Derived1>
{
}

There's still a cast, but that's unfortunately unavoidable as far as I'm aware. You'd almost certainly want to check it in the constructor, too:

public Base()
{
    if (this as T == null)
    {
        // throw some exception
    }
}

It's ugly, but it'll work... and the ugliness is confined to the base class.

---

Original answer

One way to do it would be to put Method into a generic interface and implement it explicitly:

public interface IFoo<T> {
    T Method();
}

public abstract class Base : IFoo<Base>
{
    Base IFoo<Base>.Method()
    {
        return this;
    }
}

public class Derived1 : IFoo<Derived1>
{
    public Derived1 Method()
    {
        // If you need to call the base version, you'll
        // need ((IFoo<Base>)this).Method()
        return this;
    }
}

It's not nice, but it would work... where possible, I think I'd try to avoid needing it, to be honest. (And yes, I've come across similar situations when implementing protocol buffers. It's annoying.)

Answer 2

I believe you can use the dynamic keyword on C# 4.0:

public abstract class Base { 
    public dynamic Method() { return this; }
}

public class Derived1: Base { ... }

public class Derived2: Base { ... }

public class Main {
    public static int Main() {
        Derived1 d1 = new Derived1();
        Derived1 x = d1.Method();
        Console.WriteLine(x.GetType()); // outputs Derived1
        Derived2 d2 = new Derived2();
        Derived2 y = d2.Method();
        Console.WriteLine(y.GetType()); // outputs Derived2
    }
}

Answer 3

Seems there are many ways to accomplish this: Also possible to do with Extension Methods.
Which has the benefit of allowing you to do with classes you don't own, and you only have to do it once, not once for each derived/base class. This will do exactly what you are looking for.

public class BaseClass
{

}
public class DerivedClass: BaseClass
{

}
public static class BaseClassHelpers
{
    public static T Method<T>(this T b) where T : BaseClass
    {
        return b;
    }
}    

in use:

DerivedClass d = new DerivedClass();
DerivedClass dd = d.Method();
Console.WriteLine(dd.GetType());

result in console:

DerivedClass

Answer 4

Also with generics but without the interface:

public abstract class Base<T> where T : Base<T>
{
    public virtual T Method()
    {
        return (T) this;
    }
}

public class Derived1 : Base<Derived1>
{
    public override Derived1 Method()
    {
        return base.Method();
    }
}

public class Derived2: Base<Derived2> { }

public class Program {
public static int Main() {
    Derived1 d1 = new Derived1();
    Derived1 x = d1.Method();
    Derived2 d2 = new Derived2();
    Derived2 y = d2.Method();
    return 0;
}

Answer 5

If your method has parameters of type T, then the explicit generic arguments are not needed.

public class Base
{
    public T Method<T>()where T: Base
    {
        return (T)this;
    }
}

public class Derived1 : Base { }
public class Derived2 : Base { }

Derived1 d1 = new Derived1();
Derived1 x = d1.Method<Derived1>();
Derived2 d2 = new Derived2();
Derived2 y = d2.Method<Derived2>();

Answer 6

This is a solution without casting

public abstract class Base<T> where T : Base<T>
{
    public T Method()
    {
        return ThisDerived;
    }

    // It is worth to do this if you need the "this" of the derived class often in the base class
    protected abstract T ThisDerived { get; }
}

public class Derived1 : Base<Derived1>
{
    protected override Derived1 ThisDerived{ get { return this; } } 
}

public class Derived2 : Base<Derived2>
{
    protected override Derived2 ThisDerived { get { return this; } }
}

Answer 7

There is a very simple way of achieving the desired result with the new keyword and hide-by-signature:

class Base
{
    public virtual Base Method () { return this ; }
}

class Derived1: Base 
{ 
    public new Derived1 Method () { return this ; }
}

class Derived2: Base
{
    public new Derived2 Method () { return this ; }
}