Déclaration des Enums dans les classes dérivées

Question

Je développe un programme dans VB.NET.

J'ai une énumération appelée PriceType qui est déclarée dans une super classe ItemPriceBase. Il existe 3 classes dérivées de ItemPriceBase - ItemPriceMeasured, ItemPriceNDI et ItemPriceExtraCost. Le sous-ensemble de PriceTypes pour ces classes est totalement unique de chaque - Les prix mesurés sont de 1 à 6, les prix NDI sont de 7 à 15 et les prix ExtraCost de 16 à 22.

Y a-t-il un moyen de déclarer l'énumération dans la super classe et puis étendre l'énumération dans chacune des classes dérivées afin qu'ils n'aient accès qu'à ces options, mais je peux toujours accéder à une propriété de la super classe qui retourne une énumération de PriceType?

Merci, Dane.

Answer 1

Pas exactement. Étant donné que les énumérations sont vraiment juste des entiers, vous pouvez faire quelque chose comme ceci:

Enum BaseTypes 
    A = 1 
    B 
    C 
End Enum 

'start with an arbitrarily high number to avoid colliding with BaseTypes 
Enum DerivedTypes 
    D = 10 
    E 
    F 
End Enum 

'ditto 
Enum OtherDerivedTypes 
    G = 20 
    H 
    I 
End Enum 

Vous pouvez passer les types dérivés dans une méthode qui attend le type de base en les jetant comme le type de base, par exemple (BaseTypes)DerivedTypes.E Cela ne fonctionnera bien sûr en supposant que vous ne faites pas des déclarations de cas non-virtuelle ou lié à la vérification dans votre BaseClass et vos classes dérivées redéfinissent les méthodes pertinentes, comme suit:

Classe de base:

Private Overridable Sub HandleValue(ByVal val As BaseTypes) 
    Select Case val 
     Case BaseTypes.A 
      'do something 
      Exit Select 
     Case BaseTypes.B 
      'do something else 
      Exit Select 
    End Select 
End Sub 

classe dérivée:

Private Overloads Overrides Sub HandleValues(ByVal val As BaseTypes) 
    Select Case DirectCast(val, DerivedTypes) 
     Case DerivedTypes.D 
      'do something D-ish 
      Exit Select 
     Case DerivedTypes.E 
      'do something E-like 
      Exit Select 
     Case Else 
      'what we got wasnt a DerivedType, pass it off to the base 
      MyBase.HandleValues(val) 
      Exit Select 
    End Select 
End Sub 

Notez que ce ne fonctionne que pour une chaîne de succession linéaire - par exemple, il se décompose s'il y a des classes dérivées de même niveau, car il devient très difficile pour eux de transmettre correctement les valeurs d'énumération au bon frère, plutôt qu'à un parent qui a simplement une portée plus limitée.

En général, je ne recommanderais pas cette approche pour l'extensibilité ouverte. Comme vous pouvez le voir, c'est un cauchemar de maintenance. Si vous disposez d'un ensemble d'utilisations bien défini et délimité qui sera principalement défini dans la pierre, alors cela est réalisable.

Answer 2

Les énumérations ne peuvent utiliser que les types entiers intégrés. Vous ne pouvez pas dériver d'un Enum; ils sont implicitement scellés.

Tous les Enums dérivent de System.Enum, qui dérive de System.ValueType, et ils sont sealed, c'est-à-dire que vous ne pouvez pas en dériver.

Answer 3

Dans ce type de scénario, j'utilise généralement un objet enum au lieu de types enum. Par exemple:

public class BaseEnumType 
{ 
public readonly static BaseEnumType A=new BaseEnumType(0,"A"); 
public readonly static BaseEnumType B=new BaseEnumType(10,"B"); 
public readonly static BaseEnumType C=new BaseEnumType(20,"C"); 
public readonly static BaseEnumType[] AllBase=new []{A,B,C}; 
public int Value{get;private set;} 
public string Name {get;private set;} 
protected BaseEnumType(int value,string name) 
{ 
Value=value; 
Name=name; 
} 

} 

Ensuite, vous pouvez tirer de cette BaseEnumType:

public class ChildEnumType:BaseEnumType 
{ 
public readonly static ChildEnumType D=new ChildEnumType(30,"D"); 
public readonly static ChildEnumType[] AllChild=new []{A,B,C,D}; 

protected ChildEnumType(int value,string name):BaseEnumType(value,name){} 
}