Possibility of returning derived type from inherited operator

Question

Hello forum,
I am wondering the possibility of returning a derived type from an inherited operator. A test case would include two class definitions such as:
Public Class Base
Dim _a
Public ReadOnly Property A As Integer
Get
Return _a
End Get
End Property
Public Shared Operator +(ByVal base1 As Base, _
ByVal base2 As Base) As Base
Return New Base(base1.A + base2.A)
End Operator
Public Sub New(ByVal a As Integer)
_a = a
End Sub
End Class
Public Class Derived
Inherits Base
Public Sub New(ByVal a As Integer)
MyBase.New(a)
End Sub
End Class
and implementation such as:
Dim derivedA As Derived = New Derived(1)
Dim derivedB As Derived = New Derived(1)
Dim derivedResult As Derived = derivedA + derivedB
'would like result as derived, not base!
This test case returns the error that the derivedResult cannot by cast to the base type (as this is how the operator is defined). I am wondering: is there a way to change the operator definition so that the derived type is returned from the operation? There
could be many derived types and avoiding overloading the method in each type definition could reduce the amount of code.
Many thanks.

Answer 1

I'm just Frank, not "Mr. Smith". ;-)
I suspect that Reed is onto it with generics. He's quite familiar with it and in a question I posted a few years ago - about derived classes - he answered it using generics.
Let's see what you or he comes up with. :)
Still lost in code, just at a little higher level.
Haha, I was like "who is Mr. Smith.... oh yeah, that's Frank's last name".  ;)
@James3210:  same here... it's just Reed.  Wearing a shirt with a collar is about as formal as I get.  :)
Anyway, back to the subject at hand, I think the generic method in conjunction with the operator overload is the way to go.  Since you'll have to write the operator on each class anyway, at least you can copy-paste the operator code and then just change
the type used for "T":
Public Class FooBase
Private anInteger As Integer
Protected Shared Function Add(Of T As {FooBase, New})(source As T, target As T) As FooBase
Return New T() With {.anInteger = source.anInteger + target.anInteger}
End Function
Public Shared Operator +(source As FooBase, target As FooBase) As FooBase
Return FooBase.Add(Of FooBase)(source, target)
End Operator
End Class
Public Class DerivedFoo
Inherits FooBase
Public Overloads Shared Operator +(source As DerivedFoo, target As DerivedFoo) As DerivedFoo
Return FooBase.Add(Of DerivedFoo)(source, target)
End Operator
End Class
Public Class DerivedFooTwo
Inherits FooBase
Public Overloads Shared Operator +(source As DerivedFooTwo, target As DerivedFooTwo) As DerivedFooTwo
Return FooBase.Add(Of DerivedFooTwo)(source, target)
End Operator
End Class
In this example the shared Add() method is internal to the FooBase objects, but you could make the access modifier public if you wanted to expose the method for direct use.
-EDIT-
Sorry, I forgot you wanted to return the object type from the operator, not the internal result.  I've updated the code to return a new object instance.
Reed Kimble - "When you do things right, people won't be sure you've done anything at all"