How to conduct a fully synchronous multi-step database operation? - asp.net

Question

Current project:
DotNet 4.7
MVC 5
C# 7.1
Repository pattern that uses Linq Lambda for CRUD operations
I have a bit of a problem with regards to what might seem like a concurrency issue, but really isn’t.
You see, the system I am building allows a user to register for a class. Each class has a certain capacity, and there needs to be the ability to have people sitting in both Enrolled and Waitlisted states.
The Registration table does this by having an Enrolled boolean, true for Enrolled, False for waitlisted. The problem is, during the registration process, I need a query-count that brings up the number of existing Registered users, sees how many open spots there still are by comparing the Enrolled=yes count to the capacity value of the class (a different table), and if there are any open spots, allows a user to register with the Enrolled flag set to true. If there are no spots left, the user is registered with the Enrolled flag is set to False.
The problem exists when there is one spot left and two users sign up simultaneously (or close enough for the system to be working on one operation at the same time as the other). I have seen timestamps on the existing Registration table, and there are times when two users are very, very close together in having their data entered.
I need a system, either in SQL or in MVC, that will only do one user registration at a time. That there will be no chance whatsoever that it starts a second user registration (the query to see how many Enrolled=yes there are in the Registrations table) until the saving of the first user's registration is done. In no case should the number of Enrolled=yes registrations ever exceed the capacity of the class that the user is enrolling in.
In other words, the actual query-count-compare-decide-record process (at least two touches of the database, one to query, one to record) needs to be absolutely SYNCHRONOUS, and essentially block all other registration attempts until the process is done. Because this will be done in one block of code, I can safely say that the table will never be “locked” for any longer than it actually takes to run the code; this process is after all relevant user interaction. But since this is a read (counting all the current registrations where Enrolled = yes, to determine if current write needs to be Enrolled=yes or =no) followed by a write, I am worried about a second read occurring between the read and the write of the first, and that the second write occurs after the first, leaving the Enrolled=true count in an incompliant state.
Since the number of users who are signing up will only ever be small(ish), I am not overly concerned about performance, but I am stumped on how to actually implement this.
Suggestions?

Answer 1

IMO, the most important thing is, implement the validation in the database, at least. Don't allow the data to violate a rule like this.
I think you should just use an insert/update trigger and block a statement if it violates your constraint. It's the same as implementing a check constraint, but gives you the flexibility to check the class capacity, count the number of students in the class, and throw an error (rolling back the transaction) if you ever exceed the student limit in a course.
The trigger executes in the same transaction as the DML statement that triggers it, so if you THROW an error, you roll it all back. Something like this should work:
CREATE TABLE class (class_id INT, capacity INT)
GO
CREATE TABLE registration (class_id INT, student_id INT, enrolled BIT)
GO
CREATE TRIGGER i_registration
ON registration
FOR INSERT, UPDATE
AS
BEGIN
SET NOCOUNT ON;
IF EXISTS (
SELECT * FROM (
SELECT SUM(CASE WHEN enrolled = 1 THEN 1 ELSE 0 END) OVER (PARTITION BY r.class_id) enrolled, c.capacity
FROM registration r
INNER JOIN class c ON r.class_id = c.class_id
)sq WHERE enrolled > capacity
)
THROW 51000, 'Class is full!', 1
END
GO
And some sample DML statements:
insert into class values (1, 5)
insert into registration values (1, 1, 1)
insert into registration values (1, 2, 1)
insert into registration values (1, 3, 0)
insert into registration values (1, 4, 0)
insert into registration values (1, 5, 1)
insert into registration values (1, 6, 1)
insert into registration values (1, 7, 1)
insert into registration values (1, 8, 1) -- blocked!
update registration set enrolled = 1 where student_id = 3 -- blocked!
When you call SaveChangesAsync() in your client app, it's going to raise an exception (System.Data.Entity.Infrastructure.DbUpdateException), and you'll be able to see your exception message & number by cascading through Inner Exceptions until you find a System.Data.SqlClient.SqlException. You can use these to determine how to present the error message to the user: