How to Query a DataTable with LINQ in C#

By the end of this page, you will understand why a DataTable cannot be queried directly with standard LINQ syntax, how AsEnumerable() makes LINQ work with table rows, and how to safely read column values using Field<T>(). You will also see practical examples, common mistakes, and a small project that filters data from a DataTable.

A DataTable stores rows of data in memory, but it does not directly implement the generic sequence interface that standard LINQ queries expect.

LINQ works best with collections such as:

• IEnumerable<T>
• List<T>
• arrays
• other generic sequences

A DataTable contains rows as DataRow objects, but to use LINQ query syntax like from ... where ... select ..., you usually need to convert the table into something LINQ can enumerate as a sequence of rows.

That is why C# provides the AsEnumerable() extension method for DataTable.

var results = myDataTable.AsEnumerable();

This gives you an IEnumerable<DataRow>, which LINQ can query.

Another important part is reading values from a DataRow. A DataRow stores column values as objects, so LINQ queries often use:

row.Field<int>("RowNo")

Think of a DataTable as a filing cabinet and each DataRow as one paper file.

LINQ expects a line of items it can walk through one by one, like files laid out on a desk. But a DataTable is not automatically presented that way for generic LINQ.

AsEnumerable() is the step that takes the files out of the cabinet and lays them on the desk so LINQ can inspect them one at a time.

Then Field<T>() is like reading a labeled field from each paper file in the correct data type:

• "RowNo" as an int
• "Name" as a string
• "Price" as a decimal

So the process is:

1. Convert the DataTable into an enumerable row sequence.
2. Read values from each row by column name.
3. Filter or transform the rows with LINQ.

The basic pattern is:

using System.Data;
using System.Linq;

var results = from row in myDataTable.AsEnumerable()
              where row.Field<int>("RowNo") == 1
              select row;

You can also write the same query with method syntax:

var results = myDataTable.AsEnumerable()
                         .Where(row => row.Field<int>("RowNo") == 1);

Example: filter rows by column value

using System;
using System.Data;
using System.Linq;

DataTable table = new DataTable();
table.Columns.Add("RowNo", typeof(int));
table.Columns.Add("Name", typeof(string));

table.Rows.Add(1, "Alice");
table.Rows.Add(2, "Bob");
table.Rows.Add(1, "Charlie");

var results = from row  table.AsEnumerable()
               row.Field<>() == 
               row;

 ( row  results)
{
    Console.WriteLine();
}

Consider this code:

DataTable table = new DataTable();
table.Columns.Add("RowNo", typeof(int));
table.Columns.Add("Name", typeof(string));

table.Rows.Add(1, "Alice");
table.Rows.Add(2, "Bob");

table.Rows.Add(1, "Charlie");

var results = table.AsEnumerable()
                   .Where(row => row.Field<int>("RowNo") == 1)
                   .Select(row => row.Field<string>("Name"));

Here is what happens step by step:

1. A DataTable is created.
2. Two columns are added:
   • RowNo as int
   • Name as string
3. Three rows are inserted.
4. AsEnumerable() exposes the rows as IEnumerable<DataRow>.
5. Where(...) checks each row:

LINQ on DataTable is useful in many existing .NET applications.

Filtering imported data

If you load CSV or Excel data into a DataTable, you can use LINQ to find rows matching conditions:

• invalid records
• duplicate IDs
• rows missing required values

Working with database results

Some older systems still use SqlDataAdapter to fill a DataTable. LINQ makes it easier to:

• filter active users
• sort invoice rows
• extract only needed columns

Reporting and dashboards

A report may gather raw data into a DataTable, then use LINQ to:

• group values
• compute totals
• display only a subset of rows

Validation pipelines

Before saving data, LINQ can help detect:

• missing fields
• out-of-range values
• duplicate business keys

In real projects, developers often use LINQ on DataTable in small, focused ways rather than building huge query expressions.

Common patterns

Guard clauses before querying

if (table == null || table.Rows.Count == 0)
{
    return;
}

This prevents null-reference problems and pointless queries.

Validation before reading typed values

var validRows = table.AsEnumerable()
                     .Where(row => !row.IsNull("RowNo"));

This is helpful when database data may contain DBNull.

Early filtering

var activeRows = table.AsEnumerable()
                      .Where(row => row.Field<bool>("IsActive"));

Filter early so later logic works on a smaller set.

Projection into models

Instead of passing DataRow around, many codebases map rows into objects:

var users = table.AsEnumerable()
                 .Select(row => 
                 {
                     Id = row.Field<>(),
                     Name = row.Field<>()
                 });

1. Querying the DataTable directly

Broken code:

var results = from row in myDataTable
              where row.Field<int>("RowNo") == 1
              select row;

Why it fails:

• DataTable is not directly used as IEnumerable<DataRow> for this query syntax.

Fix:

var results = from row in myDataTable.AsEnumerable()
              where row.Field<int>("RowNo") == 1
              select row;

2. Using the wrong variable name inside the query

Broken code:

var results = from myRow in myDataTable.AsEnumerable()
              where results.Field<int>("RowNo") == 1
               results;

DataTable.Select() vs LINQ

// Required namespaces
using System.Data;
using System.Linq;

// Basic LINQ query on a DataTable
var results = from row in table.AsEnumerable()
              where row.Field<int>("RowNo") == 1
              select row;

// Method syntax
var results2 = table.AsEnumerable()
                    .Where(row => row.Field<int>("RowNo") == 1);

// Select one column
var names = table.AsEnumerable()
                 .Select(row => row.Field<string>("Name"));

// Handle nullable values
var rows = table.AsEnumerable()
                .Where(row => row.Field<int?>("RowNo") == 1);

// Check for DBNull
var safeRows = table.AsEnumerable()
                    .Where(row => !row.IsNull("RowNo"));

// Convert filtered rows back to DataTable
var filteredRows = table.AsEnumerable()
                        .Where(row => row.Field<int>("RowNo") == 1);

DataTable filteredTable = filteredRows.Any()
    ? filteredRows.CopyToDataTable()
    : table.Clone();

Rules to remember

Why can't I use LINQ directly on a DataTable?

DataTable is not directly queried the same way as a generic IEnumerable<T> source in normal LINQ syntax. Use AsEnumerable() to expose its rows as IEnumerable<DataRow>.

What namespace do I need for AsEnumerable()?

You typically need System.Data and System.Linq. In many projects, the extension method support for DataTable also comes from the DataSet extensions assembly available in .NET.

What does Field() do in a DataRow?

It reads a column value from a DataRow and returns it as the specified type, such as int, string, or DateTime.

Can I return a DataTable after filtering with LINQ?

Yes. After filtering rows, call CopyToDataTable(). If the result may be empty, check with Any() first or return table.Clone().

Is DataTable.Select() better than LINQ?

Not usually. DataTable.Select() is fine for simple string-based filters, but LINQ is generally more readable, composable, and type-safe.

• IEnumerable<T> — LINQ queries are built around enumerable sequences.
• DataRow — each row in a DataTable is queried as a DataRow.
• Field<T>() — used to read typed values from DataRow columns.
• AsEnumerable() — the key extension method that enables LINQ over DataTable rows.
• Where — filters rows based on a condition.
• Select — projects rows into values or objects.
• CopyToDataTable() — converts a LINQ result of rows back into a DataTable.
• DBNull — important when table columns may contain database null values.
• Deferred execution — explains when LINQ queries actually run.
• Anonymous types — useful when projecting selected columns into lightweight objects.