用fluentdata＋webform做一个简单项目（2）－FluentData核心功能

选择FluentData，主要看中其可以自动将sql查询结果映射为指定对象。

举个例子来讲：

public class Deal 
{
    public int DealId { get; set; }
    public string Title { get; set; }
    public int FKProviderid { get; set; }
    public virtual Provider Provider { get; set; }
}

public class Provider
{
    public int ProviderId { get; set; }
    public string Name { get; set; }
}

使用FluentData如下的语句：

DbContext.Sql("select a.*,b.Name as Provider_Name from Deal a inner join Provider b on a.FKProviderId=b.ProviderId").QueryMany<Deal>();

返回一个List<Deal>并且每个Deal对象的Provider属性都会自动创建为Provider对象，并且为对象的Name赋值

FluentData可以下载到源码，但代码太多不好理解，我在下面实现了sqldatareader映射的功能，大概可以体现FluentData的实现方式：

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Web;

/// <summary>
/// 反射辅助类
/// </summary>
public static class ReflectionHelper
{
    private static readonly ConcurrentDictionary<Type, Dictionary<string, PropertyInfo>> _cachedProperties 
        = new ConcurrentDictionary<Type, Dictionary<string, PropertyInfo>>();

    public static object GetPropertyValue(object item, PropertyInfo property)
    {
        var value = property.GetValue(item, null);

        return value;
    }

    public static Dictionary<string, PropertyInfo> GetProperties(Type type)
    {
        var properties = _cachedProperties.GetOrAdd(type, BuildPropertyDictionary);

        return properties;
    }

    private static Dictionary<string, PropertyInfo> BuildPropertyDictionary(Type type)
    {
        var result = new Dictionary<string, PropertyInfo>();

        var properties = type.GetProperties();
        foreach (var property in properties)
        {
            result.Add(property.Name.ToLower(), property);
        }
        return result;
    }

    /// <summary>
    /// 判断是否是集合
    /// </summary>
    /// <param name="item"></param>
    /// <returns></returns>
    public static bool IsList(object item)
    {
        if (item is ICollection)
            return true;

        return false;
    }

