Add OrmLiteContext for holding async state, store state in CallContext by default

Author: mythz

src/ServiceStack.OrmLite/OrmLiteContext.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Runtime.Remoting.Messaging;
+
+namespace ServiceStack.OrmLite
+{
+    public class OrmLiteContext
+    {
+        public static readonly OrmLiteContext Instance = new OrmLiteContext();
+
+        /// <summary>
+        /// Tell ServiceStack to use ThreadStatic Items Collection for Context Scoped items.
+        /// Warning: ThreadStatic Items aren't pinned to the same request in async services which callback on different threads.
+        /// </summary>
+        public static bool UseThreadStatic = false;
+
+        [ThreadStatic]
+        public static IDictionary ContextItems;
+
+        /// <summary>
+        /// Gets a list of items for this context. 
+        /// </summary>
+        public virtual IDictionary Items
+        {
+            get
+            {
+                return GetItems() ?? (CreateItems());
+            }
+            set
+            {
+                CreateItems(value);
+            }
+        }
+
+        private const string _key = "__OrmLite.Items";
+
+        private IDictionary GetItems()
+        {
+            try
+            {
+                if (UseThreadStatic)
+                    return ContextItems;
+
+                return CallContext.LogicalGetData(_key) as IDictionary;
+            }
+            catch (NotImplementedException)
+            {
+                //Fixed in Mono master: https://github.com/mono/mono/pull/817
+                return CallContext.GetData(_key) as IDictionary;
+            }
+        }
+
+        private IDictionary CreateItems(IDictionary items = null)
+        {
+            try
+            {
+                if (UseThreadStatic)
+                {
+                    ContextItems = items ?? (items = new Dictionary<object, object>());
+                }
+                else
+                {
+                    CallContext.LogicalSetData(_key, items ?? (items = new ConcurrentDictionary<object, object>()));
+                }
+            }
+            catch (NotImplementedException)
+            {
+                //Fixed in Mono master: https://github.com/mono/mono/pull/817
+                CallContext.SetData(_key, items ?? (items = new ConcurrentDictionary<object, object>()));
+            }
+            return items;
+        }
+
+        public T GetOrCreate<T>(Func<T> createFn)
+        {
+            if (Items.Contains(typeof(T).Name))
+                return (T)Items[typeof(T).Name];
+
+            return (T)(Items[typeof(T).Name] = createFn());
+        }
+
+        internal static string LastCommandText
+        {
+            get
+            {
+                return Instance.Items["LastCommandText"] as string;
+            }
+            set
+            {
+                Instance.Items["LastCommandText"] = value ?? "";
+            }
+        }
+    }
+}

src/ServiceStack.OrmLite/OrmLiteExecFilter.cs

@@ -35,14 +35,14 @@ public virtual IDbCommand CreateCommand(IDbConnection dbConn)
             var dbCmd = dbConn.CreateCommand();
             dbCmd.Transaction = (ormLiteDbConn != null) ? ormLiteDbConn.Transaction : OrmLiteConfig.TSTransaction;
             dbCmd.CommandTimeout = OrmLiteConfig.CommandTimeout;
-            OrmLiteReadExpressionsApi.LastCommandText = null;
+            OrmLiteContext.LastCommandText = null;
             return dbCmd;
         }
 
         public virtual void DisposeCommand(IDbCommand dbCmd)
         {
             if (dbCmd == null) return;
-            OrmLiteReadExpressionsApi.LastCommandText = dbCmd.CommandText;
+            OrmLiteContext.LastCommandText = dbCmd.CommandText;
             dbCmd.Dispose();
         }
 

src/ServiceStack.OrmLite/OrmLiteReadExpressionsApi.cs

@@ -8,9 +8,6 @@ namespace ServiceStack.OrmLite
 {
     public static class OrmLiteReadExpressionsApi
     {
-        [ThreadStatic]
-        internal static string LastCommandText;
-
         public static T Exec<T>(this IDbConnection dbConn, Func<IDbCommand, T> filter)
         {
             return OrmLiteConfig.ExecFilter.Exec(dbConn, filter);

src/ServiceStack.OrmLite/OrmLiteWriteApi.cs

@@ -14,7 +14,7 @@ public static class OrmLiteWriteApi
         /// </summary>
         public static string GetLastSql(this IDbConnection dbConn)
         {
-            return OrmLiteReadExpressionsApi.LastCommandText;
+            return OrmLiteContext.LastCommandText;
         }
 
         /// <summary>

src/ServiceStack.OrmLite/ServiceStack.OrmLite.csproj

@@ -105,7 +105,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AliasNamingStrategy.cs" />
-    <Compile Include="Async\async.cs" />
+    <Compile Include="OrmLiteContext.cs" />
     <Compile Include="OrmLiteReadApiAsync.cs" />
     <Compile Include="Async\OrmLiteReadCommandExtensionsAsync.cs" />
     <Compile Include="Async\OrmLiteResultsFilterExtensionsAsync.cs" />