如何检查SqlDataReader对象中是否存在列？在我的数据访问层中，我创建了一个为多个存储过程调用构建相同对象的方法。其中一个存储过程具有其他存储过程未使用的附加列。我想修改该方法以适应每种情况。
我的应用程序是用 C# 编写的。
Michael Kniskern
问问题
168321 次
25 回答
353
public static class DataRecordExtensions
{
public static bool HasColumn(this IDataRecord dr, string columnName)
{
for (int i=0; i < dr.FieldCount; i++)
{
if (dr.GetName(i).Equals(columnName, StringComparison.InvariantCultureIgnoreCase))
return true;
}
return false;
}
}
像在其他一些答案中一样将Exceptions 用于控制逻辑被认为是不好的做法并且具有性能成本。它还会将误报发送到#异常抛出的分析器，上帝帮助任何人设置他们的调试器来打破抛出的异常。
GetSchemaTable() 也是许多答案中的另一个建议。这不是检查字段是否存在的首选方式，因为它并非在所有版本中都实现（它是抽象的，并且在某些版本的 dotnetcore 中抛出 NotSupportedException）。GetSchemaTable 在性能方面也过于矫枉过正，因为如果您查看源代码，它是一个非常繁重的功能。
如果您经常使用循环字段，可能会对性能产生很小的影响，并且您可能需要考虑缓存结果。
于 2009-05-01T23:51:06.473 回答
67
正确的代码是：
public static bool HasColumn(DbDataReader Reader, string ColumnName) {
foreach (DataRow row in Reader.GetSchemaTable().Rows) {
if (row["ColumnName"].ToString() == ColumnName)
return true;
} //Still here? Column not found.
return false;
}
于 2009-05-01T23:33:23.523 回答
39
在一行中，在 DataReader 检索后使用它：
var fieldNames = Enumerable.Range(0, dr.FieldCount).Select(i => dr.GetName(i)).ToArray();
然后，
if (fieldNames.Contains("myField"))
{
var myFieldValue = dr["myField"];
...
编辑
不需要加载模式的更高效的单线：
var exists = Enumerable.Range(0, dr.FieldCount).Any(i => string.Equals(dr.GetName(i), fieldName, StringComparison.OrdinalIgnoreCase));
于 2013-12-09T08:06:58.740 回答
33
我认为您最好的选择是预先在 DataReader 上调用GetOrdinal("columnName")，并在该列不存在的情况下捕获 IndexOutOfRangeException 。
其实我们来做一个扩展方法：
public static bool HasColumn(this IDataRecord r, string columnName)
{
try
{
return r.GetOrdinal(columnName) >= 0;
}
catch (IndexOutOfRangeException)
{
return false;
}
}
编辑
好的，这篇文章最近开始获得一些反对票，我不能删除它，因为它是公认的答案，所以我要更新它并（我希望）尝试证明使用异常处理是合理的控制流。
正如Chad Grant所发布的，实现此目的的另一种方法是遍历 DataReader 中的每个字段，并对您要查找的字段名称进行不区分大小写的比较。这将非常有效，并且说实话可能会比我上面的方法更好。当然，我永远不会在性能成为问题的循环中使用上述方法。
我可以想到一种情况，其中 try/GetOrdinal/catch 方法将在循环不起作用的情况下起作用。然而，现在这是一个完全假设的情况，所以这是一个非常站不住脚的理由。无论如何，请耐心等待，看看您的想法。
想象一个允许您为表中的列“别名”的数据库。想象一下，我可以定义一个表，其中包含一个名为“EmployeeName”的列，但也给它一个别名“EmpName”，并且选择任一名称都会返回该列中的数据。跟我到现在？
现在想象一下，该数据库有一个 ADO.NET 提供程序，并且他们为它编写了一个 IDataReader 实现，它考虑了列别名。
现在，dr.GetName(i)（如乍得的回答中所使用的）只能返回一个字符串，因此它必须只返回一个列上的“别名”。但是，GetOrdinal("EmpName")可以使用此提供程序字段的内部实现来检查每个列的别名以查找您要查找的名称。
在这种假设的“列别名”情况下，try/GetOrdinal/catch 方法将是确保您检查结果集中列名称的每个变体的唯一方法。
脆弱？当然。但值得深思。老实说，我更喜欢 IDataRecord 上的“官方” HasColumn 方法。
于 2008-12-17T00:12:19.740 回答
18
这是 Jasmin 想法的工作示例：
var cols = r.GetSchemaTable().Rows.Cast<DataRow>().Select
(row => row["ColumnName"] as string).ToList();
if (cols.Contains("the column name"))
{
}
于 2012-03-06T19:28:09.670 回答
13
以下内容很简单，对我有用：
bool hasMyColumn = (reader.GetSchemaTable().Select("ColumnName = 'MyColumnName'").Count() == 1);
于 2015-06-24T22:32:54.023 回答
13
这对我有用：
bool hasColumnName = reader.GetSchemaTable().AsEnumerable().Any(c => c["ColumnName"] == "YOUR_COLUMN_NAME");
于 2015-09-03T20:21:44.563 回答
9
我为 Visual Basic 用户编写了这个：
Protected Function HasColumnAndValue(ByRef reader As IDataReader, ByVal columnName As String) As Boolean
For i As Integer = 0 To reader.FieldCount - 1
If reader.GetName(i).Equals(columnName) Then
Return Not IsDBNull(reader(columnName))
End If
Next
Return False
End Function
我认为这更强大，用法是：
If HasColumnAndValue(reader, "ID_USER") Then
Me.UserID = reader.GetDecimal(reader.GetOrdinal("ID_USER")).ToString()
End If
于 2009-05-11T15:50:33.373 回答
8
如果您阅读了这个问题，迈克尔问的是 DataReader，而不是 DataRecord 人。让你的对象正确。
在 DataRecord 上使用 ar.GetSchemaTable().Columns.Contains(field)确实有效，但它会返回 BS 列（请参见下面的屏幕截图。）
要查看数据列是否存在并包含 DataReader 中的数据，请使用以下扩展：
public static class DataReaderExtensions
{
/// <summary>
/// Checks if a column's value is DBNull
/// </summary>
/// <param name="dataReader">The data reader</param>
/// <param name="columnName">The column name</param>
/// <returns>A bool indicating if the column's value is DBNull</returns>
public static bool IsDBNull(this IDataReader dataReader, string columnName)
{
return dataReader[columnName] == DBNull.Value;
}
/// <summary>
/// Checks if a column exists in a data reader
/// </summary>
/// <param name="dataReader">The data reader</param>
/// <param name="columnName">The column name</param>
/// <returns>A bool indicating the column exists</returns>
public static bool ContainsColumn(this IDataReader dataReader, string columnName)
{
/// See: http://stackoverflow.com/questions/373230/check-for-column-name-in-a-sqldatareader-object/7248381#7248381
try
{
return dataReader.GetOrdinal(columnName) >= 0;
}
catch (IndexOutOfRangeException)
{
return false;
}
}
}
用法：
public static bool CanCreate(SqlDataReader dataReader)
{
return dataReader.ContainsColumn("RoleTemplateId")
&& !dataReader.IsDBNull("RoleTemplateId");
}
调用r.GetSchemaTable().ColumnsDataReader 返回 BS 列：
于 2011-08-30T19:01:04.403 回答
5
TLDR：
关于性能和不良做法的说法有很多答案，所以我在这里澄清一下。
返回列数越多，异常路径越快，列数越少，循环路径越快，交叉点在 11 列左右。滚动到底部以查看图表和测试代码。
完整答案：
一些顶级答案的代码有效，但这里有一个潜在的争论，即基于逻辑中异常处理的接受及其相关性能的“更好”答案。
为了清除这一点，我认为没有太多关于捕获异常的指导。Microsoft 确实有一些关于抛出异常的指导。他们在那里声明：
如果可能，不要对正常的控制流使用异常。
第一个注意是“如果可能”的宽大处理。更重要的是，描述给出了这样的背景：
框架设计者应该设计 API，以便用户可以编写不抛出异常的代码
这意味着，如果您正在编写一个可能被其他人使用的 API，请让他们能够在不使用 try/catch 的情况下导航异常。例如，为您的抛出异常的 Parse 方法提供 TryParse。 尽管您不应该捕获异常，但这并没有说明任何地方。
此外，正如另一位用户指出的那样，catch 总是允许按类型过滤，并且最近允许通过when 子句进行进一步过滤。如果我们不应该使用它们，这似乎是对语言功能的浪费。
可以说，抛出异常是有一定成本的，而这个成本可能会影响重循环中的性能。但是，也可以说，在“连接的应用程序”中，异常的成本可以忽略不计。十多年前对实际成本进行了调查：C# 中的异常有多昂贵？
换句话说，数据库连接和查询的成本可能比抛出异常的成本相形见绌。
除此之外，我想确定哪种方法真正更快。正如预期的那样，没有具体的答案。
随着列数的增加，任何在列上循环的代码都会变慢。也可以说任何依赖异常的代码都会变慢，这取决于查询失败的速度。
接受Chad Grant和Matt Hamilton的答案，我运行了两种方法，最多有 20 列和高达 50% 的错误率（OP 表示他在不同的存储过程之间使用这两个测试，所以我假设只有两个）。
以下是使用LINQPad绘制的结果：
这里的之字形是每列计数中的故障率（未找到列）。
在较窄的结果集上，循环是一个不错的选择。但是，GetOrdinal/Exception 方法对列数几乎没有那么敏感，并且在 11 列左右开始优于循环方法。
也就是说，我对性能并没有真正的偏好，因为 11 列听起来很合理，因为在整个应用程序中返回的平均列数是合理的。在这两种情况下，我们在这里讨论的都是几分之一毫秒。
但是，从代码简单性和别名支持的角度来看，我可能会选择 GetOrdinal 路线。
这是 LINQPad 形式的测试。随意用自己的方法转发：
void Main()
{
var loopResults = new List<Results>();
var exceptionResults = new List<Results>();
var totalRuns = 10000;
for (var colCount = 1; colCount < 20; colCount++)
{
using (var conn = new SqlConnection(@"Data Source=(localdb)\MSSQLLocalDb;Initial Catalog=master;Integrated Security=True;"))
{
conn.Open();
//create a dummy table where we can control the total columns
var columns = String.Join(",",
(new int[colCount]).Select((item, i) => $"'{i}' as col{i}")
);
var sql = $"select {columns} into #dummyTable";
var cmd = new SqlCommand(sql,conn);
cmd.ExecuteNonQuery();
var cmd2 = new SqlCommand("select * from #dummyTable", conn);
var reader = cmd2.ExecuteReader();
reader.Read();
Func<Func<IDataRecord, String, Boolean>, List<Results>> test = funcToTest =>
{
var results = new List<Results>();
Random r = new Random();
for (var faultRate = 0.1; faultRate <= 0.5; faultRate += 0.1)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var faultCount=0;
for (var testRun = 0; testRun < totalRuns; testRun++)
{
if (r.NextDouble() <= faultRate)
{
faultCount++;
if(funcToTest(reader, "colDNE"))
throw new ApplicationException("Should have thrown false");
}
else
{
for (var col = 0; col < colCount; col++)
{
if(!funcToTest(reader, $"col{col}"))
throw new ApplicationException("Should have thrown true");
}
}
}
stopwatch.Stop();
results.Add(new UserQuery.Results{
ColumnCount = colCount,
TargetNotFoundRate = faultRate,
NotFoundRate = faultCount * 1.0f / totalRuns,
TotalTime=stopwatch.Elapsed
});
}
return results;
};
loopResults.AddRange(test(HasColumnLoop));
exceptionResults.AddRange(test(HasColumnException));
}
}
"Loop".Dump();
loopResults.Dump();
"Exception".Dump();
exceptionResults.Dump();
var combinedResults = loopResults.Join(exceptionResults,l => l.ResultKey, e=> e.ResultKey, (l, e) => new{ResultKey = l.ResultKey, LoopResult=l.TotalTime, ExceptionResult=e.TotalTime});
combinedResults.Dump();
combinedResults
.Chart(r => r.ResultKey, r => r.LoopResult.Milliseconds * 1.0 / totalRuns, LINQPad.Util.SeriesType.Line)
.AddYSeries(r => r.ExceptionResult.Milliseconds * 1.0 / totalRuns, LINQPad.Util.SeriesType.Line)
.Dump();
}
public static bool HasColumnLoop(IDataRecord dr, string columnName)
{
for (int i = 0; i < dr.FieldCount; i++)
{
if (dr.GetName(i).Equals(columnName, StringComparison.InvariantCultureIgnoreCase))
return true;
}
return false;
}
public static bool HasColumnException(IDataRecord r, string columnName)
{
try
{
return r.GetOrdinal(columnName) >= 0;
}
catch (IndexOutOfRangeException)
{
return false;
}
}
public class Results
{
public double NotFoundRate { get; set; }
public double TargetNotFoundRate { get; set; }
public int ColumnCount { get; set; }
public double ResultKey {get => ColumnCount + TargetNotFoundRate;}
public TimeSpan TotalTime { get; set; }
}
于 2019-09-18T21:43:47.287 回答
4
这是已接受答案的单行 LINQ 版本：
Enumerable.Range(0, reader.FieldCount).Any(i => reader.GetName(i) == "COLUMN_NAME_GOES_HERE")
于 2014-03-13T00:58:50.083 回答
4
这是 Jasmine 在一行中的解决方案......（还有一个，虽然很简单！）：
reader.GetSchemaTable().Select("ColumnName='MyCol'").Length > 0;
于 2014-04-24T11:33:23.167 回答
3
Hashtable ht = new Hashtable();
Hashtable CreateColumnHash(SqlDataReader dr)
{
ht = new Hashtable();
for (int i = 0; i < dr.FieldCount; i++)
{
ht.Add(dr.GetName(i), dr.GetName(i));
}
return ht;
}
bool ValidateColumn(string ColumnName)
{
return ht.Contains(ColumnName);
}
于 2012-05-09T09:28:21.210 回答
2
为了使您的代码保持健壮和干净，请使用单个扩展函数，如下所示：
Public Module Extensions
<Extension()>
Public Function HasColumn(r As SqlDataReader, columnName As String) As Boolean
Return If(String.IsNullOrEmpty(columnName) OrElse r.FieldCount = 0, False, Enumerable.Range(0, r.FieldCount).Select(Function(i) r.GetName(i)).Contains(columnName, StringComparer.OrdinalIgnoreCase))
End Function
End Module
于 2013-12-17T12:52:26.507 回答
1
此代码纠正了 Levitikon 的代码问题：（改编自：[1]：http: //msdn.microsoft.com/en-us/library/system.data.datatablereader.getschematable.aspx）
public List<string> GetColumnNames(SqlDataReader r)
{
List<string> ColumnNames = new List<string>();
DataTable schemaTable = r.GetSchemaTable();
DataRow row = schemaTable.Rows[0];
foreach (DataColumn col in schemaTable.Columns)
{
if (col.ColumnName == "ColumnName")
{
ColumnNames.Add(row[col.Ordinal].ToString());
break;
}
}
return ColumnNames;
}
从表中获取所有这些无用的列名而不是列名的原因......是因为您正在获取架构列的名称（即架构表的列名）
注意：这似乎只返回第一列的名称......
编辑：更正了返回所有列名称的代码，但您不能使用 SqlDataReader 来执行此操作
public List<string> ExecuteColumnNamesReader(string command, List<SqlParameter> Params)
{
List<string> ColumnNames = new List<string>();
SqlDataAdapter da = new SqlDataAdapter();
string connection = ""; // your sql connection string
SqlCommand sqlComm = new SqlCommand(command, connection);
foreach (SqlParameter p in Params) { sqlComm.Parameters.Add(p); }
da.SelectCommand = sqlComm;
DataTable dt = new DataTable();
da.Fill(dt);
DataRow row = dt.Rows[0];
for (int ordinal = 0; ordinal < dt.Columns.Count; ordinal++)
{
string column_name = dt.Columns[ordinal].ColumnName;
ColumnNames.Add(column_name);
}
return ColumnNames; // you can then call .Contains("name") on the returned collection
}
于 2012-04-28T04:55:14.943 回答
0
我也没有GetSchemaTable去上班，直到我找到了这条路。
基本上我这样做：
Dim myView As DataView = dr.GetSchemaTable().DefaultView
myView.RowFilter = "ColumnName = 'ColumnToBeChecked'"
If myView.Count > 0 AndAlso dr.GetOrdinal("ColumnToBeChecked") <> -1 Then
obj.ColumnToBeChecked = ColumnFromDb(dr, "ColumnToBeChecked")
End If
于 2010-04-22T07:07:53.787 回答
0
public static bool DataViewColumnExists(DataView dv, string columnName)
{
return DataTableColumnExists(dv.Table, columnName);
}
public static bool DataTableColumnExists(DataTable dt, string columnName)
{
string DebugTrace = "Utils::DataTableColumnExists(" + dt.ToString() + ")";
try
{
return dt.Columns.Contains(columnName);
}
catch (Exception ex)
{
throw new MyExceptionHandler(ex, DebugTrace);
}
}
Columns.Contains顺便说一句，不区分大小写。
于 2011-03-09T23:12:29.260 回答
0
在您的特定情况下（所有过程都有相同的列，除了一个有额外的一列），检查阅读器的FieldCount属性以区分它们会更好更快。
const int NormalColCount = .....
if(reader.FieldCount > NormalColCount)
{
// Do something special
}
您还可以（出于性能原因）将此解决方案与解决方案迭代解决方案混合。
于 2014-08-18T07:43:02.433 回答
0
我的数据访问类需要向后兼容，因此我可能会尝试访问数据库中尚不存在的版本中的列。我们返回了一些相当大的数据集，因此我不喜欢必须为每个属性迭代 DataReader 列集合的扩展方法。
我有一个实用程序类，它创建一个列的私有列表，然后有一个通用方法尝试根据列名和输出参数类型解析值。
private List<string> _lstString;
public void GetValueByParameter<T>(IDataReader dr, string parameterName, out T returnValue)
{
returnValue = default(T);
if (!_lstString.Contains(parameterName))
{
Logger.Instance.LogVerbose(this, "missing parameter: " + parameterName);
return;
}
try
{
if (dr[parameterName] != null && [parameterName] != DBNull.Value)
returnValue = (T)dr[parameterName];
}
catch (Exception ex)
{
Logger.Instance.LogException(this, ex);
}
}
/// <summary>
/// Reset the global list of columns to reflect the fields in the IDataReader
/// </summary>
/// <param name="dr">The IDataReader being acted upon</param>
/// <param name="NextResult">Advances IDataReader to next result</param>
public void ResetSchemaTable(IDataReader dr, bool nextResult)
{
if (nextResult)
dr.NextResult();
_lstString = new List<string>();
using (DataTable dataTableSchema = dr.GetSchemaTable())
{
if (dataTableSchema != null)
{
foreach (DataRow row in dataTableSchema.Rows)
{
_lstString.Add(row[dataTableSchema.Columns["ColumnName"]].ToString());
}
}
}
}
然后我可以像这样调用我的代码
using (var dr = ExecuteReader(databaseCommand))
{
int? outInt;
string outString;
Utility.ResetSchemaTable(dr, false);
while (dr.Read())
{
Utility.GetValueByParameter(dr, "SomeColumn", out outInt);
if (outInt.HasValue) myIntField = outInt.Value;
}
Utility.ResetSchemaTable(dr, true);
while (dr.Read())
{
Utility.GetValueByParameter(dr, "AnotherColumn", out outString);
if (!string.IsNullOrEmpty(outString)) myIntField = outString;
}
}
于 2015-05-14T19:40:44.300 回答
0
整个问题的关键在这里：
if (-1 == index) {
throw ADP.IndexOutOfRange(fieldName);
}
如果引用的三行（当前为第 72、73 和 74 行）被取出，那么您可以轻松检查-1以确定该列是否不存在。
在确保本机性能的同时解决此问题的唯一方法是使用Reflection基于实现，如下所示：
用途：
using System;
using System.Data;
using System.Reflection;
using System.Data.SqlClient;
using System.Linq;
using System.Web.Compilation; // I'm not sure what the .NET Core equivalent to BuildManager.cs
基于反射的扩展方法：
/// Gets the column ordinal, given the name of the column.
/// </summary>
/// <param name="reader"></param>
/// <param name="name">The name of the column.</param>
/// <returns> The zero-based column ordinal. -1 if the column does not exist.</returns>
public static int GetOrdinalSoft(this SqlDataReader reader, string name)
{
try
{
// Note that "Statistics" will not be accounted for in this implemenation
// If you have SqlConnection.StatisticsEnabled set to true (the default is false), you probably don't want to use this method
// All of the following logic is inspired by the actual implementation of the framework:
// https://referencesource.microsoft.com/#System.Data/fx/src/data/System/Data/SqlClient/SqlDataReader.cs,d66096b6f57cac74
if (name == null)
throw new ArgumentNullException("fieldName");
Type sqlDataReaderType = typeof(SqlDataReader);
object fieldNameLookup = sqlDataReaderType.GetField("_fieldNameLookup", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(reader);
Type fieldNameLookupType;
if (fieldNameLookup == null)
{
MethodInfo checkMetaDataIsReady = sqlDataReaderType.GetRuntimeMethods().First(x => x.Name == "CheckMetaDataIsReady" && x.GetParameters().Length == 0);
checkMetaDataIsReady.Invoke(reader, null);
fieldNameLookupType = BuildManager.GetType("System.Data.ProviderBase.FieldNameLookup", true, false);
ConstructorInfo ctor = fieldNameLookupType.GetConstructor(new[] { typeof(SqlDataReader), typeof(int) });
fieldNameLookup = ctor.Invoke(new object[] { reader, sqlDataReaderType.GetField("_defaultLCID", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(reader) });
}
else
fieldNameLookupType = fieldNameLookup.GetType();
MethodInfo indexOf = fieldNameLookupType.GetMethod("IndexOf", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(string) }, null);
return (int)indexOf.Invoke(fieldNameLookup, new object[] { name });
}
catch
{
// .NET Implemenation might have changed, revert back to the classic solution.
if (reader.FieldCount > 11) // Performance observation by b_levitt
{
try
{
return reader.GetOrdinal(name);
}
catch
{
return -1;
}
}
else
{
var exists = Enumerable.Range(0, reader.FieldCount).Any(i => string.Equals(reader.GetName(i), name, StringComparison.OrdinalIgnoreCase));
if (exists)
return reader.GetOrdinal(name);
else
return -1;
}
}
}
于 2019-11-13T18:46:53.107 回答
-1
如果您想要列列表并且您不想遇到异常，您也可以在 DataReader 上调用GetSchemaTable() ...
于 2008-12-17T00:27:43.283 回答
-1
采用：
if (dr.GetSchemaTable().Columns.Contains("accounttype"))
do something
else
do something
在循环中它可能不会那么有效。
于 2011-01-12T16:18:05.827 回答
-1
虽然没有公开公开的方法，但在依赖的内部类System.Data.ProviderBase.FieldNameLookup中确实存在方法。SqlDataReader
为了访问它并获得本机性能，您必须使用 ILGenerator 在运行时创建一个方法。以下代码将使您可以直接访问int IndexOf(string fieldName)该类System.Data.ProviderBase.FieldNameLookup以及执行簿记，SqlDataReader.GetOrdinal()这样就不会产生副作用。生成的代码镜像现有的SqlDataReader.GetOrdinal()，除了它调用FieldNameLookup.IndexOf()而不是FieldNameLookup.GetOrdinal(). 该GetOrdinal()方法调用IndexOf()函数并在返回时抛出异常-1，因此我们绕过该行为。
using System;
using System.Data;
using System.Data.SqlClient;
using System.Reflection;
using System.Reflection.Emit;
public static class SqlDataReaderExtensions {
private delegate int IndexOfDelegate(SqlDataReader reader, string name);
private static IndexOfDelegate IndexOf;
public static int GetColumnIndex(this SqlDataReader reader, string name) {
return name == null ? -1 : IndexOf(reader, name);
}
public static bool ContainsColumn(this SqlDataReader reader, string name) {
return name != null && IndexOf(reader, name) >= 0;
}
static SqlDataReaderExtensions() {
Type typeSqlDataReader = typeof(SqlDataReader);
Type typeSqlStatistics = typeSqlDataReader.Assembly.GetType("System.Data.SqlClient.SqlStatistics", true);
Type typeFieldNameLookup = typeSqlDataReader.Assembly.GetType("System.Data.ProviderBase.FieldNameLookup", true);
BindingFlags staticflags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Static;
BindingFlags instflags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance;
DynamicMethod dynmethod = new DynamicMethod("SqlDataReader_IndexOf", typeof(int), new Type[2]{ typeSqlDataReader, typeof(string) }, true);
ILGenerator gen = dynmethod.GetILGenerator();
gen.DeclareLocal(typeSqlStatistics);
gen.DeclareLocal(typeof(int));
// SqlStatistics statistics = (SqlStatistics) null;
gen.Emit(OpCodes.Ldnull);
gen.Emit(OpCodes.Stloc_0);
// try {
gen.BeginExceptionBlock();
// statistics = SqlStatistics.StartTimer(this.Statistics);
gen.Emit(OpCodes.Ldarg_0); //this
gen.Emit(OpCodes.Call, typeSqlDataReader.GetProperty("Statistics", instflags | BindingFlags.GetProperty, null, typeSqlStatistics, Type.EmptyTypes, null).GetMethod);
gen.Emit(OpCodes.Call, typeSqlStatistics.GetMethod("StartTimer", staticflags | BindingFlags.InvokeMethod, null, new Type[] { typeSqlStatistics }, null));
gen.Emit(OpCodes.Stloc_0); //statistics
// if(this._fieldNameLookup == null) {
Label branchTarget = gen.DefineLabel();
gen.Emit(OpCodes.Ldarg_0); //this
gen.Emit(OpCodes.Ldfld, typeSqlDataReader.GetField("_fieldNameLookup", instflags | BindingFlags.GetField));
gen.Emit(OpCodes.Brtrue_S, branchTarget);
// this.CheckMetaDataIsReady();
gen.Emit(OpCodes.Ldarg_0); //this
gen.Emit(OpCodes.Call, typeSqlDataReader.GetMethod("CheckMetaDataIsReady", instflags | BindingFlags.InvokeMethod, null, Type.EmptyTypes, null));
// this._fieldNameLookup = new FieldNameLookup((IDataRecord)this, this._defaultLCID);
gen.Emit(OpCodes.Ldarg_0); //this
gen.Emit(OpCodes.Ldarg_0); //this
gen.Emit(OpCodes.Ldarg_0); //this
gen.Emit(OpCodes.Ldfld, typeSqlDataReader.GetField("_defaultLCID", instflags | BindingFlags.GetField));
gen.Emit(OpCodes.Newobj, typeFieldNameLookup.GetConstructor(instflags, null, new Type[] { typeof(IDataReader), typeof(int) }, null));
gen.Emit(OpCodes.Stfld, typeSqlDataReader.GetField("_fieldNameLookup", instflags | BindingFlags.SetField));
// }
gen.MarkLabel(branchTarget);
gen.Emit(OpCodes.Ldarg_0); //this
gen.Emit(OpCodes.Ldfld, typeSqlDataReader.GetField("_fieldNameLookup", instflags | BindingFlags.GetField));
gen.Emit(OpCodes.Ldarg_1); //name
gen.Emit(OpCodes.Call, typeFieldNameLookup.GetMethod("IndexOf", instflags | BindingFlags.InvokeMethod, null, new Type[] { typeof(string) }, null));
gen.Emit(OpCodes.Stloc_1); //int output
Label leaveProtectedRegion = gen.DefineLabel();
gen.Emit(OpCodes.Leave_S, leaveProtectedRegion);
// } finally {
gen.BeginFaultBlock();
// SqlStatistics.StopTimer(statistics);
gen.Emit(OpCodes.Ldloc_0); //statistics
gen.Emit(OpCodes.Call, typeSqlStatistics.GetMethod("StopTimer", staticflags | BindingFlags.InvokeMethod, null, new Type[] { typeSqlStatistics }, null));
// }
gen.EndExceptionBlock();
gen.MarkLabel(leaveProtectedRegion);
gen.Emit(OpCodes.Ldloc_1);
gen.Emit(OpCodes.Ret);
IndexOf = (IndexOfDelegate)dynmethod.CreateDelegate(typeof(IndexOfDelegate));
}
}
于 2018-05-02T01:33:54.757 回答
-1
这对我有用：
public static class DataRecordExtensions
{
public static bool HasColumn(IDataReader dataReader, string columnName)
{
dataReader.GetSchemaTable().DefaultView.RowFilter = $"ColumnName= '{columnName}'";
return (dataReader.GetSchemaTable().DefaultView.Count > 0);
}
}
于 2019-06-14T00:03:58.430 回答
-1
采用：
if(Enumerable.Range(0,reader.FieldCount).Select(reader.GetName).Contains("columName"))
{
employee.EmployeeId= Utility.ConvertReaderToLong(reader["EmployeeId"]);
}
您可以从Can You get the column names from a SqlDataReader? 获得更多详细信息？.
于 2019-10-16T06:30:41.587 回答