EventFlow 1.0.5002-alpha

Prefix Reserved
.NET 6.0 This package targets .NET 6.0. The package is compatible with this framework or higher. .NET Core 3.1 This package targets .NET Core 3.1. The package is compatible with this framework or higher. .NET Standard 2.1 This package targets .NET Standard 2.1. The package is compatible with this framework or higher.
This is a prerelease version of EventFlow.
There is a newer version of this package available.
See the version list below for details. 
dotnet add package EventFlow --version 1.0.5002-alpha                

                    
                

            
NuGet\Install-Package EventFlow -Version 1.0.5002-alpha
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="EventFlow" Version="1.0.5002-alpha" />
For projects that support PackageReference, copy this XML node into the project file to reference the package. 
paket add EventFlow --version 1.0.5002-alpha                

                    
                

            
#r "nuget: EventFlow, 1.0.5002-alpha"
#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 EventFlow as a Cake Addin
#addin nuget:?package=EventFlow&version=1.0.5002-alpha&prerelease

// Install EventFlow as a Cake Tool
#tool nuget:?package=EventFlow&version=1.0.5002-alpha&prerelease

EventFlow

<table border="0" cellpadding="0" cellspacing="0"> <tr> <td width="25%"> <img src="./icon-128.png" /> </td> <td width="25%"> <p> <a href="https://www.nuget.org/packages/EventFlow/"><img src="https://img.shields.io/nuget/v/EventFlow.svg?style=flat" /></a> </p> <p> <a href="https://docs.geteventflow.net/?badge=latest"><img src="https://readthedocs.org/projects/eventflow/badge/?version=latest" /></a> </p> </td> <td width="25%"> <p> <a href="https://github.com/eventflow/EventFlow/actions/workflows/ci.yml"><img src="https://github.com/eventflow/EventFlow/actions/workflows/ci.yml/badge.svg" /></a> </p> <p> <a href="https://gitter.im/rasmus/EventFlow?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"><img src="https://badges.gitter.im/Join%20Chat.svg" /></a> </p>

</td>

</tr> </table>

NuGet feeds

EventFlow is a basic CQRS+ES framework designed to be easy to use.

Have a look at our getting started guide, the do’s and don’ts and the FAQ.

Features

  • Easy to use: Designed with sensible defaults and implementations that make it easy to create an example application
  • Highly configurable and extendable: EventFlow uses interfaces for every part of its core, making it easy to replace or extend existing features with custom implementation
  • No use of threads or background workers
  • MIT licensed Easy to understand and use license for enterprise

Versions

Development of version 1.0 has started and is mainly braking changes regarding changes related to replacing EventFlow types with that of Microsoft extension abstractions, mainly IServiceProvider and ILogger<>.

The following list key characteristics of each version as well as its related branches (not properly configured yet).

  • 1.x (under development, not all projects compile yet)

    Represents the next iteration of EventFlow that aligns EventFlow with the standard packages for .NET (Core). Releases here will only support .NET Standard, .NET Core and .NET versions going forward.

    Read the migration guide to view the full list of breaking changes as well as recommendations on how to migrate.

    NOTE: This version is under heavy development and NO stable version has yet been releases. It will take a few alpha/beta/rc releases to get this right. These will be released as soon as any significant changes have been made.

    Documentation (not complete)

    Version 1.x documentation has been pulled into this repository in order to have the code and documentation closer together and (hopefully) have the documentation updated in the same pull-requests as any code changes.

    NuGet package status

    • 🟢 compiles and pushed in -alpha releases
    • 🔴 not yet ported to 1.0
    • 💀 for packages that are removed as part of 1.0, see the migration guide for details)

    Projects

    • 🟢 EventFlow
    • 🔴 EventFlow.AspNetCore
    • 💀 EventFlow.Autofac
    • 💀 EventFlow.DependencyInjection
    • 🔴 EventFlow.Elasticsearch
    • 🔴 EventFlow.EntityFramework
    • 🔴 EventFlow.EventStores.EventStore
    • 🔴 EventFlow.Hangfire
    • 🟢 EventFlow.MongoDB
    • 🟢 EventFlow.MsSql
    • 💀 EventFlow.Owin
    • 🟢 EventFlow.PostgreSql
    • 🔴 EventFlow.RabbitMQ
    • 🟢 EventFlow.Sql
    • 🔴 EventFlow.SQLite
    • 🟢 EventFlow.TestHelpers

    Branches

    • develop-v1: Development branch, pull requests should be done here
    • release-v1: Release branch, merge commits are done to this branch from develop-v1 to create releases. Typically each commit represents a release

  • 0.x (API stable)

    The current stable version of EventFlow and has been the version of EventFlow for almost six years. 0.x versions have .NET Framework support and limited support to the Microsoft extension packages through extra NuGet packages.

    Feature and bug fix releases will still be done while there's interest in the community.

    Branches

    • develop-v0: Development branch, pull requests should be done here
    • release-v0: Release branch, merge commits are done to this branch from develop-v0 to create releases. Typically each commit represents a release

    Documentation

    Version 0.x documentation is (although a bit outdated) is live at https://docs.geteventflow.net/.

