C#

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

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