Runtime import possible? - vb.net

Question

I will try to explain the problem as clearly as possible. I am not sure if what I need is possible but expect that there must be some solution to this. I wont be able to put in actual code here but will add whatever is needed to explain the problem.
Initially we had two separate classes as defined below.
Imports QMember48
Public Class Member48
Public Function ProcessInfo(reqctx as Member48.RequestContext, memid as String)
'Code here
End Function
Public Function UpdateInfo(partner as Member48.Partner, memid as String)
'Code here
End Function
'Other methods and functions come here
End Class
Imports QMember50
Public Class Member50
Public Function ProcessInfo(reqctx as Member50.RequestContext, memid as String)
'Code here
End Function
Public Function UpdateInfo(partner as Member50.Partner, memid as String)
'Code here
End Function
'Other methods and functions come here
End Class
Basically these two classes have common methods and functions but the references are different.
We next decided to create a factory pattern to get the objects of these classes based on some input parameter.
Our current implementation of code is like this:
'Base class definition
Imports QMember48
Public MustInherit Class Member
Public MustOverride Function ProcessInfo(reqctx as Member48.RequestContext, memid as String)
Public MustOverride Function UpdateInfo(partner as Member48.Partner, memid as String)
End Class
'Factory
Public Module MemFactory
Function GetMember(val as string) as Member
'Do some processing here
If val = "500" return new Member50() else return new Member48()
End Function
End Module
The problem is that the base class refers to Member48 and when the factory generates an object for Member50, the reference to Member48 still remains. This needs to be corrected somehow in the base class. If an object of Member50 is needed, there should not be any reference to Member48. But again how do we define the base class without any hardcoded import of Member48/50 ?
Is there any way to resolve this issue? If more details are needed, I can add later.
Thanks.

Answer 1

The problem is that both Members don't have any method in common. There may be two methods with the same name, but those methods have different signatures. You can neither pass a Member48.RequestContext to a Member50, nor can you pass a Member50.RequestContext to a Member48. That's why inheritance can't applied here reasonably. A common base class of both members would be empty.
You could use a generic base class as follows:
MustInherit Class Member(Of TRequest, TPartner)
Public MustOverride Function ProcessInfo(reqctx As TRequest, memid As String)
Public MustOverride Function UpdateInfo(partner As TPartner, memid As String)
End Class
Class Member48
Inherits Member(Of QMember48.RequestContext, QMember48.Partner)
'...
End Class
Class Member50
Inherits Member(Of QMember50.RequestContext, QMember50.Partner)
'...
End Class
However, this base class does not give you any advantage with a factory. The factory would have to return an untyped Member and you'll lose any advantage of the generic implementation.
Another approach is trying to unify the RequestContexts and Partners. If the members only rely on common members, this can be done very easily with an interface. If there are no common members, you could even use an empty interface (as a hint of the requested type) and do the following:
MustInherit Class Member
Public MustOverride Function ProcessInfo(reqctx As IRequestContext, memid As String)
'...
End Class
The concrete Member would be responsible for checking for the correct type and could throw an exception if the wrong type is being passed.
The last approach is to go without any base class and let the factory return an Object (or maybe an empty base class). This might be the cleanest solution because it does not introduce any artificial inheritance where there is none. Of course, you would have to do type checks each time you access the object, but that is the same with most other methods.
Finally, there is not really a nice solution for your problem. Maybe you could revise your architecture and see if there are smarter structures or if you really need the Members as listed above.

Answer 2

Create a baseclass or interface for RequestContext and Partner, and let Member48.RequestContext/Member50.RequestContext and Member48.Partner/Member50.Partner implement those interfaces:
Public Interface IRequestContext
End Interface
Public Interface IPartner
End Interface
Class Member48RequestContext
Implements IRequestContext
End Class
Class Member48Partner
Implements IPartner
End Class
Class Member50RequestContext
Implements IRequestContext
End Class
Class Member50Partner
Implements IPartner
End Class
Now you can create a base class that accepts an IRequestContest and an IPartner:
Public MustInherit Class Member
Public MustOverride Function ProcessInfo(reqctx as IRequestContext, memid as String)
Public MustOverride Function UpdateInfo(partner as IPartner, memid as String)
End Class
and the implementation of your concrete member classes look like
Public Class Member50
Inherits Member
Public Overrides Function ProcessInfo(reqctx as IRequestContext, memid as String)
End Function
Public Overrides Function UpdateInfo(partner as IPartner, memid as String)
End Function
End Class
If you want, you could also create another subclass using generics:
Public MustInherit Class Member(Of TRequest As IRequestContext, TPartner As IPartner)
Inherits Member
Public Overrides Function ProcessInfo(reqctx as IRequestContext, memid as String)
Return ProcessInfo(DirectCast(reqctx, TRequest), memid)
End Function
Public Overrides Function UpdateInfo(partner as IPartner, memid as String)
Return UpdateInfo(DirectCast(partner, TPartner), memid)
End Function
Public Overloads MustOverride Function ProcessInfo(reqctx as TRequest, memid as String)
Public Overloads MustOverride Function UpdateInfo(partner as TPartner, memid as String)
End Class
and an implementation:
Public Class Member48
Inherits Member(Of Member48RequestContext, Member48Partner)
Public Overrides Function ProcessInfo(reqctx as Member48RequestContext, memid as String)
End Function
Public Overrides Function UpdateInfo(partner as Member48Partner, memid as String)
End Function
End Class
Note how Member48 only accepts an Member48RequestContext , instead of any IRequestContext like Member50. It's up to you if you want this extra safety.
Your factory method stays the same:
Function GetMember(val as string) as Member
'Do some processing here
If val = "500" Then
Return New Member50()
Else
Return New Member48()
End If
End Function
However, your factory still needs a reference to both Member50 and Member48, since it creates the concrete classes.
Another approach is to use a DI-container like StructureMap, which is able to scan all your assemblies automatically for all types that implement Member(Of TRequest As IRequestContext, TPartner As IPartner), asign a key to each one, and return the correct instance ,e.g. Member50 if asked for a specifig key, e.g. 500. But a full blown example of such a configuration would be out of scope of this question/answer.