eventflow / eventflow

Async/await first CQRS+ES and DDD framework for .NET

EventFlow

$ 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, 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

  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.

  • Released
  • Still development
  • Not all projects migrated yet

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

  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

  • 🟢 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 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/.

Talks directly related to EventFlow

• GOTO Aarhus 2022 by rasmus Practical event sourcing using EventFlow

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.

  • Racetimes for Azure Functions: Extends the above example to support the HTTP access via Azure Functions

  • Racetimes for Azure Functions and Event Grid: Further extends the Azure Functions Example to publish to Event Grid, following the RabbitMQ pattern

• .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.
  • Elasticsearch
  • In-memory - only for test
  • Microsoft SQL Server
  • Entity Framework Core
  • SQLite
  • PostgreSQL
• 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
  • In-memory - only for test
  • Microsoft SQL Server
  • Entity Framework Core
  • SQLite
  • PostgreSQL
• 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
  • Hangfire - home page
• 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.
  • RabbitMQ
• 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.

Useful articles related to EventFlow and DDD

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.

• Domain-Driven Design
  • Domain-Driven Design Reference by Eric Evans
  • DDD Decoded - Bounded Contexts Explained
  • Going "Events-First" for Microservices with Event Storming and DDD
• General CQRS+ES
  • CQRS Journey by Microsoft published by Microsoft
  • An In-Depth Look At CQRS by Mike Mogosanu
  • CQRS, Task Based UIs, Event Sourcing agh! by Greg Young
  • Busting some CQRS myths by Jimmy Bogard
  • CQRS applied by Gabriel Schenker
  • DDD Decoded - Entities and Value Objects Explained
• Eventual consistency
  • How To Ensure Idempotency In An Eventual Consistent DDD/CQRS Application by Mike Mogosanu
  • DDD Decoded - Don't Fear Eventual Consistency
• Why not to implement "unit of work" in DDD
  • Unit Of Work is the new Singleton by Mike Mogosanu
  • The Unit of Work and Transactions In Domain-Driven Design by Mike Mogosanu

Integration tests

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

• Elasticsearch
• EventStore
• RabbitMQ
• Microsoft SQL Server
• PostgreSQL

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

• Contributors
• JetBrains: OSS licenses
• olholm: Current logo
• iconmonstr: First logo
• JC008: License for Navicat Essentials for SQLite

License

EventFlow was originally developed in my spare time while I worked at both eBay (2015 to 2021) and Schibsted (2021 and onward).

The MIT License (MIT)

Copyright (c) 2015-2024 Rasmus Mikkelsen
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.

eventflow's Issues

Archive event streams

As an alternative to the of deleting event streams described in #48, we should provide functionality to ease the process of archiving an aggregate event stream.

OWIN package should include optional web API

Create an optional middleware that exposes the event stream and/or aggregates on a web API.

Make sure to ILMerge any additional references to e.g. web API. The EventFlow.Owin package should only reference Owin and EventFlow.

Apply missing events to read models

If a read model version doesn't match with the domain events to be applied, missing events should be loaded and applied to the read model.

Alternative interface for configuration

We need to rethink how the EventFlowOptions interface is and how users define configuration.

Proposals:

  // Option 1
  EventFlowOptions.New
    .As.EventSource().Use<MsSqlEventSource>()

  // Option 2
  EventFlowOptions.New
    .EventStore(r => r.Use<MsSqlEventStore())

@tabro Any other suggestions?

Documentation

... just an obvious reminder.

MongoDB support as event store

Try out another event store

File systems event store

As an alternative to the in-memory event store, create a file system event store that stores events as JSON on disk.

Delete event streams from event store

We should provide functionality to completely remove specific event streams from the event stores, i.e., aggregates.

Introduce aggregate event routing to allow e.g. state objects

Instead of enforcing developers to implement the Apply methods on the aggregate classes, allow event routing that could e.g. allow the Apply methods to be implemented on a nested state object instead.

Build all read models from event store

