Cast interface to concrete type

 public async Task PublishAsync<TMessage>(TMessage message) where TMessage : IApplicationEvent
        {
            if (message == null)
            {
                throw new ArgumentNullException(nameof(message));
            }
           //Получаю тут IApplicationEvent, а хотелось бы конкретный класс.
            var messageType = typeof(TMessage);
            List<ISubscription<TMessage>> subscriptionList = null;
            lock (_lock)
            {
                if (_subscriptions.ContainsKey(messageType))
                {
                    subscriptionList = new List<ISubscription<TMessage>>(
                        _subscriptions[messageType].Cast<ISubscription<TMessage>>());
                }
            }
            if (subscriptionList != null)
            {
                foreach (var subscription in subscriptionList)
                {
                    await subscription.Action(message);
                }
            }
        }

 public class RealService : IZipEventService
        {
            Random random = new Random();  
            public async Task<ICollection<IApplicationEvent>> GetZipEventsAsync(string NamePartionAction)
            {
                // fake some latency or similiar
                await Task.Delay(random.Next(10) + 10);
                // calculate two "zip codes". First: sum of all letters, Second: first letter only
                //var zip1 = cityName.Select(_ => _).Sum(_ => (int)_);
                //var zip2 = (int)cityName.First();
               var task =   Task.Factory.StartNew( () =>
                {
                    return  new List<IApplicationEvent>() {
                        new ClimbToRockNow(), new EatBananaNow(),
                       new ClimbToRockNow(), new ClimbToRockNow(), new EatBananaNow()
                    };
                });
                return await task;
            }
        }

result = await cache1.GetZipEventsAsync("One");
            foreach(var item in result)
            {
                //Соответственно тут item это IApplicationEvent.
                await eventAggregator.PublishAsync(item);
            }

 public class Subscription<TMessage> : ISubscription<TMessage> where TMessage : IApplicationEvent
    {
        private bool _disposed;
        private Guid _subscriptionId;
 
        public Subscription(IEventAggregator eventAggregator, Func<TMessage, Task> action, Guid correlationId = default(Guid))
        {
            EventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
            Action = action ?? throw new ArgumentNullException(nameof(action));
            CorrelationId = correlationId == default(Guid) ? Guid.NewGuid() : correlationId;
        }
 
        public Guid SubscriptionId
        {
            get
            {
                if (_subscriptionId == Guid.Empty)
                    _subscriptionId = Guid.NewGuid();
                return _subscriptionId;
            }
        }
 
        public Guid CorrelationId { get; set; }
 
        public Func<TMessage, Task> Action { get; private set; }
 
        public IEventAggregator EventAggregator { get; private set; }
 
        #region -- Dispose Implementation --
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        protected virtual void Dispose(bool disposing)
        {
            if (_disposed)
                return;
            if (!disposing)
                return;
            EventAggregator.UnSubscribe(this);
            _disposed = true;
        }
        #endregion
 
        #region -- Equality Implementation --
        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj))
                return false;
            if (ReferenceEquals(this, obj))
                return true;
            if (obj.GetType() != GetType())
                return false;
            return Equals((Subscription<TMessage>)obj);
        }
 
        public bool Equals(ISubscription<TMessage> other)
        {
            if (ReferenceEquals(null, other))
                return false;
            if (ReferenceEquals(this, other))
                return true;
            return _subscriptionId.Equals(other.SubscriptionId);
        }
 
        public override int GetHashCode() { return SubscriptionId.GetHashCode(); }
 
        public IEnumerator<TMessage> GetEnumerator()
        {
            throw new NotImplementedException();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            throw new NotImplementedException();
        }
 
        public static bool operator ==(Subscription<TMessage> left, Subscription<TMessage> right) { return Equals(left, right); }
 
        public static bool operator !=(Subscription<TMessage> left, Subscription<TMessage> right) { return !Equals(left, right); }
        #endregion
    }

 public ISubscription<T> Subscribe<T>(Func<T, Task> action, Guid correlationId = default(Guid)) where T : IApplicationEvent
        {
            lock (_lock)
            {
                var messageType = typeof(T);
                var subscription = new Subscription<T>(this, action, correlationId);
 
                // Check to see if we have this event message type defined in the subscriptions dictionary. If not, create the
                // event message type and add the subscription to it.
                if (_subscriptions.ContainsKey(messageType))
                {
                    // Check to see if there is already a subscription of the same type with the same correlation ID
                    if (correlationId != default(Guid))
                    {
                        var hasCorrelationID = false;
                        var subsList = _subscriptions[messageType];
 
                        // Iterate through the subscriptions and determine if there is an existing subscription with that correlation ID
                        foreach (Subscription<T> subscriptionItem in subsList)
                        {
                            // We check for a match on both the correlation Id and the action (or method to be called when event is published)
                            hasCorrelationID = subscriptionItem.CorrelationId == correlationId && subscriptionItem.Action == action;
 
                            // If we don't have a correlation Id then we continue with the loop
                            if (!hasCorrelationID)
                            {
                                continue;
                            }
 
                            // Otherwise we we pull the existing subscription out of the current list and return 
                            // that back to the subscriber.
                            subscription = subscriptionItem;
                        }
                        if (!hasCorrelationID)
                        {
                            _subscriptions[messageType].Add(subscription);
                        }
                    }
                    else
                    {
                        _subscriptions[messageType].Add(subscription);
                    }
                }
                else
                {
                    _subscriptions.GetOrAdd(messageType, new List<ISubscription<T>> { subscription });
                }
                return subscription;
            }
        }