Question

As everybody knows using virtual keyword for a method in a class allows us to override it in its derived sub-class. However, method still has to stick to the same signature e.g. return value, argument and etc.

Question: in C#, how can I can override the signature as well? is this possible?

Thanks.

Answer 1

It is not possible. You can create an overload, though, if you need it.

Edit

To make my case against new, please consider the case where you have a base object, and one that inherits from it. By placing new before the method of which you’re attempting to “change” the method signature, you’re actually wasting four key strokes.

public class Base {
    public string Foo () { return null; }
}

public class Inherited : Base {
    public new int Foo () { return 0; }
}

Now, Inherited has two methods:

public string Foo () { return null; }
public int Foo () { return 0; }

You are not actually changing the method signature. Thus, the new keyword isn’t even needed. You will get the same effect without it:

public class Inherited : Base {
    public int Foo () { return 0; }
}

The use of new is to override a non-virtual member of a base class:

public class Base { 
    public string Foo () { return null; }
}

public class Inherited : Base {
    public new string Foo () { return "Something else..."; }
}

But you will run into issues with this if you don’t pay attention to this subtlety. With virtual you get a virtual look-up table that will map your functions to the correct call. With new, you will not. If you pass in Inherited where a Base object is required (this will work, of course), the Base class’s Foo() will be called! Not, the Inherited “override” of Foo().

This is not the same behavior as overriding a virtual member.

public static class MyClass {
    public string MyMethod (Base @base) {
        return @base.Foo ();
    }
}

[Test]
public void then_it_should_return_non_null () {
    var obj = new Inherited ();
    var result = MyClass.MyMethod(obj);  // obj will get upcasted to Base
    Assert.That (result, Is.EqualTo(obj.Foo ())); // Assert fails!
}

[Test]
public void inherited_should_return_correct_value ()
{
    var obj = new Inherited ();
    var result = obj.Foo ();  // will access the "new" method, hiding Base's implementation
    Assert.That (result, Is.Not.Null);  // Assert passes! 
}