使用双泛型的C＃类：当两个泛型相同时，仅给出一个？

Question

So I'm struggling a bit with a certain piece of code, and I'm not sure if there's a better way to handle it - but it feels like it's possible.

Let's say I have a class:

public class DeviceProcessingResult<TSucceeded, TFailed>
    {
        public TSucceeded[] Succeeded { get; set; }

        public TFailed[] Failed { get; set; }

        public DeviceProcessingResult(IEnumerable<TSucceeded> succeeded, IEnumerable<TFailed> failed)
        {
            Succeeded = succeeded.Cast<TSucceeded>().ToArray();
            Failed = failed.Cast<TFailed>().ToArray();
        }
    }

I use this class to create objects that contain an Array of object that have succeeded in their processing, and an Array of objects that have failed. This type of object gets used on various parts of the code we currently have. In one of those places, we would use it like this:

return new DeviceProcessingResult<DeviceResponse, DeviceModel>(succeeded, failed);

Since we need to return the results, and the type of object that gets returned when processing has succeeded contains other/more info than the model that gets returned when processing has failed.

Now this is currently the only piece of code that has 2 different types of objects, as all other code looks like this:

return new DeviceProcessingResult<DeviceModel, DeviceModel>(succeeded, failed);

So as you see, we use 2 times the same object.

The point of this question now is: Is it possible to do something like

return new DeviceProcessingResult<DeviceModel>(succeeded, failed);

Since it's gonna be the same things there anyways? Or is there no (good) way around this and should we always specify both types?

Answer 1

The easy solution would be to simply inherit this class like this:

public class DeviceProcessingResult<T> : DeviceProcessingResult<T, T>
{
    public DeviceProcessingResult(IEnumerable<T> succeeded, IEnumerable<T> failed)
        : base(succeeded, failed)
    { /*Nothing more to do here...*/ }
}

public class DeviceProcessingResult<T, T1>
{
    public T[] Succeeded { get; set; }
    public T1[] Failed { get; set; }

    public DeviceProcessingResult(IEnumerable<T> succeeded, IEnumerable<T1> failed)
    {
        Succeeded = succeeded.ToArray();
        Failed = failed.ToArray();
    }
}

Answer 2

To do this you would need to have another intermediate class, for example:

public class public class DeviceProcessingResult<TDeviceModel> 
    : DeviceProcessingResult<TDeviceModel, TDeviceModel>
{
}

Alternatively, you can rely on the compiler inferring the types based on the parameters:

return new DeviceProcessingResult(succeeded, failed)

Answer 3

What about:

    public class DeviceProcessingResult<TFailed> : DeviceProcessingResult< DeviceResponse, TFailed>
    {
        public DeviceProcessingResult(IEnumerable<DeviceResponse> succeeded, IEnumerable<TFailed> failed) : base(succeeded, failed)
        {
        }
    }