Dataverse resilience experiment 2

private async Task CreateAndDeleteAccounts(int numberOfAccounts)
{
    var accountsToCreate = new List<Entity>();
    var count = 0;
    while (count < numberOfAccounts)
    {
        var account = new Entity("account")
        {
            ["name"] = $"Account {count}"
        };
        accountsToCreate.Add(account);
        count++;
    }

    var createdIds = new ConcurrentBag<Guid>();

    try
    {
        _logger.LogInformation($"Creating and deleting {accountsToCreate.Count} accounts");

        var startCreate = DateTime.Now;

        var parallelOptions = new ParallelOptions()
        {
            MaxDegreeOfParallelism =
                _xrmService.RecommendedDegreesOfParallelism
        };

        await Parallel.ForEachAsync(
            source: accountsToCreate,
            parallelOptions: parallelOptions,
            async (entity, token) =>
            {
                createdIds.Add(await _xrmService.CreateAsync(entity, token));
            });

        var secondsToCreate = (DateTime.Now - startCreate).TotalSeconds;

        _logger.LogInformation($"Created {accountsToCreate.Count} accounts in  {Math.Round(secondsToCreate)} seconds.");

        _logger.LogInformation($"Deleting {createdIds.Count} accounts");
        var startDelete = DateTime.Now;

        await Parallel.ForEachAsync(
            source: createdIds,
            parallelOptions: parallelOptions,
            async (id, token) =>
            {
                await _xrmService.DeleteAsync("account", id, token);
            });

        var secondsToDelete = (DateTime.Now - startDelete).TotalSeconds;

        _logger.LogInformation($"Deleted {createdIds.Count} accounts in {Math.Round(secondsToDelete)} seconds.");

    }
    catch (AggregateException ae)
    {
        var inner = ae.InnerExceptions.FirstOrDefault();
        if (inner != null)
        {
            throw inner;
        }
    }
}