C# pass an enum type to a function

Question

0.00/5 (No votes)

See more:

Hi,

I want to call Enum.TryParse<tenum> (string value, out TEnum result)

in a function that receives the type of the Enum as a parameter so i can call

the function with any enum type that i have declared in the code

something like that :

C#

void MyFunc(Enum someEnumType, string nameOfEnumValue,  out Enum value)
{
  Type TypeOfEnum = someEnumType.GetType();

  TypeOfEnum ePhaseOfSomeEnumType;

  Enum.TryParse<typeofenum>(nameOfEnumValue, out  ePhaseOfSomeEnumType);

  value = ePhaseOfSomeEnumType;
}

Thanks

What I have tried:

Searching google
Playing with GetType and Enum class

Posted 19-Aug-21 4:32am

dj4400

Updated 20-Aug-21 2:15am

Dave Kreskowiak

v2

Add a Solution

Comments

Richard MacCutchan 19-Aug-21 10:35am

What is the problem?

dj4400 19-Aug-21 10:46am

The snippet doesnt work :)

Richard MacCutchan 19-Aug-21 10:50am

And what exactly does that mean?

PIEBALDconsult 19-Aug-21 12:20pm

You're working too hard.
You might want to have a look at my : https://www.codeproject.com/Articles/23685/Enum-Utilities

MyEnum x ;
LibEnum.TryParse<myenum> ( "Value1" , out x ) ;

BillWoodruff 20-Aug-21 8:32am

The compiler has to somehow get the Type of the Enum: imho, the best way to handle this is to use the generic flavor Enum.TryParse, as shown in my answer below.

Avoid use of reflection if possible !

3 solutions

Solution 1

As far as I know, you can't use Enum.TryParse without knowing the type at compile time - enum's are pretty much syntactic sugar which compile to a value type (integer) and don't have all the "baggage" a full class would have including inheritance (which isn;t allowed for value types at all)

So you can't really use automated systems to do that, but it isn't difficult to do it manually: Enum.GetNames[^] and Enum.GetValues[^] should provide enough data.
Alternatively, you could look at how the system does it: Reference Source[^] but that may just show you why it's not something they felt would be necessary ... :laugh:

It's a little odd to even try to do that though - it's not something I've ever seen the need for!

Posted 19-Aug-21 4:57am

OriginalGriff

Comments

BillWoodruff 20-Aug-21 8:28am

me curious: do you think the facility for using generic flavor TryParse, as shown in my answer here, meets the needs of the OP ?

OriginalGriff 20-Aug-21 8:38am

I'm not convinced he knows what he wants / is doing - he seems to want to pass an enum type name as a string at runtime and get a suitable output from that.

Which is a silly idea to my mind.

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard Deeming · Accepted Answer · 2021-08-19T05:01:00

Unfortunately, there isn't a non-generic overload of TryParse. Which means you'll need to use some reflection to invoke the method.

For example:

C#

public static class EnumExtensions
{
    public static bool TryParse(Type enumType, string value, bool ignoreCase, out Enum result)
    {
        if (enumType is null) throw new ArgumentNullException(nameof(enumType));
        if (!enumType.IsEnum) throw new ArgumentException("Not an enum type.", nameof(enumType));
        
        MethodInfo baseMethod = typeof(Enum).GetMethods(BindingFlags.Public | BindingFlags.Static)
            .Where(m => m.Name == nameof(Enum.TryParse))
            .First(m => m.GetParameters().Length == 3);
        
        MethodInfo realMethod = baseMethod.MakeGenericMethod(enumType);
        object[] parameters = new object[] { value, ignoreCase, null };
        bool parsed = (bool)realMethod.Invoke(null, parameters);
        result = parsed ? (Enum)parameters[2] : default;
        return parsed;
    }
    
    public static bool TryParse(Type enumType, string value, out Enum result)
    {
        if (enumType is null) throw new ArgumentNullException(nameof(enumType));
        if (!enumType.IsEnum) throw new ArgumentException("Not an enum type.", nameof(enumType));
        
        MethodInfo baseMethod = typeof(Enum).GetMethods(BindingFlags.Public | BindingFlags.Static)
            .Where(m => m.Name == nameof(Enum.TryParse))
            .First(m => m.GetParameters().Length == 2);
        
        MethodInfo realMethod = baseMethod.MakeGenericMethod(enumType);
        object[] parameters = new object[] { value, null };
        bool parsed = (bool)realMethod.Invoke(null, parameters);
        result = parsed ? (Enum)parameters[1] : default;
        return parsed;
    }
}

BillWoodruff · Accepted Answer · 2021-08-20T02:15:00

I've been using this without any problems:

public static class EnumExtensions
{
    public static T GetEnumValue<T>(this string valuename)
        where T : struct
    {
        T value = default(T);
    
        if(Enum.TryParse<T>(valuename, out value))
        {
            return value;
        }
    
        throw new ArgumentException($"{valuename} failed to convert to {typeof(T)}");
    }
}

Sample usage:

public enum TestEnum
{
    abcm = 4,
    def = 19
}

// in some method
TestEnum val1 = "def".GetEnumValue<TestEnum>();

// force an error
TestEnum val2 = "xxx".GetEnumValue<TestEnum>();

Note: now that there is an Enum constraint, why can't we use that here instead of 'struct ?

C# pass an enum type to a function

3 solutions

Solution 2

Solution 1

Solution 3

Add your solution here

Preview 0