Convert latest Dapper to use C# 5 so builds on CI

Author: mythz

src/ServiceStack.OrmLite/Dapper/CommandDefinition.cs

@@ -61,12 +61,18 @@ internal void OnCompleted()
         /// <summary>
         /// Should data be buffered before returning?
         /// </summary>
-        public bool Buffered => (Flags & CommandFlags.Buffered) != 0;
+        public bool Buffered
+        {
+            get { return (Flags & CommandFlags.Buffered) != 0; }
+        }
 
         /// <summary>
         /// Should the plan for this query be cached?
         /// </summary>
-        internal bool AddToCache => (Flags & CommandFlags.NoCache) == 0;
+        internal bool AddToCache
+        {
+            get { return (Flags & CommandFlags.NoCache) == 0; }
+        }
 
         /// <summary>
         /// Additional state flags against this command
@@ -76,7 +82,10 @@ internal void OnCompleted()
         /// <summary>
         /// Can async queries be pipelined?
         /// </summary>
-        public bool Pipelined => (Flags & CommandFlags.Pipelined) != 0;
+        public bool Pipelined
+        {
+            get { return (Flags & CommandFlags.Pipelined) != 0; }
+        }
 
         /// <summary>
         /// Initialize the command definition

src/ServiceStack.OrmLite/Dapper/DefaultTypeMap.cs

@@ -166,7 +166,7 @@ public SqlMapper.IMemberMap GetMember(string columnName)
                 return new SimpleMemberMap(columnName, property);
 
             // roslyn automatically implemented properties, in particular for get-only properties: <{Name}>k__BackingField;
-            var backingFieldName = $"<{columnName}>k__BackingField";
+            var backingFieldName = String.Format("<{0}>k__BackingField", columnName);
 
             // preference order is:
             // exact match over underscre match, exact case over wrong case, backing fields over regular fields, match-inc-underscores over match-exc-underscores
@@ -178,7 +178,7 @@ public SqlMapper.IMemberMap GetMember(string columnName)
             if (field == null && MatchNamesWithUnderscores)
             {
                 var effectiveColumnName = columnName.Replace("_", "");
-                backingFieldName = $"<{effectiveColumnName}>k__BackingField";
+                backingFieldName = String.Format("<{0}>k__BackingField", effectiveColumnName);
 
                 field = _fields.FirstOrDefault(p => string.Equals(p.Name, effectiveColumnName, StringComparison.Ordinal))
                     ?? _fields.FirstOrDefault(p => string.Equals(p.Name, backingFieldName, StringComparison.Ordinal))

src/ServiceStack.OrmLite/Dapper/DynamicParameters.cs

@@ -306,7 +306,10 @@ protected void AddParameters(IDbCommand command, SqlMapper.Identity identity)
         /// <summary>
         /// All the names of the param in the bag, use Get to yank them out
         /// </summary>
-        public IEnumerable<string> ParameterNames => parameters.Select(p => p.Key);
+        public IEnumerable<string> ParameterNames
+        {
+            get { return parameters.Select(p => p.Key); }
+        }
 
 
         /// <summary>
@@ -404,7 +407,7 @@ public DynamicParameters Output<T>(T target, Expression<Func<T, object>> express
             if (setter != null) goto MAKECALLBACK;
 
             // Come on let's build a method, let's build it, let's build it now!
-            var dm = new DynamicMethod($"ExpressionParam{Guid.NewGuid()}", null, new[] { typeof(object), GetType() }, true);
+            var dm = new DynamicMethod(String.Format("ExpressionParam{0}", Guid.NewGuid()), null, new[] { typeof(object), GetType() }, true);
             var il = dm.GetILGenerator();
 
             il.Emit(OpCodes.Ldarg_0); // [object]

src/ServiceStack.OrmLite/Dapper/SimpleMemberMap.cs

@@ -68,7 +68,10 @@ public SimpleMemberMap(string columnName, ParameterInfo parameter)
         /// <summary>
         /// Target member type
         /// </summary>
-        public Type MemberType => Field?.FieldType ?? Property?.PropertyType ?? Parameter?.ParameterType;
+        public Type MemberType
+        {
+            get { return Field != null ? Field.FieldType : (Property != null ? Property.PropertyType : (Parameter != null ? Parameter.ParameterType : null)); }
+        }
 
         /// <summary>
         /// Target property

src/ServiceStack.OrmLite/Dapper/SqlMapper.DapperRow.cs

@@ -136,7 +136,11 @@ bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, objec
                 return dic.Remove(item.Key);
             }
 
-            bool ICollection<KeyValuePair<string, object>>.IsReadOnly => false;
+            bool ICollection<KeyValuePair<string, object>>.IsReadOnly
+            {
+                get { return false; }
+            }
+
             #endregion
 
             #region Implementation of IDictionary<string,object>

src/ServiceStack.OrmLite/Dapper/SqlMapper.DataTable.cs

@@ -11,7 +11,10 @@ private sealed class DapperTable
             string[] fieldNames;
             readonly Dictionary<string, int> fieldNameLookup;
 
-            internal string[] FieldNames => fieldNames;
+            internal string[] FieldNames
+            {
+                get { return fieldNames; }
+            }
 
             public DapperTable(string[] fieldNames)
             {
@@ -43,9 +46,15 @@ internal int AddField(string name)
                 return oldLen;
             }
 
-            internal bool FieldExists(string key) => key != null && fieldNameLookup.ContainsKey(key);
+            internal bool FieldExists(string key)
+            {
+                return key != null && fieldNameLookup.ContainsKey(key);
+            }
 
-            public int FieldCount => fieldNames.Length;
+            public int FieldCount
+            {
+                get { return fieldNames.Length; }
+            }
         }
     }
 }

