在不知道泛型类型的情况下转换为泛型类型

Question

I have an interface ( ValueControl ) using a generic type and have another class ( ValueControlHandler ) which uses an instance of that interface. Now when I create ValueControlHandler in CreateHandler I need to pass the generic types. Now TCtrl is "easy" (I just use ValueControl but I don't know how to set TVal .

Public Interface ValueControl(Of T)
    ReadOnly Property Value As T
End Interface

Public Interface CtrlChanges
    Function HasChanges() As Boolean
End Interface

Friend Class ValueControlHandler(Of TCtrl As ValueControl(Of TVal), TVal)
    Implements CtrlChanges
    ....
End Class

Private Function DummyCreateHandler(Of TVal)(ByVal ctrl as ValueControl(Of TVal)) As CtrlChanges
    Return New ValueControlHandler(Of ValueControl(Of TVal), TVal)(ctrl)
End Function

Private Function CreateHandler(ByVal ctrl As Object) As CtrlChanges
    If TypeOf ctrl Is ValueControl(Of ValueControl(Of ???), ???) Then  ' <!--- Problem here
        Return New ValueControlHandler(Of ValueControl(Of ???), ???)(ctrl)  ' <!--- Problem here
    ElseIf Typeof ctrl Is AnotherType Then
        Return New AnotherCtrlChanges(....)
    Else
        Return Nothing
    End If
End Function

The tricky part is, that I don't even need to know the type as I'm interested in the CtrlChanges part. Is the only solution to drop the generics and default to Object ? I also tried it with DummyCreateHandler but then I still don't know how to check the type and it didn't really help much for the second call.

Here is the complete class from ValueControlHandler if this helps:

Friend Class ValueControlHandler(Of TCtrl As ValueControl(Of TVal), TVal)
    Implements CtrlChanges

    Protected ReadOnly Ctrl As TCtrl

    Protected ReadOnly Val As TVal

    Public Sub New(ByVal Ctrl As TCtrl)
        Me.Ctrl = Ctrl
        Me.Val = CurrentValue
    End Sub

    Public ReadOnly Property CurrentValue As TVal
        Get
            Return Ctrl.Value
        End Get
    End Property

    Public Overridable Function HasChanges() As Boolean Implements CtrlChanges.HasChanges
        Return CType(CurrentValue, Object) <> Val
    End Function
End Class

Answer 1

Have you considered including a factory method as part of ValueControl ? (Side note, the "I" prefix on interfaces is a standard convention)

(Note, my VB.NET is a bit rusty, hopefully you can get the intent of this approach despite my typos):

Public Interface IValueControl(Of T)
   ReadOnly Property Value As T
   ValueControlHandler(Of T) CreateValueControlHandler(ctrl As IValueControl(Of T))
End Interface

Then each control can generate it's own ValueControlHandler :

Public Class MyControl Inherits Textbox Implements IValueControl(Of String)

   Public Function ValueControlHandler(Of T) CreateValueControlHandler()

      Return New ValueControlHandler(Of MyControl, String)(Me)

   End Fucntion

End Class

Answer 2

CreateHandler could take the type to parameterize on as an argument. Then, you would do something like this:

Private Function CreateHandler(ByVal ctrl As Object, ByVal TVal as Type) As CtrlChanges

    '...
    Dim genericValueControlType = GetType(ValueControl(Of )) 'Intentionally blank, the type is the unspecialized generic type.
    Dim specificValueControlType = genericValueControlType.MakeGenericType(TVal)

    'Untested, might need to be Is instead of =
    If ctrl.GetType() = specificValueControlType Then
        Dim genericHandlerType = GetType(ValueControlHandler(Of ) 'Untested, might need a comma to indicate two missing type params
        Dim specificHandlerType = genericHandlerType.MakeGenericType(specificValueControlType, TVal)
        Dim retval = specificHandlerType.GetConstructor({}).Invoke({})
        Return CType(retval, CtrlChanges)
    End If
End Function

Depending on the level of detail in your factory routine, you could also consider building up based on reflection and/or one or more conventions. Unfortunately, the lack of static interface methods in .NET means that convention is the only way to invoke a logically- Shared routine across different implementations of an interface (that, or making something that is logically Shared a per-instance method anyway so that it can be put on an interface; I've done both and neither is completely satisfactory).