How to override generic method with derived type in c#

Question

I have the following classes:

public interface IService
{
    void ApplyChanges<T>(T parameters) where T : ParamBase;
}

public class ServiceBase : IService
{
    public virtual void ApplyChanges<T>(T parameters) where T : ParamBase
    { }
}
public abstract class Service : ServiceBase
{
    public override void ApplyChanges<T>(T parameters) where T : ParamBase
    {
        Console.WriteLine(parameters.Param2);
        //Apply changes logic here...
    }
}

public abstract class ParamBase
{
    public string Param1 { get; set; }
}

public class ParamA : ParamBase
{
    public string Param2 { get; set; }
}

Here my test main class:

void Main()
{
  var service = new Service();
  var paramA = new ParamA();
  paramA.Param2 = "Test2";
  service.ApplyChanges<ParamA>(paramA);
}

What is wrong with that implementation? How can I access parameters.Param2from the overriden ApplyChanges method in my Service class?

The general idea is that I have a ServiceBase and I want to be able for its derived classes to pass different parameter types to the ApplyChanges method.

Why do you have an implementation of ApplyChanges that doesnt do anything? Is this just in the example? — Domysee, Mar 05 '16 at 13:20
@Domysee yes this is a simplified version of my real application. I just want to figure out the generic inheritance and type casting.. — Adolfo Perez, Mar 05 '16 at 13:20
`Param2` isn't part of `ParamBase` so the generic `T:where ParamBase` doesn't know anything about `Param2`. — freedomn-m, Mar 05 '16 at 13:27
You're not using generics correctly. I suspect you are making a design error. What are you _really_ trying to do? — Benjamin Hodgson, Mar 05 '16 at 13:28
@BenjaminHodgson the general idea is that I have a `ServiceBase` and I want to be able for its derived classes to pass different parameter types to the `ApplyChanges` method. — Adolfo Perez, Mar 05 '16 at 13:29
If you're doing a cast in generic method(which you're basically asking for), you shouldn't be using generics at all. — Sriram Sakthivel, Mar 05 '16 at 13:29

score 7 · Accepted Answer · edited May 23 '17 at 12:02

I'm making a leap here, but it sounds like you intend to have multiple "services", each with an associated parameter type.

Putting a type parameter on the method, as you have done in the example, forces all implementations of that method to be polymorphic. (The technical term for this is higher-rank quantification.)

Instead, you should associate the type parameter with the service itself. This allows a given implementation of the contract to declare which parameter type it's associated with. While you're at it, I wouldn't bother with the base classes or the type bounds.

interface IService<in T>
{
    void ApplyChanges(T param);
}

class Param1
{
    public int X { get; set; }
}
class Service1 : IService<Param1>
{
    public void ApplyChanges(Param1 param)
    {
        param.X = 123;
    }
}

class Param2
{
    public int Y { get; set; }
}
class Service2 : IService<Param2>
{
    public void ApplyChanges(Param2 param)
    {
        param.Y = 456;
    }
}

Domysee · Answer 2 · 2016-03-05T13:35:57.457

You shouldnt impose stronger constraints for method overrides. An overridden method should expand the possible input parameters and reduce the possible outcomes. Otherwise it breaks Liskov Substitution Principle. C# does not allow you to do that.

That said, if you really want it, you could. You won't get compiler warnings in the calling code though. Use that solution if you cannot change the base class.

public class Service<TParam> : Service where TParam : ParamA
{
    public override void ApplyChanges<T>(T parameters)
    {
        Console.WriteLine((parameters as TParam).Param2);
    }
}

A better solution would be to add a type parameter to ServiceBase and IService.

public interface IService<TParam>
   where TParam : ParamBase
{
    void ApplyChanges(TParam parameters);
}

public abstract class ServiceBase<TParam> : IService<TParam>
    where TParam : ParamBase
{
    public virtual void ApplyChanges(TParam parameters)
    { }
}
public class Service : ServiceBase<ParamA>
{
    public override void ApplyChanges(ParamA parameters)
    {
        Console.WriteLine(parameters.Param2);
    }
}

I get this error when doing that: Constraints for override and explicit interface implementation methods are inherited from the base method, so they cannot be specified directly — Adolfo Perez, Mar 05 '16 at 13:15
I agree that my example feels like a code smell and I wouldn't want to force the casting as you suggest. Which other elegant option so I can have a base method which can be passed different derived parameter types? — Adolfo Perez, Mar 05 '16 at 13:30
Thanks for your suggestion this is much better. I'll have to be fair and give the answer to BenjaminHodgson since he posted a very similar example first. — Adolfo Perez, Mar 05 '16 at 13:48

score 0 · Answer 3 · answered Nov 26 '19 at 23:33

Really, instead of replacing the interface's generic type, it is cleaner to use a "Type Guard". I say cleaner because the interface's method signature stays consistent, and really, what's more important than how your interface is used? (Obviously puppies are more important)

Within the method itself, you can make sure that the type is the one desired as such...

public void Method(ParentRequest req){
if(req is ChildRequest request){
//Do logic here
} else {
    throw new Exception($"request is of type {req.GetType().Name} and must be of type ParentRequest");
    }
}

How to override generic method with derived type in c#

3 Answers3

Linked

Related