Reflection problem in C#
What about "dynamic"?
object a = 10;
object b = 0.5f;
dynamic c = (dynamic)a * (dynamic)b;
object result = c;
This will "just work", even when a and b are more complex types with custom multiplication operators, because the CLR will do at runtime what the normal compiler would have done at compile-time. It will even optimize it for you during the first invocation. However, I have never used Unity and have no idea if that feature of C# is supported.
The alternatives would be to either re-implement C#'s entire type system or to restrict your scripts to a few well-known type and do a switch on these. Do you really intend to use any types besides float, int and enums in these scripts?
if (someObject is float)
{
float value = (float)someObject;
// do stuff with it.
}
else if (someObject is YourEnumType)
{
YourEnumType value = (YourEnumType)someObject;
// do stuff with it.
}
Or a Dictionary<Type,Action<object>>:
table[typeof(float)] = FunctionFloat;
table[typeof(YourEnumType)] = FunctionYourEnumType;
void FunctionFloat(object o)
{
var value = (float)o;
// do stuff
}
void FunctionYourEnumType(object o)
{
var value = (YourEnumType)o;
// do stuff
}
And call it with:
table[someObject.GetType()](someObject);
Obviously this gets out of hand quite quickly.
To expand on ferrous' reply, I would probably just convert all your values to a common type (Single, Double, etc.) for the purpose of performing calculations, then then convert the result back to the proper result type when finished.
You could use generic methods for arithmetic operators such as those provided by MiscUtil (http://www.yoda.arachsys.com/csharp/miscutil/usage/genericoperators.html), invoking, for example, Multiply<T>(T, T) through reflection.
However, that seems a bit overkill. Is there any reason you can't just cast the stat value from object to float when you're performing the arithmetic?
Is there any reason you can't just cast the stat value from object to float when you're performing the arithmetic?
I cannot because I would not know the actual type of the stat that has been read in.
Dictionary<Type,Action<object>>:
table[typeof(float)] = FunctionFloat;
table[typeof(YourEnumType)] = FunctionYourEnumType;
void FunctionFloat(object o)
{
var value = (float)o;
// do stuff
}
void FunctionYourEnumType(object o)
{
var value = (YourEnumType)o;
// do stuff
}
And call it with:
table[someObject.GetType()](someObject);
This should work for me. I have int, float and 3 types of enums among all my stats so it should be manageable.
Even Jeff's suggestion should work for me.
Multiply<T>(T, T) through reflection.
I need to get down to the board and find out which one seems better. Will post solution soon. Thanks a lot guys.
This is how I did it in the end. Comments and suggestions are welcome as usual. :)