How would one add Domain Events, or perhaps use our own versions of Entity and Aggregate Root

[jeffward01]

Hello again!

I have (2) questions, maybe I should split it up into (2) posts, but they are also related.

Questions

1.) How would one add events? Usually the void RaiseEvent(<someEventClass>) { ... } resides in the AggregateRoot, or as some prefer (myself included) in the Entity class.

2.) This is an expansion on question 1. Many of us have our own Entity and AggregateRoot classes we use in our own codebase. For example, mine looks something like:

public abstract partial class Entity<TKey> : IGeneratesDomainEvents, IEntity<TKey>, IEntity
    where TKey : IComparable<TKey>, IEquatable<TKey>
{
    private readonly ConcurrentQueue<IDomainEvent> _domainEvents = new();

    private DateTime _createdAt;

    private DateTime _deactivatedAt;

    private DateTime _deletedAt;

    private DateTime _modifiedAt;

    public abstract object[] GetKeys();

     public TKey? Id { get; }

    public bool IsActive { get; }

    public bool IsDeactivated { get; }

    public bool IsSoftDeleted { get; }

    public bool IsDeactivatedAndDeleted { get; }

    public bool HasPrimaryKey => this.IsTransient.IsFalse();

    public abstract bool IsTransient { get; }

    public DateTime? SoftDeletedAtUtc =>
        this._deletedAt.Equals(default) ? default : this._deletedAt;

    public DateTime CreatedAtUtc => this._createdAt.Equals(default) ? default : this._createdAt;

    public DateTime? DeactivatedAtUtc =>
        this._deactivatedAt.Equals(default) ? default : this._deactivatedAt;

    public DateTime ModifiedAtUtc => this._modifiedAt.Equals(default) ? default : this._modifiedAt;

    public TKey CreatedByUserId { get; }

    public TKey? DeletedByUserId { get; }

    public TKey? DeactivatedByUserId { get; }

    public TKey? ModifiedByUserId { get; }

    public void MarkCreate(TKey createdByUserId, DateTime? utcDateTime = null) { }

    public void MarkDeactivate(TKey deactivatedByUserId, DateTime? utcDateTime = null) { }

    public void MarkSoftDelete(TKey deletedByUserId, DateTime? utcDateTime = null) { }

    public void MarkModified(TKey modifiedByUserId, DateTime? utcDateTime = null) { }

    public void ClearDomainEvents()
    {
        this._domainEvents.Clear();
    }

    public int GetRaisedDomainEventCount()
    {
        return this._domainEvents.Count;
    }

    public IEnumerable<IDomainEvent> GetAllDomainEvents()
    {
        return this._domainEvents;
    }

    public async IAsyncEnumerable<IDomainEvent> GetAllDomainEventsAsync(
        [EnumeratorCancellation] CancellationToken cancellationToken = default
    )
    {
        await foreach (
            IDomainEvent domainEvent in this._domainEvents
                .ToAsyncEnumerable()
                .WithCancellation(cancellationToken)
        )
        {
            yield return domainEvent;
        }
    }

    protected internal virtual void RaiseDomainEvent(IDomainEvent domainEvent)
    {
        this._domainEvents.Enqueue(domainEvent);
    }
}

I copy pasted my code from some interfaces, so its not accurate, but you get the point.

Im sure many people have their own implementations, how would one work with the library while using their own base models?

Thanks!

[xavierjohn]

Maybe I should breakup the DDD assembly to ValueObject and AggregateRoot, then people can avoid the AggregateRoot assembly

[jeffward01]

Hm, maybe:

• breakup the DDD assembly
• substitute the abstract clases for interfaces (IEntity<T>, IEntity, etc...) interfaces, and just have them be empty markers?
  I have not looked closely at your code, but it seems like Entity and AggregateRoot are just empty classes as it is.

I know ABP has some great examples in their code of generic DDD interfaces if you want to take a look here just for your own reading

Ive been a developer for 10 years now, but im only just diving into DDD, i'm going to watch some videos on it, and refer to your library. I'll make some PR requests if I have some time!

I love what you are doing for CSharpFunctionalExtensions also!

[xavierjohn]

I will break it up into

• FunctionalDDD.DDD (Entity, AggregateRoot & ValueObject)
• FunctionalDDD.ROP (ROP stuff, Error & ErrorList)

I wonder if there is a better name than FunctionalDDD since FunctionalDDD.DDD has redundant DDD.

[xavierjohn]

I split the packages to RailwayOrientedProgramming and DomainDrivenDesign. Now you should be able to use your own DDD classes.

[jeffward01]

Very cool, thanks for doing this. I am going to make a suggestion that https://github.com/vkhorikov/CSharpFunctionalExtensions does the same.

Very cool library btw, im using it in an app Im creating. I plan to make a sample project after I have the app made. I am a little behind schedule on this

[jeffward01]

vkhorikov/CSharpFunctionalExtensions#435