I have the following method:
public static IEnumerable<Dictionary<string, object>> GetRowsIter
(this SqlCeResultSet resultSet)
{
// Make sure we don't multi thread the database.
lock (Database)
{
if (resultSet.HasRows)
{
resultSet.Read();
do
{
var resultList = new Dictionary<string, object>();
for (int i = 0; i < resultSet.FieldCount; i++)
{
var value = resultSet.GetValue(i);
resultList.Add(resultSet.GetName(i), value == DBNull.Value
? null : value);
}
yield return resultList;
} while (resultSet.Read());
}
yield break;
}
I just added the lock(Database)
to try and get rid of some concurancy issues. I am curious though, will the yield return
free the lock on Database
and then re-lock when it goes for the next iteration? Or will Database
remain locked for the entire duration of the iteration?
No the yield return
will not cause any locks to be freed / unlocked. The lock
statement will expand out to a try / finally
block and the iterator will not treat this any differently than an explicit try / finally
in the iterator method.
The details are a bit more complicated but the basic rules for when a finally
block will run inside an iterator method is
Dispose
is called the finally
blocks in scope at the point of the suspend will run finally
the finally
block runs. yield break
statement the finally
blocks in scope at the point of the yield break
will run The lock translates to try/finally (normal c#)
In Iterator blocks (aka yield), "finally" becomes part of the IDisposable.Dispose() implementation of the enumerator . This code is also invoked internally when you consume the last of the data.
"foreach" automatically calls Dispose(), so if you consume with "foreach" (or regualar LINQ etc) it will get unlocked.
However, if the caller uses GetEnumerator() directly (very rare) and doesnt read all the data and doesn't call Dispose() then the lock will not be released.
I would have to check to see if or gets a finaliser; it might get released by GC, but I wouldn't bet money on it.
The Database object will be locked until iteration finishes (or the iterator is disposed).
This might lead to excessive periods of locking, and I would recommend against doing it like this.
The lock remains in effect until you get outside of the scope of lock(). Yielding does not do that.
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.