From 202cdf63704bc04fb0a027fe26372d9cb4515ca2 Mon Sep 17 00:00:00 2001 From: "Dailey, Alaric" Date: Sat, 24 Oct 2026 07:42:22 -0500 Subject: [PATCH 1/2] Make type map updates thread-safe --- Dapper/SqlMapper.cs | 65 ++++++++++++--------- Directory.Packages.props | 1 + tests/Dapper.Tests/Dapper.Tests.csproj | 5 +- tests/Dapper.Tests/FakeDbTests.Issue1439.cs | 51 ++++++++++++++++ 4 files changed, 91 insertions(+), 31 deletions(-) create mode 100644 tests/Dapper.Tests/FakeDbTests.Issue1439.cs diff --git a/Dapper/SqlMapper.cs b/Dapper/SqlMapper.cs index 8f3956cab..e9575975f 100644 --- a/Dapper/SqlMapper.cs +++ b/Dapper/SqlMapper.cs @@ -168,7 +168,8 @@ where pair.Value > 1 select Tuple.Create(pair.Key, pair.Value); } - private static Dictionary typeMap; + private static Dictionary typeMap; + private static readonly object typeMapSyncLock = new(); [Flags] internal enum TypeMapEntryFlags @@ -290,23 +291,26 @@ public static void AddTypeMap(Type type, DbType dbType) /// The type to map from. /// The database type to map to. /// Whether to prefer over . - public static void AddTypeMap(Type type, DbType dbType, bool useGetFieldValue) - { - // use clone, mutate, replace to avoid threading issues - var snapshot = typeMap; - var flags = TypeMapEntryFlags.None; - if (dbType >= 0) - { - flags |= TypeMapEntryFlags.SetType; - } - if (useGetFieldValue) - { - flags |= TypeMapEntryFlags.UseGetFieldValue; - } - var value = new TypeMapEntry(dbType, flags); - if (snapshot.TryGetValue(type, out var oldValue) && oldValue.Equals(value)) return; // nothing to do - - SetTypeMap(new Dictionary(snapshot) { [type] = value }); + public static void AddTypeMap(Type type, DbType dbType, bool useGetFieldValue) + { + lock (typeMapSyncLock) + { + // use clone, mutate, replace to avoid threading issues + var snapshot = typeMap; + var flags = TypeMapEntryFlags.None; + if (dbType >= 0) + { + flags |= TypeMapEntryFlags.SetType; + } + if (useGetFieldValue) + { + flags |= TypeMapEntryFlags.UseGetFieldValue; + } + var value = new TypeMapEntry(dbType, flags); + if (snapshot.TryGetValue(type, out var oldValue) && oldValue.Equals(value)) return; // nothing to do + + SetTypeMap(new Dictionary(snapshot) { [type] = value }); + } } private static void SetTypeMap(Dictionary value) @@ -324,17 +328,20 @@ private static void SetTypeMap(Dictionary value) /// Removes the specified type from the Type/DbType mapping table. /// /// The type to remove from the current map. - public static void RemoveTypeMap(Type type) - { - // use clone, mutate, replace to avoid threading issues - var snapshot = typeMap; - - if (!snapshot.ContainsKey(type)) return; // nothing to do - - var newCopy = new Dictionary(snapshot); - newCopy.Remove(type); - - SetTypeMap(newCopy); + public static void RemoveTypeMap(Type type) + { + lock (typeMapSyncLock) + { + // use clone, mutate, replace to avoid threading issues + var snapshot = typeMap; + + if (!snapshot.ContainsKey(type)) return; // nothing to do + + var newCopy = new Dictionary(snapshot); + newCopy.Remove(type); + + SetTypeMap(newCopy); + } } /// diff --git a/Directory.Packages.props b/Directory.Packages.props index 2f91a3cca..8f2772419 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -35,6 +35,7 @@ + diff --git a/tests/Dapper.Tests/Dapper.Tests.csproj b/tests/Dapper.Tests/Dapper.Tests.csproj index 93b498618..09947a89a 100644 --- a/tests/Dapper.Tests/Dapper.Tests.csproj +++ b/tests/Dapper.Tests/Dapper.Tests.csproj @@ -31,8 +31,9 @@ - - + + + diff --git a/tests/Dapper.Tests/FakeDbTests.Issue1439.cs b/tests/Dapper.Tests/FakeDbTests.Issue1439.cs new file mode 100644 index 000000000..e2548c9a1 --- /dev/null +++ b/tests/Dapper.Tests/FakeDbTests.Issue1439.cs @@ -0,0 +1,51 @@ +#if !NET481 +using System; +using System.Data; +using System.Threading.Tasks; +using pengdows.crud.fakeDb; +using Xunit; + +namespace Dapper.Tests +{ + public sealed class FakeDbIssue1439Tests + { + [Fact] + public void ConcurrentTypeMapUpdatesAreNotLost() + { + var types = new[] + { + typeof(Marker), typeof(Marker), typeof(Marker), typeof(Marker), + typeof(Marker), typeof(Marker), typeof(Marker), typeof(Marker), + typeof(Marker), typeof(Marker), typeof(Marker), typeof(Marker), + typeof(Marker), typeof(Marker), typeof(Marker), typeof(Marker) + }; + + try + { + Parallel.ForEach(types, type => SqlMapper.AddTypeMap(type, DbType.String)); + + using var conn = new fakeDbConnection(new FakeDataStore()); + foreach (var type in types) conn.EnqueueNonQueryResult(1); + conn.Open(); + + foreach (var type in types) + { + var parameters = new DynamicParameters(); + parameters.Add("value", Activator.CreateInstance(type)); + conn.Execute("select @value", parameters); + +#pragma warning disable 618 + Assert.Equal(DbType.String, SqlMapper.LookupDbType(type, "value", true, out _)); +#pragma warning restore 618 + } + } + finally + { + foreach (var type in types) SqlMapper.RemoveTypeMap(type); + } + } + + private sealed class Marker { } + } +} +#endif From 35a173d5509b20dd90dddb04977e82914edb2a90 Mon Sep 17 00:00:00 2001 From: "Dailey, Alaric" Date: Sat, 24 Oct 2026 10:34:37 -0500 Subject: [PATCH 2/2] Strengthen type-map thread-safety test; publish typeMap via volatile Replace the Parallel.ForEach test with barrier-synchronised add/add and add/remove races that fail reliably on the unlocked code. Mark the type-map snapshot field volatile. Co-Authored-By: Claude Sonnet 5.5 --- Dapper/SqlMapper.cs | 73 ++++----- tests/Dapper.Tests/FakeDbTests.Issue1439.cs | 160 +++++++++++++------- 2 files changed, 146 insertions(+), 87 deletions(-) diff --git a/Dapper/SqlMapper.cs b/Dapper/SqlMapper.cs index e9575975f..7575ce4cc 100644 --- a/Dapper/SqlMapper.cs +++ b/Dapper/SqlMapper.cs @@ -168,8 +168,9 @@ where pair.Value > 1 select Tuple.Create(pair.Key, pair.Value); } - private static Dictionary typeMap; - private static readonly object typeMapSyncLock = new(); + // replaced wholesale (never mutated) under typeMapSyncLock; volatile so readers always observe the latest published snapshot + private static volatile Dictionary typeMap; + private static readonly object typeMapSyncLock = new(); [Flags] internal enum TypeMapEntryFlags @@ -291,26 +292,26 @@ public static void AddTypeMap(Type type, DbType dbType) /// The type to map from. /// The database type to map to. /// Whether to prefer over . - public static void AddTypeMap(Type type, DbType dbType, bool useGetFieldValue) - { - lock (typeMapSyncLock) - { - // use clone, mutate, replace to avoid threading issues - var snapshot = typeMap; - var flags = TypeMapEntryFlags.None; - if (dbType >= 0) - { - flags |= TypeMapEntryFlags.SetType; - } - if (useGetFieldValue) - { - flags |= TypeMapEntryFlags.UseGetFieldValue; - } - var value = new TypeMapEntry(dbType, flags); - if (snapshot.TryGetValue(type, out var oldValue) && oldValue.Equals(value)) return; // nothing to do - - SetTypeMap(new Dictionary(snapshot) { [type] = value }); - } + public static void AddTypeMap(Type type, DbType dbType, bool useGetFieldValue) + { + lock (typeMapSyncLock) + { + // use clone, mutate, replace to avoid threading issues + var snapshot = typeMap; + var flags = TypeMapEntryFlags.None; + if (dbType >= 0) + { + flags |= TypeMapEntryFlags.SetType; + } + if (useGetFieldValue) + { + flags |= TypeMapEntryFlags.UseGetFieldValue; + } + var value = new TypeMapEntry(dbType, flags); + if (snapshot.TryGetValue(type, out var oldValue) && oldValue.Equals(value)) return; // nothing to do + + SetTypeMap(new Dictionary(snapshot) { [type] = value }); + } } private static void SetTypeMap(Dictionary value) @@ -328,20 +329,20 @@ private static void SetTypeMap(Dictionary value) /// Removes the specified type from the Type/DbType mapping table. /// /// The type to remove from the current map. - public static void RemoveTypeMap(Type type) - { - lock (typeMapSyncLock) - { - // use clone, mutate, replace to avoid threading issues - var snapshot = typeMap; - - if (!snapshot.ContainsKey(type)) return; // nothing to do - - var newCopy = new Dictionary(snapshot); - newCopy.Remove(type); - - SetTypeMap(newCopy); - } + public static void RemoveTypeMap(Type type) + { + lock (typeMapSyncLock) + { + // use clone, mutate, replace to avoid threading issues + var snapshot = typeMap; + + if (!snapshot.ContainsKey(type)) return; // nothing to do + + var newCopy = new Dictionary(snapshot); + newCopy.Remove(type); + + SetTypeMap(newCopy); + } } /// diff --git a/tests/Dapper.Tests/FakeDbTests.Issue1439.cs b/tests/Dapper.Tests/FakeDbTests.Issue1439.cs index e2548c9a1..662216632 100644 --- a/tests/Dapper.Tests/FakeDbTests.Issue1439.cs +++ b/tests/Dapper.Tests/FakeDbTests.Issue1439.cs @@ -1,51 +1,109 @@ -#if !NET481 -using System; -using System.Data; -using System.Threading.Tasks; -using pengdows.crud.fakeDb; -using Xunit; - -namespace Dapper.Tests -{ - public sealed class FakeDbIssue1439Tests - { - [Fact] - public void ConcurrentTypeMapUpdatesAreNotLost() - { - var types = new[] - { - typeof(Marker), typeof(Marker), typeof(Marker), typeof(Marker), - typeof(Marker), typeof(Marker), typeof(Marker), typeof(Marker), - typeof(Marker), typeof(Marker), typeof(Marker), typeof(Marker), - typeof(Marker), typeof(Marker), typeof(Marker), typeof(Marker) - }; - - try - { - Parallel.ForEach(types, type => SqlMapper.AddTypeMap(type, DbType.String)); - - using var conn = new fakeDbConnection(new FakeDataStore()); - foreach (var type in types) conn.EnqueueNonQueryResult(1); - conn.Open(); - - foreach (var type in types) - { - var parameters = new DynamicParameters(); - parameters.Add("value", Activator.CreateInstance(type)); - conn.Execute("select @value", parameters); - -#pragma warning disable 618 - Assert.Equal(DbType.String, SqlMapper.LookupDbType(type, "value", true, out _)); -#pragma warning restore 618 - } - } - finally - { - foreach (var type in types) SqlMapper.RemoveTypeMap(type); - } - } - - private sealed class Marker { } - } -} -#endif +#if !NET481 +using System; +using System.Collections.Generic; +using System.Data; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Xunit; + +namespace Dapper.Tests +{ + public sealed class FakeDbIssue1439Tests + { + private sealed class Marker { } + + // distinct closed types: Marker, Marker>, ... + private static Type[] MakeTypes(int count) + { + var types = new Type[count]; + var t = typeof(Marker); + for (int i = 0; i < count; i++) + { + types[i] = t; + t = typeof(Marker<>).MakeGenericType(t); + } + return types; + } + + [Fact] + public void ConcurrentAddTypeMapUpdatesAreNotLost() + { + const int Threads = 8, PerThread = 16, Rounds = 25; + var types = MakeTypes(Threads * PerThread); + try + { + for (int round = 0; round < Rounds; round++) + { + using var barrier = new Barrier(Threads); + var tasks = Enumerable.Range(0, Threads).Select(n => Task.Factory.StartNew(() => + { + barrier.SignalAndWait(); + foreach (var type in types.Skip(n * PerThread).Take(PerThread)) + { + SqlMapper.AddTypeMap(type, DbType.String); + } + }, TaskCreationOptions.LongRunning)).ToArray(); + Task.WaitAll(tasks); + + foreach (var type in types) + { +#pragma warning disable 618 + Assert.Equal(DbType.String, SqlMapper.LookupDbType(type, "value", true, out _)); +#pragma warning restore 618 + } + + // clear again so the next round races from a clean map + foreach (var type in types) SqlMapper.RemoveTypeMap(type); + } + } + finally + { + foreach (var type in types) SqlMapper.RemoveTypeMap(type); + } + } + + [Fact] + public void ConcurrentAddAndRemoveDoNotLoseOtherUpdates() + { + const int PerThread = 64, Rounds = 25; + var keep = MakeTypes(PerThread); + var churn = MakeTypes(PerThread * 2).Skip(PerThread).ToArray(); + try + { + for (int round = 0; round < Rounds; round++) + { + using var barrier = new Barrier(2); + var adder = Task.Factory.StartNew(() => + { + barrier.SignalAndWait(); + foreach (var type in keep) SqlMapper.AddTypeMap(type, DbType.String); + }, TaskCreationOptions.LongRunning); + var churner = Task.Factory.StartNew(() => + { + barrier.SignalAndWait(); + foreach (var type in churn) + { + SqlMapper.AddTypeMap(type, DbType.Int32); + SqlMapper.RemoveTypeMap(type); + } + }, TaskCreationOptions.LongRunning); + Task.WaitAll(adder, churner); + + foreach (var type in keep) + { +#pragma warning disable 618 + Assert.Equal(DbType.String, SqlMapper.LookupDbType(type, "value", true, out _)); +#pragma warning restore 618 + } + foreach (var type in keep) SqlMapper.RemoveTypeMap(type); + } + } + finally + { + foreach (var type in keep.Concat(churn)) SqlMapper.RemoveTypeMap(type); + } + } + } +} +#endif