Sprawdź nazwę kolumny w obiekcie SqlDataReader

Jak sprawdzić, czy kolumna istnieje w pliku SqlDataReader obiekcie? W mojej warstwie dostępu do danych utworzyłem metodę, która buduje ten sam obiekt dla wielu wywołań procedur składowanych. Jedna z procedur przechowywanych ma dodatkową kolumnę, która nie jest używana przez inne procedury przechowywane. Chcę zmodyfikować metodę, aby dostosować ją do każdego scenariusza.

Moja aplikacja jest napisana w języku C #.

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;
    }
}

Używanie Exceptions do logiki sterowania, jak w niektórych innych odpowiedziach, jest uważane za złą praktykę i wiąże się z kosztami wydajności. Wysyła również fałszywe alarmy do profilera zgłoszonych # wyjątków i niech Bóg pomoże każdemu, kto ustawi swojego debuggera na złamanie zgłoszonych wyjątków.

GetSchemaTable () to także kolejna sugestia w wielu odpowiedziach. Nie byłby to preferowany sposób sprawdzania istnienia pola, ponieważ nie jest on implementowany we wszystkich wersjach (jest abstrakcyjny i zgłasza NotSupportedException w niektórych wersjach dotnetcore). GetSchemaTable ma również zbyt dużą wydajność, ponieważ jest to dość ciężka funkcja, jeśli sprawdzisz źródło .

Pętlowanie przez pola może mieć niewielki wpływ na wydajność, jeśli często go używasz i możesz rozważyć buforowanie wyników.

O wiele lepiej jest użyć tej funkcji boolowskiej:

r.GetSchemaTable().Columns.Contains(field)

Jedno połączenie - bez wyjątków. Może powodować wewnętrzne wyjątki, ale nie sądzę.

UWAGA: W komentarzach poniżej zorientowaliśmy się ... Właściwy kod to tak naprawdę:

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; 
}

Myślę, że najlepszym rozwiązaniem jest wywołanie GetOrdinal („columnName”) na swoim DataReaderze z góry i wyłapanie IndexOutOfRangeException na wypadek, gdyby kolumna nie była obecna.

W rzeczywistości stwórzmy metodę rozszerzenia:

public static bool HasColumn(this IDataRecord r, string columnName)
{
    try
    {
        return r.GetOrdinal(columnName) >= 0;
    }
    catch (IndexOutOfRangeException)
    {
        return false;
    }
}

Edytować

Ok, ten post zaczyna ostatnio zbierać kilka głosów negatywnych i nie mogę go usunąć, ponieważ jest to zaakceptowana odpowiedź, więc zaktualizuję go i (mam nadzieję) spróbuję uzasadnić użycie obsługi wyjątków jako kontrola przepływu.

Innym sposobem osiągnięcia tego, jak napisał Chad Grant , jest przejście przez każde pole w czytniku danych i wykonanie rozróżniania wielkości liter dla szukanej nazwy pola. To zadziała naprawdę dobrze i prawdę mówiąc prawdopodobnie będzie działało lepiej niż moja metoda powyżej. Z pewnością nigdy nie użyłbym powyższej metody w pętli, w której występowanie stanowiło problem.

Mogę wymyślić jedną sytuację, w której metoda try / GetOrdinal / catch będzie działać tam, gdzie pętla nie działa. Jest to jednak obecnie całkowicie hipotetyczna sytuacja, więc jest to bardzo słabe uzasadnienie. Niezależnie od tego, znoś mnie i zobacz, co myślisz.

Wyobraź sobie bazę danych, która pozwoliła na „alias” kolumn w tabeli. Wyobraź sobie, że mógłbym zdefiniować tabelę z kolumną o nazwie „Nazwa pracownika”, ale także nadać jej alias „Nazwa Emp”, a wybranie jednej z nazw zwróciłoby dane w tej kolumnie. Do tej pory ze mną?

Wyobraź sobie teraz, że istnieje dostawca ADO.NET dla tej bazy danych i zakodowali dla niej implementację IDataReader, która uwzględnia aliasy kolumn.