Examples

  • Complete: Shows a complete example on how to use EventFlow with in-memory event store and read models in a relatively few lines of code
  • Shipping: To get a more complete example of how EventFlow could be used, have a look at the shipping example found here in the code base. The example is based on the shipping example from the book "Domain-Driven Design - Tackling Complexity in the Heart of Software" by Eric Evans. Its in-progress, but should provide inspiration on how to use EventFlow on a larger scale. If you have ideas and/or comments, create a pull request or an issue

External Examples

List of examples create by different community members. Note that many of these examples will be using EventFlow 0.x.

Create a pull request to get your exampled linked from here.

  • Racetimes: Shows some features of EventFlow that are not covered in the complete example. It features entities, a read model for an entity, delete on read models, specifications and snapshots.

  • .NET Core: A Web API running .NET Core 2.2 using the event flow. It uses the pre-defined command/entities/events from the complete example. There are endpoints to create a new example event, getting a data model and to replay all data models.

  • ElasticSearch/.NET Core: It is configured with EventFlow, ElasticSearch, EventStore, and RabbitMq. See "withRabbitMq" branch for #384.

  • Vehicle Tracking: A Microservice on .NET Core 2.2 with docker based, you can up the service with docker-compose, this project using various tools to up the services aka. Linux Docker based on .NET Core, RabbitMq, EntityFramework with SQL Server and using EventFlow following CQRS-ES architecture and all microservice can access through ApiGateway which using Ocelot

  • RestAirline: A classic DDD with CQRS-ES, Hypermedia API project based on EventFlow. It's targeted to ASP.NET Core 2.2 and can be deployed to docker and k8s.

  • Full Example: A console application on .NET Core 2.2. You can up the services using docker-compose file. Docker-compose file include EventStore, RabbitMq, MongoDb, and PostgreSQL. It include following EventFlow concepts:

    • Aggregates
    • Command bus and commands
    • Synchronous subscriber
    • Event store (GES)
    • In-memory read model.
    • Snapshots (MongoDb)
    • Sagas
    • Event publising (In-memory, RabbitMq)
    • Metadata
    • Command bus decorator, custom value object, custom execution result, ...

Overview

Here is a list of the EventFlow concepts. Use the links to navigate to the documentation.

  • Aggregates: Domains object that guarantees the consistency of changes being made within each aggregate
  • Command bus and commands: Entry point for all command/operation execution.
  • Event store: Storage of the event stream for aggregates. Currently there is support for these storage types.
    • In-memory - only for test
    • Files - only for test
    • Microsoft SQL Server
    • Entity Framework Core
    • SQLite
    • PostgreSQL
    • EventStore - home page
  • Subscribers: Listeners that act on specific domain events. Useful if an specific action needs to be triggered after a domain event has been committed.
  • Read models: Denormalized representation of aggregate events optimized for reading fast. Currently there is support for these read model storage types. For the SQL storage types the queries are being generated automatically with quoted columns and table names.
  • Snapshots: Instead of reading the entire event stream every single time, a snapshot can be created every so often that contains the aggregate state. EventFlow supports upgrading existing snapshots, which is useful for long-lived aggregates. Snapshots in EventFlow are opt-in and EventFlow has support for
  • Sagas: Also known as process managers, coordinates and routes messages between bounded contexts and aggregates
  • Queries: Value objects that represent a query without specifying how its executed, that is let to a query handler
  • Jobs: Perform scheduled tasks at a later time, e.g. publish a command. EventFlow provides support for these job schedulers
  • Event upgrade: As events committed to the event store is never changed, EventFlow uses the concept of event upgraders to deprecate events and replace them with new during aggregate load.
  • Event publishing: Sometimes you want other applications or services to consume and act on domains. For this EventFlow supports event publishing.
  • Metadata: Additional information for each aggregate event, e.g. the IP of the user behind the event being emitted. EventFlow ships with several providers ready to use used.
  • Value objects: Data containing classes used to validate and hold domain data, e.g. a username or e-mail.
  • Customize: Almost every single part of EventFlow can be swapped with a custom implementation through the embedded IoC container.

Complete example

Here's a complete example on how to use the default in-memory event store along with an in-memory read model.

The example consists of the following classes, each shown below

  • ExampleAggregate: The aggregate root
  • ExampleId: Value object representing the identity of the aggregate root
  • ExampleEvent: Event emitted by the aggregate root
  • ExampleCommand: Value object defining a command that can be published to the aggregate root
  • ExampleCommandHandler: Command handler which EventFlow resolves using its IoC container and defines how the command specific is applied to the aggregate root
  • ExampleReadModel: In-memory read model providing easy access to the current state

Note: This example is part of the EventFlow test suite, so checkout the code and give it a go.

