Dataflow.Pipeline

Dataflow.pipeline

Una representación de tubería simple para .NET.
Representa una secuencia de pasos que procesan de manera consistente.
Permite descomponer un gran grupo de código en piezas pequeñas para una mejor legibilidad, extensibilidad y capacidad de prueba.

Uso

En primer lugar, debe crear un tipo que se pasará entre los pasos de la tubería:

 public class InsurancePremiumModel
{
  public decimal TotalPremium { get ; set ; }
}

Use PipelineBuilder para crear tuberías y llenar uno con pasos. Como ejemplo, supongamos que queremos calcular la prima de seguro común para el conjunto de clientes:

 var customers = GetCustomers ( ) ;
var customersCount = customers . Count ( ) ;

var builder = PipelineBuilder < InsurancePremiumModel >
  . StartWith ( ( model , next ) => {
    var basePrice = GetBasePrice ( Options . Ambulance , customers ) ;
    var ambulancePremium = _ambulanceService . Calculate ( basePrice ) ;
    model . TotalPremium += customersCount * ambulancePremium ;
    return next . Invoke ( model ) ;
  } )
  . AddStep ( ( model , next ) => {
    var basePrice = GetBasePrice ( Options . Dental , customers ) ;
    var dentalPremium = _dentalService . Calculate ( basePrice ) ;
    model . TotalPremium += customersCount * dentalPremium ;
    return next . Invoke ( model ) ;
  } )
  . AddStep ( ( model , next ) => {
    var basePrice = GetBasePrice ( Options . HomeCare , customers ) ;
    var homeCarePremium = _homeCareService . Calculate ( basePrice ) ;
    model . TotalPremium += customersCount * homeCarePremium ;
    return next . Invoke ( model ) ;
  } ) ;

Es posible describir un paso de tubería como un tipo mediante la implementación de una interfaz ipipelineste. En un ejemplo a continuación, creamos RoundOffStep para redondear la prima de seguro total que obtuvimos:

 public class RoundOffStep
  : IPipelineStep < PriceModel >
  {
        public Task < PriceModel > InvokeAsync ( PriceModel input , Func < PriceModel , Task < PriceModel > > next )
        {
            input . TotalPremium = RoundOff ( input . TotalPremium ) ;
            return next . Invoke ( input ) ;
        }
        
        private decimal RoundOff ( decimal price )
        {
            var rem = price % 10 ;
            
            if ( rem == 0 ) return price ;
            
            var result = Math . Round ( price / 10 , MidpointRounding . AwayFromZero ) * 10 ;

            return rem < 5 ? result + 10.00m : result ;
        }

    }

Por lo tanto, puede agregar un paso recién creado al constructor como este:

  builder . AddStep < RoundOffStep > ( ) ;

Para obtener el objeto de la tubería, utilice el método de compilación de PipelineBuilder. Después de eso, puede llamar al método ExecheAsync of Pipeline para realizar todos los pasos agregados:

  var pipeline = builder . Build ( ) ;
  var result = await pipeline . ExecuteAsync ( new InsurancePremiumModel ( ) ) ;