IDataReader转List

最新推荐文章于 2022-09-06 22:44:55 发布
最新推荐文章于 2022-09-06 22:44:55 发布
阅读量1.3k 收藏
点赞数
分类专栏： C# 文章标签： c# 
//http://www.cnblogs.com/vwxyzh/archive/2009/11/12/1601724.html



using System;
using System.Collections.Generic;
using System.Data;
using System.Reflection;
using System.Reflection.Emit;

namespace DataAccessors
{
    /// <summary>
    /// DataReader Extensions
    /// </summary>
    public static class DataReaderExtensions
    {

        #region Static Readonly Fields
        private static readonly MethodInfo DataRecord_ItemGetter_String =
            typeof(IDataRecord).GetMethod("get_Item", new Type[] { typeof(string) });
        private static readonly MethodInfo DataRecord_ItemGetter_Int =
            typeof(IDataRecord).GetMethod("get_Item", new Type[] { typeof(int) });
        private static readonly MethodInfo DataRecord_GetOrdinal =
            typeof(IDataRecord).GetMethod("GetOrdinal");
        private static readonly MethodInfo DataReader_Read =
            typeof(IDataReader).GetMethod("Read");
        private static readonly MethodInfo Convert_IsDBNull =
            typeof(Convert).GetMethod("IsDBNull");
        private static readonly MethodInfo DataRecord_GetDateTime =
            typeof(IDataRecord).GetMethod("GetDateTime");
        private static readonly MethodInfo DataRecord_GetDecimal =
            typeof(IDataRecord).GetMethod("GetDecimal");
        private static readonly MethodInfo DataRecord_GetDouble =
            typeof(IDataRecord).GetMethod("GetDouble");
        private static readonly MethodInfo DataRecord_GetInt32 =
            typeof(IDataRecord).GetMethod("GetInt32");
        private static readonly MethodInfo DataRecord_GetInt64 =
            typeof(IDataRecord).GetMethod("GetInt64");
        private static readonly MethodInfo DataRecord_GetString =
            typeof(IDataRecord).GetMethod("GetString");
        private static readonly MethodInfo DataRecord_IsDBNull =
            typeof(IDataRecord).GetMethod("IsDBNull");
        #endregion

        #region Public Static Methods

        /// <summary>
        /// 把结果集流转换成数据实体列表
        /// </summary>
        /// <typeparam name="T">数据实体类型</typeparam>
        /// <param name="reader">结果集流</param>
        /// <returns>数据实体列表</returns>
        public static List<T> Select<T>(this IDataReader reader)
            where T : class, new()
        {
            if (reader == null)
                throw new ArgumentNullException("reader");
            return EntityConverter<T>.Select(reader);
        }

        /// <summary>
        /// 把结果集流转换成数据实体序列（延迟）
        /// </summary>
        /// <typeparam name="T">数据实体类型</typeparam>
        /// <param name="reader">结果集流</param>
        /// <returns>数据实体序列（延迟）</returns>
        public static IEnumerable<T> SelectLazy<T>(this IDataReader reader)
            where T : class, new()
        {
            if (reader == null)
                throw new ArgumentNullException("reader");
            return EntityConverter<T>.SelectDelay(reader);
        }

        #endregion

        #region Class: EntityConverter<T>