Teraz dr.GetName(i)(użyte w odpowiedzi Chada) może zwrócić tylko jeden ciąg, więc musi zwrócić tylko jeden z „aliasów” w kolumnie. Jednak GetOrdinal("EmpName")przydałby wewnętrzną realizację polach tego dostawcy w celu sprawdzenia każdej kolumny alias dla nazwy, której szukasz.

W tej hipotetycznej sytuacji „kolumny z aliasem” metoda try / GetOrdinal / catch byłaby jedynym sposobem, aby upewnić się, że sprawdzane są wszystkie odmiany nazwy kolumny w zestawie wyników.

Słaby? Pewnie. Ale warto pomyśleć. Szczerze mówiąc wolałbym raczej „oficjalną” metodę HasColumn na IDataRecord.

W jednym wierszu użyj tego po pobraniu DataReadera:

var fieldNames = Enumerable.Range(0, dr.FieldCount).Select(i => dr.GetName(i)).ToArray();

Następnie,

if (fieldNames.Contains("myField"))
{
    var myFieldValue = dr["myField"];
    ...

Edytować

Znacznie bardziej wydajna jedna linijka, która nie wymaga ładowania schematu:

var exists = Enumerable.Range(0, dr.FieldCount).Any(i => string.Equals(dr.GetName(i), fieldName, StringComparison.OrdinalIgnoreCase));

Oto działająca próbka pomysłu Jasmina:

var cols = r.GetSchemaTable().Rows.Cast<DataRow>().Select
    (row => row["ColumnName"] as string).ToList(); 

if (cols.Contains("the column name"))
{

}

to działa dla mnie:

bool hasColumnName = reader.GetSchemaTable().AsEnumerable().Any(c => c["ColumnName"] == "YOUR_COLUMN_NAME");

Poniższe jest proste i działało dla mnie:

 bool hasMyColumn = (reader.GetSchemaTable().Select("ColumnName = 'MyColumnName'").Count() == 1);

Jeśli przeczytasz pytanie, Michael zapytał o DataReader, a nie ludzi DataRecord. Zrób swoje przedmioty we właściwy sposób.

Używać r.GetSchemaTable().Columns.Contains(field) na DataRecord działa, ale zwraca kolumny BS (patrz zrzut ekranu poniżej).

Aby sprawdzić, czy kolumna danych istnieje ORAZ zawiera dane w czytniku danych, użyj następujących rozszerzeń:

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;
        }
    }
}

Stosowanie:

    public static bool CanCreate(SqlDataReader dataReader)
    {
        return dataReader.ContainsColumn("RoleTemplateId") 
            && !dataReader.IsDBNull("RoleTemplateId");
    }

Wywołanie r.GetSchemaTable().Columnsw DataReader zwraca kolumny BS:

Napisałem dla użytkowników 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

Myślę, że jest to bardziej wydajne, a użycie jest następujące:

If HasColumnAndValue(reader, "ID_USER") Then
    Me.UserID = reader.GetDecimal(reader.GetOrdinal("ID_USER")).ToString()
End If

Oto jedna liniowa wersja linq akceptowanej odpowiedzi:

Enumerable.Range(0, reader.FieldCount).Any(i => reader.GetName(i) == "COLUMN_NAME_GOES_HERE")

Oto rozwiązanie od Jasmine w jednym wierszu ... (jeszcze jedno, proste!):

reader.GetSchemaTable().Select("ColumnName='MyCol'").Length > 0;

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);
    }

TLDR:

Wiele odpowiedzi z twierdzeniami na temat wydajności i złych praktyk, więc wyjaśniam to tutaj.

Trasa wyjątku jest szybsza dla większej liczby zwracanych kolumn, trasa pętli jest szybsza dla mniejszej liczby kolumn, a punkt podziału wynosi około 11 kolumn. Przewiń w dół, aby zobaczyć wykres i kod testowy.

Pełna odpowiedź:

Kod niektórych najważniejszych odpowiedzi działa, ale tutaj jest debata na temat „lepszej” odpowiedzi opartej na akceptacji obsługi wyjątków w logice i związanej z nią wydajności.

