Comment vérifier si une colonne existe dans une table de données ?

Question

J'ai une table de données générée avec le contenu d'un fichier csv. J'utilise d'autres informations pour faire correspondre certaines colonnes du csv (maintenant dans la table de données) aux informations que l'utilisateur doit remplir.

Dans le meilleur des mondes, la cartographie serait toujours possible. Mais ce n'est pas la réalité... Donc, avant d'essayer de mapper la valeur de la colonne de la table de données, je dois vérifier si cette colonne existe. Si je ne fais pas cette vérification, j'ai une ArgumentException.

Bien sûr, je peux vérifier cela avec un code comme celui-ci :

try
{
    //try to map here.
}
catch (ArgumentException)
{ }

mais j'ai pour l'instant 3 colonnes à cartographier et certaines ou toutes peuvent exister/manquer

Existe-t-il un bon moyen de vérifier si une colonne existe dans une table de données ?

Answer 1

DataColumnCollection col = datatable.Columns;        
if (!columns.Contains("ColumnName1"))
{
   //Column1 Not Exists
}

if (columns.Contains("ColumnName2"))
{
   //Column2 Exists
}

Answer 2

Vous pouvez consulter le Columns d'une propriété donnée DataTable il s'agit d'une liste de toutes les colonnes du tableau.

private void PrintValues(DataTable table)
{
    foreach(DataRow row in table.Rows)
    {
        foreach(DataColumn column in table.Columns)
        {
            Console.WriteLine(row[column]);
        }
    }
}

http://msdn.microsoft.com/en-us/library/system.data.datatable.columns.aspx

Answer 3

Il convient de souligner que Contains(...) y IndexOf(...) >= 0 sont toutes deux insensibles à la casse.

Un bon conseil est d'interdire les colonnes multiples ayant le même nom qui ne diffèrent que par la casse ! Mais si vous le faites, alors Contains affiche un comportement étrange :

// In all tests below, "IndexOf(...) >= 0" gives the same result
DataTable dt1 = new DataTable();
dt1.Columns.Add("Test");

dt1.Columns.Contains("Test"); // true, and same result with "IndexOf >= 0"
dt1.Columns.Contains("test"); // true...surprise!
dt1.Columns.Contains("TEST"); // true...surprise again!

DataTable dt2 = new DataTable();
dt2.Columns.Add("Test");
dt2.Columns.Add("test"); // works, but not recommended!
// Note: Adding a 2nd column with the same case, i.e. "Test", is not allowed

dt2.Columns.Contains("test"); // true
dt2.Columns.Contains("Test"); // true
dt2.Columns.Contains("TEST"); // false...huh?

Le profil de performance de Contains est également étrange. Les deux dt1.Columns.Contains("Test"); y dt1.Columns.Contains("test"); retourner TRUE. Un chronométrage minutieux montre que lorsque le nom de la colonne existe avec la même casse, Contains est super rapide, presque comme HashSet::Contains . Mais lorsque le nom de la colonne existe avec une casse différente (par exemple "test"), les performances sont beaucoup plus lentes, comme si chaque colonne était vérifiée... et le retour est quand même VRAI !

Ces comportements étranges semblent être une caractéristique de DataTable::Columns::Contains . Si vous avez besoin d'une sensibilité explicite à la casse, ou pour obtenir un comportement plus cohérent lorsque les noms de colonnes ne diffèrent que par la casse, envisagez :

private bool ContainsCaseSensitive(DataTable dt, string colName)
{
    foreach (DataColumn col in dt.Columns)
    {
        if (col.ColumnName.Equals(colName))
            return true;
    }

    return false;
}

Les performances de ContainsCaseSensitive est similaire à Contains lorsque la colonne que vous recherchez a une faible Ordinal position, ou n'existe pas, dans la DataTable. Pour les colonnes ayant une Ordinal position, alors ContainsCaseSensitive est un peu plus lent que Contains o IndexOf >= 0 .