        /// <summary>
        /// 实体转换器
        /// </summary>
        /// <typeparam name="T">数据实体类型</typeparam>
        private class EntityConverter<T>
            where T : class, new()
        {

            #region Struct: DbColumnInfo

            private struct DbColumnInfo
            {
                public readonly string PropertyName;
                public readonly string ColumnName;
                public readonly Type Type;
                public readonly MethodInfo SetMethod;
                public readonly bool IsOptional;

                public DbColumnInfo(PropertyInfo prop, DbColumnAttribute attr)
                {
                    PropertyName = prop.Name;
                    ColumnName = attr.ColumnName ?? prop.Name;
                    Type = prop.PropertyType;
                    SetMethod = prop.GetSetMethod(false);
                    IsOptional = attr.IsOptional;
                }
            }

            #endregion

            #region Fields
            private static Converter<IDataReader, T> dataLoader;
            private static Converter<IDataReader, List<T>> batchDataLoader;
            #endregion

            #region Properties

            private static Converter<IDataReader, T> DataLoader
            {
                get
                {
                    if (dataLoader == null)
                        dataLoader = CreateDataLoader(new List<DbColumnInfo>(GetProperties()));
                    return dataLoader;
                }
            }

            private static Converter<IDataReader, List<T>> BatchDataLoader
            {
                get
                {
                    if (batchDataLoader == null)
                        batchDataLoader = CreateBatchDataLoader(new List<DbColumnInfo>(GetProperties()));
                    return batchDataLoader;
                }
            }

            #endregion

            #region Init Methods

            private static IEnumerable<DbColumnInfo> GetProperties()
            {
                DbResultAttribute dbResult = Attribute.GetCustomAttribute(typeof(T), typeof(DbResultAttribute), true) as DbResultAttribute;
                foreach (var prop in typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public))
                {
                    if (prop.GetIndexParameters().Length > 0)
                        continue;
                    var setMethod = prop.GetSetMethod(false);
                    if (setMethod == null)
                        continue;
                    var attr = Attribute.GetCustomAttribute(prop, typeof(DbColumnAttribute), true) as DbColumnAttribute;
                    if (dbResult != null && dbResult.DefaultAsDbColumn)
                        if (attr != null && attr.Ignore)
                            continue;
                        else
                            attr = attr ?? new DbColumnAttribute();
                    else
                        if (attr == null || attr.Ignore)
                            continue;
                    yield return new DbColumnInfo(prop, attr);
                }
            }

            //private static Converter<IDataReader, T> CreateDataLoaderOld(List<DbColumnInfo> columnInfoes)
            //{
            //    DynamicMethod dm = new DynamicMethod(string.Empty, typeof(T),
            //        new Type[] { typeof(IDataReader) }, typeof(EntityConverter<T>));
            //    ILGenerator il = dm.GetILGenerator();
            //    il.Emit(OpCodes.Newobj, typeof(T).GetConstructor(Type.EmptyTypes));
            //    foreach (var column in columnInfoes)
            //    {
            //        Label common = il.DefineLabel();
            //        il.Emit(OpCodes.Dup);
            //        il.Emit(OpCodes.Ldarg_0);
            //        il.Emit(OpCodes.Dup);
            //        il.Emit(OpCodes.Ldstr, column.ColumnName);
            //        il.Emit(OpCodes.Callvirt, DataRecord_GetOrdinal);
            //        il.Emit(OpCodes.Callvirt, DataRecord_ItemGetter_Int);
            //        il.Emit(OpCodes.Dup);
            //        il.Emit(OpCodes.Call, Convert_IsDBNull);
            //        il.Emit(OpCodes.Brfalse_S, common);
            //        il.Emit(OpCodes.Pop);
            //        il.Emit(OpCodes.Ldnull);
            //        il.MarkLabel(common);
            //        il.Emit(OpCodes.Unbox_Any, column.Type);
            //        il.Emit(OpCodes.Callvirt, column.SetMethod);
            //    }
            //    il.Emit(OpCodes.Ret);
            //    return (Converter<IDataReader, T>)dm.CreateDelegate(typeof(Converter<IDataReader, T>));
            //}

            private static Converter<IDataReader, T> CreateDataLoader(List<DbColumnInfo> columnInfoes)
            {
                DynamicMethod dm = new DynamicMethod(string.Empty, typeof(T),
                    new Type[] { typeof(IDataReader) }, typeof(EntityConverter<T>));
                ILGenerator il = dm.GetILGenerator();
                LocalBuilder item = il.DeclareLocal(typeof(T));
                // [ int %index% = arg.GetOrdinal(%ColumnName%); ]
                LocalBuilder[] colIndices = GetColumnIndices(il, columnInfoes);
                // T item = new T { %Property% = ... };
                BuildItem(il, columnInfoes, item, colIndices);
                // return item;
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ret);
                return (Converter<IDataReader, T>)dm.CreateDelegate(typeof(Converter<IDataReader, T>));
            }

            //private static Converter<IDataReader, List<T>> CreateBatchDataLoaderOld(List<DbColumnInfo> columnInfoes)
            //{
            //    DynamicMethod dm = new DynamicMethod(string.Empty, typeof(List<T>),
            //        new Type[] { typeof(IDataReader) }, typeof(EntityConverter<T>));
            //    ILGenerator il = dm.GetILGenerator();
            //    LocalBuilder list = il.DeclareLocal(typeof(List<T>));
            //    LocalBuilder item = il.DeclareLocal(typeof(T));
            //    Label exit = il.DefineLabel();
            //    Label loop = il.DefineLabel();
            //    // List<T> list = new List<T>();
            //    il.Emit(OpCodes.Newobj, typeof(List<T>).GetConstructor(Type.EmptyTypes));
            //    il.Emit(OpCodes.Stloc_S, list);
            //    // [ int %index% = arg.GetOrdinal(%ColumnName%); ]
            //    LocalBuilder[] colIndices = new LocalBuilder[columnInfoes.Count];
            //    for (int i = 0; i < colIndices.Length; i++)
            //    {
            //        colIndices[i] = il.DeclareLocal(typeof(int));
            //        il.Emit(OpCodes.Ldarg_0);
            //        il.Emit(OpCodes.Ldstr, columnInfoes[i].ColumnName);
            //        il.Emit(OpCodes.Callvirt, DataRecord_GetOrdinal);
            //        il.Emit(OpCodes.Stloc_S, colIndices[i]);
            //    }
            //    // while (arg.Read()) {
            //    il.MarkLabel(loop);
            //    il.Emit(OpCodes.Ldarg_0);
            //    il.Emit(OpCodes.Callvirt, DataReader_Read);
            //    il.Emit(OpCodes.Brfalse, exit);
            //    // T item = new T();
            //    il.Emit(OpCodes.Newobj, typeof(T).GetConstructor(Type.EmptyTypes));
            //    il.Emit(OpCodes.Stloc_S, item);
            //    for (int i = 0; i < colIndices.Length; i++)
            //    {
            //        // item.%Property% = (%PropertyType%)arg[%index%];
            //        Label common = il.DefineLabel();
            //        il.Emit(OpCodes.Ldloc_S, item);
            //        il.Emit(OpCodes.Ldarg_0);
            //        il.Emit(OpCodes.Ldloc_S, colIndices[i]);
            //        il.Emit(OpCodes.Callvirt, DataRecord_ItemGetter_Int);
            //        il.Emit(OpCodes.Dup);
            //        il.Emit(OpCodes.Call, Convert_IsDBNull);
            //        il.Emit(OpCodes.Brfalse_S, common);
            //        il.Emit(OpCodes.Pop);
            //        il.Emit(OpCodes.Ldnull);
            //        il.MarkLabel(common);
            //        il.Emit(OpCodes.Unbox_Any, columnInfoes[i].Type);
            //        il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
            //    }
            //    // list.Add(item);
            //    il.Emit(OpCodes.Ldloc_S, list);
            //    il.Emit(OpCodes.Ldloc_S, item);
            //    il.Emit(OpCodes.Callvirt, typeof(List<T>).GetMethod("Add"));
            //    // }
            //    il.Emit(OpCodes.Br, loop);
            //    // return list;
            //    il.MarkLabel(exit);
            //    il.Emit(OpCodes.Ldloc_S, list);
            //    il.Emit(OpCodes.Ret);
            //    return (Converter<IDataReader, List<T>>)dm.CreateDelegate(typeof(Converter<IDataReader, List<T>>));
            //}

