Dataflow.Pipeline

DataFlow.pipeline

Eine einfache Pipeline -Darstellung für .NET.
Repräsentiert eine Folge von Schritten, die konsequent verarbeiten.
Es ermöglicht es, eine große Gruppe von Code in kleine Stücke zu zerlegen, um eine bessere Lesbarkeit, Erweiterbarkeit und Testbarkeit zu erzielen.

Verwendung

Zunächst sollten Sie einen Typ erstellen, der zwischen den Pipeline -Schritten übergeben wird:

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

Verwenden Sie PipelineBuilder, um Pipeline zu erstellen und eine mit Schritten zu füllen. Nehmen wir beispielsweise an, dass wir die gemeinsame Versicherungsprämie für Kundenmenge berechnen möchten:

 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 ist möglich, einen Pipeline -Schritt als Typ zu beschreiben, indem eine Schnittstelle ipipelInstep implementiert wird. In einem folgenden Beispiel erstellen wir Roundoffstep, um die gesamte Versicherungsprämie abzurunden, die wir erhalten haben:

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

    }

So können Sie dem Erbauer wie folgt einen neu erstellten Schritt hinzufügen:

  builder . AddStep < RoundOffStep > ( ) ;

Um die Pipeline -Objektverwendung zu erhalten, die Methode des PipelineBuilders erstellt. Danach können Sie die Methode Executeasync von Pipeline aufrufen, um alle hinzugefügten Schritte auszuführen:

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