我正在使用返回数据阅读器的第三方库。我想要一种简单且尽可能通用的方法将其转换为对象列表。
例如，假设我有一个具有 2 个属性 EmployeeId 和 Name 的类“Employee”，我希望将数据读取器（包含员工列表）转换为 List
我想我别无选择，只能遍历数据读取器的行并将它们中的每一个转换为我将添加到列表中的 Employee 对象。有更好的解决方案吗？我正在使用 C# 3.5，理想情况下我希望它尽可能通用，以便它适用于任何类（DataReader 中的字段名称与各种对象的属性名称匹配）。
【问题讨论】：
标签： c# list datareader
请检查这个答案
使用反射 + lambda 表达式进行简单、快速的 IDataReader 到 IEnumerable<T> 转换
【讨论】：
我的版本
用法：
var Q = await Reader.GetTable<DbRoom>("SELECT id, name FROM rooms");
PgRoom 是
public class DbRoom
{
[Column("id")]
public int Id { get; set; }
[Column("name")]
public string Name { get; set; }
}
Reader.GetTable 包含：
using (var R = await Q.ExecuteReaderAsync())
{
List<T> Result = new List<T>();
Dictionary<int, PropertyInfo> Props = new Dictionary<int, PropertyInfo>();
foreach (var p in typeof(T).GetProperties())
{
for (int i = 0; i < R.FieldCount; i++)
{
if (p.GetCustomAttributes<ColumnAttribute>().FirstOrDefault(t => t.Name == R.GetName(i)) != null
&& p.PropertyType == R.GetFieldType(i))
{
Props.Add(i, p);
}
}
}
while (await R.ReadAsync())
{
T row = new T();
foreach (var kvp in Props)
{
kvp.Value.SetValue(row, R[kvp.Key]);
}
Result.Add(row);
}
return Result;
}
【讨论】：
我找到了这个解决方案。
var cmd = ctx.Connection.CreateCommand();
T result = DbDataReaderdHelper.Fill<T>(cmd)
public static class DbDataReaderdHelper
{
public static List<T> Fill<T>(DbCommand dbCommand) where T : new()
{
List<T> result = new List<T>();
var reader = dbCommand.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
Type type = typeof(T);
T obj = (T)Activator.CreateInstance(type);
PropertyInfo[] properties = type.GetProperties();
foreach (PropertyInfo property in properties)
{
var value = reader[property.Name];
try
{
if (value != null)
{
var convertedValue = TypeDescriptor.GetConverter(property.PropertyType).ConvertFromInvariantString(value.ToString());
property.SetValue(obj, convertedValue);
}
}
catch {}
}
result.Add(obj);
}
}
reader.Close();
return result;
}
}
【讨论】：
像魔法一样
我个人讨厌在构造函数中进行手动映射，我也不喜欢自己进行反思。所以这里有另一个解决方案，由美妙的（而且相当普遍的）Newtonsoft JSON 库提供。
仅当您的属性名称与 datareader 列名称完全匹配时它才会起作用，但它对我们来说效果很好。
...假设您有一个数据读取器名称“yourDataReader”...
var dt = new DataTable();
dt.Load(yourDataReader);
// creates a json array of objects
string json = Newtonsoft.Json.JsonConvert.SerializeObject(dt);
// this is what you're looking for right??
List<YourEntityType> list =
Newtonsoft.Json.JsonConvert
.DeserializeObject<List<YourEntityType>>(json);
【讨论】：
对于 .NET Core 2.0：
这是一个与 .NET CORE 2.0 一起使用的扩展方法，用于执行 RAW SQL 并将结果映射到任意类型的 LIST：
用法：
var theViewModel = new List();
string theQuery = @"SELECT * FROM dbo.Something";
theViewModel = DataSQLHelper.ExecSQL(theQuery,_context);
using Microsoft.EntityFrameworkCore;
using System.Data;
using System.Data.SqlClient;
using System.Reflection;
public static List ExecSQL(string query, myDBcontext context)
{
using (context)
{
using (var command = context.Database.GetDbConnection().CreateCommand())
{
command.CommandText = query;
command.CommandType = CommandType.Text;
context.Database.OpenConnection();
using (var result = command.ExecuteReader())
{
List<T> list = new List<T>();
T obj = default(T);
while (result.Read())
{
obj = Activator.CreateInstance<T>();
foreach (PropertyInfo prop in obj.GetType().GetProperties())
{
if (!object.Equals(result[prop.Name], DBNull.Value))
{
prop.SetValue(obj, result[prop.Name], null);
}
}
list.Add(obj);
}
return list;
}
}
}
}
【讨论】：
最简单的解决方案：
var dt=new DataTable();
dt.Load(myDataReader);
list<DataRow> dr=dt.AsEnumerable().ToList();
然后选择它们以便将它们映射到任何类型。
【讨论】：
注意：这是 .NET Core 代码
如果您不介意外部依赖项（惊人的Fast Member nuget 包），这是一个愚蠢的性能选项：
public static T ConvertToObject<T>(this SqlDataReader rd) where T : class, new()
{
Type type = typeof(T);
var accessor = TypeAccessor.Create(type);
var members = accessor.GetMembers();
var t = new T();
for (int i = 0; i < rd.FieldCount; i++)
{
if (!rd.IsDBNull(i))
{
string fieldName = rd.GetName(i);
if (members.Any(m => string.Equals(m.Name, fieldName, StringComparison.OrdinalIgnoreCase)))
{
accessor[t, fieldName] = rd.GetValue(i);
}
}
}
return t;
}
使用方法：
public IEnumerable<T> GetResults<T>(SqlDataReader dr) where T : class, new()
{
while (dr.Read())
{
yield return dr.ConvertToObject<T>());
}
}
【讨论】：
我们已经实施了以下解决方案，感觉效果很好。它非常简单，并且需要比映射器做的更多的接线。但是，有时手动控制也不错，老实说，您只需连接一次就完成了。
简而言之：我们的域模型实现了一个接口，该接口具有一个方法，该方法接受IDataReader 并从中填充模型属性。然后我们使用泛型和反射来创建模型的实例并在其上调用Parse 方法。
我们考虑使用构造函数并将IDataReader 传递给它，但我们所做的基本 性能检查似乎表明接口始终更快（如果只是一点点）。此外，接口路由通过编译错误提供即时反馈。
我喜欢的一件事是，您可以将private set 用于下面示例中的Age 等属性，并直接从数据库中设置它们。
public interface IDataReaderParser
{
void Parse(IDataReader reader);
}
public class Foo : IDataReaderParser
{
public string Name { get; set; }
public int Age { get; private set; }
public void Parse(IDataReader reader)
{
Name = reader["Name"] as string;
Age = Convert.ToInt32(reader["Age"]);
}
}
public class DataLoader
{
public static IEnumerable<TEntity> GetRecords<TEntity>(string connectionStringName, string storedProcedureName, IEnumerable<SqlParameter> parameters = null)
where TEntity : IDataReaderParser, new()
{
using (var sqlCommand = new SqlCommand(storedProcedureName, Connections.GetSqlConnection(connectionStringName)))
{
using (sqlCommand.Connection)
{
sqlCommand.CommandType = CommandType.StoredProcedure;
AssignParameters(parameters, sqlCommand);
sqlCommand.Connection.Open();
using (var sqlDataReader = sqlCommand.ExecuteReader())
{
while (sqlDataReader.Read())
{
//Create an instance and parse the reader to set the properties
var entity = new TEntity();
entity.Parse(sqlDataReader);
yield return entity;
}
}
}
}
}
}
要调用它，您只需提供类型参数
IEnumerable<Foo> foos = DataLoader.GetRecords<Foo>(/* params */)
【讨论】：
new() 作为通用约束。感谢您也善意地表达它，没有反对和反对的投票！
你真的需要一个列表，还是 IEnumerable 足够好？
我知道您希望它是通用的，但更常见的模式是在接受数据行（或 IDataRecord）的目标对象类型上有一个静态工厂方法。看起来像这样：
public class Employee
{
public int Id { get; set; }
public string Name { get; set; }
public static Employee Create(IDataRecord record)
{
return new Employee
{
Id = record["id"],
Name = record["name"]
};
}
}
.
public IEnumerable<Employee> GetEmployees()
{
using (var reader = YourLibraryFunction())
{
while (reader.Read())
{
yield return Employee.Create(reader);
}
}
}
如果你真的需要一个列表而不是 IEnumerable，你可以在结果上调用.ToList()。我想您也可以使用泛型 + 委托来使此模式的代码也更可重用。
更新：我今天又看到了，想写通用代码：
public IEnumerable<T> GetData<T>(IDataReader reader, Func<IDataRecord, T> BuildObject)
{
try
{
while (reader.Read())
{
yield return BuildObject(reader);
}
}
finally
{
reader.Dispose();
}
}
//call it like this:
var result = GetData(YourLibraryFunction(), Employee.Create);
【讨论】：
IEnumerable，然后可能会调用ToList，我肯定有同样的看法。
虽然我不建议将此用于生产代码，但您可以使用反射和泛型自动执行此操作：
public static class DataRecordHelper
{
public static void CreateRecord<T>(IDataRecord record, T myClass)
{
PropertyInfo[] propertyInfos = typeof(T).GetProperties();
for (int i = 0; i < record.FieldCount; i++)
{
foreach (PropertyInfo propertyInfo in propertyInfos)
{
if (propertyInfo.Name == record.GetName(i))
{
propertyInfo.SetValue(myClass, Convert.ChangeType(record.GetValue(i), record.GetFieldType(i)), null);
break;
}
}
}
}
}
public class Employee
{
public int Id { get; set; }
public string LastName { get; set; }
public DateTime? BirthDate { get; set; }
public static IDataReader GetEmployeesReader()
{
SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["NorthwindConnectionString"].ConnectionString);
conn.Open();
using (SqlCommand cmd = new SqlCommand("SELECT EmployeeID As Id, LastName, BirthDate FROM Employees"))
{
cmd.Connection = conn;
return cmd.ExecuteReader(CommandBehavior.CloseConnection);
}
}
public static IEnumerable GetEmployees()
{
IDataReader rdr = GetEmployeesReader();
while (rdr.Read())
{
Employee emp = new Employee();
DataRecordHelper.CreateRecord<Employee>(rdr, emp);
yield return emp;
}
}
}
然后您可以使用CreateRecord<T>() 从数据读取器的字段中实例化任何类。
<asp:GridView ID="GvEmps" runat="server" AutoGenerateColumns="true"></asp:GridView>
GvEmps.DataSource = Employee.GetEmployees();
GvEmps.DataBind();
【讨论】：
您可以构建一个扩展方法，例如：
public static List<T> ReadList<T>(this IDataReader reader,
Func<IDataRecord, T> generator) {
var list = new List<T>();
while (reader.Read())
list.Add(generator(reader));
return list;
}
并像这样使用它：
var employeeList = reader.ReadList(x => new Employee {
Name = x.GetString(0),
Age = x.GetInt32(1)
});
乔尔的建议很好。您可以选择返回IEnumerable<T>。上面的代码很容易转换：
public static IEnumerable<T> GetEnumerator<T>(this IDataReader reader,
Func<IDataRecord, T> generator) {
while (reader.Read())
yield return generator(reader);
}
如果要自动将列映射到属性，代码思路是一样的。您可以将上述代码中的generator 函数替换为一个函数，该函数询问typeof(T) 并通过读取匹配的列使用反射设置对象的属性。但是，我个人更喜欢定义一个工厂方法（就像 Joel 的回答中提到的那样）并将它的委托传递给这个函数：
var list = dataReader.GetEnumerator(Employee.Create).ToList();
【讨论】：