This is similar to this question Call overloaded generic method from generic method but it's not the same: in that case, the method returned void, while I need to return the generic type T, so the proposed solution does not work.
I'm implementing a tuple-like class which has generic parameters and accessors for these parameters:
public class MyClass<T1, T2>
{
private readonly T1 _item1;
private readonly T2 _item2;
public MyClass(T1 item1, T2 item2)
{
_item1 = item1;
_item2 = item2;
}
public T1 GetItem(T1 _) => _item1;
public T2 GetItem(T2 _) => _item2;
private T GetItem<T>(T x)
{
throw new ArgumentException();
// return x;
}
public T Get<T>()
{
return GetItem(default(T));
}
}
I would like to use this class like this:
var obj = new MyClass<int, string>(1, "hello");
var a = obj.Get<int>();
var b = obj.Get<string>();
But if I try this, the Generic T GetItem<T>(T x) is always called (the exception is thrown), and not the non-generic implementations.
If I try to access the GetItem method directly, it works as intended:
var obj = new MyClass<int, string>(1, "hello");
var q = obj.GetItem(default(int));
var w = obj.GetItem(default(string));
q and w contain 1 and hello as expected.
Is there a way for me to use this class as I want (using obj.Get<T>)? I want to avoid Item1 Item2 Item3 getters.
But if I try this, the Generic
T GetItem<T>(T x)is always called (the exception is thrown), and not the non-generic implementations.
That's because overload resolution happens at compile-time, and at compile-time, the concrete type of T is unknown.
Is there a way for me to use this class as I want (using
obj.Get<T>)?
Using plain old dynamic type checking, sure:
public class MyClass<T1, T2>
{
private readonly T1 _item1;
private readonly T2 _item2;
public MyClass(T1 item1, T2 item2)
{
_item1 = item1;
_item2 = item2;
}
public T Get<T>()
{
if (typeof(T) == typeof(T1))
{
return (T)(object)_item1;
}
if (typeof(T) == typeof(T2))
{
return (T)(object)_item2;
}
throw new InvalidOperationException();
}
}
The advantage of this solution is that the behavior of the edge cases (T1 == T2, or T matches neither T1 nor T2) is properly defined and easy to see.
Alternatively, you can use the dynamic "hack" used in the question you linked to, you just need to cast the result to T: return (T)GetItem((dynamic)default(T));, here's a working fiddle.
But this is just plain ugly, please don't do that. Compare the fiddle with the version above and try to judge honestly which one is easier to read, easier to understand, and, thus, easier to maintain.
Collected from the Internet
Please contact [email protected] to delete if infringement.
Comments