Controlla il nome della colonna in un oggetto SqlDataReader

Come posso verificare se esiste una colonna in a SqlDataReader oggetto? Nel mio livello di accesso ai dati, ho creato un metodo che crea lo stesso oggetto per più chiamate di procedure memorizzate. Una delle stored procedure ha una colonna aggiuntiva che non viene utilizzata dalle altre stored procedure. Voglio modificare il metodo per adattarlo a ogni scenario.

La mia domanda è scritta in 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;
    }
}

L'uso di Exceptions come logica di controllo come in alcune altre risposte è considerato una cattiva pratica e ha costi di prestazione. Invia inoltre falsi positivi al profiler delle # eccezioni generate e dio aiuta chiunque a impostare il proprio debugger per interrompere le eccezioni generate.

GetSchemaTable () è anche un altro suggerimento in molte risposte. Questo non sarebbe un modo preferito per verificare l'esistenza di un campo in quanto non è implementato in tutte le versioni (è astratto e genera NotSupportedException in alcune versioni di dotnetcore). GetSchemaTable è anche eccessivo in termini di prestazioni in quanto è una funzione piuttosto pesante se si controlla la fonte .

Il ciclo attraverso i campi può avere un piccolo impatto sulle prestazioni se lo usi molto e potresti prendere in considerazione la memorizzazione nella cache dei risultati.

È molto meglio usare questa funzione booleana:

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

Una chiamata: nessuna eccezione. Potrebbe generare eccezioni internamente, ma io non la penso così.

NOTA: Nei commenti seguenti, l'abbiamo capito ... il codice corretto è in realtà questo:

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

Penso che la tua scommessa migliore sia chiamare GetOrdinal ("columnName") sul tuo DataReader in anticipo e catturare un IndexOutOfRangeException nel caso in cui la colonna non sia presente.

In effetti, facciamo un metodo di estensione:

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

modificare

Ok, questo post sta iniziando a raccogliere alcuni voti negativi ultimamente e non posso eliminarlo perché è la risposta accettata, quindi lo aggiornerò e (spero) cercherò di giustificare l'uso della gestione delle eccezioni come flusso di controllo.

L'altro modo per raggiungere questo obiettivo, come pubblicato da Chad Grant , è quello di scorrere ogni campo nel DataReader ed effettuare un confronto senza distinzione tra maiuscole e minuscole per il nome del campo che stai cercando. Funzionerà davvero bene e, in verità, probabilmente funzionerà meglio del mio metodo sopra. Certamente non avrei mai usato il metodo sopra in un ciclo in cui performace era un problema.

Posso pensare a una situazione in cui il metodo try / GetOrdinal / catch funzionerà dove il ciclo non funziona. È, tuttavia, una situazione completamente ipotetica in questo momento, quindi è una giustificazione molto fragile. Indipendentemente da ciò, abbi pazienza con me e vedi cosa ne pensi.

Immagina un database che ti ha permesso di "alias" le colonne all'interno di una tabella. Immagina di poter definire una tabella con una colonna chiamata "EmployeeName" ma anche di dargli un alias di "EmpName", e fare una selezione per entrambi i nomi restituirebbe i dati in quella colonna. Con me finora?

Ora immagina che ci sia un provider ADO.NET per quel database, e hanno codificato un'implementazione IDataReader che tiene conto degli alias di colonna.

Ora, dr.GetName(i)(come usato nella risposta di Chad) può restituire solo una singola stringa, quindi deve restituire solo uno degli "alias" su una colonna. Però,GetOrdinal("EmpName") possibile utilizzare l'implementazione interna dei campi di questo provider per controllare l'alias di ogni colonna per il nome che stai cercando.

In questa ipotetica situazione di "colonne con alias", il metodo try / GetOrdinal / catch sarebbe l'unico modo per essere sicuri di verificare ogni variazione del nome di una colonna nel gruppo di risultati.

Fragile? Sicuro. Ma vale la pena pensarci. Onestamente preferirei piuttosto un metodo HasColumn "ufficiale" su IDataRecord.

In una riga, utilizzalo dopo il recupero del tuo DataReader:

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