            private static Converter<IDataReader, List<T>> CreateBatchDataLoader(List<DbColumnInfo> columnInfoes)
            {
                DynamicMethod dm = new DynamicMethod(string.Empty, typeof(List<T>),
                    new Type[] { typeof(IDataReader) }, typeof(EntityConverter<T>));
                ILGenerator il = dm.GetILGenerator();
                LocalBuilder list = il.DeclareLocal(typeof(List<T>));
                LocalBuilder item = il.DeclareLocal(typeof(T));
                Label exit = il.DefineLabel();
                Label loop = il.DefineLabel();
                // List<T> list = new List<T>();
                il.Emit(OpCodes.Newobj, typeof(List<T>).GetConstructor(Type.EmptyTypes));
                il.Emit(OpCodes.Stloc_S, list);
                // [ int %index% = arg.GetOrdinal(%ColumnName%); ]
                LocalBuilder[] colIndices = GetColumnIndices(il, columnInfoes);
                // while (arg.Read()) {
                il.MarkLabel(loop);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Callvirt, DataReader_Read);
                il.Emit(OpCodes.Brfalse, exit);
                //      T item = new T { %Property% = ... };
                BuildItem(il, columnInfoes, item, colIndices);
                //      list.Add(item);
                il.Emit(OpCodes.Ldloc_S, list);
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Callvirt, typeof(List<T>).GetMethod("Add"));
                // }
                il.Emit(OpCodes.Br, loop);
                il.MarkLabel(exit);
                // return list;
                il.Emit(OpCodes.Ldloc_S, list);
                il.Emit(OpCodes.Ret);
                return (Converter<IDataReader, List<T>>)dm.CreateDelegate(typeof(Converter<IDataReader, List<T>>));
            }

            private static LocalBuilder[] GetColumnIndices(ILGenerator il, List<DbColumnInfo> columnInfoes)
            {
                LocalBuilder[] colIndices = new LocalBuilder[columnInfoes.Count];
                for (int i = 0; i < colIndices.Length; i++)
                {
                    // int %index% = arg.GetOrdinal(%ColumnName%);
                    colIndices[i] = il.DeclareLocal(typeof(int));
                    if (columnInfoes[i].IsOptional)
                    {
                        // try {
                        il.BeginExceptionBlock();
                    }
                    il.Emit(OpCodes.Ldarg_0);
                    il.Emit(OpCodes.Ldstr, columnInfoes[i].ColumnName);
                    il.Emit(OpCodes.Callvirt, DataRecord_GetOrdinal);
                    il.Emit(OpCodes.Stloc_S, colIndices[i]);
                    if (columnInfoes[i].IsOptional)
                    {
                        Label exit = il.DefineLabel();
                        il.Emit(OpCodes.Leave_S, exit);
                        // } catch (IndexOutOfRangeException) {
                        il.BeginCatchBlock(typeof(IndexOutOfRangeException));
                        // //forget the exception
                        il.Emit(OpCodes.Pop);
                        // int %index% = -1; // if not found, -1
                        il.Emit(OpCodes.Ldc_I4_M1);
                        il.Emit(OpCodes.Stloc_S, colIndices[i]);
                        il.Emit(OpCodes.Leave_S, exit);
                        // } catch (ArgumentException) {
                        il.BeginCatchBlock(typeof(ArgumentException));
                        // forget the exception
                        il.Emit(OpCodes.Pop);
                        // int %index% = -1; // if not found, -1
                        il.Emit(OpCodes.Ldc_I4_M1);
                        il.Emit(OpCodes.Stloc_S, colIndices[i]);
                        il.Emit(OpCodes.Leave_S, exit);
                        // }
                        il.EndExceptionBlock();
                        il.MarkLabel(exit);
                    }
                }
                return colIndices;
            }

            private static void BuildItem(ILGenerator il, List<DbColumnInfo> columnInfoes,
                LocalBuilder item, LocalBuilder[] colIndices)
            {
                // T item = new T();
                il.Emit(OpCodes.Newobj, typeof(T).GetConstructor(Type.EmptyTypes));
                il.Emit(OpCodes.Stloc_S, item);
                Label skip = new Label();
                for (int i = 0; i < colIndices.Length; i++)
                {
                    if (columnInfoes[i].IsOptional)
                    {
                        // if %index% == -1 then goto skip;
                        skip = il.DefineLabel();
                        il.Emit(OpCodes.Ldloc_S, colIndices[i]);
                        il.Emit(OpCodes.Ldc_I4_M1);
                        il.Emit(OpCodes.Beq, skip);
                    }
                    if (IsCompatibleType(columnInfoes[i].Type, typeof(int)))
                    {
                        // item.%Property% = arg.GetInt32(%index%);
                        ReadInt32(il, item, columnInfoes, colIndices, i);
                    }
                    else if (IsCompatibleType(columnInfoes[i].Type, typeof(int?)))
                    {
                        // item.%Property% = arg.IsDBNull ? default(int?) : (int?)arg.GetInt32(%index%);
                        ReadNullableInt32(il, item, columnInfoes, colIndices, i);
                    }
                    else if (IsCompatibleType(columnInfoes[i].Type, typeof(long)))
                    {
                        // item.%Property% = arg.GetInt64(%index%);
                        ReadInt64(il, item, columnInfoes, colIndices, i);
                    }
                    else if (IsCompatibleType(columnInfoes[i].Type, typeof(long?)))
                    {
                        // item.%Property% = arg.IsDBNull ? default(long?) : (long?)arg.GetInt64(%index%);
                        ReadNullableInt64(il, item, columnInfoes, colIndices, i);
                    }
                    else if (IsCompatibleType(columnInfoes[i].Type, typeof(decimal)))
                    {
                        // item.%Property% = arg.GetDecimal(%index%);
                        ReadDecimal(il, item, columnInfoes[i].SetMethod, colIndices[i]);
                    }
                    else if (columnInfoes[i].Type == typeof(decimal?))
                    {
                        // item.%Property% = arg.IsDBNull ? default(decimal?) : (int?)arg.GetDecimal(%index%);
                        ReadNullableDecimal(il, item, columnInfoes[i].SetMethod, colIndices[i]);
                    }
                    else if (columnInfoes[i].Type == typeof(DateTime))
                    {
                        // item.%Property% = arg.GetDateTime(%index%);
                        ReadDateTime(il, item, columnInfoes[i].SetMethod, colIndices[i]);
                    }
                    else if (columnInfoes[i].Type == typeof(DateTime?))
                    {
                        // item.%Property% = arg.IsDBNull ? default(DateTime?) : (int?)arg.GetDateTime(%index%);
                        ReadNullableDateTime(il, item, columnInfoes[i].SetMethod, colIndices[i]);
                    }
                    else
                    {
                        // item.%Property% = (%PropertyType%)arg[%index%];
                        ReadObject(il, item, columnInfoes, colIndices, i);
                    }
                    if (columnInfoes[i].IsOptional)
                    {
                        // :skip
                        il.MarkLabel(skip);
                    }
                }
            }

            private static bool IsCompatibleType(Type t1, Type t2)
            {
                if (t1 == t2)
                    return true;
                if (t1.IsEnum && Enum.GetUnderlyingType(t1) == t2)
                    return true;
                var u1 = Nullable.GetUnderlyingType(t1);
                var u2 = Nullable.GetUnderlyingType(t2);
                if (u1 != null && u2 != null)
                    return IsCompatibleType(u1, u2);
                return false;
            }

            private static void ReadInt32(ILGenerator il, LocalBuilder item,
                List<DbColumnInfo> columnInfoes, LocalBuilder[] colIndices, int i)
            {
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndices[i]);
                il.Emit(OpCodes.Callvirt, DataRecord_GetInt32);
                il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
            }

            private static void ReadNullableInt32(ILGenerator il, LocalBuilder item,
                List<DbColumnInfo> columnInfoes, LocalBuilder[] colIndices, int i)
            {
                var local = il.DeclareLocal(columnInfoes[i].Type);
                Label intNull = il.DefineLabel();
                Label intCommon = il.DefineLabel();
                il.Emit(OpCodes.Ldloca, local);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndices[i]);
                il.Emit(OpCodes.Callvirt, DataRecord_IsDBNull);
                il.Emit(OpCodes.Brtrue_S, intNull);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndices[i]);
                il.Emit(OpCodes.Callvirt, DataRecord_GetInt32);
                il.Emit(OpCodes.Call, columnInfoes[i].Type.GetConstructor(
                    new Type[] { Nullable.GetUnderlyingType(columnInfoes[i].Type) }));
                il.Emit(OpCodes.Br_S, intCommon);
                il.MarkLabel(intNull);
                il.Emit(OpCodes.Initobj, columnInfoes[i].Type);
                il.MarkLabel(intCommon);
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ldloc, local);
                il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
            }

            private static void ReadInt64(ILGenerator il, LocalBuilder item,
                List<DbColumnInfo> columnInfoes, LocalBuilder[] colIndices, int i)
            {
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndices[i]);
                il.Emit(OpCodes.Callvirt, DataRecord_GetInt64);
                il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
            }

            private static void ReadNullableInt64(ILGenerator il, LocalBuilder item,
                List<DbColumnInfo> columnInfoes, LocalBuilder[] colIndices, int i)
            {
                var local = il.DeclareLocal(columnInfoes[i].Type);
                Label intNull = il.DefineLabel();
                Label intCommon = il.DefineLabel();
                il.Emit(OpCodes.Ldloca, local);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndices[i]);
                il.Emit(OpCodes.Callvirt, DataRecord_IsDBNull);
                il.Emit(OpCodes.Brtrue_S, intNull);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndices[i]);
                il.Emit(OpCodes.Callvirt, DataRecord_GetInt64);
                il.Emit(OpCodes.Call, columnInfoes[i].Type.GetConstructor(
                    new Type[] { Nullable.GetUnderlyingType(columnInfoes[i].Type) }));
                il.Emit(OpCodes.Br_S, intCommon);
                il.MarkLabel(intNull);
                il.Emit(OpCodes.Initobj, columnInfoes[i].Type);
                il.MarkLabel(intCommon);
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ldloc, local);
                il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
            }

            private static void ReadDecimal(ILGenerator il, LocalBuilder item,
                MethodInfo setMethod, LocalBuilder colIndex)
            {
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndex);
                il.Emit(OpCodes.Callvirt, DataRecord_GetDecimal);
                il.Emit(OpCodes.Callvirt, setMethod);
            }

            private static void ReadNullableDecimal(ILGenerator il, LocalBuilder item,
                MethodInfo setMethod, LocalBuilder colIndex)
            {
                var local = il.DeclareLocal(typeof(decimal?));
                Label decimalNull = il.DefineLabel();
                Label decimalCommon = il.DefineLabel();
                il.Emit(OpCodes.Ldloca, local);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndex);
                il.Emit(OpCodes.Callvirt, DataRecord_IsDBNull);
                il.Emit(OpCodes.Brtrue_S, decimalNull);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndex);
                il.Emit(OpCodes.Callvirt, DataRecord_GetDecimal);
                il.Emit(OpCodes.Call, typeof(decimal?).GetConstructor(new Type[] { typeof(decimal) }));
                il.Emit(OpCodes.Br_S, decimalCommon);
                il.MarkLabel(decimalNull);
                il.Emit(OpCodes.Initobj, typeof(decimal?));
                il.MarkLabel(decimalCommon);
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ldloc, local);
                il.Emit(OpCodes.Callvirt, setMethod);
            }

            private static void ReadDateTime(ILGenerator il, LocalBuilder item,
                MethodInfo setMethod, LocalBuilder colIndex)
            {
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndex);
                il.Emit(OpCodes.Callvirt, DataRecord_GetDateTime);
                il.Emit(OpCodes.Callvirt, setMethod);
            }

            private static void ReadNullableDateTime(ILGenerator il, LocalBuilder item,
                MethodInfo setMethod, LocalBuilder colIndex)
            {
                var local = il.DeclareLocal(typeof(DateTime?));
                Label dtNull = il.DefineLabel();
                Label dtCommon = il.DefineLabel();
                il.Emit(OpCodes.Ldloca, local);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndex);
                il.Emit(OpCodes.Callvirt, DataRecord_IsDBNull);
                il.Emit(OpCodes.Brtrue_S, dtNull);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndex);
                il.Emit(OpCodes.Callvirt, DataRecord_GetDateTime);
                il.Emit(OpCodes.Call, typeof(DateTime?).GetConstructor(new Type[] { typeof(DateTime) }));
                il.Emit(OpCodes.Br_S, dtCommon);
                il.MarkLabel(dtNull);
                il.Emit(OpCodes.Initobj, typeof(DateTime?));
                il.MarkLabel(dtCommon);
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ldloc, local);
                il.Emit(OpCodes.Callvirt, setMethod);
            }

            private static void ReadObject(ILGenerator il, LocalBuilder item,
                List<DbColumnInfo> columnInfoes, LocalBuilder[] colIndices, int i)
            {
                Label common = il.DefineLabel();
                il.Emit(OpCodes.Ldloc_S, item);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldloc_S, colIndices[i]);
                il.Emit(OpCodes.Callvirt, DataRecord_ItemGetter_Int);
                il.Emit(OpCodes.Dup);
                il.Emit(OpCodes.Call, Convert_IsDBNull);
                il.Emit(OpCodes.Brfalse_S, common);
                il.Emit(OpCodes.Pop);
                il.Emit(OpCodes.Ldnull);
                il.MarkLabel(common);
                il.Emit(OpCodes.Unbox_Any, columnInfoes[i].Type);
                il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
            }

            #endregion

            #region Internal Methods

            internal static IEnumerable<T> SelectDelay(IDataReader reader)
            {
                while (reader.Read())
                    yield return DataLoader(reader);
            }

            internal static List<T> Select(IDataReader reader)
            {
                return BatchDataLoader(reader);
            }

            #endregion

        }

        #endregion

    }

}



