C#

BillWoodruff wrote:

But, consider: hard-coded conversion requires design-time "world knowledge" of each Type.

What is desired is a run-time conversion method t

MyType MyProperty { get; set; }

int x = typeof(int).ToEnum<int>("Friday");
// ArgumentException: Type provided must be an Enum.

public static TEnum ToEnum<TEnum>(this Type tenum, string str, bool ignoreCase = false) where TEnum : struct, Enum { ... }
...

WeekDays friday = typeof(WeekDays).ToEnum<WeekDays>("friday");
// Works as expected.

int x = typeof(int).ToEnum<int>("Friday");
// Compiler error: CS0315 
// The type 'int' cannot be used as type parameter 'TEnum' in the generic type or method 'ToEnum<TEnum>(Type, string, bool)'. 
// There is no boxing conversion from 'int' to 'System.Enum'.

enum A { Zero = 0, One = 1, Two = 2, Default = One }
enum B { Zero = 1, One = 2, Two = 4, Default = Two }

B x = typeof(A).ToEnum<B>("Default");
B y = typeof(A).ToEnum<B>("Two");

public static class EnumHelper
{
    public static TEnum ToEnum<TEnum>(string str, bool ignoreCase) where TEnum : struct, Enum { ... }
}
...
WeekDays friday = EnumHelper.ToEnum<WeekDays>("friday");

public static TEnum ToEnum<TEnum>(this TEnum ignored, string str, bool ignoreCase) where TEnum : struct, Enum { ... }
...
WeekDays friday = WeekDays.Monday.ToEnum("friday");

    // Enum Type, string, optional bool => Enum value
public static TEnum ToEnum<TEnum>(this Type tenum, string str, bool ignorecase = false)
    where TEnum : struct, IConvertible
{
    if (! tenum.IsEnum)
        throw new ArgumentException("TEnum must be an Enum type");

    TEnum result;

    // note ignore case parameter
    if (Enum.TryParse<TEnum>(str, ignorecase, out result))
    {
        return result;
    }

    throw new ArgumentException($"{str} is not a valid string for conversion to {tenum.FullName}");
}

Richard Deeming wrote:

However, I'm not too keen on having to pass the enum type twice. It's not clear from the signature which type will be used - the generic type parameter, or the tenum argument.

// Enum Type, string, optional bool => Enum value
public static TEnum ToEnum<TEnum>(this Type tenum, string str, bool ignorecase = false)
    where TEnum : struct, IConvertible
{
    Type returntype = typeof(TEnum);

    if (!returntype.IsEnum)
        throw new ArgumentException("Return Type must be an Enum type");

    if (!tenum.IsEnum)
        throw new ArgumentException("Type parameter must be an Enum type");

    if (tenum != returntype)
        throw new ArgumentException("Type and Return type must be the same");

    TEnum result;

    // note ignore case parameter
    if (Enum.TryParse<TEnum>(str, ignorecase, out result))
    {
        return result;
    }

    throw new ArgumentException($"{str} is not a valid string for conversion to {tenum.FullName}");
}

public static TEnum ToEnum<TEnum>(this Type tenum, string str, bool ignoreCase = false)
    where TEnum : struct, Enum
{
    #if DEBUG
    
    if (tenum != typeof(TEnum))
        throw new ArgumentException("Type {tenum.FullName} does not match return type {typeof(TEnum).FullName}");
    
    #endif
    
    if (Enum.TryParse<TEnum>(str, ignoreCase, out TEnum result))
    {
        return result;
    }
    
    throw new ArgumentException($"'{str}' is not a valid string for conversion to {typeof(TEnum).FullName}");
}

// sample call
var econverter = WeekDays.Default.MakeConverter<WeekDays>();

WeekDays wkd = econverter("monday", false);

public static Func<string, bool, TEnum> MakeConverter<TEnum>(this Enum tenum)
    where TEnum : struct, IConvertible
{ 
    Type returntype = typeof(TEnum);

    if (!returntype.IsEnum)
        throw new ArgumentException("Return type must be an Enum type");

    Type argtype = tenum.GetType();

    if (! argtype.IsEnum)
        throw new ArgumentException("Type parameter must be an Enum type");

    if (argtype != returntype)
        throw new ArgumentException("Type and Return type must be the same");

    Func<string, bool, TEnum> xFunc = null;

    try
    {
        xFunc = (string str, bool ignorecase) =>
        {
            TEnum result;

            // note ignore case parameter
            if (Enum.TryParse<TEnum>(str, ignorecase, out result))
            {
                return result;
            }

            throw new ArgumentException(
                $"{str} is not a valid string for conversion to {typeof(TEnum).FullName}");
        };
    }
    catch (Exception ex)
    {
        throw new TypeInitializationException(typeof(TEnum).FullName, ex.InnerException);
    }

    return xFunc;
}

public static Func<string, bool, TEnum> MakeConverter<TEnum>(this TEnum tenum) ...
var econverter = WeekDays.Default.MakeConverter();

public static Func<string, bool, TEnum> MakeConverter<TEnum>(this TEnum tenum)
    where TEnum : struct, Enum
{
    return (str, ignoreCase) =>
    {
        if (Enum.TryParse<TEnum>(str, ignoreCase, out var result)) return result;
        throw new ArgumentException($"'{str}' is not a valid string for conversion to {typeof(TEnum).FullName}");
    };
}

return (str, ignoreCase) => Enum.TryParse<TEnum>(str, ignoreCase, out var result) ? result
    : throw new ArgumentException($"'{str}' is not a valid string for conversion to {typeof(TEnum).FullName}");

public static Func<string, bool, TEnum> MakeConverter<TEnum>(this TEnum tenum) where TEnum : struct, Enum
   => (str, ignoreCase) => Enum.TryParse<TEnum>(str, ignoreCase, out var result) ? result
    : throw new ArgumentException($"'{str}' is not a valid string for conversion to {typeof(TEnum).FullName}");

public delegate TEnum EnumConverterDelegate<TEnum>(string str, bool ignoreCase = false) where TEnum : struct, Enum;

public static EnumConverterDelegate<TEnum> MakeConverter<TEnum>(this TEnum value) where TEnum : struct, Enum
   => (str, ignoreCase) => Enum.TryParse<TEnum>(str, ignoreCase, out var result) ? result
    : throw new ArgumentException($"'{str}' is not a valid string for conversion to {typeof(TEnum).FullName}");