Ciao a tutti

Stavo pensando al pattern Strategy, un altro pattern comportamentale che ci puo aiutare nella realizzazione di alcuni componenti pacchettizzati riutilizzabili per la nostra applicazione.
Il suo scopo è dare al programmatore un interfaccia per eseguire delle regole di business così da astrarre la logica della regola dalla sua implementazione nel nostro codice.

Esempio:

//Interfaccia di contesto per eseguire gli Strategy
static class BusinessRuleProvider
{
   //classe StrategyContext per calcoli ad un parametro
   class StrategyContext1<T>
   {
      Funct<T,T> Strategy {get;set;}
      T Execute(T x) {
         return Strategy!=null ? Strategy(x) : default(T); }
   }
   //classe StrategyContext per calcoli ad due parametri
   class StrategyContext2<T>
   {
      Funct<T,T,T> Strategy {get;set;}
      T Execute(T x, T y) {
         return Strategy!=null ? Strategy(x,y) : default(T); }
   }  
   //classe contenente le regole di business concrete
   static class Strategies
   {
      static Func<float,float> ArrotondaPerEccesso = x=> (float)Math.Ceiling(x);
      static Func<float,float> ArrotondaPerDifetto = x=> (float)Math.Floor(x);
      static Func<float,float,float> SommaEArrotondaPerEccesso = (x,y)=> (float)Math.Ceiling(x+y);
      static Func<float,float,float> SommaEArrotondaPerDifetto = (x,y)=> (float)Math.Floor(x+y);
   }
   //qui vado a censire nella mia classe statica StrategyProvider le strategie utilizzabili
   static StrategyContext1<float> Arrotonda()
   {
      return new StrategyContext1<float>() { Strategy=Strategies.ArrotondaPerEccesso } ;
   }
   static StrategyContext2<float> SommaEArrotonda()
   {
      return new StrategyContext2<float>() { Strategy=Strategies.SommaEArrotondaPerEccesso } ;
   }
}

In questo modo è possibile creare un repository di regole di business ed utilizzarle in ogni punto della nostra applicazione senza dover modificare l'implementazione nel caso di dover cambiare la strategia che c'è dietro la regola di business

float x = 100.00F;
float y = 24.55F;
var arrotonda = BusinessRuleProvider.Arrotonda();
var somma = BusinessRuleProvider.SommaEArrotonda();
var risp1 = arrotonda.Execute(x);
var risp2 = somma.Execute(x,y);