How to check if a column exists in a datatable

Question

I have a datable generated with the content of a csv file. I use other information to map some column of the csv (now in the datatable) to information the user is required to fill.

In the best world the mapping would be alway possible. But this is not reality... So before I try to map the datatable column value I would need to check if that column even exist. If I don't do this check I have an ArgumentException.

Of course I can check this with some code like this :

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

but I have for now 3 columns to map and some or all might be existing/missing

Is there a good way to check if a column exist in a datatable?

Selfgoverned

Are you dealing with a DataSet/DataTable? If so, you can look at the table's Column collection for a list of all columns in the table. – Gyronny

Yes, @Gyronny the content of the csv is dumped in a datatable. I will have a look in this direction. – Pubilis

Answer 1

You can use operator Contains,

private void ContainColumn(string columnName, DataTable table)
{
    DataColumnCollection columns = table.Columns;        
    if (columns.Contains(columnName))
    {
       ....
    }
}

MSDN - DataColumnCollection.Contains()

Bytom

are you sure this is linq? I don't have any reference to linq in my code and this work – Pubilis

it's operator simple of columns – Bytom

This is not a linq extension method, rather a member of the DataColumnCollection type, but would also work nicely. – Gyronny

@AghilasYakoub Sure is, I forgot about that one. Probably the better way to go in this case as well. One thing though, "You can use operator Contains" - It's not an operator, it's a member method. – Gyronny

Answer 2

myDataTable.Columns.Contains("col_name")

Equatorial

Answer 3

For Multiple columns you can use code similar to one given below.I was just going through this and found answer to check multiple columns in Datatable.

 private bool IsAllColumnExist(DataTable tableNameToCheck, List<string> columnsNames)
    {
        bool iscolumnExist = true;
        try
        {
            if (null != tableNameToCheck && tableNameToCheck.Columns != null)
            {
                foreach (string columnName in columnsNames)
                {
                    if (!tableNameToCheck.Columns.Contains(columnName))
                    {
                        iscolumnExist = false;
                        break;
                    }
                }
            }
            else
            {
                iscolumnExist = false;
            }
        }            
        catch (Exception ex)
        {

        }
        return iscolumnExist;
    }

Phthisic

Answer 4

It is much more accurate to use IndexOf:

If dt.Columns.IndexOf("ColumnName") = -1 Then
    'Column not exist
End If

If the Contains is used it would not differentiate between ColumName and ColumnName2.

Update:

If ds.Tables("TableName").Columns.IndexOf("ColumnName") = -1 Then
    'Column not exist
End If

Joe

Contains does not have the behavior you describe. it's not like a string.contains. It's more "does my collection contains a column with this name?" and not "does my collection contains a column with a name containing this name?" – Pubilis

How can we specified the table name? for example if ColumnName exist in Table1... – Porphyry

Yes. I have modified my answer. – Joe

Answer 5

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

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

Winshell

Answer 6

Base on accepted answer, I made an extension method to check column exist in table as

I shared for whom concern.

 public static class DatatableHelper
 {
        public static bool ContainColumn(this DataTable table, string columnName)
        {
            DataColumnCollection columns = table.Columns;
            if (columns.Contains(columnName))
            {
                return true;
            }

            return false;
        }
}

And use as dtTagData.ContainColumn("SystemName")

Moreland

Answer 7

You can look at the Columns property of a given DataTable, it is a list of all columns in the table.

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

Gyronny

Answer 8

Worth pointing out that Contains(...) and IndexOf(...) >= 0 are both case-insensitive.

Good advise is to disallow multiple columns having the same name which differ only by case! But if you do, then Contains displays some odd behaviour:

// 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?

The performance profile of Contains is also strange. Both dt1.Columns.Contains("Test"); and dt1.Columns.Contains("test"); return TRUE. Careful timing shows that when the column name exists with the same case, Contains is super-fast, almost like HashSet::Contains. But when the column name exists with different case (e.g. "test"), the performance is much slower, almost like every column is checked...and then the return is TRUE anyway!

These odd behaviours appear to be a feature of DataTable::Columns::Contains. If you need explicit case-sensitivity, or to get more consistent behaviour where you may have column names differing only by case, consider:

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

The performance of ContainsCaseSensitive is similar to Contains when the column you are searching for has a low Ordinal position, or does not exist, in the DataTable. For columns with a high Ordinal position, then ContainsCaseSensitive is a bit slower than Contains or IndexOf >= 0.

Menam