We need support for flushing all read models and then building them again from the event store. Its critical that both the purge and rebuild is controlled explicitly by the developer.

Add NOLOCK to MSSQL SELECT statements

As the title says

SELECT * FROM [dbo].[table1] WITH (NOLOCK)

Aggregate snapshotting

Instead of loading the entire event history for a aggregate, load a snapshot representing e.g. events 1 to 100 and then continue from there.

Problems

• How to handle event upgrading

Required functionality

• Delete snapshots and fallback to event loading

Create more metadata providers

Add a few more metadata providers that developers can use if they like

Examples:

• Add event assembly name and version
• Add event type
• Add environment specific information as e.g. machine name

Use of nvarchar on AggregateId in EventStores.MsSql could impact indexing

Is unicode needed in the aggregate id and should it be 255 long?

Using unicode in an indexed field does have an impact on the available key space in a data page in sql server which could result in performance issues when handling huge volumes of event data in the event store.

Move remove base class `EventStore`

It seems like the functionality put into the EventStore base class could be moved to a separate class. This class would then have the following responsibility

• Gathering metadata for events
• Mapping from the uncommitted events to serialized events
• Mapping from committed events to domain events

In short, map between storage to domain

Integration tests for MSSQL packages

Complete integration testing with MSSQL is needed to make it less likely that these components breake.

Implement optimistic concurrency for read models

Version should be checked on reading and writing updates to read models to ensure that no-one updated the read model while we were e.g. applying events to ours.

Elasticsearch read model store

Create a read model store for Elasticsearch.

Provide a EventStore event store

Create a NuGet package for https://geteventstore.com as event store.

Create NuGet package for make domain tests easier

Instead of leaving developers to implement their own helpers for testing domain code, they should be provided by the framework.

Create a read model store manager

Pull stuff related to read model stores out of CommandBus and put it into another class

Aggregate/event caching

Make it possible to do custom aggregate/event caching and provide an in-memory implementation that can be used

Not possible to resolve IOwinContext from singleton event store

As the in-memory event store is a singleton, it cannot resolve the metadata providers that depend on IOwinContext. The workaround is to use a event store that resolves to a new instance each time.

Can we do things better

Have a look at these recommended articles and see if there's any lessons that can be implemented in EventFlow.

• https://www.cuttingedge.it/blogs/steven/pivot/entry.php?id=91
• https://www.cuttingedge.it/blogs/steven/pivot/entry.php?id=92

Create ISubscribeAsynchronousTo

Developers might want to add some processing of events for later and although it is currently possible to do this, we should help developers.

• Create new the interface ISubscribeAsynchronousTo<T>
• Add a method on IEventJsonSerializer that can serialize IDomainEvents to help developers e.g. send events through RabbitMQ for asynchronous processing
• Create a new interface and service similar to IDispatchToEventSubscribers than can invoke those who implement the newly created ISubscribeAsynchronousTo<T> that can be called from e.g. a RabbitMQ consumer
• Maybe add a helper class that can handle the deserialization and invocation of the dispatcher

Read models that span multiple aggregates

The current implementation of read models only take events from a single aggregate. We need a method for creating read models than span multiple aggregates.

Problems

• As optimistic concurrency within one aggregate is handled by the event store, how to handle when events are applied to a read model that spans multiple aggregates and the events are committed simultaneously.

Why does Command.Publish() require a CancellationToken?

Command.Publish() uses an async adapter internally but externally presents itself as not being async and the need to pass a cancellationToken parameter appears confusing.

Make EventFlow Test Helpers usable in projects that implement EventFlow

Getting a testing system up in EventFlow can be intimidating and time consuming, event if you understand the basics. Ensuring that existing test helpers are usable by projects implementing EventFlow, overall adoption rates and implementation quality in downstream projects will be improved.

Example:
In EventFlow.MsSql.Tests.Helpers the MsSqlHelper helper class does not allow for explicit database names and TestDatabase drops the database as it is designed for use in unit tests and not integration tests. A bool transient option can be added to indicated if a database should be dropped after a test to allow the developer to use a growing set of event stream data.

