Dataflow.Pipeline

DataFlow.pipline

Uma representação simples de pipeline para .Net.
Representa uma sequência de etapas que processam de forma consistente.
Ele permite dividir um grande monte de código em pedaços pequenos para obter melhor legibilidade, extensibilidade e testabilidade.

Uso

Primeiro, você deve criar um tipo que será passado entre as etapas do pipeline:

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

Use PipelineBuilder para criar o pipeline e preencher um com etapas. Como exemplo, vamos supor que queremos calcular o prêmio de seguro comum para o 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 ) ;
  } ) ;

É possível descrever uma etapa do pipeline como um tipo implementando uma interface iPipelineStep. Em um exemplo abaixo, criamos RoundOffstep para completar o prêmio total de seguro que recebemos:

 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 ;
        }

    }

Então, você pode adicionar etapa recém -criada para o construtor assim:

  builder . AddStep < RoundOffStep > ( ) ;

Para obter o método de uso do objeto de pipeline, a criação do PipelineBuilder. Depois disso, você pode chamar o método de execução do pipeline para executar todas as etapas adicionadas:

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