src/ServiceStack.OrmLite/Dapper/SqlMapper.cs

@@ -356,6 +356,7 @@ public static DbType GetDbType(object value)
         /// <summary>
         /// OBSOLETE: For internal usage only. Lookup the DbType and handler for a given Type and member
         /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         [Obsolete(ObsoleteInternalUsageOnly, false)]
 #if !COREFX
         [Browsable(false)]
@@ -403,7 +404,8 @@ public static DbType LookupDbType(Type type, string name, bool demand, out IType
             }
 #endif
             if(demand)
-                throw new NotSupportedException($"The member {name} of type {type.FullName} cannot be used as a parameter value");
+                throw new NotSupportedException(
+                    String.Format("The member {0} of type {1} cannot be used as a parameter value", name, type.FullName));
             return DbType.Object;
 
         }
@@ -2152,7 +2154,7 @@ internal static Action<IDbCommand, object> CreateParamInfoGenerator(Identity ide
             {
                 filterParams = !smellsLikeOleDb.IsMatch(identity.sql);
             }
-            var dm = new DynamicMethod($"ParamInfo{Guid.NewGuid()}", null, new[] { typeof(IDbCommand), typeof(object) }, type, true);
+            var dm = new DynamicMethod(String.Format("ParamInfo{0}", Guid.NewGuid()), null, new[] { typeof(IDbCommand), typeof(object) }, type, true);
 
             var il = dm.GetILGenerator();
 
@@ -2812,7 +2814,7 @@ private static Func<IDataReader, object> GetTypeDeserializerImpl(
         )
         {
             var returnType = type.IsValueType() ? typeof(object) : type;
-            var dm = new DynamicMethod($"Deserialize{Guid.NewGuid()}", returnType, new[] { typeof(IDataReader) }, type, true);
+            var dm = new DynamicMethod(String.Format("Deserialize{0}", Guid.NewGuid()), returnType, new[] { typeof(IDataReader) }, type, true);
             var il = dm.GetILGenerator();
             il.DeclareLocal(typeof(int));
             il.DeclareLocal(type);
@@ -2886,8 +2888,12 @@ private static Func<IDataReader, object> GetTypeDeserializerImpl(
                     var ctor = typeMap.FindConstructor(names, types);
                     if (ctor == null)
                     {
-                        string proposedTypes = $"({string.Join(", ", types.Select((t, i) => t.FullName + " " + names[i]).ToArray())})";
-                        throw new InvalidOperationException($"A parameterless default constructor or one matching signature {proposedTypes} is required for {type.FullName} materialization");
+                        string proposedTypes = String.Format("({0})",
+                            string.Join(", ", types.Select((t, i) => t.FullName + " " + names[i]).ToArray()));
+                        throw new InvalidOperationException(
+                            String.Format(
+                                "A parameterless default constructor or one matching signature {0} is required for {1} materialization",
+                                proposedTypes, type.FullName));
                     }
 
                     if (ctor.GetParameters().Length == 0)
@@ -3328,7 +3334,8 @@ public static void ThrowDataException(Exception ex, int index, IDataReader reade
                         formattedValue = valEx.Message;
                     }
                 }
-                toThrow = new DataException($"Error parsing column {index} ({name}={formattedValue})", ex);
+                toThrow = new DataException(
+                    String.Format("Error parsing column {0} ({1}={2})", index, name, formattedValue), ex);
             }
             catch
             { // throw the **original** exception, wrapped as DataException

src/ServiceStack.OrmLite/Dapper/WrappedReader.cs

@@ -38,14 +38,20 @@ void IDataReader.Close()
             reader?.Close();
         }
 
-        int IDataReader.Depth => Reader.Depth;
+        int IDataReader.Depth
+        {
+            get { return Reader.Depth; }
+        }
 
         DataTable IDataReader.GetSchemaTable()
         {
             return Reader.GetSchemaTable();
         }
 
-        bool IDataReader.IsClosed => reader?.IsClosed ?? true;
+        bool IDataReader.IsClosed
+        {
+            get { return reader != null ? reader.IsClosed : true; }
+        }
 
         bool IDataReader.NextResult()
         {
@@ -57,7 +63,10 @@ bool IDataReader.Read()
             return Reader.Read();
         }
 
-        int IDataReader.RecordsAffected => Reader.RecordsAffected;
+        int IDataReader.RecordsAffected
+        {
+            get { return Reader.RecordsAffected; }
+        }
 
         void IDisposable.Dispose()
         {
@@ -68,7 +77,10 @@ void IDisposable.Dispose()
             cmd = null;
         }
 
-        int IDataRecord.FieldCount => Reader.FieldCount;
+        int IDataRecord.FieldCount
+        {
+            get { return Reader.FieldCount; }
+        }
 
         bool IDataRecord.GetBoolean(int i)
         {
@@ -180,8 +192,14 @@ bool IDataRecord.IsDBNull(int i)
             return Reader.IsDBNull(i);
         }
 
-        object IDataRecord.this[string name] => Reader[name];
+        object IDataRecord.this[string name]
+        {
+            get { return Reader[name]; }
+        }
 
-        object IDataRecord.this[int i] => Reader[i];
+        object IDataRecord.this[int i]
+        {
+            get { return Reader[i]; }
+        }
     }
 }

src/ServiceStack.OrmLite/Dapper/XmlHandlers.cs

@@ -20,6 +20,9 @@ protected override XmlDocument Parse(string xml)
             doc.LoadXml(xml);
             return doc;
         }
-        protected override string Format(XmlDocument xml) => xml.OuterXml;
+        protected override string Format(XmlDocument xml)
+        {
+            return xml.OuterXml;
+        }
     }
 }