Handle transient MSSQL exceptions

There are several MSSQL exceptions which should be retried.

• http://www.getcodesamples.com/src/A122E27E/5586EA7F

Introduce a simple saga system

Inspiration

• https://msdn.microsoft.com/en-us/library/jj591569.aspx
• http://blog.jonathanoliver.com/cqrs-sagas-with-event-sourcing-part-i-of-ii/

Notes

• Its critical that the saga system is optional, as developers might a different view on how to write sagas or even if they should be used

In-memory event store should also throw optimistic concurrency exceptions

The in-memory event store should also throw optimistic concurrency exceptions if there's a conflict

Cleanup too many `ToList()`

Currently the code has way too many ToList() operations. In some places there's no need and we should return IEnumerable<T> instead and use yield.

Replace reflection magic

Have a look at this to see if some of EventFlows reflection code can be simplified.

https://github.com/ploeh/Albedo

Consider change to LibLog

Instead of creating yet another log framework within EventFlow, consider changing to LibLog and then embed the DLL with ILMerge.

https://github.com/damianh/LibLog

EventFlowGuide

I started a set of simple guides to using EventFlow. Every guide uses Nocco to generate line comments and guides to explain the code and use of EventFlow.

Your input would be appreciated.

See https://github.com/JC008/EventFlowGuide

Help with creation of SQL for MSSQL read models

Instead of developers writing their SQL manually for MSSQL read models, create a helper classes that can assist them.

Its vital that this is opt-in.

OWIN support

Create a NuGet package for OWIN support along with a few metadata providers.

Create a sample domain for test

To better get an understanding of how changes affect developers using EventFlow, and improve testing, create a complete domain with multiple aggregates and events and then test it using e.g. SpecFlow.

Statistics module

Be able to gather timing statistics from within EventFlow

Something similar to this

using (_timer.Measure("description"))
{
   // stuff to time
}

Add cancellation token support

It would seem like cancellation tokens has been forgotten

Remove global sequence number

From https://groups.yahoo.com/neo/groups/domaindrivendesign/conversations/topics/18453

Order is only assured per a handler within an aggregate root boundary.
There is no assurance of order between handlers or between aggregates.
Trying to provide those things leads to the dark side.

Greg Young

Limit visibility of IEmit.Apply()

The IEmit interface forces the Apply method on an AggregateRoot to be public and exposes them to external abuse.

Is it possible to use a IEventWriter<> concept with a nested class to prevent external access to the Apply methods?

See the code below and last section for IEventWriter.

using EventFlow.Aggregates;
using EventFlow.Exceptions;
using Membership.Event;
using System;

namespace Membership.Aggregate
{
    public class Signup : AggregateRoot<Signup, AccountId>,
        IEmit<SignupStarted>,
        IEmit<SignupConfirmed>
    {
        public Signup(AccountId id)
            : base(id)
        {
            // void
        }

        public bool Confirmed { get; private set; }
        public string Email { get; private set; }
        public string Name { get; private set; }

        private string _confirmationCode { get; set; }

        private string _passwordHash { get; set; }

        // QUESTION how can apply be limited to being called by specific libraries but still implement the interface IEmit...
        // QUESTION can an inverted IEventWriter<TAggregate, TIdentity>() be used to move all Apply methods into a AggretageWriter class
        public void Apply(SignupStarted e)
        {
            Name = e.Name;
            Email = e.Email;
            _passwordHash = e.PasswordHash;
            _confirmationCode = e.ConfirmationCode;
        }

        public void Apply(SignupConfirmed e)
        {
            // QUESTION how can event datetime be accessed
            Confirmed = true;
        }

        internal void ConfirmSignup(string confirmationCode)
        {
            // TODO
        }

        internal void Start(string name, string email, string password)
        {
            if (!IsNew)
            {
                throw DomainError.With("User already created");
            }

            var hasher = new Crypto.PasswordHasher();
            var h = hasher.HashPassword(password);
            // TODO setup the confirmation token
            var c = "123";
            Emit(new SignupStarted(name, email, h, c));
        }

        // POTENTIAL SOLUTION limit access to Apply methods that are exposed by their interface nature iow public
        private class SignupEventWriter : EventWriter<Signup, AccountId>,
            IApply<Signup, SignupStarted>,
            IApply<Signup, SignupConfirmed>
        {
            public void Apply(Signup aggregate, SignupStarted e)
            {
                aggregate.Name = e.Name;
                aggregate.Email = e.Email;
                aggregate._passwordHash = e.PasswordHash;
                aggregate._confirmationCode = e.ConfirmationCode;
            }

            public void Apply(Signup aggregate, SignupConfirmed e)
            {
                aggregate.Confirmed = true;
            }
        }
    }
}