[Test]
public async Task Example()
{
  // We wire up EventFlow with all of our classes. Instead of adding events,
  // commands, etc. explicitly, we could have used the the simpler
  // AddDefaults(Assembly) instead.
  var serviceCollection = new ServiceCollection()
    .AddLogging()
    .AddEventFlow(o => o
      .AddEvents(typeof(ExampleEvent))
      .AddCommands(typeof(ExampleCommand))
      .AddCommandHandlers(typeof(ExampleCommandHandler))
      .UseInMemoryReadStoreFor<ExampleReadModel>());

  using (var serviceProvider = serviceCollection.BuildServiceProvider())
  {
    // Create a new identity for our aggregate root
    var exampleId = ExampleId.New;

    // Resolve the command bus and use it to publish a command
    var commandBus = serviceProvider.GetRequiredService<ICommandBus>();
    await commandBus.PublishAsync(
      new ExampleCommand(exampleId, 42), CancellationToken.None);

    // Resolve the query handler and use the built-in query for fetching
    // read models by identity to get our read model representing the
    // state of our aggregate root
    var queryProcessor = serviceProvider.GetRequiredService<IQueryProcessor>();
    var exampleReadModel = await queryProcessor.ProcessAsync(
      new ReadModelByIdQuery<ExampleReadModel>(exampleId), CancellationToken.None);

    // Verify that the read model has the expected magic number
    exampleReadModel.MagicNumber.Should().Be(42);
  }
}

// The aggregate root
public class ExampleAggregate : AggregateRoot<ExampleAggregate, ExampleId>,
  IEmit<ExampleEvent>
{
  private int? _magicNumber;

  public ExampleAggregate(ExampleId id) : base(id) { }

  // Method invoked by our command
  public void SetMagicNumber(int magicNumber)
  {
    if (_magicNumber.HasValue)
      throw DomainError.With("Magic number already set");

    Emit(new ExampleEvent(magicNumber));
  }

  // We apply the event as part of the event sourcing system. EventFlow
  // provides several different methods for doing this, e.g. state objects,
  // the Apply method is merely the simplest
  public void Apply(ExampleEvent aggregateEvent)
  {
    _magicNumber = aggregateEvent.MagicNumber;
  }
}

// Represents the aggregate identity (ID)
public class ExampleId : Identity<ExampleId>
{
  public ExampleId(string value) : base(value) { }
}

// A basic event containing some information
public class ExampleEvent : AggregateEvent<ExampleAggregate, ExampleId>
{
  public ExampleEvent(int magicNumber)
  {
      MagicNumber = magicNumber;
  }

  public int MagicNumber { get; }
}

// Command for update magic number
public class ExampleCommand : Command<ExampleAggregate, ExampleId>
{
  public ExampleCommand(
    ExampleId aggregateId,
    int magicNumber)
    : base(aggregateId)
  {
    MagicNumber = magicNumber;
  }

  public int MagicNumber { get; }
}

// Command handler for our command
public class ExampleCommandHandler
  : CommandHandler<ExampleAggregate, ExampleId, ExampleCommand>
{
  public override Task ExecuteAsync(
    ExampleAggregate aggregate,
    ExampleCommand command,
    CancellationToken cancellationToken)
  {
    aggregate.SetMagicNumber(command.MagicNumber);
    return Task.CompletedTask;;
  }
}