Aby to wyjaśnić, nie wierzę, że istnieje wiele wskazówek dotyczących wyjątków ŁOWIENIE. Microsoft ma pewne wskazówki dotyczące wyjątków WYPROWADZANIE. Tam stwierdzają:

Jeśli to możliwe, NIE używaj wyjątków dla normalnego przepływu kontroli.

Pierwsza uwaga to łagodność „jeśli to możliwe”. Co ważniejsze, opis podaje następujący kontekst:

framework designers should design APIs so users can write code that does not throw exceptions

Oznacza to, że jeśli piszesz interfejs API, który może być używany przez kogoś innego, daj mu możliwość poruszania się po wyjątku bez próbowania / chwytania. Na przykład podaj TryParse ze swoją metodą analizy wyjątków Parse. Nigdzie nie mówi to jednak, że nie powinieneś wychwytywać wyjątku.

Ponadto, jak zauważa inny użytkownik, połowy zawsze pozwalały na filtrowanie według typu, a nieco później na dalsze filtrowanie poprzez klauzulę when . Wydaje się to stratą funkcji językowych, jeśli nie powinniśmy ich używać.

Można powiedzieć, że istnieje NIEKTÓRY koszt rzuconego wyjątku, który może MNIE wpłynąć na wydajność w ciężkiej pętli. Można jednak powiedzieć, że koszt wyjątku będzie znikomy w „połączonej aplikacji”. Rzeczywisty koszt zbadano ponad dziesięć lat temu: https://stackoverflow.com/a/891230/852208 Innymi słowy, koszt połączenia i zapytania do bazy danych może być niższy niż w przypadku zgłoszonego wyjątku.

Poza tym chciałem ustalić, która metoda naprawdę jest szybsza. Zgodnie z oczekiwaniami nie ma konkretnej odpowiedzi.

Każdy kod, który zapętla się nad kolumnami, staje się wolniejszy w miarę istnienia liczby kolumn. Można również powiedzieć, że każdy kod, który opiera się na wyjątkach, zwolni w zależności od częstotliwości, w której zapytanie nie zostanie znalezione.

Biorąc odpowiedzi zarówno Chada Granta, jak i Matta Hamiltona, zastosowałem obie metody z maksymalnie 20 kolumnami i do 50% poziomu błędu (OP wskazał, że używa tego testu między różnymi procesami, więc założyłem, że tylko dwa) .

Oto wyniki przedstawione za pomocą LinqPad:

Zygzaki tutaj są wskaźnikami błędów (nie znaleziono kolumny) w obrębie każdej liczby kolumn.

W porównaniu z węższymi zestawami wyników, zapętlenie jest dobrym wyborem. Jednak metoda GetOrdinal / Exception nie jest tak wrażliwa na liczbę kolumn i zaczyna przewyższać metodę zapętlania około 11 kolumn.

To powiedziawszy, tak naprawdę nie mam preferencji pod względem wydajności, ponieważ 11 kolumn brzmi rozsądnie, ponieważ średnia liczba kolumn zwrócona w całej aplikacji. W obu przypadkach mówimy tutaj o ułamkach milisekundy.

Jednak z punktu widzenia prostoty kodu i obsługi aliasów prawdopodobnie wybrałbym trasę GetOrdinal.

Oto test w formie linqpad. Zapraszam do repost z własną metodą:

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; }


}

Ten kod rozwiązuje problemy, które miał Levitikon ze swoim kodem: (zaadaptowano z: [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;
}

Powodem, dla którego wszystkie te bezużyteczne nazwy kolumn są uzyskiwane, a nie nazwa kolumny z tabeli ... jest to, że otrzymujesz nazwę kolumny schematu (tj. Nazwy kolumn dla tabeli schematów)

UWAGA: wydaje się, że to zwraca tylko nazwę pierwszej kolumny ...

EDYCJA: poprawiony kod, który zwraca nazwę wszystkich kolumn, ale nie można do tego użyć 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
}

Aby Twój kod był niezawodny i czysty, użyj jednej funkcji rozszerzenia, takiej jak ta:

    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

Nie zabrałem się też GetSchemaTabledo pracy, dopóki nie znalazłem w ten sposób .

