Support for materialize float and DateTimeOffset types. (#149)

* Support for materialize float and DateTimeOffset types.
* CodeFactor issues
* Code review issues.

Author: Burgyn

Kros.KORM/src/Kros.KORM/Materializer/DynamicMethodModelFactory.cs

@@ -1,4 +1,5 @@
 using Kros.Caching;
+using Kros.Extensions;
 using Kros.KORM.Converter;
 using Kros.KORM.Injection;
 using Kros.KORM.Metadata;
@@ -27,7 +28,6 @@ public class DynamicMethodModelFactory : IModelFactory
         private readonly static List<IConverter> _converters = new List<IConverter>();
         private readonly static List<IInjector> _injectors = new List<IInjector>();
 
-        private readonly static ICache<string, MethodInfo> _methodsInfo = new Cache<string, MethodInfo>();
         private readonly static MethodInfo _fnIsDBNull = typeof(IDataRecord).GetMethod("IsDBNull");
         private readonly static MethodInfo _fnGetValue = typeof(IDataRecord).GetMethod("GetValue", new Type[] { typeof(int) });
         private readonly static MethodInfo _fnConvert = typeof(IConverter).GetMethod("Convert");
@@ -39,6 +39,9 @@ public class DynamicMethodModelFactory : IModelFactory
         private readonly static MethodInfo _fnInjectorsListGetItem = typeof(List<IInjector>).GetProperty("Item").GetGetMethod();
         private readonly static MethodInfo _fnInjectorMethodInfo =
             typeof(IInjector).GetMethod(nameof(IInjector.GetValue), new Type[] { typeof(string) });
+        private readonly static Dictionary<string, MethodInfo> _readerValueGetters = InitReaderValueGetters();
+        private readonly static MethodInfo _getValueMethodInfo =
+            typeof(IDataRecord).GetMethod("GetValue", new Type[] { typeof(int) });
 
         #endregion
 
@@ -51,9 +54,7 @@ public class DynamicMethodModelFactory : IModelFactory
         /// <exception cref="System.ArgumentNullException">databaseMapper;Argument 'databaseMapper' is required.</exception>
         public DynamicMethodModelFactory(IDatabaseMapper databaseMapper)
         {
-            Check.NotNull(databaseMapper, nameof(databaseMapper));
-
-            _databaseMapper = databaseMapper;
+            _databaseMapper = Check.NotNull(databaseMapper, nameof(databaseMapper));
         }
 
         #endregion
@@ -111,8 +112,7 @@ private static T FactoryForValueType<T>(IDataReader reader)
             Type destType = typeof(T);
             Type srcType = reader.GetFieldType(0);
 
-            var valueGetter = _methodsInfo.Get(srcType.Name,
-                                () => typeof(IDataRecord).GetMethod("Get" + srcType.Name, new Type[] { typeof(int) }));
+            var valueGetter = GetReaderValueGetter(srcType);
 
             var value = valueGetter.Invoke(reader, new object[] { 0 });
             if (destType.Name == srcType.Name)
@@ -261,10 +261,9 @@ private static void FillingValuesWithoutConverter(ILGenerator ilGenerator,
                                                            ColumnInfo columnInfo,
                                                                  Type srcType)
         {
-            bool? castNeeded = null;
+            bool castNeeded = false;
 
-            var valuegetter = _methodsInfo.Get(srcType.Name,
-                () => typeof(IDataRecord).GetMethod("Get" + srcType.Name, new Type[] { typeof(int) }));
+            MethodInfo valuegetter = GetReaderValueGetter(srcType);
 
             if (valuegetter != null
                 && valuegetter.ReturnType == srcType
@@ -273,37 +272,80 @@ private static void FillingValuesWithoutConverter(ILGenerator ilGenerator,
             {
                 castNeeded = false;
             }
+            else if ((srcType == columnInfo.PropertyInfo.PropertyType) ||
+                     (srcType == Nullable.GetUnderlyingType(columnInfo.PropertyInfo.PropertyType)))
+            {
+                valuegetter = _getValueMethodInfo;
+                castNeeded = true;
+            }
             else
             {
-                if (srcType == typeof(byte[]) && srcType == columnInfo.PropertyInfo.PropertyType)
-                {
-                    valuegetter = typeof(IDataRecord).GetMethod("GetValue", new Type[] { typeof(int) });
-                    castNeeded = true;
-                }
+                throw new InvalidOperationException(
+                    Properties.Resources.CannotMaterializeSourceValue.Format(srcType, columnInfo.PropertyInfo.PropertyType));
             }
 
-            if (castNeeded.HasValue)
-            {
-                ilGenerator.Emit(OpCodes.Ldarg_0);
-                ilGenerator.Emit(OpCodes.Ldc_I4, fieldIndex);
-                ilGenerator.Emit(OpCodes.Callvirt, valuegetter);
+            ilGenerator.Emit(OpCodes.Ldarg_0);
+            ilGenerator.Emit(OpCodes.Ldc_I4, fieldIndex);
+            ilGenerator.Emit(OpCodes.Callvirt, valuegetter);
 
-                if (castNeeded.Value)
-                {
-                    ilGenerator.Emit(OpCodes.Castclass, columnInfo.PropertyInfo.PropertyType);
-                }
-                else
+            if (castNeeded)
+            {
+                EmitCastValue(ilGenerator, columnInfo, srcType);
+            }
+            else
+            {
+                if (Nullable.GetUnderlyingType(columnInfo.PropertyInfo.PropertyType) != null)
                 {
-                    if (Nullable.GetUnderlyingType(columnInfo.PropertyInfo.PropertyType) != null)
-                    {
-                        ilGenerator.Emit(OpCodes.Newobj,
-                            columnInfo.PropertyInfo.PropertyType.GetConstructor(
-                                new Type[] { Nullable.GetUnderlyingType(columnInfo.PropertyInfo.PropertyType) }));
-                    }
+                    ilGenerator.Emit(OpCodes.Newobj,
+                        columnInfo.PropertyInfo.PropertyType.GetConstructor(
+                            new Type[] { Nullable.GetUnderlyingType(columnInfo.PropertyInfo.PropertyType) }));
                 }
+            }
 
-                ilGenerator.Emit(OpCodes.Callvirt, columnInfo.PropertyInfo.GetSetMethod(true));
+            ilGenerator.Emit(OpCodes.Callvirt, columnInfo.PropertyInfo.GetSetMethod(true));
+        }
+
+        private static void EmitCastValue(ILGenerator ilGenerator, ColumnInfo columnInfo, Type srcType)
+        {
+            if (srcType.IsValueType)
+            {
+                ilGenerator.Emit(OpCodes.Unbox_Any, columnInfo.PropertyInfo.PropertyType);
+            }
+            else
+            {
+                ilGenerator.Emit(OpCodes.Castclass, columnInfo.PropertyInfo.PropertyType);
             }
         }
+
+        private static Dictionary<string, MethodInfo> InitReaderValueGetters()
+        {
+            var getters = new Dictionary<string, MethodInfo>(StringComparer.CurrentCultureIgnoreCase);
+
+            MethodInfo CreateReaderValueGetter(string typeName)
+                => typeof(IDataRecord).GetMethod($"Get{typeName}", new Type[] { typeof(int) });
+
+            void Add<T>()
+                => getters.Add(typeof(T).Name, CreateReaderValueGetter(typeof(T).Name));
+
+            Add<Boolean>();
+            Add<Byte>();
+            Add<Char>();
+            Add<DateTime>();
+            Add<Decimal>();
+            Add<Double>();
+            Add<Guid>();
+            Add<Int16>();
+            Add<Int32>();
+            Add<Int64>();
+
+            Add<String>();
+
+            getters.Add(nameof(Single), CreateReaderValueGetter("Float"));
+
+            return getters;
+        }
+
+        private static MethodInfo GetReaderValueGetter(Type srcType)
+            => _readerValueGetters.ContainsKey(srcType.Name) ? _readerValueGetters[srcType.Name] : null;
     }
 }

Kros.KORM/src/Kros.KORM/Properties/Resources.Designer.cs

@@ -120,6 +120,9 @@
   <data name="BinaryOperatorIsNotSupported" xml:space="preserve">
     <value>The binary operator '{0}' is not supported.</value>
   </data>
+  <data name="CannotMaterializeSourceValue" xml:space="preserve">
+    <value>Can't materialize source value type '{0}' to destination type '{1}' without defined converter.</value>
+  </data>
   <data name="CannotOpenConnectionWhenGeneratingPrimaryKeys" xml:space="preserve">
     <value>There was a failure to open the database connection at the time the primary keys are generated. Try add 'Persist Security Info=TRUE' to the connection string.</value>
   </data>

Kros.KORM/src/Kros.KORM/Properties/Resources.resx

@@ -34,14 +34,14 @@ private class DataTypesData
             public byte ColByte { get; set; }
             public int ColInt32 { get; set; }
             public long ColInt64 { get; set; }
-            //public float ColSingle { get; set; }
+            public float ColSingle { get; set; }
             public double ColDouble { get; set; }
             public decimal ColDecimal { get; set; }
             public decimal ColCurrency { get; set; }
             public DateTime ColDate { get; set; }
             public DateTime ColDateTime { get; set; }
             public DateTime ColDateTime2 { get; set; }
-            //public DateTimeOffset ColDateTimeOffset { get; set; }
+            public DateTimeOffset ColDateTimeOffset { get; set; }
             public DateTime ColSmallDateTime { get; set; }
             public Guid ColGuid { get; set; }
             public bool ColBool { get; set; }
@@ -773,14 +773,14 @@ private static DataTypesData CreateRecord(int id)
                 ColByte = (byte)id,
                 ColInt32 = id * 100,
                 ColInt64 = id * 100000000000,
-                //ColSingle = id * (float)100000000000.12345,
+                ColSingle = id * (float)100000000000.12345,
                 ColDouble = id * 100000000000.12345,
                 ColDecimal = id * (decimal)100000000000.12345,
                 ColCurrency = id * (decimal)100000000000.12345,
                 ColDate = new DateTime(1978, 12, id),
                 ColDateTime = new DateTime(1978, 12, id, 10, 11, 22),
                 ColDateTime2 = new DateTime(1978, 12, id, 10, 11, 22),
-                //ColDateTimeOffset = new DateTimeOffset(1978, 12, id, 10, 11, 22, 123, TimeSpan.FromHours(id)),
+                ColDateTimeOffset = new DateTimeOffset(1978, 12, id, 10, 11, 22, 123, TimeSpan.FromHours(id)),
                 ColSmallDateTime = new DateTime(1978, 12, id, 10, 11, 0),
                 ColGuid = Guid.Parse($"{id}0000000-0000-0000-0000-000000000000"),
                 ColBool = (id % 2) == 0,

Kros.KORM/tests/Kros.KORM.UnitTests/Integration/DbSetShould.cs

@@ -35,6 +35,10 @@ public void CreateFactoryWhichKnowFillingObjectsWithPrimitiveTypes()
             foo.PropertyDouble.Should().Be(45.78);
             foo.PropertyDecimal.Should().Be(785.78M);
             foo.PropertyDateTime.Should().Be(new DateTime(1980, 7, 24));
+            foo.DateTimeOffset.Should().Be(new DateTimeOffset(1985, 9, 20, 10, 11, 22, 123, TimeSpan.FromHours(5)));
+            foo.DateTimeOffsetNullable.Should().Be(new DateTimeOffset(1985, 9, 20, 10, 11, 22, 123, TimeSpan.FromHours(5)));
+            foo.Float.Should().Be(12.8F);
+            foo.FloatNullable.Should().Be(45.89F);
             foo.Is.Should().BeTrue();
             foo.PropertyGuid.Should().Be(new Guid("ddc995d7-4dda-41ca-abab-7f45e651784a"));
         }
@@ -350,6 +354,10 @@ private TableInfo CreateTableInfo()
                 new ColumnInfo(){ Name = "PropertyDateTimeNullable", PropertyInfo = GetPropertyInfo<Foo>("PropertyDateTimeNullable")},
                 new ColumnInfo(){ Name = "PropertyEnumConv", PropertyInfo = GetPropertyInfo<Foo>("PropertyEnumConv"), Converter = new TestEnumConverter()},
                 new ColumnInfo(){ Name = "Age", PropertyInfo = GetPropertyInfo<Foo>("Age")},
+                new ColumnInfo(){ Name = "Float", PropertyInfo = GetPropertyInfo<Foo>("Float")},
+                new ColumnInfo(){ Name = "FloatNullable", PropertyInfo = GetPropertyInfo<Foo>("FloatNullable")},
+                new ColumnInfo(){ Name = "DateTimeOffset", PropertyInfo = GetPropertyInfo<Foo>("DateTimeOffset")},
+                new ColumnInfo(){ Name = "DateTimeOffsetNullable", PropertyInfo = GetPropertyInfo<Foo>("DateTimeOffsetNullable")},
                 new ColumnInfo(){ Name = "Service", PropertyInfo = GetPropertyInfo<Foo>("Service")}
             };
 
