public async Task HandleAsync(UpdateUserCommand message)
        {
            var user = await domainRepository.GetByKeyAsync<Guid, User>(message.UserId);
            bool updated = false;
            if (!string.IsNullOrEmpty(message.DisplayName) && user.DisplayName != message.DisplayName)
            {
                user.ChangeDisplayName(message.DisplayName);
                updated = true;
            }
            if (!string.IsNullOrEmpty(message.Email) && user.Email != message.Email)
            {
                user.ChangeEmail(message.Email);
                updated = true;
            }
            if (updated)
            {
                await domainRepository.SaveAsync<Guid, User>(user);
            }
        }

      public async Task SaveAsync<TKey, TAggregateRoot>(TAggregateRoot aggregateRoot, bool purge = true)
            where TKey : IEquatable<TKey>
            where TAggregateRoot : class, IAggregateRoot<TKey>, new()
        {
            // When doing a CQRS architecture with Event Sourcing (ES), this step should be going
            // to save the events occurred within the aggregate. In this example, we simply save
            // the entire aggregate root to avoid handling the snapshots.

            await this.SaveAggregateAsync<TKey, TAggregateRoot>(aggregateRoot);
            foreach(var evnt in aggregateRoot.UncommittedEvents)
            {
                messagePublisher.Publish(evnt);
            }

            if (purge)
            {
                ((IPurgeable)aggregateRoot).Purge();
            }
        }