Contention error when repeatedly updating a data entity with a foreach in c #

Question

How is it possible to optimize the update of an entity, when this entity is updated many times per second by request of the server ?. The method used for the update is developed as follows:

public async Task<bool> Update(T entity, string key)
    {
        try
        {
            MakeConnection();
            var trans = _db.BeginTransaction();
            var type = typeof(T);
            var keyFactory = _db.CreateKeyFactory(type.Name);
            var task = trans.Lookup(keyFactory.CreateKey(key));
            if (task != null)
            {
                _cache.KeyCache[type.Name] = _db.CreateKeyFactory(type.Name);
                var entities = _mapper.Map<Entity>(entity);
                task = entities;
                trans.Update(task);
            }
            await trans.CommitAsync();
        }
        catch (Exception e)
        {
            throw new InvalidOperationException($"An error occurred, {e}");
        }
        return true;
    }

and this is the error:

InvalidOperationException: An error occurred, Grpc.Core.RpcException: Status(StatusCode=Aborted, Detail="too much contention on these datastore entities. please try again. entity groups: [(app=p~********, *********, "76fcb9c1-009e-****-b54f-68a45e9c****")]")

Answer 1

There is a limit to the frequency with which you can update an entity, due to the distributed fault tolerance which DataStore provides. It’s recommend updating once per second at most, although in practice you can likely exceed this several times over.

You can read the documentation about Datastore contention. According to the doc, if you're expecting to update a single entity or write to an entity group more than several times per second, it's best to re-work your design early-on to avoid possible contention once your application is deployed.

One of the possible options is to use Sharding counters.