Allowed the ability to add an internal mapping provider which maps SQL query results into a new entity form

Author: johelvisguzman

src/DotNetToolkit.Repository/Configuration/Mapper/DefaultMapper.cs

@@ -0,0 +1,75 @@
+namespace DotNetToolkit.Repository.Configuration.Mapper
+{
+    using Conventions;
+    using Extensions;
+    using System;
+    using System.Collections.Generic;
+    using System.Data;
+    using System.Linq;
+    using System.Reflection;
+
+    /// <summary>
+    /// An implementation of <see cref="IMapper{T}" />.
+    /// </summary>
+    internal class DefaultMapper<T> : IMapper<T> where T : class
+    {
+        #region Fields
+
+        private readonly Dictionary<string, PropertyInfo> _propertiesMapping;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultMapper{T}"/> class.
+        /// </summary>
+        public DefaultMapper()
+        {
+            _propertiesMapping = typeof(T).GetRuntimeProperties()
+                .Where(x => x.IsPrimitive() && x.IsColumnMapped())
+                .OrderBy(x => x.GetColumnOrder())
+                .ToDictionary(x => x.GetColumnName(), x => x);
+        }
+
+        #endregion
+
+        #region Implementation of IMapper<out T>
+
+        /// <summary>
+        /// Maps each element to a new form.
+        /// </summary>
+        /// <param name="reader">The data reader used for transforming each element.</param>
+        /// <returns>The new projected element form.</returns>
+        public T Map(IDataReader reader)
+        {
+            if (reader == null)
+                throw new ArgumentNullException(nameof(reader));
+
+            var entity = Activator.CreateInstance<T>();
+
+            for (var i = 0; i < reader.FieldCount; i++)
+            {
+                var name = reader.GetName(i);
+                var value = reader[name];
+
+                if (value == DBNull.Value)
+                    value = null;
+
+                if (_propertiesMapping.ContainsKey(name))
+                {
+                    if (!reader.IsDBNull(reader.GetOrdinal(name)))
+                    {
+                        var pi = _propertiesMapping[name];
+
+                        pi.SetValue(entity, value);
+                    }
+                }
+            }
+
+            return entity;
+        }
+
+        #endregion
+    }
+}

src/DotNetToolkit.Repository/Configuration/Mapper/IMapper.cs

@@ -0,0 +1,18 @@
+namespace DotNetToolkit.Repository.Configuration.Mapper
+{
+    using System.Data;
+
+    /// <summary>
+    /// Represents a mapper which takes a data reader returned by an executed SQL query and maps it into new entity form.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    public interface IMapper<out T> where T : class
+    {
+        /// <summary>
+        /// Maps each element to a new form.
+        /// </summary>
+        /// <param name="reader">The data reader used for transforming each element.</param>
+        /// <returns>The new projected element form.</returns>
+        T Map(IDataReader reader);
+    }
+}

src/DotNetToolkit.Repository/Configuration/Mapper/IMapperProvider.cs

@@ -0,0 +1,15 @@
+namespace DotNetToolkit.Repository.Configuration.Mapper
+{
+    /// <summary>
+    /// Represents a mapping provider.
+    /// </summary>
+    public interface IMapperProvider
+    {
+        /// <summary>
+        /// Creates a mapper for the specified entity type.
+        /// </summary>
+        /// <typeparam name="T">The type of the entity.</typeparam>
+        /// <returns>The <see cref="IMapper{T}"/>.</returns>
+        IMapper<T> Create<T>() where T : class;
+    }
+}

src/DotNetToolkit.Repository/Configuration/Mapper/MapperProvider.cs

@@ -0,0 +1,66 @@
+namespace DotNetToolkit.Repository.Configuration.Mapper
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// An implementation of <see cref="IMapperProvider" />.
+    /// </summary>
+    public class MapperProvider : IMapperProvider
+    {
+        private static volatile MapperProvider _instance;
+        private static readonly object _syncRoot = new object();
+        private readonly Dictionary<Type, IMapper<object>> _mappings = new Dictionary<Type, IMapper<object>>();
+
+        /// <summary>
+        /// Gets the instance.
+        /// </summary>
+        internal static MapperProvider Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_instance == null)
+                            _instance = new MapperProvider();
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        /// <summary>
+        /// Creates a mapper for the specified entity type.
+        /// </summary>
+        /// <typeparam name="T">The type of the entity.</typeparam>
+        /// <returns>The <see cref="IMapper{T}"/>.</returns>
+        public IMapper<T> Create<T>() where T : class
+        {
+            if (_mappings.ContainsKey(typeof(T)))
+                return (IMapper<T>)_mappings[typeof(T)];
+
+            return new DefaultMapper<T>();
+        }
+
+        /// <summary>
+        /// Registers a mapper for the specified entity type.
+        /// </summary>
+        /// <typeparam name="T">The type of the entity.</typeparam>
+        /// <param name="mapper">The mapper to register.</param>
+        public MapperProvider Register<T>(IMapper<T> mapper) where T : class
+        {
+            if (mapper == null)
+                throw new ArgumentNullException(nameof(mapper));
+
+            if (_mappings.ContainsKey(typeof(T)))
+                _mappings[typeof(T)] = mapper;
+            else
+                _mappings.Add(typeof(T), mapper);
+
+            return this;
+        }
+    }
+}

