C#

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

using System;

namespace EnumConvert
{
    public enum MyEnum
    {
        None = 0,
        First,
        Second,
        Third,
        Last
    }

    public static class EnumExtensions
    {
        public static Tenum ToEnum<Tenum>(this Tenum theEnum, string str, bool ignoreCase = false)
            where Tenum : struct, Enum
        {
            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}");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyEnum myEnum = new MyEnum();

            var none = myEnum.ToEnum("None");
            Console.WriteLine($"'None' results in {none} with a value of {(int)none}");

            var first = myEnum.ToEnum("First");
            Console.WriteLine($"'First' results in {first} with a value of {(int)first}");

            var last = myEnum.ToEnum("last", true);
            Console.WriteLine($"'last' results in {last} with a value of {(int)last}");

            try
            {
                last = myEnum.ToEnum("last", false);
                Console.WriteLine($"'last' results in {last} with a value of {(int)last}");
            }
            catch
            {
                Console.WriteLine("Error trying to convert 'last' to MyEnum");
            }

            try
            {
                var random = myEnum.ToEnum("Random", true);
                Console.WriteLine($"'Random' results in {random} with a value of {(int)random}");
            }
            catch
            {
                Console.WriteLine("Error trying to convert 'random' to MyEnum");
            }

        }
    }
}

MyEnum myEnum = new MyEnum();

Matthew Dennis wrote:

C#

MyEnum myEnum = new MyEnum();

MyEnum myEnum = default; // C# 7.1+

// Or:
MyEnum myEnum = 0;

// Or:
var myEnum = default(MyEnum);

using System;

namespace EnumConvert
{
    public enum MyEnum
    {
        None = 0,
        First,
        Second,
        Third,
        Last
    }

    public static class EnumExtensions
    {
        public static Tenum ToEnum<Tenum>(this string str, bool ignoreCase = false)
            where Tenum : struct, Enum
        {
            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}");
        }
    }

   class Program
    {
        static void Main(string[] args)
        {
            var none =("None").ToEnum<MyEnum>();
            Console.WriteLine($"'None' results in {none} with a value of {(int)none}");

            var first = "First".ToEnum<MyEnum>();
            Console.WriteLine($"'First' results in {first} with a value of {(int)first}");

            var last = "last".ToEnum<MyEnum>(true); 
            Console.WriteLine($"'last' results in {last} with a value of {(int)last}");

            try
            {
                last = "last".ToEnum<MyEnum>(false);
                Console.WriteLine($"'last' results in {last} with a value of {(int)last}");
            }
            catch
            {
                Console.WriteLine("Error trying to convert 'last' to MyEnum");
            }

            try
            {
                var random = "Random".ToEnum<MyEnum>(true);
                Console.WriteLine($"'Random' results in {random} with a value of {(int)random}");
            }
            catch
            {
                Console.WriteLine("Error trying to convert 'random' to MyEnum");
            }

        }
    }
}

Quote:

imho, you do pay a price for either one: the first example extends string; I think extending basic types is generally a mistake. In the second example, you pay a price for the rather awkward structure of the calling format.

BillWoodruff wrote:

1. where T : struct, Enum ... fails without 'struct, and 'struct must precede 'Enum

BillWoodruff wrote:

2. 'default cannot be used directly ... WeekDays.Default throws an error

 public static T IntToEnum<T>(int value, T defaultValue)
 {
     T enumValue = (Enum.IsDefined(typeof(T), value)) ? (T)(object)value : defaultValue;
     return enumValue;
 }

 public static T StringToEnum<T>(string value, T defaultValue)
 {
     T enumValue = (Enum.IsDefined(typeof(T), value)) ? (T)Enum.Parse(typeof(T), value) : defaultValue;
     return enumValue;
}