如何在 SqlDataReader 中使用泛型

Question

我正在尝试想出一种方法，只需将表从 SQL Server 加载到类中，而无需告诉它任何内容。基本上，只需创建类并让它知道要加载什么，基于此。这是我到目前为止所拥有的。

我的问题是，有没有什么方法可以避免硬编码类型，调用 reader.readString，reader。基于 FieldType 的 readInt32 等？

 private Int32? readInt32(SqlDataReader reader, string columnName)
    {
        Int32? result = null;


        if (!reader.IsDBNull(reader.GetOrdinal(columnName)))
        {
            result = reader.GetInt32(reader.GetOrdinal(columnName));
        };

        return result;
    }

  public List<T> readTable(string table, string wherecls, string connStr)
    {
        List<T> result = new List<T>();
        using (SqlConnection connection = new SqlConnection(connStr))
        {
            using (SqlCommand command = connection.CreateCommand())
            {
                command.CommandText = "select * from " + table;
                if (wherecls.Length > 0) command.CommandText += " where " + wherecls;
                connection.Open();
                using (var reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        Object i = Activator.CreateInstance(typeof(T));

                        System.Reflection.FieldInfo[] fieldInfoList = typeof(T).GetFields();
                        foreach (System.Reflection.FieldInfo f in fieldInfoList)
                        {
                            if (f.FieldType == typeof(string)) f.SetValue(i, readString(reader, f.Name));
                            if (f.FieldType == typeof(Int32)) f.SetValue(i, readInt32(reader, f.Name));
                            if (f.FieldType == typeof(Int16)) f.SetValue(i, readInt16(reader, f.Name));
                            if (f.FieldType == typeof(byte)) f.SetValue(i, readByte(reader, f.Name));
                            if (f.FieldType == typeof(short)) f.SetValue(i, readShort(reader, f.Name));
                        }
                        result.Add((T)i);
                    }
                }
            }
        }
        return result;
    }

谢谢， 丹·蔡斯

Answer 1

你所描述的是很多工作......并且正是像“dapper”这样的工具已经做的。所以我的建议是：use dapper:

// Dapper adds a Query<T>(this DbConnection, ...) extension method
var data = connection.Query<T>(sql, args).AsList();

我会，但是，说

string wherecls

让我脊背发凉-这听起来像是SQL注入的噩梦。但是......这取决于你。

Answer 2

试试这个。

确保该类型有一个公共默认构造函数——一个不带参数的构造函数——并且 SQL 字符串中的列名与该类型的公共属性的名称完全匹配。

namespace MyNamespace {
    using System;
    using System.Collections.Generic;
    using System.Data.SqlClient;
    using System.Reflection;

    public static class MyExtensions {

        public static IEnumerable<T> Query<T>(this SqlConnection cn, string sql) {
            Type TypeT = typeof(T);
            ConstructorInfo ctor = TypeT.GetConstructor(Type.EmptyTypes);
            if (ctor == null) {
                throw new InvalidOperationException($"Type {TypeT.Name} does not have a default constructor.");
            }
            using (SqlCommand cmd = new SqlCommand(sql, cn)) {
                using (SqlDataReader reader = cmd.ExecuteReader()) {
                    while (reader.Read()) {
                        T newInst = (T)ctor.Invoke(null);
                        for (int i = 0; i < reader.FieldCount; i++) {
                            string propName = reader.GetName(i);
                            PropertyInfo propInfo = TypeT.GetProperty(propName);
                            if (propInfo != null) {
                                object value = reader.GetValue(i);
                                if (value == DBNull.Value) {
                                    propInfo.SetValue(newInst, null);
                                } else {
                                    propInfo.SetValue(newInst, value);
                                }
                            }
                        }
                        yield return newInst;
                    }
                }
            }
        }
    }
}

Answer 3

也许我的解决方案更好一点。我使用扩展来填充类型 T，并按我喜欢的顺序处理空值和填充属性。

例子：

public async Task<ObservableCollection<T>> Search_data<T>()
    {
        var data = new ObservableCollection<T>();

        try
        {
            using (OracleConnection con = new OracleConnection(connn_string))
            {
                con.Open();

                OracleCommand cmd = new OracleCommand("MySchema.SomeTable", con)
                {
                    CommandType = CommandType.StoredProcedure
                };
              
                cmd.Parameters.Add("result", OracleDbType.RefCursor, ParameterDirection.Output);
                
                using (OracleDataReader rdr = cmd.ExecuteReader())
                {
                    while (await rdr.ReadAsync())
                    {
                        var item = Activator.CreateInstance<T>();

                        item.SetValue("NAME", rdr.IsDBNull(0) ? null : rdr.GetString(0));
                        item.SetValue("SURNAME", rdr.IsDBNull(1) ? null : rdr.GetString(1));
                        item.SetValue("ADDRESS", rdr.IsDBNull(2) ? null : rdr.GetString(2));
                      
                        data.Add(item);

                    };
                }
            }
            return data;
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
             
            return null;
        }
    }

分机：

public static void SetValue<T>(this T _source, string _property_name, object _value)
    {
        _source.GetType().GetProperty(_property_name).SetValue(_source, _value);
    }