namespace EventFlow.Aggregates
{
    public interface IApply<TAggregate, in TAggregateEvent>
        where TAggregate : IAggregateRoot<IIdentity>
        where TAggregateEvent : IAggregateEvent
    {
        void Apply(TAggregate aggregate, TAggregateEvent e);
    }

    //public interface IEmit<????> ???
    //

    public interface IEventWriter<TAggregate, TIdentity>
    {
    }

    public abstract class EventWriter<TAggregate, TIdentity>
        where TAggregate : AggregateRoot<TAggregate, TIdentity>
        where TIdentity : IIdentity
    {
    }

    // changes are required in AggregateRoot.ApplyEvents to support this
    // IEmit is an issue ....
}

Configurable background jobs

As an integrated part of EventFlow, it should be possible to create background jobs. These could be used for several things.

• Better transient fault handling
• Fire and forget commands
• Delayed execution

Several methods could be used, but as the "core" of EventFlow doesn't have background jobs, the feature should be disabled by default and left as a configuration option.

These could be used for implementing the jobs.

• RabbitMQ
• Hangfire

Run time event mapping

Migrate event to newer/other versions at run-time to facilitate the deprecation of events.

Introduce ITimeMachine

Create a service for getting DateTimeOffset.Now to make it easier to test time.

Update README with shields

Examples

• https://github.com/fsprojects/Paket/blob/master/README.md

ReadModelStore should cache Apply method infos

As the title says...

Implement optimistic concurrency for MSSQL event store

The event store checks that no events was written via the indexes, but we need to implement retry and make the exception more explicit.

Be able to configure "point of no return" for cancellation

Cancellation tokens are used everywhere, but different applications might have completely different views on what is supposed to be cancelled.

• Likely to have cancellation
  • Command execution and storage of events in event store
• Unlikely to have cancellation
  • Read model updates. The application might depend on read models, so if the event store is updated but the read models isn't, some application might enter a faulty state.
  • Notification of event subscribers

Cross assembly type cast exception when implementing a new AutofacAggregateFactory and using AutofacResolver.

A cross assembly type cast issue forces the extension method to configure the aggregate factory to be implemented in eventflow.dll and not eventflow.autofac.dll.

EXCEPTION DETAILS
An exception of type 'System.InvalidCastException' occurred in EventFlow.Autofac.dll but was not handled in user code

Additional information: [A] EventFlow.Configuration.Registrations.AutofacResolver cannot be cast to[B] EventFlow.Configuration.Registrations.AutofacResolver.Type A originates from 'EventFlow, Version=0.0.1.0, Culture=neutral, PublicKeyToken=null' in the context 'Default' at location 'C:\Users\Jaco\Projects\EventFlowGuide\UsingAggregateState\bin\Debug\EventFlow.dll'. Type B originates from 'EventFlow.Autofac, Version=0.0.1.0, Culture=neutral, PublicKeyToken=null' in the context 'Default' at location 'C:\Users\Jaco\Projects\EventFlowGuide\UsingAggregateState\bin\Debug\EventFlow.Autofac.dll'.

See https://github.com/JC008/EventFlow/tree/autofac-aggregatefactory for details