DurableMediator.OutOfProcess 3.1.0-preview-1

This is a prerelease version of DurableMediator.OutOfProcess.
There is a newer version of this package available.
See the version list below for details.
dotnet add package DurableMediator.OutOfProcess --version 3.1.0-preview-1                
NuGet\Install-Package DurableMediator.OutOfProcess -Version 3.1.0-preview-1                
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="DurableMediator.OutOfProcess" Version="3.1.0-preview-1" />                
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add DurableMediator.OutOfProcess --version 3.1.0-preview-1                
#r "nuget: DurableMediator.OutOfProcess, 3.1.0-preview-1"                
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install DurableMediator.OutOfProcess as a Cake Addin
#addin nuget:?package=DurableMediator.OutOfProcess&version=3.1.0-preview-1&prerelease

// Install DurableMediator.OutOfProcess as a Cake Tool
#tool nuget:?package=DurableMediator.OutOfProcess&version=3.1.0-preview-1&prerelease                

Durable Mediator

#

Durable Mediator is an extension to the Durable Task library which allows for running MediatR Requests as activities in orchestrations without any complex ceremony.

Blog post

https://medium.com/tripleuniverse/how-to-effectively-work-with-stateful-processes-in-a-stateless-environment-ae4d014d5606

Getting started

To get started with running orchestrations which call MediatR Requests as activities, which are called "Workflows", follow these steps:

First start by defining a workflow request:

public record WorkflowRequest(Guid SomeId) : IWorkflowRequest
{
    public string WorkflowName => "Human readable workflow name";
    public string InstanceId => SomeId.ToString();
};

Also, create a IRequest that needs to be called from the workflow:

public record MediatorRequest(Guid SomeId) : IRequest;

Create a request handler that handles this MediatR request:

public class MediatorRequestHandler : IRequestHandler<MediatorRequest>
{
    private readonly ILogger<MediatorRequestHandler> _logger;

    public RequestAHandler(ILogger<MediatorRequestHandler> logger)
    {
        _logger = logger;
    }

    public Task<Unit> Handle(MediatorRequest request, CancellationToken cancellationToken)
    {
        _logger.LogInformation("Processing RequestA");

        return Task.FromResult(Unit.Value);
    }
}

Create a workflow that handles the WorkflowRequest:

[DurableTask(nameof(ExampleWorkflow))]
public class ExampleWorkflow : Workflow<WorkflowRequest>
{
    private readonly ILogger<ABCWorkflow> _logger;

    public ExampleWorkflow(ILogger<ABCWorkflow> logger) 
    {
        _logger = logger;
    }

    public override async Task OrchestrateAsync(IWorkflowExecution<WorkflowRequest> execution)
    {
        var logger = execution.OrchestrationContext.CreateReplaySafeLogger(_logger);

        logger.LogInformation("Start with workflow");

        await execution.SendAsync(new MediatorRequest(execution.Request.SomeId));

        logger.LogInformation("Workflow done");
    }
}

Create a Azure Function that triggers this workflow:

public static class WorkflowTrigger
{
    [Function(nameof(WorkflowTrigger))]
    public static async Task<IActionResult> TriggerOrchestratorAsync(
        [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "workflow")] HttpRequestMessage req,
        [DurableClient] DurableTaskClient client)
    {
        var startDetails = await client.ScheduleNewExampleWorkflowInstanceAsync(new WorkflowRequest(Guid.NewGuid()));

        var response = req.CreateResponse(HttpStatusCode.Accepted);

        response.WriteString(startDetails);

        return response;
    }
}

In your function app startup, add the required MediatR services by including services.AddMediatR(typeof(MediatorRequest).Assembly);.

When running your function app you will see that next to the WorkflowTrigger Http Trigger function, an Orchestration Trigger function called "WorkflowRequest" and a "DurableMediatorEntity" Entity Trigger function are added. When http function triggers the start of the workflow, the orchestration function will orchestrate the workflow and invoke ExampleWorkflow. Each call to the execution.SendAsync will trigger the durable mediator action to execute the MediatR Request in a separate activity after which the orchestration resumes. No more calling context.CallActivity and guessing what parameters to pass in.

The execution exposes the TaskOrchestrationContext from the Durable Task library, giving full access to creating timers for durable delays, locking entities for critical sections, or wait for external events. The execution also exposes CallSubWorkflowAsync, which allows workflows to initiate other workflows, and even await their responses, making it easy to compose workflows.

Unit testing

#

See the OutOfProcessFunctionApp.Tests in the example folder for how to test workflows using scenarios. A scenario looks like this:

public class ExampleWorkflowScenario : Scenario
{
    private readonly Guid _requestId = Guid.NewGuid();

    public override void Setup(IScenarioSetup scenarioSetup, Mock<TaskOrchestrationContext> taskOrchestrationContextMock)
    {
    }

    public override IWorkflowRequest Request => new ExampleWorkflowRequest(_requestId);

    public override IEnumerable<object> RunScenario(IScenarioRun scenarioRun)
    {
        yield return new MediatorRequest(_requestId);
    }
}

Based on what the Setup configures and simulates, the RunScenario should output what MediatR requests the workflow should emit. Next to MediatR requests, things like delays, exceptions, calls to other workflows and outputs can be completely unit tested.

Examples

See the OutOfProcessFunctionApp in the example folder for more examples.

Product Compatible and additional computed target framework versions.
.NET net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (1)

Showing the top 1 NuGet packages that depend on DurableMediator.OutOfProcess:

Package Downloads
DurableMediator.OutOfProcess.Testing

Durable Mediator is an extension to the Durable Task library which allows for running MediatR Requests as activities in orchestrations without any complex ceremony. This package allows for testing workflows using scenarios.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
3.1.0 129 4/16/2024
3.1.0-preview-1 104 4/16/2024
3.0.1-preview 114 10/10/2023
3.0.0-preview 102 9/26/2023
1.0.0 164 9/26/2023 1.0.0 is deprecated because it is no longer maintained.