using System;


namespace DataAccessors
{
    /// <summary>
    /// 标示该属性是（或不是）数据列
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, Inherited = true, AllowMultiple = false)]
    public sealed class DbColumnAttribute : Attribute
    {


        /// <summary>
        /// 列名（缺省时使用属性名）
        /// </summary>
        public string ColumnName { get; set; }


        /// <summary>
        /// 是否强制忽略该属性
        /// </summary>
        public bool Ignore { get; set; }


        /// <summary>
        /// 可选数据列（Reader中不存在该列时，保持默认值）
        /// </summary>
        public bool IsOptional { get; set; }


    }


    /// <summary>
    /// 标示该类为数据库的结果集实体
    /// </summary>
    [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
    public sealed class DbResultAttribute : Attribute
    {


        /// <summary>
        /// 默认所有属性是数据列
        /// </summary>
        public DbResultAttribute()
            : this(true) { }


        /// <summary>
        /// 默认所有属性是（或不是）数据列
        /// </summary>
        /// <param name="defaultAsDbColumn">默认是数据列</param>
        public DbResultAttribute(bool defaultAsDbColumn)
        {
            DefaultAsDbColumn = defaultAsDbColumn;
        }


        /// <summary>
        /// 默认是数据列
        /// </summary>
        public bool DefaultAsDbColumn { get; private set; }


    }


}

