Upgrade to latest version of Dapper

Removed refs to System.Xml.Linq to avoid adding any additional deps to
OrmLite

Author: mythz

src/ServiceStack.OrmLite/Dapper/CommandDefinition.cs

@@ -0,0 +1,192 @@
+#if NET45
+#define ASYNC
+#endif
+
+using System;
+using System.Data;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Threading;
+
+//Apache 2.0 License: https://github.com/StackExchange/dapper-dot-net/blob/master/License.txt
+namespace ServiceStack.OrmLite.Dapper
+{
+    /// <summary>
+    /// Represents the key aspects of a sql operation
+    /// </summary>
+    public struct CommandDefinition
+    {
+        internal static CommandDefinition ForCallback(object parameters)
+        {
+            if (parameters is DynamicParameters)
+            {
+                return new CommandDefinition(parameters);
+            }
+            else
+            {
+                return default(CommandDefinition);
+            }
+        }
+
+        internal void OnCompleted()
+        {
+            (Parameters as SqlMapper.IParameterCallbacks)?.OnCompleted();
+        }
+
+        /// <summary>
+        /// The command (sql or a stored-procedure name) to execute
+        /// </summary>
+        public string CommandText { get; }
+
+        /// <summary>
+        /// The parameters associated with the command
+        /// </summary>
+        public object Parameters { get; }
+
+        /// <summary>
+        /// The active transaction for the command
+        /// </summary>
+        public IDbTransaction Transaction { get; }
+
+        /// <summary>
+        /// The effective timeout for the command
+        /// </summary>
+        public int? CommandTimeout { get; }
+
+        /// <summary>
+        /// The type of command that the command-text represents
+        /// </summary>
+        public CommandType? CommandType { get; }
+
+        /// <summary>
+        /// Should data be buffered before returning?
+        /// </summary>
+        public bool Buffered => (Flags & CommandFlags.Buffered) != 0;
+
+        /// <summary>
+        /// Should the plan for this query be cached?
+        /// </summary>
+        internal bool AddToCache => (Flags & CommandFlags.NoCache) == 0;
+
+        /// <summary>
+        /// Additional state flags against this command
+        /// </summary>
+        public CommandFlags Flags { get; }
+
+        /// <summary>
+        /// Can async queries be pipelined?
+        /// </summary>
+        public bool Pipelined => (Flags & CommandFlags.Pipelined) != 0;
+
+        /// <summary>
+        /// Initialize the command definition
+        /// </summary>
+        public CommandDefinition(string commandText, object parameters = null, IDbTransaction transaction = null, int? commandTimeout = null,
+                                 CommandType? commandType = null, CommandFlags flags = CommandFlags.Buffered
+#if ASYNC
+                                 , CancellationToken cancellationToken = default(CancellationToken)
+#endif
+            )
+        {
+            CommandText = commandText;
+            Parameters = parameters;
+            Transaction = transaction;
+            CommandTimeout = commandTimeout;
+            CommandType = commandType;
+            Flags = flags;
+#if ASYNC
+            CancellationToken = cancellationToken;
+#endif
+        }
+
+        private CommandDefinition(object parameters) : this()
+        {
+            Parameters = parameters;
+        }
+
+#if ASYNC
+
+        /// <summary>
+        /// For asynchronous operations, the cancellation-token
+        /// </summary>
+        public CancellationToken CancellationToken { get; }
+#endif
+
+        internal IDbCommand SetupCommand(IDbConnection cnn, Action<IDbCommand, object> paramReader)
+        {
+            var cmd = cnn.CreateCommand();
+            var init = GetInit(cmd.GetType());
+            init?.Invoke(cmd);
+            if (Transaction != null)
+                cmd.Transaction = Transaction;
+            cmd.CommandText = CommandText;
+            if (CommandTimeout.HasValue)
+            {
+                cmd.CommandTimeout = CommandTimeout.Value;
+            }
+            else if (SqlMapper.Settings.CommandTimeout.HasValue)
+            {
+                cmd.CommandTimeout = SqlMapper.Settings.CommandTimeout.Value;
+            }
+            if (CommandType.HasValue)
+                cmd.CommandType = CommandType.Value;
+            paramReader?.Invoke(cmd, Parameters);
+            return cmd;
+        }
+
+        private static SqlMapper.Link<Type, Action<IDbCommand>> commandInitCache;
+
+        private static Action<IDbCommand> GetInit(Type commandType)
+        {
+            if (commandType == null)
+                return null; // GIGO
+            Action<IDbCommand> action;
+            if (SqlMapper.Link<Type, Action<IDbCommand>>.TryGet(commandInitCache, commandType, out action))
+            {
+                return action;
+            }
+            var bindByName = GetBasicPropertySetter(commandType, "BindByName", typeof(bool));
+            var initialLongFetchSize = GetBasicPropertySetter(commandType, "InitialLONGFetchSize", typeof(int));
+
+            action = null;
+            if (bindByName != null || initialLongFetchSize != null)
+            {
+                var method = new DynamicMethod(commandType.Name + "_init", null, new Type[] { typeof(IDbCommand) });
+                var il = method.GetILGenerator();
+
+                if (bindByName != null)
+                {
+                    // .BindByName = true
+                    il.Emit(OpCodes.Ldarg_0);
+                    il.Emit(OpCodes.Castclass, commandType);
+                    il.Emit(OpCodes.Ldc_I4_1);
+                    il.EmitCall(OpCodes.Callvirt, bindByName, null);
+                }
+                if (initialLongFetchSize != null)
+                {
+                    // .InitialLONGFetchSize = -1
+                    il.Emit(OpCodes.Ldarg_0);
+                    il.Emit(OpCodes.Castclass, commandType);
+                    il.Emit(OpCodes.Ldc_I4_M1);
+                    il.EmitCall(OpCodes.Callvirt, initialLongFetchSize, null);
+                }
+                il.Emit(OpCodes.Ret);
+                action = (Action<IDbCommand>)method.CreateDelegate(typeof(Action<IDbCommand>));
+            }
+            // cache it
+            SqlMapper.Link<Type, Action<IDbCommand>>.TryAdd(ref commandInitCache, commandType, ref action);
+            return action;
+        }
+
+        private static MethodInfo GetBasicPropertySetter(Type declaringType, string name, Type expectedType)
+        {
+            var prop = declaringType.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
+            if (prop != null && prop.CanWrite && prop.PropertyType == expectedType && prop.GetIndexParameters().Length == 0)
+            {
+                return prop.GetSetMethod();
+            }
+            return null;
+        }
+    }
+
+}

