Enfasi polimorfiche per la gestione dello stato

Question

come gestisco Enum senza utilizzare switch o se le istruzioni in C#?

Per esempio

enum Pricemethod 
{ 
    Max, 
    Min, 
    Average 
} 

... e ho una classe Article

public class Article 
{ 
    private List<Double> _pricehistorie; 

    public List<Double> Pricehistorie 
    { 
     get { return _pricehistorie; } 
     set { _pricehistorie = value; } 
    } 

    public Pricemethod Pricemethod { get; set; } 

    public double Price 
    { 
     get { 
      switch (Pricemethod) 
      { 
       case Pricemethod.Average: return Average(); 
       case Pricemethod.Max: return Max(); 
       case Pricemethod.Min: return Min(); 
      } 

     } 
    } 

} 

voglio evitare l'istruzione switch e renderlo generico.

Per un Pricemethod specifico chiamare un Calcolo specifico e restituirlo.

get { return CalculatedPrice(Pricemethod); } 

Quale motivo è da utilizzare qui e forse qualcuno ha una buona idea di implementazione. Ho già cercato uno schema di stato, ma non penso che sia quello giusto.

Answer 1

come si gestiscono le enumerazioni senza utilizzare 0.123.o if dichiarazioni in C#?

Non è così. le enumerazioni sono solo una sintassi piacevole per scrivere const int.

considerare questo modello:

public abstract class PriceMethod 
{ 
    // Prevent inheritance from outside. 
    private PriceMethod() {} 

    public abstract decimal Invoke(IEnumerable<decimal> sequence); 

    public static PriceMethod Max = new MaxMethod(); 

    private sealed class MaxMethod : PriceMethod 
    { 
    public override decimal Invoke(IEnumerable<decimal> sequence) 
    { 
     return sequence.Max(); 
    } 
    } 

    // etc, 
} 

E ora si può dire

public decimal Price 
{ 
    get { return PriceMethod.Invoke(this.PriceHistory); } 
} 

E l'utente può dire

myArticle.PriceMethod = PriceMethod.Max; 
decimal price = myArticle.Price; 

Answer 2

Si potrebbe creare un interface e class ca che implementano:

public interface IPriceMethod 
{ 
    double Calculate(IList<double> priceHistorie); 
} 
public class AveragePrice : IPriceMethod 
{ 
    public double Calculate(IList<double> priceHistorie) 
    { 
     return priceHistorie.Average(); 
    } 
} 
// other classes 
public class Article 
{ 
    private List<Double> _pricehistorie; 

    public List<Double> Pricehistorie 
    { 
     get { return _pricehistorie; } 
     set { _pricehistorie = value; } 
    } 

    public IPriceMethod Pricemethod { get; set; } 

    public double Price 
    { 
     get { 
      return Pricemethod.Calculate(Pricehistorie); 
     } 
    } 

} 

Edit: un altro modo è usare un Dictionary per mappare Func s, quindi non c'è bisogno di creare classi solo per questo (questo codice è basato sul codice da Servy, che nel frattempo cancellato la sua risposta):

public class Article 
{ 
    private static readonly Dictionary<Pricemethod, Func<IEnumerable<double>, double>> 
     priceMethods = new Dictionary<Pricemethod, Func<IEnumerable<double>, double>> 
     { 
      {Pricemethod.Max,ph => ph.Max()}, 
      {Pricemethod.Min,ph => ph.Min()}, 
      {Pricemethod.Average,ph => ph.Average()}, 
     }; 

    public Pricemethod Pricemethod { get; set; } 
    public List<Double> Pricehistory { get; set; } 

    public double Price 
    { 
     get 
     { 
      return priceMethods[Pricemethod](Pricehistory); 
     } 
    } 
}