private async ValueTask ProcessEventReply(string routingKey, string eventName, ReadOnlyMemory <byte> message,
                                                  CancellationToken cancel = default)
        {
            if (SubsManager.HasSubscriptionsForEventReply(routingKey))
            {
                var subscriptions = SubsManager.GetHandlersForEventReply(routingKey);
                if (!subscriptions.Any())
                {
                    Logger.LogError("ProcessEventReply subscriptions no items! " + routingKey);
                }
                foreach (var subscription in subscriptions)
                {
                    switch (subscription.SubscriptionManagerType)
                    {
                    case SubscriptionManagerType.Rpc:
                        try
                        {
                            if (EventHandler is null)
                            {
                                Logger.LogError("ProcessEventReply _eventHandler is null!");
                            }
                            else
                            {
                                var eventType = SubsManager.GetEventTypeByName(routingKey);
                                if (eventType is null)
                                {
                                    Logger.LogError("ProcessEventReply: eventType is null! " + routingKey);
                                    return;
                                }

                                var eventResultType = SubsManager.GetEventReplyTypeByName(routingKey);
                                if (eventResultType is null)
                                {
                                    Logger.LogError("ProcessEventReply: eventResultType is null! " + routingKey);
                                    return;
                                }

                                await using var ms = new MemoryStream(message.ToArray());
                                var integrationEvent = Serializer.Deserialize(eventResultType, ms);
                                var concreteType     =
                                    typeof(IIntegrationRpcHandler <,>).MakeGenericType(eventType,
                                                                                       eventResultType);
                                await((ValueTask)concreteType.GetMethod("HandleReply")
                                      .Invoke(EventHandler, new[] { integrationEvent, cancel })).ConfigureAwait(false);
                            }
                        }
                        catch (Exception ex)
                        {
                            Logger.LogError("ProcessEventReply: " + ex.Message + " - " + ex.StackTrace);
                        }
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                }
            }
            else
            {
                Logger.LogError("ProcessEventReply HasSubscriptionsForEventReply " + routingKey + " No Subscriptions!");
            }
        }