Creating Sequential Numbers

EfCoreSequentialNumberRepository.cs

    public class EfCoreSequentialNumberRepository : EfCoreRepository<IQaDbContext, SequentialNumber, Guid>, ISequentialNumberRepository
    {
        public EfCoreSequentialNumberRepository(IDbContextProvider<IQaDbContext> dbContextProvider)
            : base(dbContextProvider)
        {

        }

        public virtual SequentialNumber FindBySequenceName(string sequenceName)
        {
            return DbSet.FirstOrDefault(n => n.SequenceName == sequenceName);
        }
    }

ISequentialNumberManager.cs

    public interface ISequentialNumberManager : IDomainService
    {
        Task<int> GetNextAsync(string sequenceName);
    }

ISequentialNumberRepository.cs

 public interface ISequentialNumberRepository : IBasicRepository<SequentialNumber, Guid>
    {
        [CanBeNull]
        SequentialNumber FindBySequenceName([NotNull] string sequenceName);
    }

SequentialNumber.cs

 public class SequentialNumber : AggregateRoot<Guid>, IMultiTenant
    {
        public virtual Guid? TenantId { get; protected set; }

        public virtual string SequenceName { get; protected set; }

        public virtual int CurrentValue { get; protected set; }

        protected SequentialNumber()
        {

        }

        public SequentialNumber([NotNull]string sequenceName, Guid? tenantId = null)
        {
            SequenceName = Check.NotNull(sequenceName, nameof(sequenceName));
            TenantId = tenantId;
            CurrentValue = 1;
            ConcurrencyStamp = Guid.NewGuid().ToString();
        }

        public void Increment()
        {
            ++CurrentValue;
        }
    }

SequentialNumberManager.cs

 public class SequentialNumberManager : DomainService, ISequentialNumberManager
    {
        private const int GetNextTryCount = 3;

        private readonly ISequentialNumberRepository _sequentialNumberRepository;

        public SequentialNumberManager(ISequentialNumberRepository sequentialNumberRepository)
        {
            _sequentialNumberRepository = sequentialNumberRepository;
        }

        public async Task<int> GetNextAsync([NotNull] string sequenceName)
        {
            Check.NotNull(sequenceName, nameof(sequenceName));

            Exception exception = null;

            for (var i = 0; i < GetNextTryCount; i++)
            {
                try
                {
                    return await GetNextInternalAsync(sequenceName);
                }
                catch (Exception e)
                {
                    exception = e;
                }
            }

            throw exception;
        }

        private async Task<int> GetNextInternalAsync(string sequenceName)
        {
            var sequentialNumber = _sequentialNumberRepository.FindBySequenceName(sequenceName);

            if (sequentialNumber == null)
            {
                sequentialNumber = await _sequentialNumberRepository.InsertAsync(new SequentialNumber(sequenceName, CurrentTenant.Id), autoSave: true);
            }
            else
            {
                sequentialNumber.Increment();
                await _sequentialNumberRepository.UpdateAsync(sequentialNumber, autoSave: true);
            }

            return sequentialNumber.CurrentValue;
        }
    }