Quickstart: Workflow

Note

The workflow building block is currently in alpha.

Let’s take a look at the Dapr . In this Quickstart, you’ll create a simple console application to demonstrate Dapr’s workflow programming model and the workflow management APIs.

The order-processor console app starts and manages the lifecycle of the OrderProcessingWorkflow workflow that stores and retrieves data in a state store. The workflow consists of four workflow activities, or tasks:

  • NotifyActivity: Utilizes a logger to print out messages throughout the workflow
  • ReserveInventoryActivity: Checks the state store to ensure that there is enough inventory for the purchase
  • ProcessPaymentActivity: Processes and authorizes the payment
  • UpdateInventoryActivity: Removes the requested items from the state store and updates the store with the new remaining inventory value

In this guide, you’ll:

  • Run the order-processor application.
  • Start the workflow and watch the workflow activites/tasks execute.
  • Review the workflow logic and the workflow activities and how they’re represented in the code.

Currently, you can experience the Dapr Workflow using the .NET SDK.

For this example, you will need:

Clone the .

In a new terminal window, navigate to the order-processor directory:

  1. cd workflows/csharp/sdk/order-processor

In the terminal, start the order processor app alongside a Dapr sidecar:

This starts the order-processor app with unique workflow ID and runs the workflow activities.

Expected output:

  1. == APP == Starting workflow 6d2abcc9 purchasing 10 Cars
  3. == APP == info: Microsoft.DurableTask.Client.Grpc.GrpcDurableTaskClient[40]
  4. == APP ==       Scheduling new OrderProcessingWorkflow orchestration with instance ID '6d2abcc9' and 47 bytes of input data.
  5. == APP == info: WorkflowConsoleApp.Activities.NotifyActivity[0]
  6. == APP ==       Received order 6d2abcc9 for 10 Cars at $15000
  7. == APP == info: WorkflowConsoleApp.Activities.ReserveInventoryActivity[0]
  8. == APP ==       Reserving inventory for order 6d2abcc9 of 10 Cars
  9. == APP == info: WorkflowConsoleApp.Activities.ReserveInventoryActivity[0]
  10. == APP ==       There are: 100, Cars available for purchase
  12. == APP == Your workflow has started. Here is the status of the workflow: Dapr.Workflow.WorkflowState
  14. == APP == info: WorkflowConsoleApp.Activities.ProcessPaymentActivity[0]
  15. == APP ==       Processing payment: 6d2abcc9 for 10 Cars at $15000
  16. == APP == info: WorkflowConsoleApp.Activities.ProcessPaymentActivity[0]
  17. == APP ==       Payment for request ID '6d2abcc9' processed successfully
  18. == APP == info: WorkflowConsoleApp.Activities.UpdateInventoryActivity[0]
  19. == APP ==       Checking Inventory for: Order# 6d2abcc9 for 10 Cars
  20. == APP ==       There are now: 90 Cars left in stock
  21. == APP == info: WorkflowConsoleApp.Activities.NotifyActivity[0]
  22. == APP ==       Order 6d2abcc9 has completed!
  24. == APP == Workflow Status: Completed

When you ran dapr run --app-id order-processor dotnet run:

  1. A unique order ID for the workflow is generated (in the above example, ) and the workflow is scheduled.
  2. The NotifyActivity workflow activity sends a notification saying an order for 10 cars has been received.
  3. The ReserveInventoryActivity workflow activity checks the inventory data, determines if you can supply the ordered item, and responds with the number of cars in stock.
  4. Your workflow starts and notifies you of its status.
  5. The ProcessPaymentActivity workflow activity begins processing payment for order 6d2abcc9 and confirms if successful.
  6. The UpdateInventoryActivity workflow activity updates the inventory with the current available cars after the order has been processed.
  7. The NotifyActivity workflow activity sends a notification saying that order 6d2abcc9 has completed.
  8. The workflow terminates as completed.

order-processor/Program.cs

  • The unique workflow order ID is generated
  • The workflow is scheduled
  • The workflow status is retrieved
  • The workflow and the workflow activities it invokes are registered

order-processor/Workflows/OrderProcessingWorkflow.cs

In OrderProcessingWorkflow.cs, the workflow is defined as a class with all of its associated tasks (determined by workflow activities).

  1. using Dapr.Workflow;
  2. //...
  4. class OrderProcessingWorkflow : Workflow<OrderPayload, OrderResult>
  5.     {
  6.         public override async Task<OrderResult> RunAsync(WorkflowContext context, OrderPayload order)
  7.         {
  8.             string orderId = context.InstanceId;
  10.             // Notify the user that an order has come through
  11.             await context.CallActivityAsync(
  12.                 nameof(NotifyActivity),
  13.                 new Notification($"Received order {orderId} for {order.Quantity} {order.Name} at ${order.TotalCost}"));
  15.             string requestId = context.InstanceId;
  17.             // Determine if there is enough of the item available for purchase by checking the inventory
  18.             InventoryResult result = await context.CallActivityAsync<InventoryResult>(
  19.                 nameof(ReserveInventoryActivity),
  20.                 new InventoryRequest(RequestId: orderId, order.Name, order.Quantity));
  22.             // If there is insufficient inventory, fail and let the user know 
  23.             if (!result.Success)
  24.             {
  25.                 // End the workflow here since we don't have sufficient inventory
  26.                     nameof(NotifyActivity),
  27.                     new Notification($"Insufficient inventory for {order.Name}"));
  29.             }
  31.             // There is enough inventory available so the user can purchase the item(s). Process their payment
  32.             await context.CallActivityAsync(
  33.                 nameof(ProcessPaymentActivity),
  34.                 new PaymentRequest(RequestId: orderId, order.Name, order.Quantity, order.TotalCost));
  36.             try
  37.             {
  38.                 // There is enough inventory available so the user can purchase the item(s). Process their payment
  39.                 await context.CallActivityAsync(
  40.                     nameof(UpdateInventoryActivity),
  41.                     new PaymentRequest(RequestId: orderId, order.Name, order.Quantity, order.TotalCost));                
  42.             }
  43.             catch (TaskFailedException)
  44.             {
  45.                 // Let them know their payment was processed
  46.                 await context.CallActivityAsync(
  47.                     nameof(NotifyActivity),
  48.                     new Notification($"Order {orderId} Failed! You are now getting a refund"));
  49.                 return new OrderResult(Processed: false);
  50.             }
  52.             // Let them know their payment was processed
  53.             await context.CallActivityAsync(
  54.                 nameof(NotifyActivity),
  55.                 new Notification($"Order {orderId} has completed!"));
  57.             // End the workflow with a success result
  58.             return new OrderResult(Processed: true);
  59.         }
  60.     }

order-processor/Activities directory

The Activities directory holds the four workflow activities used by the workflow, defined in the following files:

  • NotifyActivity.cs
  • ReserveInventoryActivity.cs
  • ProcessPaymentActivity.cs
  • UpdateInventoryActivity.cs

Watch this video to walk through the Dapr Workflow .NET demo:

We’re continuously working to improve our Quickstart examples and value your feedback. Did you find this Quickstart helpful? Do you have suggestions for improvement?

Join the discussion in our discord channel.