Poi,

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

modificare

One-liner molto più efficiente che non richiede di caricare lo schema:

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

Ecco un esempio funzionante dell'idea di Jasmin:

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

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

}

questo funziona per me:

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

Quanto segue è semplice e ha funzionato per me:

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

Se leggi la domanda, Michael ha chiesto di DataReader, non di DataRecord. Ottieni i tuoi oggetti giusti.

Usare un r.GetSchemaTable().Columns.Contains(field) su un DataRecord funziona, ma restituisce colonne BS (vedere la schermata seguente).

Per vedere se esiste una colonna di dati E contiene dati in un DataReader, utilizzare le seguenti estensioni:

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

Uso:

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

La chiamata r.GetSchemaTable().Columnsa un DataReader restituisce colonne BS:

Ho scritto per gli utenti di 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

Penso che questo sia più potente e l'uso sia:

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

Ecco una versione linq di una riga della risposta accettata:

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

Ecco la soluzione di Jasmine in una riga ... (un'altra, anche se semplice!):

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:

Molte risposte con affermazioni su prestazioni e cattive pratiche, quindi chiarisco che qui.

Il percorso di eccezione è più veloce per un numero maggiore di colonne restituite, il percorso del ciclo è più veloce per un numero inferiore di colonne e il punto di crossover è di circa 11 colonne. Scorri verso il basso per visualizzare un grafico e un codice di prova.

Risposta completa:

Il codice per alcune delle risposte migliori funziona, ma qui c'è un dibattito sottostante per la risposta "migliore" basata sull'accettazione della gestione delle eccezioni nella logica e delle prestazioni correlate.

Per chiarire ciò, non credo che ci siano molte indicazioni riguardo alle eccezioni di CATCHING. Microsoft ha alcune indicazioni per quanto riguarda le eccezioni di LANCIO. Lì dichiarano:

NON utilizzare eccezioni per il normale flusso di controllo, se possibile.

La prima nota è la clemenza di "se possibile". Ancora più importante, la descrizione fornisce questo contesto:

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

Ciò significa che se stai scrivendo un'API che potrebbe essere utilizzata da qualcun altro, dai loro la possibilità di navigare in un'eccezione senza provare / catturare. Ad esempio, fornire un TryParse con il metodo Parse che genera eccezioni. Da nessuna parte questo dice che non dovresti prendere un'eccezione.

Inoltre, come sottolineato da un altro utente, le catture hanno sempre consentito il filtraggio per tipo e in qualche modo recentemente consentono un ulteriore filtraggio tramite la clausola when . Sembra uno spreco di funzionalità linguistiche se non dovremmo usarle.

Si può dire che vi è ALCUNO costo per un'eccezione generata e che può influire sulle prestazioni in un ciclo pesante. Tuttavia, si può anche affermare che il costo di un'eccezione sarà trascurabile in una "applicazione connessa". Il costo effettivo è stato esaminato oltre un decennio fa: https://stackoverflow.com/a/891230/852208 In altre parole, è probabile che il costo di una connessione e una query di un database riducano quello di un'eccezione generata.

A parte questo, volevo determinare quale metodo fosse veramente più veloce. Come previsto, non esiste una risposta concreta.

Qualsiasi codice che scorre sopra le colonne diventa più lento man mano che esiste il numero di colonne. Si può anche dire che qualsiasi codice che si basa su eccezioni rallenterà a seconda della velocità con cui la query non viene trovata.

Prendendo le risposte di Chad Grant e Matt Hamilton, ho eseguito entrambi i metodi con un massimo di 20 colonne e un tasso di errore fino al 50% (l'OP ha indicato che stava usando questi due test tra processi diversi, quindi ne ho ipotizzati solo due) .

Ecco i risultati, tracciati con LinqPad:

Gli zigzag qui sono i tassi di errore (colonna non trovata) all'interno di ogni conteggio delle colonne.

Su insiemi di risultati più ristretti, il looping è una buona scelta. Tuttavia, il metodo GetOrdinal / Exception non è altrettanto sensibile al numero di colonne e inizia a sovraperformare il metodo di ciclo attorno a 11 colonne.

Detto questo, in realtà non ho una preferenza prestazionale in quanto 11 colonne sembrano ragionevoli poiché un numero medio di colonne restituite su un'intera applicazione. In entrambi i casi stiamo parlando di frazioni di millisecondo qui.

Tuttavia, dal punto di vista della semplicità del codice e del supporto alias, probabilmente andrei con il percorso GetOrdinal.

Ecco il test in formato linqpad. Sentiti libero di ripubblicare con il tuo metodo:

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


}

Questo codice corregge i problemi che Levitikon aveva con il loro codice: (adattato da: [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;
}

Il motivo per ottenere tutti quei nomi di colonne inutili e non il nome della colonna dalla tabella ... È perché stai ottenendo il nome della colonna dello schema (ovvero i nomi delle colonne per la tabella Schema)

NOTA: questo sembra restituire solo il nome della prima colonna ...

EDIT: codice corretto che restituisce il nome di tutte le colonne, ma non è possibile utilizzare un SqlDataReader per farlo

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
}

Per mantenere il codice solido e pulito, utilizzare una singola funzione di estensione, come questa:

    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

Né sono riuscito GetSchemaTablea lavorare, fino a quando non l'ho trovato in questo modo .

Fondamentalmente faccio questo:

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 è maiuscole e minuscole.

Nella tua situazione particolare (tutte le procedure hanno le stesse colonne tranne 1 che ha 1 colonna aggiuntiva), sarà meglio e più veloce controllare il lettore. Proprietà FieldCount per distinguerli.

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

So che è un vecchio post, ma ho deciso di rispondere per aiutare gli altri nella stessa situazione. puoi anche (per motivi di prestazioni) mescolare questa soluzione con la soluzione iterante.

La mia classe di accesso ai dati deve essere retrocompatibile, quindi potrei provare ad accedere a una colonna in una versione in cui non esiste ancora nel database. Abbiamo alcuni set di dati piuttosto grandi che vengono restituiti, quindi non sono un grande fan di un metodo di estensione che deve iterare la raccolta di colonne DataReader per ogni proprietà.

Ho una classe di utilità che crea un elenco privato di colonne e quindi ha un metodo generico che tenta di risolvere un valore basato sul nome di una colonna e sul tipo di parametro di output.

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

Quindi posso semplicemente chiamare il mio codice in questo modo

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

La chiave per l'intero problema è qui :

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

Se le tre linee di riferimento (attualmente le linee 72, 73 e 74) vengono rimosse, è possibile verificare facilmente la presenza di -1 determinare se la colonna non esiste.

L'unico modo per ovviare a questo mentre garantendo prestazioni native è utilizzare a Reflection un'implementazione basata, come la seguente:

usings:

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

Il metodo di estensione basato su Reflection:

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

Puoi anche chiamare GetSchemaTable () sul tuo DataReader se desideri l'elenco di colonne e non vuoi ottenere un'eccezione ...

Che ne dite di

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

Probabilmente non sarebbe così efficiente in un ciclo

Sebbene non esista un metodo esposto pubblicamente, esiste un metodo nella classe interna System.Data.ProviderBase.FieldNameLookupcheSqlDataReader si basa.

Per accedervi e ottenere prestazioni native, è necessario utilizzare ILGenerator per creare un metodo in fase di esecuzione. Il seguente codice vi darà accesso diretto int IndexOf(string fieldName)in System.Data.ProviderBase.FieldNameLookupclasse e di eseguire la tenuta libro che SqlDataReader.GetOrdinal()fa in modo che non v'è alcun effetto collaterale. Il codice generato rispecchia quello esistente SqlDataReader.GetOrdinal()tranne per il fatto che chiama FieldNameLookup.IndexOf()invece di FieldNameLookup.GetOrdinal(). Il GetOrdinal()metodo chiama la IndexOf()funzione e genera un'eccezione se -1viene restituito, quindi ignoriamo quel comportamento.

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

}

questo lavoro per me

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

puoi ottenere maggiori dettagli da qui: puoi ottenere i nomi delle colonne da un SqlDataReader?