Friend Shared Function ConvertOrDefault(Of T As {Structure, IConvertible})(convertFrom As Object, ignoreCase As Boolean) As T
        Dim retVal As T
        If Not GetType(T).IsEnum Then
            Throw New ArgumentException("Type must be enum")
        ElseIf convertFrom Is Nothing OrElse Not TypeOf convertFrom Is String Then
            Return New T
        ElseIf [Enum].TryParse(convertFrom.ToString(), ignoreCase, retVal) Then
            Return retVal
        Else
            Return New T
        End If
End Function

Friend Shared Function Convert(Of T)(value as Object) As T
    If GetType(T).IsEnum Then
         Return Enums.ConvertOrDefault(Of T)(value, True)
    Else : return DirectCast(value, T)
    End If
End Function

Type argument 'T' does not inherit from or implement the constraint type 'System.IConvertible'
Type argument 'T' does not satisfy the 'Structure' constraint for type parameter 'T'

Dim type As Type = GetType(T)

If type.IsEnum Then
    Select Case type.Name
        Case "EnumTypeOne"
            Return DirectCast(DirectCast(Enums.ConvertOrDefault(Of EnumTypeOne)(value, True), Object), T)
         ' ...

Dim id as Byte() = Convert(dataReader("id_column"))
Dim something as SomeEnum = Convert(dataReader("somethingCol"))
'...

Friend Shared Function ConvertOrDefault(Of T As{New}) convertFrom As Object, ignoreCase As Boolean) As T
    If Not GetType(T).IsEnum Then
        Throw New ArgumentException("Type must be enum")
    ElseIf convertFrom Is Nothing OrElse Not TypeOf convertFrom Is String Then
        Return New T
    End If
    Try
        Return CType([Enum].Parse(GetType(T), convertFrom.ToString(), ignoreCase), T)
    Catch ex As Exception
    End Try

    ' default
    Return New T
End Function

Friend Shared Function Convert(Of T)(value As Object) As T
   If GetType(T).IsEnum Then
      Return ConvertOrDefault(Of T)(value, True)
   Else
      Return DirectCast(value, T)
   End If
End Function

Friend Shared Function ConvertOrDefault(Of TEnum)(convertFrom As Object, ignoreCase As Boolean) As TEnum
   ' Since this function only excepts Enum types, declaring the return value
   ' will initialize it to zero.
   Dim retVal As TEnum
   Dim typeTEnum As System.Type = GetType(TEnum)
   If typeTEnum.IsEnum Then
      Dim convertFromString As String = TryCast(convertFrom, String)
      If convertFrom IsNot Nothing AndAlso convertFromString IsNot Nothing Then
         Try
            retVal = DirectCast(System.Enum.Parse(typeTEnum, convertFromString), TEnum)
         Catch ex As ArgumentNullException
            ' eat it
         Catch ex As ArgumentException
            ' eat it
         Catch ex As OverflowException
            ' eat it
         End Try
      End If
   Else
      Throw New ArgumentException("Type must be enum")
   End If
   Return retVal
End Function

public class BoolEnum
{
    private static Dictionary<bool, BoolEnum>   allValuesByNaturalValue = new Dictionary<bool, BoolEnum>();
    private static Dictionary<string, BoolEnum> allValuesByTextValue    = new Dictionary<string, BoolEnum>();
    private static Dictionary<int, BoolEnum>    allValuesByInteger      = new Dictionary<int, BoolEnum>();

    private string boolText;
    private int    integerValue;
    private bool   naturalValue;

    public static readonly BoolEnum True  = new BoolEnum(true, "Is True", 1);
    public static readonly BoolEnum False = new BoolEnum(false, "Is False", 0);

    private BoolEnum(bool naturalValue, string boolText, int integerValue)
    {
        this.naturalValue = naturalValue;
        this.boolText     = boolText;
        this.integerValue = integerValue;
        allValuesByNaturalValue.Add(naturalValue, this);
        allValuesByTextValue.Add(boolText, this);
        allValuesByInteger.Add(integerValue, this);
    }

    public static BoolEnum TrySelect(bool naturalValue, BoolEnum defaultValue)
    {
        BoolEnum returnValue;
        if (allValuesByNaturalValue.TryGetValue(naturalValue, out returnValue)) return returnValue;
        return defaultValue;
    }

    public static BoolEnum TrySelect(string boolText, BoolEnum defaultValue)
    {
        BoolEnum returnValue;
        if (allValuesByTextValue.TryGetValue(boolText, out returnValue)) return returnValue;
        return defaultValue;
    }

    public static BoolEnum TrySelect(int integerValue, BoolEnum defaultValue)
    {
        BoolEnum returnValue;
        if (allValuesByInteger.TryGetValue(integerValue, out returnValue)) return returnValue;
        return defaultValue;
    }

    public static implicit operator bool(BoolEnum boolEnum)
    {
        return boolEnum != null ? boolEnum.naturalValue : false;
    }

    public static implicit operator string(BoolEnum boolEnum)
    {
        return boolEnum != null ? boolEnum.boolText : "Is False";
    }

    public static implicit operator int(BoolEnum boolEnum)
    {
        return boolEnum != null ? boolEnum.integerValue : 0;
    }

    public bool   NaturalValue { get { return this.naturalValue; } }
    public string BoolText     { get { return this.boolText; } }
    public int    IntegerValue { get { return this.integerValue; } }

