Dataflow.Pipeline

Dataflow.pipeline

Une représentation de pipeline simple pour .NET.
Représente une séquence d'étapes qui traitent de manière cohérente.
Il permet de décomposer un grand tas de code en petits morceaux pour une meilleure lisibilité, extensibilité et testabilité.

Usage

Tout d'abord, vous devez créer un type qui sera passé entre les étapes du pipeline:

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

Utilisez PipelineBuilder pour créer un pipeline et remplissez-en un avec des étapes. Par exemple, supposons que nous voulons calculer la prime d'assurance commune pour un ensemble de clients:

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

Il est possible de décrire une étape de pipeline comme un type en implémentant une interface iPipelinestep. Dans un exemple ci-dessous, nous créons un randonnée pour compléter la prime d'assurance totale, nous avons obtenu:

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

    }

Ainsi, vous pouvez ajouter une étape nouvellement créée à Builder comme ceci:

  builder . AddStep < RoundOffStep > ( ) ;

Pour obtenir la méthode d'utilisation d'objets de pipeline de construction de pipelinebuilder. Après cela, vous pouvez appeler la méthode Executeasync de Pipeline pour effectuer toutes les étapes ajoutées:

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