Akka.Serialization.Hyperion 1.5.57-beta2

• .NETStandard 2.0

  • Akka (>= 1.5.57-beta2)
  • Hyperion (>= 0.12.2)
  • System.Reflection (>= 4.3.0)
  • System.Runtime (>= 4.3.1)

• net6.0

  • Akka (>= 1.5.57-beta2)
  • Hyperion (>= 0.12.2)

Akka.NET v1.5.57-beta2 is a beta release containing significant new APIs for Akka.Persistence that add completion callbacks and async handler support.

**New Features:**

* [Persistence completion callbacks via Defer - simplified alternative](https://github.com/akkadotnet/akka.net/pull/7957) - This release adds completion callback and async handler support to `Persist`, `PersistAsync`, `PersistAll`, and `PersistAllAsync` methods in Akka.Persistence. Key improvements include:
 - **Async Handler Support**: All persist methods now support `Func<TEvent, Task>` handlers for async event processing
 - **Completion Callbacks**: `PersistAll` and `PersistAllAsync` now accept optional completion callbacks (both sync `Action` and async `Func<Task>`) that execute after all events are persisted and handled
 - **Ordering Guarantees**: Completion callbacks use `Defer`/`DeferAsync` internally to maintain strict ordering guarantees
 - **Zero Breaking Changes**: All new APIs are additive overloads

**Code Examples:**

```csharp
// Async handler support - process events asynchronously
Persist(new OrderPlaced(orderId), async evt =>
{
   await _orderService.ProcessOrderAsync(evt);
});

// PersistAll with completion callback - know when all events are done
PersistAll(orderEvents, evt =>
{
   _state.Apply(evt);
}, onComplete: () =>
{
   // All events persisted and handlers executed
   _logger.Info("Order batch completed");
   Sender.Tell(new BatchComplete());
});

// PersistAll with async handler AND async completion callback
PersistAll(events,
   handler: async evt => await ProcessEventAsync(evt),
   onCompleteAsync: async () =>
   {
       await NotifyCompletionAsync();
       Sender.Tell(Done.Instance);
   });

// PersistAllAsync with completion - allows commands between handlers
PersistAllAsync(largeEventBatch,
   handler: evt => _state.Apply(evt),
   onComplete: () => Sender.Tell(new BatchProcessed()));
```

**Technical Details:**

The implementation maintains Akka.Persistence's strict ordering guarantees by using `Defer`/`DeferAsync` for completion callbacks, ensuring they execute in order even when called with empty event collections. The new async handler invocations (`IAsyncHandlerInvocation`) are processed via `RunTask` to preserve the actor's single-threaded execution model.

1 contributor since release 1.5.57-beta1

| COMMITS | LOC+ | LOC- | AUTHOR |
| --- | --- | --- | --- |
| 1 | 1386 | 67 | Aaron Stannard |

To [see the full set of changes in Akka.NET v1.5.57-beta2, click here](https://github.com/akkadotnet/akka.net/milestone/141?closed=1)