In this post I am presenting a couple of things I’ve learned from the analysis of a problem, that manifested itself in an occasional HTTP 500 errors in production instance of an ASP.NET application. This time I don’t aim at exhaustively explaining every single point, because each of them could be a subject of a dedicated blog post.
The story begins with SQL error: SQLEXCEPTION: Transaction was deadlocked on lock resources with another process and has been chosen as the deadlock victim.
In any reasonably modern version of SQL Server Management Studio there is an
system_healthunder Management → Extended Events. It allows for viewing some important server logs, among which
xml_deadlock_reportin particularly interesting. It is very important to have an access to the production instance of database server in order to be able to watch the logs.
In this particular case, these
xml_deadlock_reportscontained one suspicious attribute: isolationlevel = Serializable (4) and the SQL code was a
SELECT. I would not expect my
SELECTs running with Serializable isolation level.
The isolation level is an attribute of a connection between a client and the database server. A connection is called session in SQL Server terminology. An explicit
BEGIN TRANis not necessary for the isolation level to be applied. Every SQL statement runs in its own statement-wide transaction. However, for such narrow-scoped transactions, in practice it may not make any difference whether you raise the isolation level or not. The difference can be observed when a transaction is explicit and spans multiple SQL statements.
The cause of setting the serialization level to Serializable was the behaviour of the
TransactionScope. If you use it, it raises the isolation level. It is just a peculiarity of this very API of the .NET framework. It is good to know this.
- SQL Server, at last in 2012 and some (I am not sure exactly which ones) later versions, does not reset the isolation level when ADO.NET disposes of a connection. A connection returns back to the connection pool  and is reused by subsequent
SqlConnectionobjects unless they have different connection string.
- The connection pool size, if the connection pooling is active, poses the limit of how many concurrent connections to a database server a .NET application can make. If there are no free connections in the pool, an exception is thrown .
Eliminating the usage of
TransactionScopedid not solve the issue. Even if you run
SELECTs under the default Read Committed isolation level, these still issues Shared locks which may deadlock with Exclusive locks of
UPDATEs. In any reasonably high production data traffic, where
SELECTs span multiple tables, which are also very frequently updated, it is highly probable, that a deadlock will occur.
The difference between running
SELECTunder Serializable isolation level and Read Committed level is that in the former, the locks are kept from the moment of executing the
SELECTuntil the transaction ends. You can observe it by manually beginning a Serializable transaction, running any
dm_tran_locksDMV and only then committing (or rolling back, whatever) the transaction. With Read Committed level locks are not kept until an explicit transaction ends, they are released immediately after execution of a
SELECTfinishes. These are the same kind of locks, Shared locks. This implies one cannot observe the difference between executing a
SELECTunder Serializable and Read Committed, when there is no explicit transaction and thus, there is only a statement-wide transaction which releases locks immediately after the results are returned.
- Setting isolation level of Read Uncommitted is practically equivalent to running a
SELECT WITH(NOLOCK)hint, even if you don’t explicitly open a transaction.
In Entity Framework a
SqlConnectionis opened for every materialization of the query, the results are returned, and the connection is immediately closed and returned back to the pool . The connection lifetime is by no means related to the scope of
DbContextobject. I can see a kind of similarity between how Entity Framework uses
SqlConnections and how ASP.NET makes use of threads when executing
asyncmethods. A thread is released on every
awaitand can be used for doing something more valuable than waiting. Similarly, a
SqlConnectionis released right after materialization and can be used for executing different command, in different request (in case of ASP.NET) even before
DbContextis disposed of.
- It is not that obvious how to reset the isolation level of the connection. You see, every time your C# code using Entity Framework results in sending a SQL to the SQL Server, it can take different connection from the pool (if anyone knows if there is any ordering applied when retrieving connections from the pool, please feel free to comment). It may or may not be the same connection you used previously. Consequently, it is not easy to ‘catch’ the underlying connection using Entity Framework. You can call
BeginTransactionevery time you use
DbContext, and then you are guaranteed to own the connection for all your SQL commands. But that way you are forcing opening transaction when you don’t really need one. What I recommend is to handle
DbConnectionobject as described in . You can do it either on opening the connection or on closing it.
In SQL Server you can monitor open sessions with the following query:
select DB_NAME(s.database_id) as DbName, case s.transaction_isolation_level WHEN 0 THEN 'Unspecified' WHEN 1 THEN 'ReadUncommitted' WHEN 2 THEN 'ReadCommitted' WHEN 3 THEN 'RepeatableRead' WHEN 4 THEN 'Serializable' WHEN 5 THEN 'Snapshot' end as Level, s.session_id as Session from sys.dm_exec_sessions s where DB_NAME(s.database_id) <> 'master' order by s.last_request_end_time desc;