Generic unboxing of boxed value types

Question

I have a generic function that is constrained to struct. My inputs are boxed ("objects"). Is it possible to unbox the value at runtime to avoid having to check for each possible type and do the casts manually?

See the above example:

   public struct MyStruct
    {
        public int Value;
    }

    public void Foo<T>(T test)
        where T : struct
    {
        // do stuff
    }

    public void TestFunc()
    {
        object o = new MyStruct() { Value = 100 }; // o is always a value type

        Foo(o);
    }

In the example, I know that o must be a struct (however, it does not need to be MyStruct ...). Is there a way to call Foo without tons of boilerplate code to check for every possible struct type?

Thank you.

Answer 1

No; you're using object, which is (by definition) not a struct/value type. Why are you intentionally boxing the value in this way?

Answer 2

The whole point of using generics is to avoid situations like this.

When you actually "close" the generic with a type of struct, you eliminate the need for runtime type checking: ie.

Foo<MyStruct>(MyStruct test);

Your implementation of Foo, can safely assume that it's dealing with a struct.

Answer 3

(Marked as CW because you can't pass an instance of ValueType to a generic requiring a struct, but it might be helpful for others who come across this question).

---

Instead of declaring o as an object, you can use a type of System.ValueType, which can only be assigned struct values; you cannot store an object in a ValueType.

However, I'm honestly not sure if that does anything in terms of (un)boxing. Note that ECMA-334 11.1.1 says:

System.ValueType is not itself a value-type. Rather, it is a class-type from which all value-types are automatically derived.

Answer 4

.NET Generics are implemented in a manner that allows value types as a generic type parameter without incurring any boxing/unboxing overhead. Because your're casting to object before calling Foo you don't take advantage of that, in fact you're not even taking advantage of generics at all.

The whole point of using generics in the first place is to replace the "object-idiom". I think you're missing the concept here. Whatever type T happens to be, it is available at run-time and because you constrained it to struct guaranteed to be a struct type.

Your TestFunc could be written like this without problem:

public void TestFunc()
{
    MyStruct o = new MyStruct() { Value = 100 }; // o is always a value type

    Foo<MyStruct>(o);
}

Looking at Foo, it would look like this in your example:

public void Foo<T>(T test)
    where T : struct
{
    T copy = test; // T == MyStruct
}

EDIT:

Ok, since the OP clarified what he wants to call the generic method but doesn't know the type of his struct (it's just object). The easiest way to call your generic method with the correct type parameter is to use a little reflection.

public void TestFunc()
{
    object o = new DateTime();

    MethodInfo method = this.GetType().GetMethod("Foo");
    MethodInfo generic = method.MakeGenericMethod(o.GetType());
    generic.Invoke(this, new object[] {o});


}
public void Foo<T>(T test)
    where T : struct
{
    T copy = test; // T == DateTime
}

Answer 5

I dont know exactly what you are trying to archieve, but you could pass a delegate/lambda to unbox the value, and select some value in the struct you are interested in:

(Updated this code snippet after slurmomatics comment)

public void Foo<TValue>(object test, Func<object, TValue> ValueSelector)
           where TValue : struct
{
    TValue value = ValueSelector(test);

    // do stuff with 'value'
}

public void TestFunc()
{
    object o = new MyStruct() { Value = 100 };

    // Do the unboxing in the lambda.
    // Additionally you can also select some 
    // value, if you need to, like in this example
    Foo(o, x => ((MyStruct)x).Value);
}

Update:

Then do this:

public static void Foo<TUnboxed>(object test)
                     where TUnboxed : struct
{
    try
    {
        TUnboxed unboxed = (TUnboxed)test;
    }
    catch (InvalidCastException ex)
    {
        // handle the exception or re-throw it...
        throw ex;
    }

    // do stuff with 'unboxed'
}

public void TestFunc()
{
    // box an int
    object o = 100;

    // Now call foo, letting it unbox the int.
    // Note that the generic type can not be infered
    // but has to be explicitly given, and has to match the 
    // boxed type, or throws an `InvalidCastException`
    Foo<int>(o);
}