Types dépendants en VB.NET

Question

Je me demandais s'il est possible d'avoir des types dépendants dans VB.Net 4, ou alternativement, s'il est possible de construire des objets hérités basés sur le(s) paramètre(s) du constructeur de la classe de base. Par exemple,

Class BaseClass
   Sub New(type as String)
       If type = "One" then
           Me = New Child1  'Assignment to Me is syntax error, but it explains the concept...
       Else
           Me = New OtherChild
       End If
   End Sub
End Class

Class Child1
    Inherits BaseClass
...

Class OtherChild
    Inherits BaseClass
..

..
Sub Main()
   Dim c1 As New BaseClass("One")
   Dim c2 As New BaseClass("Two")
   OverloadedMethod(c1) 'Outputs One
   OverloadedMethod(c2) 'Outputs Two
End Sub

Sub OverloadedMethod(C as Class1)
   Console.Write("One")
End Sub

Sub OverloadedMethod(C as OtherClass)
   Console.Write("Two")
End Sub

EDIT : Explications sur les types dépendants :

Types de dépendance sont des types qui sont construits à partir de certains paramètres (par exemple, une valeur scalaire). C'est un concept bien connu dans certains langages de programmation (principalement fonctionnels) (par exemple Haskell). Par exemple, dans un hypothétique langage impératif qui supporte les types dépendants, on peut écrire :

Matrix(3,10) A; //A is a 10x10x10 3D Matrix
Matrix(2,3)  B; //B is a 3x3 2D Matrix

Et puis

A(0,0,0) = 10;
B(0,0) = -2;
B(1,1,0) = 5; // Type Error

Answer 1

EDIT : Au vu de vos commentaires, je n'étais pas au courant des types dépendants. Il semble que ceux-ci ne soient pas encore implémentés dans un langage de programmation orienté objet. Il existe recherche de combiner les deux, mais il semble que nous ne sommes pas encore à l'étape de la mise en œuvre AFAIK.

Pour l'instant, un Constructeur ne peut pas construire autre chose que le type qu'il construit (dans votre exemple BaseClass ).

Le plus proche que vous pourriez obtenir serait avec une usine abstraite . Cela ressemblerait à ceci (j'ai gardé la chaîne de caractères, et rendu la méthode statique pour simplifier, mais elle ne fait généralement pas partie du modèle, lisez à ce sujet pour plus de détails) :

   Class ClassFactory
      Public Shared Function GenerateBaseClassObject(type As String) As BaseClass
         If type = "One" Then
            Return New Child1  
         Else
            Return New OtherChild
         End If
      End Function
   End Class

Pour ce qui est de l'autre partie de votre question, la surcharge, cela ne ferait que rendre plus difficile la définition de vos méthodes en dehors de votre hiérarchie d'objets. Comme vous pouvez le voir, la fabrique abstraite renvoie un objet BaseClass et personne ne sait, en dehors de la fabrique et des objets construits, quel est leur véritable type (si l'on ne tient pas compte de la réflexion et du moulage, ce serait tout simplement confus à ce stade). Vous devriez retravailler votre hiérarchie d'objets pour encapsuler les différences entre vos deux types de classes.

Un remaniement complet et fonctionnel de votre code ressemblerait à ceci :

MustInherit Class BaseClass
      Public MustOverride Sub Output()
   End Class

   Class Child1
      Inherits BaseClass

      Public Overrides Sub Output()
         Console.Write("One")
      End Sub
   End Class

   Class OtherChild
      Inherits BaseClass

      Public Overrides Sub Output()
         Console.Write("Two")
      End Sub
   End Class

   Class ClassFactory
      Public Shared Function GenerateBaseClassObject(type As String) As BaseClass
         If type = "One" Then
            Return New Child1
         Else
            Return New OtherChild
         End If
      End Function
   End Class

   Sub Main()
      Dim c1 As BaseClass = ClassFactory.GenerateBaseClassObject("One")
      Dim c2 As BaseClass = ClassFactory.GenerateBaseClassObject("Two")
      c1.Output()
      c2.Output()
      Console.ReadLine()
   End Sub