C＃：重写抽象方法的更好方法，在该方法中，被重写的方法将忽略其某些参数

Question

So, I have an abstract class with a method with 3 parameters, which is overridden in a particular base class.

The abstract method is in the following form:

internal override void SummonJonSkeet(string dumbQuestion, int a, int b)
{
    // Call upon Jon Skeet and his followers to correct my ignorant ways. 
}

In most of the subclasses that implement the given method, all 3 parameters are needed to produce a correct result. However, in this particular instance the only valid values of a and b are 0.

Currently what I am doing is just ignoring their values within the method, and providing a warning in the documentation comment for the method, but this just feels...wrong.

There has to be a better way than forcing a programmer (well, me) to insert junk arguments into the method call just to make the compiler happy, while still requiring the use of these arguments for every other subclass that implements the method.

Maybe this is a dumb question, since my solution works, but it just feels like it's not a smart way to do it. For example, some idiot (probably me) shouldn't be able to come along and cause an unhandled exception by inserting some ridiculous number into an argument that isn't used in the first place.

Answer 1

Another option (given that you mentioned the parameters are really coordinates that may or may not be used) could be just to make the values nullable with default values of null.

internal override void SummonJonSkeet(string dumbQuestion, int? a = null, int? b = null)

You'd have to match the abstract definition as well, but this shows the approach.

This allows the sub-classes to call SummonJonSkeet("my question") or SummonJonSkeet("my question", 1, 2) based on its implementation. The sub-classes that expect the values can then check a.HasValue or a != null to throw errors when values does not exist for parameters when expected to have values. To get the primitive value, just call a.Value .

Answer 2

You might consider an approach that creates a class for the parameters (assuming you might need these parameters to have specific names or various types).

public class BasicQuestionParameters { public string DumbQuestion {get;set;} }

Then, you could modify your abstract class to be generic that requires a type that is of the type BasicQuestionParameters.

public abstract class SummonBase<TParams> where TParams : BasicQuestionParameters
{
     abstract void SummonJobSkeet(TParams question);
}

Now you can implement your sub-classes to define what type of question parameters it needs as long as they start from your basic one.

public class MySummonBasic : SummonBase<BasicQuestionParameters>
{
    internal override void SummonJonSkeet(BasicQuestionParameters question) {...}
}

The benefit here is now you can add additional parameters by inheritance:

public class HardQuestionParameters : BasicQuestionParameters
{
    public int A {get;set;}
    public int B {get;set;}
}

And then use this in only the sub-classes that need the more refined type:

public class HardSummon : SummonBase<HardQuestionParameters>
{
     internal override void SummonJonSkeet(HardQuestionParameters question) {...}
}

Now each sub-class has exactly the parameters it needs and nothing more or less. This approach has the added benefit that if you find a set of sub-classes need an additional parameter (C), you can do it by only needing to update the sub-classes that need to use the additional parameter. No need to touch all the other sub-classes that just need the basic parameters.

Answer 3

If you do not use the int parameters, you can change the signature of the virtual method to:

internal override void SummonJonSkeet(string dumbQuestion, params int[] values)
{
    //...
}

In this way you can call it with only the string parameter, like this:

this.SummonJonSkeet(dumbQuestion);