Question

此问题的扩展passing static reflection information to static generic methods

我试图创建一个通用类型阅读器，因为我使用Classes进行大量数据访问，并且我正在尝试创建一个相当通用的方法，允许在没有太多代码的情况下读取数据。

执行大部分阅读的代码部分如下所示

 public static T Read<T>(string field,IDataRecord data )
    {
        Type type1 = typeof (T);
        try
        {
            if (type1 == typeof( String ))
            {
                return (T)Convert.ChangeType( readString( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( int? ))
            {
                return (T)Convert.ChangeType( readIntN( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( Guid? ))
            {
                return (T)Convert.ChangeType( readGuidN( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( double? ))
            {
                return (T)Convert.ChangeType( readDoubleN( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( decimal? ))
            {
                var res = readDecimalN(data[field].ToString());
                return (T)Convert.ChangeType( res, typeof( T ) );
            }
            if (type1 == typeof( float? ))
            {
                return (T)Convert.ChangeType( readFloatN( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( bool? ))
            {
                return (T)Convert.ChangeType( readBoolN( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( DateTime? ))
            {
                return (T)Convert.ChangeType( readDatetimeN( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( int ))
            {
                return (T)Convert.ChangeType( readInt( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( long? ))
            {
                return (T)Convert.ChangeType( readLongN( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( long ))
            {
                return (T)Convert.ChangeType( readLong( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( Guid ))
            {
                return (T)Convert.ChangeType(readGuid( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( double ))
            {
                return (T)Convert.ChangeType( readDouble( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( decimal ))
            {
                return (T)Convert.ChangeType( readDecimal( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( float ) || type1 == typeof( Single ))
            {
                return (T)Convert.ChangeType( readFloat( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( bool ))
            {
                return (T)Convert.ChangeType( readBool( data[field].ToString() ), typeof( T ) );
            }
            if (type1 == typeof( DateTime ))
            {
                return (T)Convert.ChangeType( readDatetime( data[field].ToString() ), typeof( T ) );
            }
        }
        catch (Exception)
        {
            throw;
        }
        throw new Exception(String.Format("Data Type Not Supported: {0}", type1));
    }

但是这会抛出无效的强制转换异常。

readXXX方法工作正常，每个返回语句都出现问题

我也尝试过使用

public static T SafeConvert<T>(string s, T defaultValue)
{
if ( string.IsNullOrEmpty(s) )
    return defaultValue;
return (T)Convert.ChangeType(s, typeof(T));
}

但它仍然失败

编辑：

通过

调用该方法

private static List<T> GetItems<T>(IDataReader reader)
    {
        var items = new List<T>();
        while (reader.Read())
        {
            Type type1 = typeof (T);
            var item = (T) Activator.CreateInstance(typeof (T), new object[] {});
            foreach (PropertyInfo info in type1.GetProperties())
            {
                int written = 0;
                if (info.CanWrite)
                {
                    #region

                    try
                    {
                        Type dataType = info.PropertyType;
                        MethodInfo method = typeof (DataReader).GetMethod("Read",BindingFlags.Static | BindingFlags.Public);
                        MethodInfo generic = method.MakeGenericMethod(dataType);
                        var t = generic.Invoke(null, new object[] {info.Name, reader});
                        info.SetValue( item, t );

更多...

人们似乎在问我使用它是什么，最终它允许我在一行中创建一个可通过传递文件Location或sql查询从任何来源读取的可通过CSV或SQL读取的数据。

//returns Ienumerable<MyClass>
var list = Reader.ReadSql<MyClass>(DataBases.Test,"select * from TestTable where someAttribute  = 1");
// also returns Ienumerable MyClass
var list2 = Readre.ReadCsv<MyClass>(@"c:\file1.csv",",");

我现在正在运行，但它需要在每个实现中重复if dataType == typeof（string）的长列表，我希望将其重构为单个泛型Read方法，但是我遇到转换问题

Answer 1

您更新的问题说它有效，但您想要重构。好吧，你可以！

Dictionary<Type, Func<string, IDataRecord, object>> converters_ = new Dictionary<Type, Func<string, IDataRecord, object>>();

converters_[typeof(bool)] = (s) => { return readBoolN( data[s].ToString() ); };
// repeat for other types:

Then

 public static T Read<T>(string field,IDataRecord data )
 {
     return (T)converters_[typeof(T)](field, data);
 }

Answer 2

您在没有GetMethod的情况下调用了Binder，您如何获得预期的仿制药？
Read<T>将在没有用于推断类型的参数的情况下被调用，您是否期望每次使用类型参数调用它时？
如果2符合您的预期，那么与调用GetXXX方法有什么不同？

我无法遵循您的原始设计，但请考虑以下代码：

public static partial class DataReaderExtensions {
    /// <summary>
    /// <para>Copy data to target object</para>
    /// <para>Class which implements IDataRecord usually also implements IDataReader</para>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="data"></param>
    /// <param name="target"></param>
    /// <returns>the count of field or property copied</returns>
    public static int CopyTo<T>(this IDataRecord data, T target) {
        return (
            from column in
                Enumerable.Range(0, data.FieldCount).Select(
                    (x, i) => new {
                        DataType=data.GetFieldType(i),
                        ColumnName=data.GetName(i)
                    }
                    )
            let type=target.GetType()
            from member in type.GetMembers()
            let typeMember=
                member is PropertyInfo
                    ?(member as PropertyInfo).PropertyType
                    :member is FieldInfo
                        ?(member as FieldInfo).FieldType
                        :default(MemberInfo)
            where typeMember==column.DataType
            let name=member.Name
            where name==column.ColumnName
            let invokeAttr=
                BindingFlags.SetProperty|BindingFlags.SetField|
                BindingFlags.NonPublic|BindingFlags.Public|
                BindingFlags.Instance
            select type.InvokeMember(name, invokeAttr, default(Binder), target, new[] { data[name] })
            ).Count();
    }
}

您可以将data直接复制到自定义类型的实例，例如：

reader.CopyTo(myObject);

无论公开/非公开，它都会自动将列名与字段/属性进行映射;最后返回复制元素的数量。

尝试使用反射创建通用Type Reader

2 个答案: