Fix threading issue in ModelDefinition

Author: mythz

src/ServiceStack.OrmLite/ModelDefinition.cs

@@ -62,76 +62,56 @@ public string ModelName
 
         public FieldDefinition PrimaryKey
         {
-            get
-            {
-                return this.FieldDefinitions.First(x => x.IsPrimaryKey);
-            }
+            get { return this.FieldDefinitions.First(x => x.IsPrimaryKey); }
         }
 
         public List<FieldDefinition> FieldDefinitions { get; set; }
 
         private FieldDefinition[] fieldDefinitionsArray;
         public FieldDefinition[] FieldDefinitionsArray
         {
-            get
-            {
-                if (fieldDefinitionsArray == null)
-                {
-                    fieldDefinitionsArray = FieldDefinitions.ToArray();
-                }
-                return fieldDefinitionsArray;
-            }
+            get { return fieldDefinitionsArray; }
         }
 
         public List<FieldDefinition> IgnoredFieldDefinitions { get; set; }
 
         private FieldDefinition[] ignoredFieldDefinitionsArray;
         public FieldDefinition[] IgnoredFieldDefinitionsArray
         {
-            get
-            {
-                if (ignoredFieldDefinitionsArray == null)
-                {
-                    ignoredFieldDefinitionsArray = IgnoredFieldDefinitions.ToArray();
-                }
-                return ignoredFieldDefinitionsArray;
-            }
+            get { return ignoredFieldDefinitionsArray; }
         }
 
         private FieldDefinition[] allFieldDefinitionsArray;
         public FieldDefinition[] AllFieldDefinitionsArray
         {
-            get
-            {
-                if (allFieldDefinitionsArray == null)
-                {
-                    List<FieldDefinition> allItems = new List<FieldDefinition>(FieldDefinitions);
-                    allItems.AddRange(IgnoredFieldDefinitions);
-                    allFieldDefinitionsArray = allItems.ToArray();
-                }
-                return allFieldDefinitionsArray;
-            }
+            get { return allFieldDefinitionsArray; }
         }
 
+        private readonly object fieldDefLock = new object();
         private Dictionary<string, FieldDefinition> fieldDefinitionMap;
         private Func<string, string> fieldNameSanitizer;
         public Dictionary<string, FieldDefinition> GetFieldDefinitionMap(Func<string, string> sanitizeFieldName)
         {
             if (fieldDefinitionMap == null || fieldNameSanitizer != sanitizeFieldName)
             {
-                fieldNameSanitizer = sanitizeFieldName;
-                fieldDefinitionMap = new Dictionary<string, FieldDefinition>();
-                foreach (var fieldDef in FieldDefinitionsArray)
+                lock (fieldDefLock)
                 {
-                    fieldDefinitionMap[sanitizeFieldName(fieldDef.FieldName)] = fieldDef;
+                    if (fieldDefinitionMap == null || fieldNameSanitizer != sanitizeFieldName)
+                    {
+                        fieldDefinitionMap = new Dictionary<string, FieldDefinition>();
+                        fieldNameSanitizer = sanitizeFieldName;
+                        foreach (var fieldDef in FieldDefinitionsArray)
+                        {
+                            fieldDefinitionMap[sanitizeFieldName(fieldDef.FieldName)] = fieldDef;
+                        }
+                    }
                 }
             }
             return fieldDefinitionMap;
         }
 
         public List<CompositeIndexAttribute> CompositeIndexes { get; set; }
 
-
         public FieldDefinition GetFieldDefinition<T>(Expression<Func<T, object>> field)
         {
             var fn = GetFieldName(field);
@@ -147,13 +127,24 @@ string GetFieldName<T>(Expression<Func<T, object>> field)
                 var me = lambda.Body as MemberExpression;
                 return me.Member.Name;
             }
-            else
-            {
-                var operand = (lambda.Body as UnaryExpression).Operand;
-                return (operand as MemberExpression).Member.Name;
-            }
+            
+            var operand = (lambda.Body as UnaryExpression).Operand;
+            return (operand as MemberExpression).Member.Name;
         }
 
+        public void AfterInit()
+        {
+            fieldDefinitionsArray = FieldDefinitions.ToArray();
+            ignoredFieldDefinitionsArray = IgnoredFieldDefinitions.ToArray();
+
+            var allItems = new List<FieldDefinition>(FieldDefinitions);
+            allItems.AddRange(IgnoredFieldDefinitions);
+            allFieldDefinitionsArray = allItems.ToArray();
+
+            SqlSelectAllFromTable = "SELECT {0} FROM {1} "
+                .Fmt(OrmLiteConfig.DialectProvider.GetColumnNames(this),
+                     OrmLiteConfig.DialectProvider.GetQuotedTableName(this));
+        }
     }
 
 

src/ServiceStack.OrmLite/OrmLiteConfigExtensions.cs

@@ -189,9 +189,7 @@ internal static ModelDefinition GetModelDefinition(this Type modelType)
                     modelDef.RowVersion = fieldDefinition;
             }
 
-            modelDef.SqlSelectAllFromTable = "SELECT {0} FROM {1} "
-                .Fmt(OrmLiteConfig.DialectProvider.GetColumnNames(modelDef),
-                     OrmLiteConfig.DialectProvider.GetQuotedTableName(modelDef));
+            modelDef.AfterInit();
 
             Dictionary<Type, ModelDefinition> snapshot, newCache;
             do

tests/ServiceStack.OrmLite.Tests/Issues/MultithreadingIssueTests.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using NUnit.Framework;
+using ServiceStack.Text;
+
+namespace ServiceStack.OrmLite.Tests.Issues
+{
+    [Explicit]
+    [TestFixture]
+    public class MultithreadingIssueTests
+        : OrmLiteTestBase
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<ModelWithDifferentNumTypes>();
+            }
+        }
+
+        [Test]
+        public void Can_SaveAll_in_multiple_threads()
+        {
+            var errors = new List<string>();
+            int threads = 0;
+            var mainLock = new object();
+
+            10.Times(() => {
+                ThreadPool.QueueUserWorkItem(_ => {
+
+                    Interlocked.Increment(ref threads);
+                    var threadId = Thread.CurrentThread.ManagedThreadId;
+                    "Thread {0} started...".Print(threadId);
+                    
+                    var rows = 10.Times(i => ModelWithDifferentNumTypes.Create(i));
+                    using (var db = OpenDbConnection())
+                    {
+                        100.Times(i =>
+                        {
+                            try
+                            {
+                                db.SaveAll(rows);
+                            }
+                            catch (Exception ex)
+                            {
+                                lock (errors)
+                                    errors.Add(ex.Message + "\nStackTrace:\n" + ex.StackTrace);
+                            }
+                        });
+                    }
+
+                    "Thread {0} finished".Print(threadId);
+                    if (Interlocked.Decrement(ref threads) == 0)
+                    {
+                        "All Threads Finished".Print();
+                        lock (mainLock)
+                            Monitor.Pulse(mainLock);
+                    }
+                });
+            });
+
+            lock (mainLock)
+                Monitor.Wait(mainLock);
+
+            "Stopping...".Print();
+            errors.PrintDump();
+
+            Assert.That(errors.Count, Is.EqualTo(0));
+        }
+    }
+}

tests/ServiceStack.OrmLite.Tests/ServiceStack.OrmLite.Tests.csproj

@@ -124,6 +124,7 @@
     <Compile Include="Expression\SqlExpressionTests.cs" />
     <Compile Include="Expression\SelectExpressionTests.cs" />
     <Compile Include="Issues\MismatchSchemaTests.cs" />
+    <Compile Include="Issues\MultithreadingIssueTests.cs" />
     <Compile Include="LicenseUsageTests.cs" />
     <Compile Include="LoadReferencesJoinTests.cs" />
     <Compile Include="LoadReferencesTests.cs" />