Port Persistence to C# about protoactor-dotnet

[cpx86]

Cool, I'll get to work on the receive pipeline first, then continue with persistence.

[cpx86]

Given a receive pipeline like that which exists in Go right now, adding persistence without inheritance shouldn't be too difficult.

The main problem that I see is to find a suitable replacement for the mixin/embedded field. One option is to replace it with an interface that you need to implement, containing the ProviderState, EventIndex, etc. The downside of it is that the implementation of those properties will be forced upon each actor implementation. One way of making it a bit easier on the actor implementer is to wrap all of the embedded fields in a composed type.

So you would have something like the below (based on existing persistence example). It is basically equivalent to the Go implementation except you need to "dot in" to access the persistence stuff, and the Actor needs to implement an auto-property from the interface. Thoughts?

// user code
class MyPersistentActor : IActor, IPersistentActor
{
    public PersistenceState PersistenceState { get; set; }
    public Task ReceiveAsync(IContext context)
    {
        switch (context.Message)
        {
            case RenameCommand rename:
                PersistenceState.PersistReceive(rename);
                break;
            case AddItemCommand addItem:
                PersistenceState.PersistReceive(addItem);
                break;
        }
    }
}

// protoactor implementation
public interface IPersistentActor
{
    PersistenceState PersistenceState { get; set; }
}

public class PersistenceState
{
    public ProviderState ProviderState { get; set; }
    public int EventIndex { get; set; }
    public IContext Context { get; set; }
    public bool Recovering { get; set; }

    public void Init(PersistenceProvider provider, IContext context)
    {
        ProviderState = provider.GetState();
        Context = context;
        Recovering = true;
        //... more init code
    }
}

Receive Using(PersistenceProvider provider)
{
    return context =>
    {
        switch (context.Message)
        {
            case Started started:
                break;
            case Replay replay:
                var p = context.Actor as IPersistentActor;
                if (p != null)
                {
                    p.PersistenceState = new PersistenceState();
                    p.PersistenceState.Init(provider, context);
                }
                break;
        }
    };
}

[rogeralsing]

Love it, your interface suggestion is as good as it gets in C# IMO.
I cant see any other non magic way of doing this with less code.

[rogeralsing]

This has been merged, closing