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

[no name] 19-Aug-21 10:35am

What is the problem?

dj4400 19-Aug-21 10:46am

The snippet doesnt work :)

[no name] 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

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

C# pass an enum type to a function

3 solutions

Solution 2

Solution 1

Solution 3

Add your solution here

Preview 0

Existing Members

...or Join us