@@ -367,7 +375,11 @@ private List<Dictionary<string, object>> CreateData()
             List<Dictionary<string, object>> ret = new List<Dictionary<string, object>>();
 
             AddRow(ret, 1, "Hello", 45.78, (decimal)785.78, new DateTime(1980, 7, 24),
-                true, new Guid("ddc995d7-4dda-41ca-abab-7f45e651784a"), 18.5F);
+                true, new Guid("ddc995d7-4dda-41ca-abab-7f45e651784a"), 18.5F,
+                floatValue: 12.8F,
+                floatNullableValue: 45.89F,
+                dateTimeOffset: new DateTimeOffset(1985, 9, 20, 10, 11, 22, 123, TimeSpan.FromHours(5)),
+                dateTimeOffsetNullable: new DateTimeOffset(1985, 9, 20, 10, 11, 22, 123, TimeSpan.FromHours(5)));
 
             return ret;
         }
@@ -380,7 +392,11 @@ private static void AddRow(List<Dictionary<string, object>> ret,
                                                            DateTime birthday,
                                                                bool iS,
                                                                Guid guid,
-                                                            Single? age)
+                                                            Single? age,
+                                                            float floatValue,
+                                                            float? floatNullableValue,
+                                                            DateTimeOffset dateTimeOffset,
+                                                            DateTimeOffset? dateTimeOffsetNullable)
         {
             Dictionary<string, object> row = new Dictionary<string, object>() { { "Id", id },
                                                                                 { "FirstName", firstName },
@@ -389,7 +405,11 @@ private static void AddRow(List<Dictionary<string, object>> ret,
                                                                                 { "Birthday", birthday},
                                                                                 { "Is", iS},
                                                                                 { "PropertyGuid", guid},
-                                                                                { "Age", age} };
+                                                                                { "Age", age},
+                                                                                { "Float", floatValue},
+                                                                                { "FloatNullable", floatNullableValue},
+                                                                                { "DateTimeOffset", dateTimeOffset},
+                                                                                { "DateTimeOffsetNullable", dateTimeOffsetNullable}};
 
             ret.Add(row);
         }
@@ -449,6 +469,14 @@ private class Foo
 
             public double? Age { get; set; }
 
+            public float Float { get; set; }
+
+            public float? FloatNullable { get; set; }
+
+            public DateTimeOffset DateTimeOffset { get; set; }
+
+            public DateTimeOffset? DateTimeOffsetNullable { get; set; }
+
             [NoMap()]
             public TestService Service { get; set; }
         }