Question

I need to keep track of a sequential Id, this is being returned to me via a SP which is doing a max(id) across 4 tables, there is no identifer/sequence in the db which is managing the sequence. This will obviously have concurrency issues so i created a helper class to ensure unique Id’s are always generated.

The helper is initialised via its repository, which initially calls the DB to find the current Id, all subsequent requests for an Id are serviced in memory via the helper. There will only ever be 1 app using the DB (mine) so i dont need to worry about someone else coming along and creating transactions & throwing the Id out of sync. I think ive got the basics of thread-saftey but im worried about a race condition when the helper is initialised, can someone please advise 🙂

private class TransactionIdProvider
{
private static readonly object Accesslock = new object();
private int _transactionId;
public int NextId
{
    get
    {
        lock (Accesslock)
        {
            if(!Initialised) throw new Exception("Must Initialise with id first!!");
            return _transactionId++;
        }
    }
}

public bool Initialised { get; private set; }

public void SetId(int id)
{
    lock (Accesslock)
    {
        if (Initialised) return;
        _transactionId = id;
        Initialised = true;
    }
}

public TransactionIdProvider()
{
    Initialised = false;
}
}

The helper class is initialised in a repository:

private static readonly TransactionIdProvider IdProvider = new TransactionIdProvider();

    public int GetNextTransactionId()
    {
        if(!IdProvider.Initialised)
        {
            // Ask the DB
            int? id = _context.GetNextTransactionId().First();
            if (!id.HasValue)
                throw new Exception("No transaction Id returned");
            IdProvider.SetId(id.Value);
        }

        return IdProvider.NextId;
    }

Answer 1

It is thread-safe, but it’s unnecessarily slow.
You don’t need a lock to just increment a number; instead, you can use atomic math.

Also, you’re sharing the lock across all instances (it’s static), which is unnecessary. (There’s nothing wrong with having two different instances run at once)

Finally, (IMHO) there is no point in having a separate uninitialized state.

I would write it like this:

class TransactionIdProvider {
    private int nextId;
    public TransactionIdProvider(int id) {
        nextId = value;
    }

    public int GetId() {
        return Interlocked.Increment(ref nextId);
    }
}