    /// <summary>
    /// 是否Nullable
    /// </summary>
    /// <param name="property"></param>
    /// <returns></returns>
    public static bool IsNullable(PropertyInfo property)
    {
        if (property.PropertyType.IsGenericType &&
            property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
            return true;

        return false;
    }

    /// <summary>
    /// Includes a work around for getting the actual type of a Nullable type.
    /// 获取属性的类型，若参数可空，返回实际类型。
    /// 注：若参数可空，返回如下形式：System.Nullable`1[System.Int32]，通过GetGenericArguments()函数获取数组的第一个值即为实际类型
    /// </summary>
    public static Type GetPropertyType(PropertyInfo property)
    {
        if (IsNullable(property))
            return property.PropertyType.GetGenericArguments()[0];

        return property.PropertyType;
    }

    /// <summary>
    /// 创建实例
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public static object GetDefault(Type type)
    {
        if (type.IsValueType)
            return Activator.CreateInstance(type);
        return null;
    }

    /// <summary>
    /// 判断是否是枚举类型，基元类型、值类型、文本类型、日期类型
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public static bool IsBasicClrType(Type type)
    {
        if (type.IsEnum
            || type.IsPrimitive
            || type.IsValueType
            || type == typeof(string)
            || type == typeof(DateTime))
            return true;

        return false;
    }

    /// <summary>
    /// 是否是自定义实体类型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    public static bool IsCustomEntity<T>()
    {
        var type = typeof(T);
        if (type.IsClass && Type.GetTypeCode(type) == TypeCode.Object)
            return true;
        return false;
    }


    /// <summary>
    /// 获取类型的属性信息
    /// </summary>
    /// <param name="type"></param>
    /// <param name="refresh"></param>
    /// <returns></returns>
    public static Dictionary<string, PropertyInfo> GetProperties(Type type, bool refresh)
    {
        try
        {
            Dictionary<string, PropertyInfo> dicts = new Dictionary<string, PropertyInfo>();
            if (!_cachedProperties.TryGetValue(type, out dicts))
            {
                PropertyInfo[] pis = type.GetProperties();
                Dictionary<string, PropertyInfo> dict = new Dictionary<string, PropertyInfo>();
                foreach (var pi in pis)
                {
                    dict.Add(pi.Name, pi);
                }

                _cachedProperties.TryAdd(type, dict);
                _cachedProperties.TryGetValue(type, out dicts);
            }
            return dicts;
        }
        catch (Exception ex)
        {
            throw new ArgumentException("获取属性列表失败：" + ex.Message);
        }
    }

    /// <summary>
    /// sdr转换为属性值
    /// </summary>
    /// <param name="o"></param>
    /// <param name="pi"></param>
    /// <param name="sdr"></param>
    public static void ConvertType<T>(T t, SqlDataReader sdr)
    {
        try
        {
            Type type = typeof(T);
            var pis = GetProperties(type, false);

            List<PropertyInfo> infos = new List<PropertyInfo>();
            List<string> subInfos = new List<string>();

            for (int i = 0; i < sdr.FieldCount; i++)
            {
                string colName = sdr.GetName(i).Trim();
                PropertyInfo pi;

                if (colName.Contains("_"))
                {
                    subInfos.Add(colName);
                    colName = colName.Substring(0, colName.IndexOf("_"));
                }

                if (pis.TryGetValue(colName, out pi))
                {
                    infos.Add(pi);
                }
            }

            foreach (var p in infos)
            {
                if (IsBasicClrType(p.PropertyType))
                {
                    if (sdr[p.Name] != null)
                    {
                        if (sdr[p.Name] != DBNull.Value)
                        {
                            p.SetValue(t, Convert.ChangeType(sdr[p.Name], GetPropertyType(p)), null);
                        }
                    }
                }
                else
                {
                    Type ty = GetPropertyType(p);
                    var sub = ConvertType(ty, sdr, p.PropertyType.Name, subInfos);
                    p.SetValue(t, Convert.ChangeType(sub, ty), null);
                }
            }
        }
        catch(Exception ex)
        {
            throw new ArgumentException("无法映射属性，属性和sql语句中的字段名称不符：" + ex.Message);
        }   
    }

    /// <summary>
    /// sdr转换为子属性值
    /// </summary>
    /// <param name="o"></param>
    /// <param name="pi"></param>
    /// <param name="sdr"></param>
    /// <param name="prefix"></param>
    public static object ConvertType(Type type, SqlDataReader sdr, string prefix, List<string> cols)
    {
        try
        {
            var pi = GetProperties(type, false);
            var obj = Activator.CreateInstance(type);

            foreach (var p in pi)
            {
                var coln = prefix + "_" + p.Value.Name;
                if (cols.Contains(coln))
                {
                    if (sdr[coln] != DBNull.Value)
                    {
                        p.Value.SetValue(obj, Convert.ChangeType(sdr[coln], p.Value.PropertyType), null);
                    }
                }
            }
            return obj;
        }
        catch
        {
            throw new ArgumentException("无法映射属性，属性和sql语句中的字段名称不符");
        }
    }
}

测试代码：

using (SqlConnection conn = new SqlConnection("Data Source=.;Initial Catalog=xxxxxx;Persist Security Info=True;User ID=xxxxx;Password=xxxx"))
        {
            string sql = "select a.Title,b.Name as Provider_Name from Deal a left join Provider b on a.FKProviderId=b.ProviderId";
            SqlCommand sc = new SqlCommand(sql, conn);
            List<Deal> deals = new List<Deal>();

            conn.Open();
            SqlDataReader reader = sc.ExecuteReader();

            while (reader.Read())
            {
                Deal deal = new Deal();
                ReflectionHelper.ConvertType<Deal>(deal, reader);
                deals.Add(deal);
            }

            reader.Close();

            GridView1.DataSource = deals;
            GridView1.DataBind();
        }

实现的功能有限，用于说明fluentdata的部分原理，希望能抛砖引玉