Initialize a non-generic object with a generic object

Question

Sometimes I do not get those Ts of C# Generics right. I have a generic struct

public struct ValueWithUnit<T>
{
    public ValueWithUnit(T _value, Unit _unit)
    {
        Unit = _unit;
        Value = _value;
    }
    public Unit Unit { get; }
    public T Value { get; }
}

(Unitis an enum, T should be numeric, but there is no constraint available for that purpose).

For WCF I need a non-generic version of that, with T being double. So I thought of:

public struct DoubleValueWithUnit 
{
    public DoubleValueWithUnit(double _value, Unit _unit)
    {
        Unit = _unit;
        Value = _value;
    }
    public DoubleValueWithUnit(ValueWithUnit<T> _valueWithUnit)
    {
        Unit = _valueWithUnit.Unit;
        Value = Convert.ToDouble(_valueWithUnit.Value);
    }
    public Unit Unit { get; set; }
    public double Value { get; set; }
}

But the second constructor does not compile: error CS0246: The type or namespace name 'T' could not be found ... and Convert.ToDouble complains with Cannot resolve method 'ToDouble(T)' Candidates are...

I know I can add a conversion method to the generic class:

    public DoubleValueWithUnit ToDoubleValueWithUnit()
    {
        return new DoubleValueWithUnit(Convert.ToDouble(Value), Unit);
    }

That works. But is there any possibility to add a constructor with a generic parameter to a non-generic class/struct?

Why don't you just use `ValueWithUnit` instead of `DoubleValueWithUnit`? — Maarten, May 30 '17 at 07:08
What you're trying to do [isn't possible](https://stackoverflow.com/questions/700966/generic-type-in-constructor) - however, Maarten's advice is probably the best solution here — Rob, May 30 '17 at 07:12

score 2 · Answer 1 · answered May 30 '17 at 07:17

2

I don't think this constructor should exist at all:

public DoubleValueWithUnit(ValueWithUnit<T> _valueWithUnit)
{
    Unit = _valueWithUnit.Unit;
    Value = Convert.ToDouble(_valueWithUnit.Value);
}

Why do you want to convert a ValueWithUnit<T> to a DoubleValueWithUnit? With some values of T, this does not make sense. How do you convert a BinaryFormatter to double? Or a Form to double? These simply should not be allowed at compile time.

So you either do this:

public DoubleValueWithUnit(ValueWithUnit<double> _valueWithUnit)
{
    Unit = _valueWithUnit.Unit;
    Value = _valueWithUnit.Value;
}

Or remove the constructor all together.

answered May 30 '17 at 07:17

Sweeper

213,210
22
193
313

"Why do you want to convert" - WCF does not cope with generics. "T" is de facto numeric, but there is no `where T : numeric` available. – Bernhard Hiller May 30 '17 at 08:52
@BernhardHiller I see. Then I suggest you to write a constructor for every numeric type. – Sweeper May 30 '17 at 08:54

score 0 · Answer 2 · answered May 30 '17 at 07:13

In the second example, T is simply not defined. So you cannot use T in the context of that struct.

Just remove this constructor:

public DoubleValueWithUnit(ValueWithUnit<T> _valueWithUnit)

Since you would like to convert anything passed to Double, define a constructor taking as input an object. In the constructor try to cast and throw an exception if the object is not convertible.

public DoubleValueWithUnit(object obj, Unit unit)
{
    Unit = unit;
    try
    {
       Value = Convert.ToDouble( obj );
    }
    catch( Exception )
    {
       throw new ArgumentException("Cannot convert to double", nameof(obj) );
    }        
}

Throwing exception in constructor is also not a good idea... Just notifying. — kuskmen, May 30 '17 at 07:17
@kuskmen Contracts work exactly that way. Don't mind. (what you say is not true) — Mauro Sampietro, May 30 '17 at 07:18

score 0 · Answer 3 · answered May 30 '17 at 10:31

My current solution is to have the struct implementing a generic interface which in turn inherits from a non-generic interface:

public struct ValueWithUnit<T> : IValueWithUnit<T> {...}

public interface IValueWithUnit<out T> : IValueWithUnit // where T: number
{
    new T Value { get; }
}
public interface IValueWithUnit
{
    object Value { get; }
    Unit Unit { get; }
}

Now, I can pass a ValueWithUnit<T> into the (modified) constructor:

public DoubleValueWithUnit(IValueWithUnit _valueWithUnit)
{
    Unit = _valueWithUnit.Unit;
    Value = Convert.ToDouble(_valueWithUnit.Value);
}

Still I am not sure if there are better solutions possible.

Initialize a non-generic object with a generic object

3 Answers3