Zasadniczo robię to:

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

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 jest rozróżniana wielkość liter btw.

W twojej konkretnej sytuacji (wszystkie procedury mają te same kolumny, z wyjątkiem 1, która ma dodatkową 1 kolumnę), lepiej i szybciej będzie sprawdzać czytnik. Właściwość FieldCount, aby je rozróżnić.

const int NormalColCount=.....
if(reader.FieldCount > NormalColCount)
{
// Do something special
}

Wiem, że to stary post, ale postanowiłem odpowiedzieć, aby pomóc innym w tej samej sytuacji. możesz także (ze względu na wydajność) mieszać to rozwiązanie z iteracyjnym rozwiązaniem.

Moja klasa dostępu do danych musi być kompatybilna z poprzednimi wersjami, więc być może próbuję uzyskać dostęp do kolumny w wydaniu, w którym jeszcze jej nie ma w bazie danych. Zwracane są pewne dość duże zestawy danych, więc nie jestem wielkim fanem metody rozszerzenia, która musi iterować kolekcję kolumn DataReader dla każdej właściwości.

Mam klasę narzędzi, która tworzy prywatną listę kolumn, a następnie ma ogólną metodę, która próbuje rozwiązać wartość na podstawie nazwy kolumny i typu parametru wyjściowego.

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());
            }
        }
    }
}

Następnie mogę tak po prostu wywołać mój kod

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;
    }
}

Klucz do całego problemu jest tutaj :

if (-1 == index) {
    throw ADP.IndexOutOfRange(fieldName);
}

Jeśli odwołane trzy linie (obecnie linie 72, 73 i 74) zostaną usunięte, możesz łatwo sprawdzić -1, czy kolumna nie istnieje.

Jedynym sposobem na obejście tego przy jednoczesnym zapewnieniu wydajności natywnej jest użycie Reflectionimplementacji opartej na następujących czynnościach:

Zastosowania:

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

Metoda rozszerzenia oparta na odbiciu:

/// 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;
        }
    }
}

Możesz także wywołać funkcję GetSchemaTable () w DataReader, jeśli chcesz wyświetlić listę kolumn i nie chcesz otrzymywać wyjątku ...

Co powiesz na

if (dr.GetSchemaTable().Columns.Contains("accounttype"))
   do something
else
   do something

Prawdopodobnie nie byłoby tak wydajne w pętli

Chociaż nie ma metody ujawnionej publicznie, metoda istnieje w klasie wewnętrznej, System.Data.ProviderBase.FieldNameLookupktóraSqlDataReader opiera.

Aby uzyskać do niego dostęp i uzyskać natywną wydajność, musisz użyć ILGenerator, aby utworzyć metodę w czasie wykonywania. Poniższy kod daje bezpośredni dostęp do int IndexOf(string fieldName)w System.Data.ProviderBase.FieldNameLookupklasie, a także wykonać księgowości, że SqlDataReader.GetOrdinal()robi tak, że nie ma efekt uboczny. Wygenerowany kod odzwierciedla istniejący, SqlDataReader.GetOrdinal()z wyjątkiem tego, że wywołuje FieldNameLookup.IndexOf()zamiast FieldNameLookup.GetOrdinal(). GetOrdinal()Metoda zwraca się do IndexOf()funkcji i zgłasza wyjątek, jeśli -1jest zwracany, więc obejścia tego zachowania.

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));
   }

}

ta praca dla mnie

public static class DataRecordExtensions
{
        public static bool HasColumn(IDataReader dataReader, string columnName)
        {
            dataReader.GetSchemaTable().DefaultView.RowFilter = $"ColumnName= '{columnName}'";
            return (dataReader.GetSchemaTable().DefaultView.Count > 0);
        }
}

if(Enumerable.Range(0,reader.FieldCount).Select(reader.GetName).Contains("columName"))
{
     employee.EmployeeId= Utility.ConvertReaderToLong(reader["EmployeeId"]);
}

możesz uzyskać więcej szczegółów tutaj: czy możesz uzyskać nazwy kolumn z SqlDataReader?