通用 class 中未使用的类型参数

Question

Lets say I have classes like the following:

public class Input<T>
{
    // some data here but type T is never directly used

    internal void Foo()
    {
        object output = someOther.CreateOutput(this);
        .....
    }
}
public class Output<T>
{
    public T Value { get; }
    //.....
}
class SomeOtherClass
{
    public Output<T> CreateOutput<T>(Input<T> input)
    {
       // type T is used here
    }
}

Resharper gives a warning here that the generic type parameter T in class Input is not used. However it is used indirectly in Foo().

My question is, can i safely ignore this Resharper warning, or is there some issue with this design? Basically I want an instance of class Input to contain information about type T so that a particular instance of Input is used to create only a particular type of Output. This might also be used to diagnose an error when output creation fails and i have access to an instance of Input (eg inside an exception) and would like to know what kind of output was getting created.

I guess to rephrase the question, is it an acceptable design to have a generic class whose type parameter defines its behavior when passed to other classes, but the type parameter is not used to define any data within this class?

Answer 1

What you wrote is a complicated version of:

public class Input
{
    internal void Foo<T>()
    {
        object output = someOther.CreateOutput<T>(this);
        .....
    }
}
public class Output<T>
{
    public T Value { get; }
    //.....
}
class SomeOtherClass
{
    public Output<T> CreateOutput<T>(Input input)
    {
       // type T is used here
    }
}

Since your Input class does not carry any information related to T there is no reason for it to be generic. What you wrote is not technically incorrect, but you're introducing an artificial restriction that a given input can only be Foo d for the concrete T it was constructed with. Artificial, since nothing in the data that Input carries depends on T in any way.

Is this bad? Dunno, did you intend it to be that way? If the constraint created this way is what you want, then suppress the warning. If it is not then change the design. That's why it's a warning, there's a good chance someone would write this unknowingly.

Answer 2

I guess to rephrase the question, is it an acceptable design to have a generic class whose type parameter defines its behavior when passed to other classes, but the type parameter is not used to define any data within this class?

I would say this should probably be fine. It is difficult to tell without more details about your particular use case since the CreateOutput method is not shown.

I have done similar things to ensure types are explicit. For example Id<T> wrapper around a Guid to help ensure Id<Orange> is not passed into a method expecting an Id<Apple> .

you might also consider storing the type as a property rather than a generic type parameter. Ie

public class Input
{ 
     private Type myType;

This might make it easier to forward the type to CreateOutput without having to make all as many methods generic, and this can have benefits and downsides depending on how you use it.

Resharper warnings are nice to have, but I would worry to much about them. I would be more concerned about actual compiler warnings.