Converting to Enum using type variable

Question

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.

What's the general problem you're trying to solve? It looks like you're trying to cast to a type not known at compile time. Is that correct? — Kevin Stricker
– Kevin Stricker, Commented Oct 5, 2011 at 3:48
That is correct! I am in the process of trying to shoehorn the given answers into my solution. — Valamas
– Valamas, Commented Oct 5, 2011 at 3:56
I noticed both solutions end with an explicit cast. If you could do that "A".ToEnum<Letters>(); would be just fine. That being said, I think it may not be possible (not sure whether dynamics in C# 4 make it possible). If you could explain why you're trying to do this, there may be a better approach to the problem. — Kevin Stricker
– Kevin Stricker, Commented Oct 5, 2011 at 4:05
I am currently trying to return the value as Enum now. I think that will work. The console appeared to work, just seeing how my software will handle it. — Valamas
– Valamas, Commented Oct 5, 2011 at 4:07
Would Enum.Parse(t, @string) as Enum; not accomplish the same thing? — Kevin Stricker
– Kevin Stricker, Commented Oct 5, 2011 at 15:42

Kevin Stricker · Accepted Answer · 2011-10-05 21:49:53Z

5

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

That accomplishes the same thing as the solution you posted.

answered Oct 5, 2011 at 21:49

Kevin Stricker

17.4k5 gold badges49 silver badges72 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Valamas Over a year ago

There is nothing like driving around all day only to find your destination was next door. Thank you so much.

Jeff Mercado · Accepted Answer · 2011-10-05 03:36:48Z

4

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.

answered Oct 5, 2011 at 3:36

Jeff Mercado

136k34 gold badges268 silver badges282 bronze badges

1 Comment

Valamas Over a year ago

Agree with removing @string and have enacted the change. Function was copied from the net as usual. Thanks.

Jeff Ogata · Accepted Answer · 2011-10-05 03:36:35Z

2

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();
}

answered Oct 5, 2011 at 3:36

Jeff Ogata

58k20 gold badges117 silver badges128 bronze badges

Comments

Antoine Trouve · Accepted Answer · 2011-10-05 04:45:43Z

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

Collectives™ on Stack Overflow

Converting to Enum using type variable

4 Answers 4

1 Comment

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related