    public static IReadOnlyCollection<BoolEnum> AllValues        { get { return allValuesByNaturalValue.Values.ToList().AsReadOnly(); } }
    public static IReadOnlyCollection<bool>     AllBooleanValues { get { return allValuesByNaturalValue.Keys.ToList().AsReadOnly(); } }
    public static IReadOnlyCollection<string>   AllTextValues    { get { return allValuesByTextValue.Keys.ToList().AsReadOnly(); } }
    public static IReadOnlyCollection<int>      AllIntegerValues { get { return allValuesByInteger.Keys.ToList().AsReadOnly(); } }

    public override string ToString()
    {
        return "[" + this.naturalValue.ToString() + ", "" + this.boolText.ToString() + "", " + this.integerValue.ToString() + "]";
    }

}

Public Class BoolEnum
    Private Shared allValuesByNaturalValue As New Dictionary(Of Boolean, BoolEnum)()
    Private Shared allValuesByTextValue As New Dictionary(Of String, BoolEnum)()
    Private Shared allValuesByInteger As New Dictionary(Of Integer, BoolEnum)()

    Private m_boolText As String
    Private m_integerValue As Integer
    Private m_naturalValue As Boolean

    Public Shared ReadOnly [True] As New BoolEnum(True, "Is True", 1)
    Public Shared ReadOnly [False] As New BoolEnum(False, "Is False", 0)

    Private Sub New(naturalValue As Boolean, boolText As String, integerValue As Integer)
        Me.m_naturalValue = naturalValue
        Me.m_boolText = boolText
        Me.m_integerValue = integerValue
        allValuesByNaturalValue.Add(naturalValue, Me)
        allValuesByTextValue.Add(boolText, Me)
        allValuesByInteger.Add(integerValue, Me)
    End Sub

    Public Shared Function TrySelect(naturalValue As Boolean, defaultValue As BoolEnum) As BoolEnum
        Dim returnValue As BoolEnum
        If allValuesByNaturalValue.TryGetValue(naturalValue, returnValue) Then
            Return returnValue
        End If
        Return defaultValue
    End Function

    Public Shared Function TrySelect(boolText As String, defaultValue As BoolEnum) As BoolEnum
        Dim returnValue As BoolEnum
        If allValuesByTextValue.TryGetValue(boolText, returnValue) Then
            Return returnValue
        End If
        Return defaultValue
    End Function

    Public Shared Function TrySelect(integerValue As Integer, defaultValue As BoolEnum) As BoolEnum
        Dim returnValue As BoolEnum
        If allValuesByInteger.TryGetValue(integerValue, returnValue) Then
            Return returnValue
        End If
        Return defaultValue
    End Function

    Public Shared Widening Operator CType(boolEnum As BoolEnum) As Boolean
        Return If(boolEnum IsNot Nothing, boolEnum.naturalValue, False)
    End Operator

    Public Shared Widening Operator CType(boolEnum As BoolEnum) As String
        Return If(boolEnum IsNot Nothing, boolEnum.boolText, "Is False")
    End Operator

    Public Shared Widening Operator CType(boolEnum As BoolEnum) As Integer
        Return If(boolEnum IsNot Nothing, boolEnum.integerValue, 0)
    End Operator

    Public ReadOnly Property NaturalValue() As Boolean
        Get
            Return Me.m_naturalValue
        End Get
    End Property
    Public ReadOnly Property BoolText() As String
        Get
            Return Me.m_boolText
        End Get
    End Property
    Public ReadOnly Property IntegerValue() As Integer
        Get
            Return Me.m_integerValue
        End Get
    End Property

    Public Shared ReadOnly Property AllValues() As IReadOnlyCollection(Of BoolEnum)
        Get
            Return allValuesByNaturalValue.Values.ToList().AsReadOnly()
        End Get
    End Property
    Public Shared ReadOnly Property AllBooleanValues() As IReadOnlyCollection(Of Boolean)
        Get
            Return allValuesByNaturalValue.Keys.ToList().AsReadOnly()
        End Get
    End Property
    Public Shared ReadOnly Property AllTextValues() As IReadOnlyCollection(Of String)
        Get
            Return allValuesByTextValue.Keys.ToList().AsReadOnly()
        End Get
    End Property
    Public Shared ReadOnly Property AllIntegerValues() As IReadOnlyCollection(Of Integer)
        Get
            Return allValuesByInteger.Keys.ToList().AsReadOnly()
        End Get
    End Property

    Public Overrides Function ToString() As String
        Return "[" + Me.m_naturalValue.ToString() + ", """ + Me.m_boolText.ToString() + """, " + Me.m_integerValue.ToString() + "]"
    End Function

End Class

Friend Function Convert(Of T)(convertFrom As Object, Optional ignoreCase As Boolean = True) As T
    If convertFrom Is Nothing Then Return Nothing
    If GetType(T) = GetType(DBNull) Then Return Nothing
    If GetType(T).IsEnum Then
        Return CTypeDynamic(Of T)([Enum].Parse(GetType(T), convertFrom.ToString(), ignoreCase))
    Else
        Return CTypeDynamic(Of T)(convertFrom)
    End If
End Function

<Extension()>
    Public Function ToEnum(Of TEnum)(ByVal value As String, ByVal defaultValue As TEnum) As TEnum
        If String.IsNullOrEmpty(value) Then
            Return defaultValue
        End If

        Return [Enum].Parse(GetType(TEnum), value, True)
    End Function