Meilleure façon de décider quelle sous-classe est nécessaire

Question

Je travaille sur une application de paiement à grande échelle pour un projet en cours. Cette extraction a de nombreux cas en fonction du niveau d'administration de l'utilisateur, comment ils sont arrivés à la caisse, et quel type d'article ils extraient, et donc le processus est extrait des pages .aspx via un ensemble de classes de contexte.

Ces classes sont toutes sous-classes à partir d'une seule classe, CheckoutContext, et le type de classe à utiliser est noté via une énumération.

Y at-il quelque chose de similaire à typedef je peux utiliser pour choisir la sous-classe à utiliser, ou devrais-je avoir simplement une méthode qui retourne la classe concernée, comme suit:

CheckoutContext chooseSubclass(CheckoutCase c) 
{ 
CheckoutContext output; 
switch (c): 
{ 
    case CheckoutCase.SingleItemNew: 
    output = new SingleItemNew; 
    break; 
    case . . . 
    return output; 
} 
}

Answer 1

If there are a large number of cases, I would create a Dictionary<CheckoutCase, Type> et le remplir une fois avec l'ensemble des toutes les valeurs CheckoutCase et les Types CheckoutContext correspondants. Vous pouvez ensuite utiliser Activator.CreateInstance pour renvoyer le type approprié au lieu d'une instruction gigantesque.

Answer 2

What you're implementing is a Factory Pattern . This is a standard practice, though it typically means writing a lot of repetitive code (much like your switch statement, which is often how they're implemented). You could do all sorts of fancy things like dynamic instantiation via reflection, but don't play with fire. Just stick with switch statement and you'll be fine.

Answer 3

You could implement this with a custom attribute and a factory method. Make all you Sub Classes implement a CustomAttribute say CheckOutCaseScenarioAttribute that takes the CheckOutCase Enum value.

Within your factory method, look for types that have this Enum Value set and create the object. This will avoid your switch case. This will work if you dont have any other initialization logic within your factory method.

Answer 4

This is called a Factory Design Pattern. I would create a static method that returns the needed class. A good practice here is to implement an Interface and return the interface.

interface ICheckoutItem 
{ 
    void CheckOut(); 
} 

Have your items implement the interface. Then in your factory method return the interface of each item.

ICheckoutItem chooseSubclass(CheckoutCase c) 
{ 
ICheckoutItem output; 
    switch (c): 
    { 
     case CheckoutCase.SingleItemNew: 
     output = new SingleItemNew; 
     break; 
     case . . . 
    return output; 
    } 
} 

Answer 5

Vous pouvez créer un attribut qui a une propriété qui serait le type de CheckoutContext:

public class CheckoutContextAttribute : Attribute 
{ 
    public Type CheckoutType{get;set;} 
} 

Ensuite, sur votre ENUM, vous pouvez mettre l'attribut correct sur le type ENUM correct:

public enum CheckoutCase 
{ 
    [CheckoutContext(CheckoutType=typeof(SingleItemNew)] 
    SingleItemNew, 
    ... 
    ... 
} 

Ensuite, dans cette méthode où vous devez renvoyer le bon type de contexte que vous utilisez la réflexion et faire quelque chose comme ceci:

public CheckoutContext GetContext(CheckoutCase c) 
{ 
    FieldInfo field = c.GetType().GetField(c.ToString()); 
    object[] attribs = field.GetCustomAttributes(typeof(CheckoutContextAttribute),false); 
    CheckountContext result = null; 
    if(attribs.Length > 0) 
    { 
     CheckoutContextAttribute attrib = attribs[0] as CheckoutContextAttribute; 
     Type type = attrib.CheckoutType; 
     result = Activator.CreateInstance(type) as CheckountContext; 
    } 

    return result; 
} 

Cela devrait faire l'affaire. Ajoutez juste une vérification de null/error pour être sûr.