mangkata
关注
专栏目录
IDataReader/DataTable扩展ToList 改进版，反射速度慢的惊人！
熊哥
02-20 1314
<br />IDataReader扩展ToList<T> 改进版<br />        //最快和直接循环差不多<br />        public static List<TResult> ToList<TResult>(this IDataReader dr, bool isClose) where TResult : class, new() {<br />            IDataReaderEntityBuilder<TResult> eblist = IDataReaderEnt
将Sql查询语句获取的数据插入到List列表里面
dengtangda9444的博客
08-15 1919
　　Sql查询语句获取的数据是分格式的，我们还用SqlDataReader来做，然后用IDataReader来接收读取，以下是代码： //我想查询一个用户表的信息，该用户有姓名，密码，信息三列 //1.定义一个用户类型的List数组，userInfo类的代码在下方 List<userInfo> userInfo = new List<userIn...
IDataReader转成List＜T＞
qq_41616234的博客
09-06 246
IDataReader 转成泛型List
C#.NET IDataReader扩展 ToList<T>/Get<T>
weixin_30668887的博客
08-16 191
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Reflection;using System.Data;using System.Data.Common;using System.Web.Script.Serialization;using Sy...
IDataReader 转换成DataTable
月骜
10-12 3258
private DataTable GetDataTableFromIDataReader (IDataReader reader)   {  DataTable dt = new DataTable();  bool init = false;  dt.BeginLoadData();  object[] vals = new object[0];  while (reader.Read())
List<T> To IDatareader For SqlBulkCopy
weixin_30636089的博客
06-13 119
原文地址：http://www.csvreader.com/csv_downloads.php或 　　　　　http://technico.qnownow.com/custom-data-reader-to-bulk-copy-data-from-object-collection-to-sql-server/ 使用场景： 　　项目中通过业务逻辑生产了多个大List<T&...
IDataReader/DataTable扩展ToList<T> 改进版，反射速度慢的惊人！
weixin_30613727的博客
09-01 123
完整源代码购买：http://livexy.taobao.com/ IDataReader扩展ToList<T> 改进版 //最快和直接循环差不多publicstaticList<TResult>ToList<TResult>(thisIDataReaderdr,boolisClose)whereTRes...
IDataReader
07-28
IDataReader是一个接口，用于提供对数据源的只读、前向、流式访问。它可以用于读取不同类型的数据库，而无需修改代码。使用IDataReader可以减少程序对特定类型数据库的依赖，提高程序的灵活性。...[ .reference_list ]
idatareader是什么
最新发布
07-28
IDataReader是一个接口，用于从数据库中检索只读、只进的数据流。它是ADO.NET中的一部分，用于提高应用程序的性能并减少系统开销。IDataReader提供了未缓冲的数据流，使过程逻辑可以有效地按顺序...[ .reference_list ]
我写了一个sql转实体类工具
苏沐云的博客
12-27 1263
一、最终效果 二、如何实现 1.数据库表生成实体类 此功能很简单实现，得益于SqlServer提供了查询数据库表的配置信息的功能。 例： --查询有权访问的数据库 use master;select name from sysdatabases order by name asc --查询数据库下的表 use 数据库名;select name from sysobjects where xtype='U' order by name asc --查询指定表配置信息 select syscolumns
AutoMapper在.Net(asp.net MVC)项目下的应用以及IDataReader转List<T>说明
Small_nie
03-26 1180
AutoMapper在.Net(asp.net MVC)项目下如何配置和应用的呢？我们首先说配置初始化 AutoMapper在.Net(asp.net MVC)项目下的应用 首先在应用启动时要注册映射的文件，直接在Global.asax中的Application_Start类中注册即可 这里我们将注册的具体方法写在了 AutoMapperUtil.RegisterAutoMapper工具类中： ...
c# IDataReader DataTable 转实体类（泛型）
qq_18932003的博客
09-28 888
namespaceComm { publicstaticclassDataConvert { /// <summary> /// 把DataRow对象转成实体类。 /// </summary> /// <typeparam name="T"></typeparam> /// <pa...
c# DataTable 转 List的两种方法
chenweilong213的博客
04-10 5072
c# DataTable 转 List的两种方法 1. 直接写一个datatable转list的类 2. 利用泛型来写，更加通用 public List<Dictionary<string, object>> DatatoTable(DataTable dt) { List<Dictionary<string, object>> list = new List<Dictionary<string, object&gt...
DataReader转到DataSet
weixin_30856965的博客
10-03 185
(1) DataReader转为DataSet的类: private DataSet DataReaderToDataSet(IDataReader reader) { DataTable table = new DataTable(); int fieldCount = reader.FieldCount; ...
DataSet与DataReader的区别
weixin_30613343的博客
04-28 107
ADO.NET提供以下两个对象，用于检索关系数据并将其存储在内存中：DataSet和DataReader。DataSet提供一个内存中数据的关系表示形式，一整套包括一些表在内的数据（这些表包含数据、对数据进行排序并约束数据），以及表之间的关系。DataReader提供一个来自数据库的快速、仅向前、只读数据流。当使用DataSet时，经常会利用DataAdapter（也可能是CommandBuild...
SQLDataReaderToList 数据读取器转换到List
firethisway的博客
01-17 3683
现在开发项目都用到3层架构，bll dal model 大量使用list来返回列表数据， 每次都需要手动写一堆代码把每行数据写到List中。public class UserInfo { public string Age { get; set; } public string Sex { get; set;
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值