src/ServiceStack.OrmLite/Dapper/CommandFlags.cs

@@ -0,0 +1,31 @@
+using System;
+
+//Apache 2.0 License: https://github.com/StackExchange/dapper-dot-net/blob/master/License.txt
+namespace ServiceStack.OrmLite.Dapper
+{
+
+    /// <summary>
+    /// Additional state flags that control command behaviour
+    /// </summary>
+    [Flags]
+    public enum CommandFlags
+    {
+        /// <summary>
+        /// No additional flags
+        /// </summary>
+        None = 0,
+        /// <summary>
+        /// Should data be buffered before returning?
+        /// </summary>
+        Buffered = 1,
+        /// <summary>
+        /// Can async queries be pipelined?
+        /// </summary>
+        Pipelined = 2,
+        /// <summary>
+        /// Should the plan cache be bypassed?
+        /// </summary>
+        NoCache = 4,
+    }
+
+}

src/ServiceStack.OrmLite/Dapper/CustomPropertyTypeMap.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Reflection;
+
+//Apache 2.0 License: https://github.com/StackExchange/dapper-dot-net/blob/master/License.txt
+namespace ServiceStack.OrmLite.Dapper
+{
+
+    /// <summary>
+    /// Implements custom property mapping by user provided criteria (usually presence of some custom attribute with column to member mapping)
+    /// </summary>
+    public sealed class CustomPropertyTypeMap : SqlMapper.ITypeMap
+    {
+        private readonly Type _type;
+        private readonly Func<Type, string, PropertyInfo> _propertySelector;
+
+        /// <summary>
+        /// Creates custom property mapping
+        /// </summary>
+        /// <param name="type">Target entity type</param>
+        /// <param name="propertySelector">Property selector based on target type and DataReader column name</param>
+        public CustomPropertyTypeMap(Type type, Func<Type, string, PropertyInfo> propertySelector)
+        {
+            if (type == null)
+                throw new ArgumentNullException(nameof(type));
+
+            if (propertySelector == null)
+                throw new ArgumentNullException(nameof(propertySelector));
+
+            _type = type;
+            _propertySelector = propertySelector;
+        }
+
+        /// <summary>
+        /// Always returns default constructor
+        /// </summary>
+        /// <param name="names">DataReader column names</param>
+        /// <param name="types">DataReader column types</param>
+        /// <returns>Default constructor</returns>
+        public ConstructorInfo FindConstructor(string[] names, Type[] types)
+        {
+            return _type.GetConstructor(new Type[0]);
+        }
+
+        /// <summary>
+        /// Always returns null
+        /// </summary>
+        /// <returns></returns>
+        public ConstructorInfo FindExplicitConstructor()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Not implemented as far as default constructor used for all cases
+        /// </summary>
+        /// <param name="constructor"></param>
+        /// <param name="columnName"></param>
+        /// <returns></returns>
+        public SqlMapper.IMemberMap GetConstructorParameter(ConstructorInfo constructor, string columnName)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Returns property based on selector strategy
+        /// </summary>
+        /// <param name="columnName">DataReader column name</param>
+        /// <returns>Poperty member map</returns>
+        public SqlMapper.IMemberMap GetMember(string columnName)
+        {
+            var prop = _propertySelector(_type, columnName);
+            return prop != null ? new SimpleMemberMap(columnName, prop) : null;
+        }
+    }
+}

src/ServiceStack.OrmLite/Dapper/DataTableHandler.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Data;
+
+#if !COREFX
+//Apache 2.0 License: https://github.com/StackExchange/dapper-dot-net/blob/master/License.txt
+namespace ServiceStack.OrmLite.Dapper
+{
+    sealed class DataTableHandler : SqlMapper.ITypeHandler
+    {
+        public object Parse(Type destinationType, object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetValue(IDbDataParameter parameter, object value)
+        {
+            TableValuedParameter.Set(parameter, value as DataTable, null);
+        }
+    }
+}
+#endif