// Read model for our aggregate
public class ExampleReadModel : IReadModel,
  IAmReadModelFor<ExampleAggregate, ExampleId, ExampleEvent>
{
  public int MagicNumber { get; private set; }

  public Task ApplyAsync(
    IReadModelContext context,
    IDomainEvent<ExampleAggregate, ExampleId, ExampleEvent> domainEvent,
    CancellationToken _cancellationToken
  {
    MagicNumber = domainEvent.AggregateEvent.MagicNumber;
    return Task.CompletedTask;
  }
}

State of EventFlow

EventFlow is still under development, especially the parts regarding how read models are re-populated.

EventFlow is currently used in production environments and performs very well, but it needs to mature before key APIs are stable.

EventFlow is greatly opinionated, but it's possible to create new implementations for almost every part of EventFlow by registering a different implementation of an interface.

Many of the technical design decisions in EventFlow is based on articles. This section lists some of them. If you have a link with a relevant article, please share it by creating an issue with the link.

Integration tests

EventFlow has several tests that verify that its ability to use the systems it integrates with correctly.

To setup a local test environment run the following commands in the checkout directory of EventFlow.

docker-compose pull
docker-compose up

Alternatively, you can skip the NUnit tests marked with the integration category.

Thanks

<table border="0" cellpadding="0" cellspacing="0"> <tr> <td width="25%"> <a href="https://www.jetbrains.com/"><img src="./Resources/jetbrains-128x128.png" /></a> </td> </tr> </table>

License

The MIT License (MIT)

Copyright (c) 2015-2021 Rasmus Mikkelsen
Copyright (c) 2015-2021 eBay Software Foundation
https://github.com/eventflow/EventFlow

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Product Compatible and additional computed target framework versions.
.NET net5.0 was computed.  net5.0-windows was computed.  net6.0 is compatible.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 was computed.  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. 
.NET Core netcoreapp3.0 was computed.  netcoreapp3.1 is compatible. 
.NET Standard netstandard2.1 is compatible. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (19)

Showing the top 5 NuGet packages that depend on EventFlow:

Package Downloads
EventFlow.AspNetCore

# EventFlow <table border=0 cellpadding=0 cellspacing=0> <tr> <td width=25%> <img src=./icon-128.png /> </td> <td width=25%> <p> <a href=https://www.nuget.org/packages/EventFlow/><img src=https://img.shields.io/nuget/v/EventFlow.svg?style=flat /></a> </p> <p> <a href=https://docs.geteventflow.net/?badge=latest><img src=https://readthedocs.org/projects/eventflow/badge/?version=latest /></a> </p> </td> <td width=25%> <p> <a href=https://ci.appveyor.com/project/eventflow/eventflow><img src=https://ci.appveyor.com/api/projects/status/51yvhvbd909e4o82/branch/develop?svg=true /></a> </p> <p> <a href=https://gitter.im/rasmus/EventFlow?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge><img src=https://badges.gitter.im/Join Chat.svg /></a> </p> <!-- <p> <a href=https://codecov.io/github/eventflow/EventFlow?branch=develop><img src=https://codecov.io/github/eventflow/EventFlow/coverage.svg?branch=develop /></a> </p> --> </td> <td width=25%> Think EventFlow is great,<br/> <a href=https://www.paypal.me/rasmusnu>buy me a cup of coffee</a> </td> </tr> </table> NuGet feeds - Official releases: https://www.nuget.org/packages/EventFlow/ - Builds: https://ci.appveyor.com/nuget/eventflow EventFlow is a basic CQRS+ES framework designed to be easy to use. Have a look at our [getting started guide](https://docs.geteventflow.net/GettingStarted.html), the [do’s and don’ts](https://docs.geteventflow.net/DosAndDonts.html) and the [FAQ](https://docs.geteventflow.net/FAQ.html). ### Features * **CQRS+ES framework** * **Async/await first:** Every part of EventFlow is written using async/await. * **Highly configurable and extendable** * **Easy to use** * **No use of threads or background workers** * **Cancellation:** All methods that does IO work or might delay execution (due to retries), takes a `CancellationToken` argument to allow you to cancel the operation ### Examples * **[Complete](#complete-example):** Shows a complete example on how to use EventFlow with in-memory event store and read models in a relatively few lines of code * **Shipping:** To get a more complete example of how EventFlow _could_ be used, have a look at the shipping example found here in the code base. The example is based on the shipping example from the book Domain-Driven Design - Tackling Complexity in the Heart of Software by Eric Evans. Its _in-progress_, but should provide inspiration on how to use EventFlow on a larger scale. If you have ideas and/or comments, create a pull request or an issue
EventFlow.Sql

# EventFlow ![EventFlow logo](https://raw.githubusercontent.com/eventflow/EventFlow/develop-v1/icon-128.png) ``` $ dotnet add package EventFlow ``` EventFlow is a basic CQRS+ES framework designed to be easy to use. Have a look at our [getting started guide](https://geteventflow.net/getting-started/), the [do’s and don’ts](https://geteventflow.net/additional/dos-and-donts/) and the [FAQ](https://geteventflow.net/additional/faq/). Alternatively, join our [Discord](https://discord.gg/QfgNPs5WxR) server to engage with the community. Its hopefully getting a reboot to kickstart the upcoming release of v1. ## Features * **Easy to use**: Designed with sensible defaults and implementations that make it easy to create an example application * **Highly configurable and extendable**: EventFlow uses interfaces for every part of its core, making it easy to replace or extend existing features with custom implementation * **No use of threads or background workers** * **MIT licensed** Easy to understand and use license for enterprise ## Versions Development of version 1.0 has started and is mainly braking changes regarding changes related to replacing EventFlow types with that of Microsoft extension abstractions, mainly `IServiceProvider` and `ILogger<>`. The following list key characteristics of each version as well as its related branches (not properly configured yet). * `1.x` Represents the next iteration of EventFlow that aligns EventFlow with the standard packages for .NET. Releases here will only support .NET Standard, .NET Core and .NET versions 6+ going forward. - Released - Still development - Not all projects migrated yet Read the [migration guide](https://geteventflow.net/migrations/v0-to-v1/) to view the full list of breaking changes as well as recommendations on how to migrate. ### Documentation Version 1.x documentation has been pulled into this repository in order to have the code and documentation closer together and have the documentation updated in the same pull-requests as any code changes. The compiled version of the documentation is available at https://geteventflow.net/. ### NuGet package status - 🟢 ported - 💚 newly added to 1.0 - 🟠 not yet ported to 1.0 - 💀 for packages that are removed as part of 1.0 (see the [migration guide](https://geteventflow.net/migrations/v0-to-v1/) for details) Projects - 🟢 `EventFlow` - 🟠 `EventFlow.AspNetCore` - 💀 `EventFlow.Autofac` - 💀 `EventFlow.DependencyInjection` - 🟠 `EventFlow.Elasticsearch` - 🟠 `EventFlow.EntityFramework` - 🟠 `EventFlow.EventStores.EventStore` - 🟢 `EventFlow.Hangfire` - 🟢 `EventFlow.MongoDB` - 🟢 `EventFlow.MsSql` - 💀 `EventFlow.Owin` - 🟢 `EventFlow.PostgreSql` - 💚 `EventFlow.Redis` - 🟠 `EventFlow.RabbitMQ` - 🟢 `EventFlow.Sql` - 🟠 `EventFlow.SQLite` - 🟢 `EventFlow.TestHelpers` ### Branches - `develop-v1`: Development branch, pull requests should be done here - `release-v1`: Release branch, merge commits are done to this branch from `develop-v1` to create releases. Typically each commit represents a release * `0.x` (legacy) The current stable version of EventFlow and has been the version of EventFlow for almost six years. 0.x versions have .NET Framework support and limited support to the Microsoft extension packages through extra NuGet packages. Feature and bug fix releases will still be done while there's interest in the community. ### Branches - `develop-v0`: Development branch, pull requests should be done here - `release-v0`: Release branch, merge commits are done to this branch from `develop-v0` to create releases. Typically each commit represents a release ### Documentation Version 0.x documentation is (although a bit outdated) is live at https://docs.geteventflow.net/.
EventFlow.DependencyInjection

# EventFlow <table border=0 cellpadding=0 cellspacing=0> <tr> <td width=25%> <img src=./icon-128.png /> </td> <td width=25%> <p> <a href=https://www.nuget.org/packages/EventFlow/><img src=https://img.shields.io/nuget/v/EventFlow.svg?style=flat /></a> </p> <p> <a href=https://docs.geteventflow.net/?badge=latest><img src=https://readthedocs.org/projects/eventflow/badge/?version=latest /></a> </p> </td> <td width=25%> <p> <a href=https://ci.appveyor.com/project/eventflow/eventflow><img src=https://ci.appveyor.com/api/projects/status/51yvhvbd909e4o82/branch/develop?svg=true /></a> </p> <p> <a href=https://gitter.im/rasmus/EventFlow?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge><img src=https://badges.gitter.im/Join Chat.svg /></a> </p> <!-- <p> <a href=https://codecov.io/github/eventflow/EventFlow?branch=develop><img src=https://codecov.io/github/eventflow/EventFlow/coverage.svg?branch=develop /></a> </p> --> </td> <td width=25%> Think EventFlow is great,<br/> <a href=https://www.paypal.me/rasmusnu>buy me a cup of coffee</a> </td> </tr> </table> NuGet feeds - Official releases: https://www.nuget.org/packages/EventFlow/ - Builds: https://ci.appveyor.com/nuget/eventflow EventFlow is a basic CQRS+ES framework designed to be easy to use. Have a look at our [getting started guide](https://docs.geteventflow.net/GettingStarted.html), the [do’s and don’ts](https://docs.geteventflow.net/DosAndDonts.html) and the [FAQ](https://docs.geteventflow.net/FAQ.html). ### Features * **CQRS+ES framework** * **Async/await first:** Every part of EventFlow is written using async/await. * **Highly configurable and extendable** * **Easy to use** * **No use of threads or background workers** * **Cancellation:** All methods that does IO work or might delay execution (due to retries), takes a `CancellationToken` argument to allow you to cancel the operation ### Examples * **[Complete](#complete-example):** Shows a complete example on how to use EventFlow with in-memory event store and read models in a relatively few lines of code * **Shipping:** To get a more complete example of how EventFlow _could_ be used, have a look at the shipping example found here in the code base. The example is based on the shipping example from the book Domain-Driven Design - Tackling Complexity in the Heart of Software by Eric Evans. Its _in-progress_, but should provide inspiration on how to use EventFlow on a larger scale. If you have ideas and/or comments, create a pull request or an issue
EventFlow.Elasticsearch

# EventFlow <table border=0 cellpadding=0 cellspacing=0> <tr> <td width=25%> <img src=./icon-128.png /> </td> <td width=25%> <p> <a href=https://www.nuget.org/packages/EventFlow/><img src=https://img.shields.io/nuget/v/EventFlow.svg?style=flat /></a> </p> <p> <a href=https://docs.geteventflow.net/?badge=latest><img src=https://readthedocs.org/projects/eventflow/badge/?version=latest /></a> </p> </td> <td width=25%> <p> <a href=https://ci.appveyor.com/project/eventflow/eventflow><img src=https://ci.appveyor.com/api/projects/status/51yvhvbd909e4o82/branch/develop?svg=true /></a> </p> <p> <a href=https://gitter.im/rasmus/EventFlow?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge><img src=https://badges.gitter.im/Join Chat.svg /></a> </p> <!-- <p> <a href=https://codecov.io/github/eventflow/EventFlow?branch=develop><img src=https://codecov.io/github/eventflow/EventFlow/coverage.svg?branch=develop /></a> </p> --> </td> <td width=25%> Think EventFlow is great,<br/> <a href=https://www.paypal.me/rasmusnu>buy me a cup of coffee</a> </td> </tr> </table> NuGet feeds - Official releases: https://www.nuget.org/packages/EventFlow/ - Builds: https://ci.appveyor.com/nuget/eventflow EventFlow is a basic CQRS+ES framework designed to be easy to use. Have a look at our [getting started guide](https://docs.geteventflow.net/GettingStarted.html), the [do’s and don’ts](https://docs.geteventflow.net/DosAndDonts.html) and the [FAQ](https://docs.geteventflow.net/FAQ.html). ### Features * **CQRS+ES framework** * **Async/await first:** Every part of EventFlow is written using async/await. * **Highly configurable and extendable** * **Easy to use** * **No use of threads or background workers** * **Cancellation:** All methods that does IO work or might delay execution (due to retries), takes a `CancellationToken` argument to allow you to cancel the operation ### Examples * **[Complete](#complete-example):** Shows a complete example on how to use EventFlow with in-memory event store and read models in a relatively few lines of code * **Shipping:** To get a more complete example of how EventFlow _could_ be used, have a look at the shipping example found here in the code base. The example is based on the shipping example from the book Domain-Driven Design - Tackling Complexity in the Heart of Software by Eric Evans. Its _in-progress_, but should provide inspiration on how to use EventFlow on a larger scale. If you have ideas and/or comments, create a pull request or an issue
EventFlow.MongoDB

# EventFlow ![EventFlow logo](https://raw.githubusercontent.com/eventflow/EventFlow/develop-v1/icon-128.png) ``` $ dotnet add package EventFlow ``` EventFlow is a basic CQRS+ES framework designed to be easy to use. Have a look at our [getting started guide](https://geteventflow.net/getting-started/), the [do’s and don’ts](https://geteventflow.net/additional/dos-and-donts/) and the [FAQ](https://geteventflow.net/additional/faq/). Alternatively, join our [Discord](https://discord.gg/QfgNPs5WxR) server to engage with the community. Its hopefully getting a reboot to kickstart the upcoming release of v1. ## Features * **Easy to use**: Designed with sensible defaults and implementations that make it easy to create an example application * **Highly configurable and extendable**: EventFlow uses interfaces for every part of its core, making it easy to replace or extend existing features with custom implementation * **No use of threads or background workers** * **MIT licensed** Easy to understand and use license for enterprise ## Versions Development of version 1.0 has started and is mainly braking changes regarding changes related to replacing EventFlow types with that of Microsoft extension abstractions, mainly `IServiceProvider` and `ILogger<>`. The following list key characteristics of each version as well as its related branches (not properly configured yet). * `1.x` Represents the next iteration of EventFlow that aligns EventFlow with the standard packages for .NET. Releases here will only support .NET Standard, .NET Core and .NET versions 6+ going forward. - Released - Still development - Not all projects migrated yet Read the [migration guide](https://geteventflow.net/migrations/v0-to-v1/) to view the full list of breaking changes as well as recommendations on how to migrate. ### Documentation Version 1.x documentation has been pulled into this repository in order to have the code and documentation closer together and have the documentation updated in the same pull-requests as any code changes. The compiled version of the documentation is available at https://geteventflow.net/. ### NuGet package status - 🟢 ported - 💚 newly added to 1.0 - 🟠 not yet ported to 1.0 - 💀 for packages that are removed as part of 1.0 (see the [migration guide](https://geteventflow.net/migrations/v0-to-v1/) for details) Projects - 🟢 `EventFlow` - 🟠 `EventFlow.AspNetCore` - 💀 `EventFlow.Autofac` - 💀 `EventFlow.DependencyInjection` - 🟠 `EventFlow.Elasticsearch` - 🟠 `EventFlow.EntityFramework` - 🟠 `EventFlow.EventStores.EventStore` - 🟢 `EventFlow.Hangfire` - 🟢 `EventFlow.MongoDB` - 🟢 `EventFlow.MsSql` - 💀 `EventFlow.Owin` - 🟢 `EventFlow.PostgreSql` - 💚 `EventFlow.Redis` - 🟠 `EventFlow.RabbitMQ` - 🟢 `EventFlow.Sql` - 🟠 `EventFlow.SQLite` - 🟢 `EventFlow.TestHelpers` ### Branches - `develop-v1`: Development branch, pull requests should be done here - `release-v1`: Release branch, merge commits are done to this branch from `develop-v1` to create releases. Typically each commit represents a release * `0.x` (legacy) The current stable version of EventFlow and has been the version of EventFlow for almost six years. 0.x versions have .NET Framework support and limited support to the Microsoft extension packages through extra NuGet packages. Feature and bug fix releases will still be done while there's interest in the community. ### Branches - `develop-v0`: Development branch, pull requests should be done here - `release-v0`: Release branch, merge commits are done to this branch from `develop-v0` to create releases. Typically each commit represents a release ### Documentation Version 0.x documentation is (although a bit outdated) is live at https://docs.geteventflow.net/.

GitHub repositories (2)

Showing the top 2 popular GitHub repositories that depend on EventFlow:

Repository Stars
twzhangyang/RestAirline
DDD+CQRS+EventSourcing+Hypermedia API+ASP.NET Core 3.1+Masstransit+terraform+docker+k8s
OKTAYKIR/EventFlow.Example
DDD+CQRS+Event-sourcing examples using EventFlow following CQRS-ES architecture. It is configured with RabbitMQ, MongoDB(Snapshot store), PostgreSQL(Read store), EventStore(GES). It's targeted to .Net Core 2.2 and include docker compose file.
Version Downloads Last updated
1.0.5007 423 11/16/2024
1.0.5004-alpha 1,694 5/23/2024
1.0.5003-alpha 13,323 6/21/2023
1.0.5002-alpha 4,592 11/11/2022
1.0.5001-alpha 2,307 3/15/2022
1.0.4748-alpha 16,162 9/9/2021
1.0.4617-alpha 1,720 6/11/2021
0.84.4 554 11/16/2024
0.83.4713 1,089,328 9/7/2021
0.82.4684 8,046 8/30/2021
0.82.4659 37,119 6/17/2021
0.81.4483 172,303 12/14/2020
0.80.4377 51,854 10/1/2020
0.79.4216 122,691 5/13/2020
0.78.4205 5,874 5/11/2020
0.77.4077 93,782 12/10/2019
0.76.4014 33,971 10/19/2019
0.75.3970 12,435 9/12/2019
0.74.3948 24,057 7/1/2019
0.73.3933 9,534 6/11/2019
0.72.3914 11,697 5/28/2019
0.71.3834 14,942 4/17/2019
0.70.3824 6,938 4/11/2019
0.69.3772 17,212 2/12/2019
0.68.3728 46,061 12/3/2018
0.67.3697 12,936 10/14/2018
0.66.3673 8,677 9/28/2018
0.65.3664 10,674 9/22/2018
0.64.3598 10,304 8/27/2018
0.63.3581 9,179 8/7/2018
0.62.3569 35,227 7/5/2018
0.61.3524 6,535 6/26/2018
0.60.3490 5,417 6/18/2018
0.59.3396 6,120 5/23/2018
0.58.3377 5,150 5/13/2018
0.57.3359 5,869 4/30/2018
0.56.3328 4,611 4/24/2018
0.55.3323 4,772 4/24/2018
0.54.3261 6,129 2/25/2018
0.53.3204 4,649 1/25/2018
0.52.3178 5,377 11/2/2017
0.51.3155 4,238 10/25/2017
0.50.3124 4,307 10/21/2017
0.49.3031 6,879 9/7/2017
0.48.2937 5,447 7/11/2017
0.47.2894 4,952 6/28/2017
0.46.2886 7,848 5/29/2017
0.45.2877 4,376 5/28/2017
0.44.2832 4,208 5/12/2017
0.43.2806 2,357 5/5/2017
0.42.2755 5,067 5/2/2017
0.41.2727 4,931 4/27/2017
0.40.2590 8,137 3/30/2017
0.39.2553 5,185 1/16/2017
0.38.2454 5,045 12/2/2016
0.37.2424 5,265 11/8/2016
0.36.2315 6,217 10/18/2016
0.35.2247 5,138 9/6/2016
0.34.2221 4,896 8/23/2016
0.33.2190 4,669 8/16/2016
0.32.2163 4,814 7/4/2016
0.31.2106 4,637 6/30/2016
0.30.2019 4,981 6/16/2016
0.29.1973 6,397 4/19/2016
0.28.1852 4,704 4/5/2016
0.27.1765 8,034 2/25/2016
0.26.1714 4,682 2/20/2016
0.25.1695 3,989 2/15/2016
0.24.1563 4,364 1/25/2016
0.23.1470 5,012 12/5/2015
0.22.1393 4,890 11/19/2015
0.21.1312 4,144 10/26/2015
0.20.1274 3,947 10/22/2015
0.19.1225 3,857 10/19/2015
0.18.1181 4,216 10/7/2015
0.17.1134 4,094 9/28/2015
0.16.1120 3,993 9/27/2015
0.15.1057 4,089 9/24/2015
0.14.1051 4,035 9/23/2015
0.13.962 4,013 9/13/2015
0.12.891 3,796 9/4/2015
0.11.751 3,765 8/24/2015
0.10.642 3,541 8/17/2015
0.9.580 3,613 7/20/2015
0.8.560 3,427 5/29/2015
0.7.481 3,416 5/22/2015
0.6.456 3,251 5/18/2015
0.5.390 3,429 5/8/2015
0.4.353 3,299 5/5/2015
0.3.292 3,870 4/30/2015

**IMPORTANT:** Major API breaking changes *might* occur between 1.0 pre-releases. As breaking
API changes will need to be tested and verified before the final 1.0 release.
Read the complete migration guide to get the full list of changes as well
as recommendations on how to do the migration.
https://github.com/eventflow/EventFlow/blob/develop-v1/MIGRATION_GUIDE.md
Changes since last 1.x pre-release, `1.0.5001-alpha`
* New/breaking: `IEventUpgrader<,>` are now (finally) async. For an easy upgrade experience,
 use the new base class `EventUpgraderNonAsync` for any existing upgraders. Its a `abstract`
 class that implements the updated interface and provides a `abstract` method with the same
 signature as the previous interface
* Fix/breaking: Event upgraders are now used during read model population. As the upgraders
 are re-used across multiple aggregates, there is a high likelihood that some additions are
 needed in any existing upgraders. Upgraders are stored on the new `IEventUpgradeContext`,
 which is created by the new `IEventUpgradeContextFactory`. Replace this if you need addition
 context during event upgrades
* Fix: `SnapshotAggregateRoot` now correctly loads previous source IDs as well
 adds the current source ID that triggered the snapshot. This causes the
 `DuplicateOperationException` to be correctly thrown if a duplicate source
 ID as added before a snapshot was taken
* Fix: Upgrade `Newtonsoft.Json` from `11.0.2` to `13.0.1` to fix DoS
 vulnerability
 - https://github.com/advisories/GHSA-5crp-9r3c-p9vr
 - https://security.snyk.io/vuln/SNYK-DOTNET-NEWTONSOFTJSON-2774678
* Fix: `UseFilesEventPersistence` should no longer throw exception for .NET regarding relative paths
Complete 1.0 change log
* New/breaking: Replace internal IoC implementation with `Microsoft.Extensions.DependencyInjection`
* New/breaking: Replace internal logging implementation with `Microsoft.Extensions.Logging`
* New/breaking: SQL read models now support different connection strings using the
 `[SqlReadModelConnectionStringName]` attribute. To allow executing queries using different
 connection strings, all methods on `IMsSqlConnection` and `ISqlConnection` now have an
 additional argument, `string connectionStringName` to signify which connection string
 should be used for the query
* New/breaking: SQL connection strings are now fetched from the
 `SqlConfiguration<T>.GetConnectionStringAsync(...)` instead of a property, allowing more
 control of the connection string used at runtime
* New/breaking: `IEventUpgrader<,>` are now (finally) async. For an easy upgrade experience,
 use the new base class `EventUpgraderNonAsync` for any existing upgraders. Its a `abstract`
 class that implements the updated interface and provides a `abstract` method with the same
 signature as the previous interface
* Fix/breaking: Event upgraders are now used during read model population. As the upgraders
 are re-used across multiple aggregates, there is a high likelihood that some additions are
 needed in any existing upgraders. Upgraders are stored on the new `IEventUpgradeContext`,
 which is created by the new `IEventUpgradeContextFactory`. Replace this if you need addition
 context during event upgrades
* New: Its now possible to change the execution timeout for database migrations using the
 `SetUpgradeExecutionTimeout(...)` on the SQL configuration
* Breaking: Removed the following dead and/or confusion MSSQL attributes. The real ones
 are named the same, with with `Sql...` instead of `MsSql...`
 - `MsSqlReadModelIdentityColumn`
 - `MsSqlReadModelIgnoreColumn`
 - `MsSqlReadModelVersionColumn`
* Breaking: Methods on `IMsSqlDatabaseMigrator` and `ISqlDatabaseMigrator` have been
 made async and have an extra `CancellationToken` argument
* Breaking: Remove support for .NET Framework and consolidate on .NET (Core) LTS versions
* Breaking: Replace internal in-memory caching with `Microsoft.Extensions.Caching.Memory`
* Breaking: Removed `IAmAsyncReadModelFor` and made `IAmReadModelFor` async
* Breaking: Removed `EventFlow.Core.AsyncHelper` as well as all async wrapper methods
 that used it
 - `IAggregateStore.Load`
 - `IAggregateStore.Store`
 - `IAggregateStore.Update`
 - `ICommandBus.Publish`
 - `IEventStore.LoadAggregate`
 - `IEventStore.LoadEvents`
 - `IEventStore.LoadAllEvents`
 - `IQueryProcessor.Process`
 - `IReadModelPopulator.Populate`
 - `IReadModelPopulator.Purge`
* Fix: `SnapshotAggregateRoot` now correctly loads previous source IDs as well
 adds the current source ID that triggered the snapshot. This causes the
 `DuplicateOperationException` to be correctly thrown if a duplicate source
 ID as added before a snapshot was taken
* Fix: Upgrade `Newtonsoft.Json` from `11.0.2` to `13.0.1` to fix DoS
 vulnerability
 - https://github.com/advisories/GHSA-5crp-9r3c-p9vr
 - https://security.snyk.io/vuln/SNYK-DOTNET-NEWTONSOFTJSON-2774678
* Version of 0.x included: `0.83.4713`. 0.x changes are merged to 1.x at regular
 intervals, but might be one or two releases behind