src/DotNetToolkit.Repository/Configuration/Options/IRepositoryOptions.cs

@@ -4,6 +4,7 @@
     using Factories;
     using Interceptors;
     using Logging;
+    using Mapper;
     using System;
     using System.Collections.Generic;
 
@@ -27,6 +28,11 @@ public interface IRepositoryOptions
         /// </summary>
         ICacheProvider CachingProvider { get; }
 
+        /// <summary>
+        /// Gets the configured mapper provider.
+        /// </summary>
+        IMapperProvider MapperProvider { get; }
+
         /// <summary>
         /// Gets the configured internal context factory.
         /// </summary>

src/DotNetToolkit.Repository/Configuration/Options/RepositoryOptions.cs

@@ -4,6 +4,7 @@
     using Factories;
     using Interceptors;
     using Logging;
+    using Mapper;
     using System;
     using System.Collections.Generic;
     using System.Linq;
@@ -19,6 +20,7 @@ public class RepositoryOptions : IRepositoryOptions
         private IRepositoryContextFactory _contextFactory;
         private ILoggerProvider _loggerProvider;
         private ICacheProvider _cachingProvider;
+        private IMapperProvider _mapperProvider;
 
         #endregion
 
@@ -39,6 +41,11 @@ public class RepositoryOptions : IRepositoryOptions
         /// </summary>
         public virtual ICacheProvider CachingProvider { get { return _cachingProvider; } }
 
+        /// <summary>
+        /// Gets the configured mapper provider.
+        /// </summary>
+        public IMapperProvider MapperProvider { get { return _mapperProvider; } }
+
         /// <summary>
         /// Gets the configured internal context factory.
         /// </summary>
@@ -54,6 +61,7 @@ public virtual bool IsConfigured
                 return ContextFactory != null ||
                        LoggerProvider != null ||
                        CachingProvider != null ||
+                       MapperProvider != null ||
                        Interceptors.Any();
             }
         }
@@ -167,7 +175,22 @@ internal RepositoryOptions With(ICacheProvider cacheProvider)
 
             return this;
         }
-        
+
+        /// <summary>
+        /// Returns the option instance with a configured mapper provider for mapping an query result to a valid entity object within the repository.
+        /// </summary>
+        /// <param name="mapperProvider">The entity mapper provider.</param>
+        /// <returns>The same option instance.</returns>
+        internal RepositoryOptions With(IMapperProvider mapperProvider)
+        {
+            if (mapperProvider == null)
+                throw new ArgumentNullException(nameof(mapperProvider));
+
+            _mapperProvider = mapperProvider;
+
+            return this;
+        }
+
         #endregion
     }
 }

src/DotNetToolkit.Repository/Configuration/Options/RepositoryOptionsBuilder.cs

@@ -4,6 +4,7 @@
     using Factories;
     using Interceptors;
     using Logging;
+    using Mapper;
     using System;
 
     /// <summary>
@@ -181,6 +182,21 @@ public RepositoryOptionsBuilder UseCachingProvider(ICacheProvider cacheProvider)
             return this;
         }
 
+        /// <summary>
+        /// Configures the repository options with a mapper provider for mapping an query result to a valid entity object within the repository.
+        /// </summary>
+        /// <param name="mapperProvider">The entity mapper provider.</param>
+        /// <returns>The same builder instance.</returns>
+        public virtual RepositoryOptionsBuilder UseMapperProvider(IMapperProvider mapperProvider)
+        {
+            if (mapperProvider == null)
+                throw new ArgumentNullException(nameof(mapperProvider));
+
+            _options.With(mapperProvider);
+
+            return this;
+        }
+
         /// <summary>
         /// Configures the repository options with an internal context factory.
         /// </summary>