CODEWITHSUNDEEP
c#reflectionenums
Valamas
Valamas

Reputation: 24729

Converting to Enum using type variable

Part of my software is using reflection. The issue I am having is that while I can get the type of the property, I cannot convert the string value using the Type from the PropertyInfo. This is the reason why i am using t in the sample code.

The below code demonstrates the issue with the error message as a code comment. The syntax error is on the t. how can I fix this problem? thanks

class Program
{
    static void Main(string[] args)
    {
        Type t = typeof(Letters);

        Letters letter = "A".ToEnum<t>(); //-- Type or namespace expected.
    }
}

public enum Letters { A, B, C }

//-- This is a copy of the EmunHelper functions from our tools library.
public static class EnumExt
{
    public static T ToEnum<T>(this string @string)
    {
        int tryInt;
        if (Int32.TryParse(@string, out tryInt)) return tryInt.ToEnum<T>();
        return (T)Enum.Parse(typeof(T), @string);
    }
    public static T ToEnum<T>(this int @int)
    {
        return (T)Enum.ToObject(typeof(T), @int);
    }
}

Solution:

The following works because when the value is set using reflection, the actual type of Enum is accepted. Where myObject.Letter = result is not.

Type t = currentProperty.PropertyType;
Enum result = Enum.Parse(t, @string) as Enum;
ReflectionHelper.SetProperty(entity, "LetterPropertyName", result);

Thank you all for your help.

Upvotes: 4

Views: 3385

Answers (4)

Kevin Stricker
Kevin Stricker

Reputation: 17388

Enum.Parse(t, @string) as Enum;

That accomplishes the same thing as the solution you posted.

Upvotes: 5

Antoine Trouve
Antoine Trouve

Reputation: 1273

I think your question can be understood in two ways: i) you want to fix a syntax error ii) you need a working implementation for the function you provide

For i), I would suggest you to change:

Letters letter = "A".ToEnum<t>()

into

Letters letter = "A".ToEnum<Letters>()

because generics are solved at compile time, hence you cannot use variables as parameters.

For ii), you may change the way you provide the type argument, from "generic" argument to "normal" argument (as proposed by Jeff Mercado). By doing so the prototype of your function becomes:

public static T ToEnum(this string @string, Type t)

I conclude with two remarks:

  • reflection is VERY slow to my experience. I once wrote an assembly parser making extensive use of reflection on enums for register names. It used to run for minutes (which used to make VS debugger complain about non-responsiveness) when an equivalent version without any reflection used to execute in less than 10 seconds.

  • as Jeff Mercado pointed out, I cannot see any good reason for you to use the same vocable for type names and variable names

Upvotes: 1

Jeff Mercado
Jeff Mercado

Reputation: 134841

To be able to call a generic method, the type must be known at compile time. Your use is invalid syntax.

To be able to call your method, you'll have to use reflection to get a reference to the correct generic function so you may call it.

public static object ToEnum(this string s, Type type)
{
    var eeType = typeof(EnumExt);
    var method = eeType.GetMethod("ToEnum", new[] { typeof(string) })
                       .MakeGenericMethod(type);
    return method.Invoke(null, new[] { s });
}

Then you could call it:

Letters letter = (Letters)"A".ToEnum(t);

p.s., I strongly urge you to change your variable names to something else. Just because you can name your variables as keywords, doesn't mean that you should.

Upvotes: 4

Jeff Ogata
Jeff Ogata

Reputation: 57783

I'm not an expert with reflection, but this works:

static void Main(string[] args)
{
    Type t = typeof(Letters);

    MethodInfo info = typeof(EnumExt).GetMethod("ToEnum", new Type[] { typeof(string) });
    var method = info.MakeGenericMethod(new Type[] { t });
    var result = (Letters)method.Invoke(null, new [] { "A" });            

    Console.ReadLine();
}

Upvotes: 2

Related Questions