Introduction

If you are working with a .NET DataTable, filtering by name usually means selecting rows whose Name column matches a value or pattern. The two common approaches are using DataView.RowFilter for UI-friendly filtering and using LINQ when you want strongly typed code and more flexible logic.

The right choice depends on where the filtered result is going. If you want a view for binding, DataView is natural. If you want to transform or copy matching rows, LINQ is often clearer.

Filter with DataView.RowFilter

RowFilter uses an expression syntax similar to SQL WHERE, but it is not full SQL. For simple string matching, it works well.

1using System;
2using System.Data;
3
4class Program
5{
6    static void Main()
7    {
8        DataTable table = new DataTable();
9        table.Columns.Add("Name", typeof(string));
10        table.Columns.Add("Age", typeof(int));
11
12        table.Rows.Add("Alice", 30);
13        table.Rows.Add("Bob", 28);
14        table.Rows.Add("Alicia", 35);
15
16        DataView view = table.DefaultView;
17        view.RowFilter = "Name = 'Alice'";
18
19        foreach (DataRowView row in view)
20        {
21            Console.WriteLine(row["Name"]);
22        }
23    }
24}

This returns only rows where the Name column is exactly Alice.

Filter by Partial Name Match

If you need “contains” or “starts with” behavior, use LIKE.

view.RowFilter = "Name LIKE 'Ali%'";

That matches Alice and Alicia.

For a contains-style search:

view.RowFilter = "Name LIKE '%lic%'";

This is useful for search boxes and grid filtering.

Use LINQ When You Want C# Logic

LINQ becomes more attractive when filtering rules get more complex or when you want case-insensitive comparisons without relying on expression syntax tricks.

1using System;
2using System.Data;
3using System.Linq;
4
5class Program
6{
7    static void Main()
8    {
9        DataTable table = new DataTable();
10        table.Columns.Add("Name", typeof(string));
11        table.Columns.Add("Age", typeof(int));
12
13        table.Rows.Add("Alice", 30);
14        table.Rows.Add("Bob", 28);
15        table.Rows.Add("Alicia", 35);
16
17        var filteredRows = table.AsEnumerable()
18            .Where(r => r.Field<string>("Name")
19                .StartsWith("ali", StringComparison.OrdinalIgnoreCase));
20
21        foreach (var row in filteredRows)
22        {
23            Console.WriteLine(row.Field<string>("Name"));
24        }
25    }
26}

LINQ is easier to test and refactor because it stays in normal C# rather than embedding a filter expression in a string.

Return a New DataTable After Filtering

If another API expects a DataTable, you can copy the filtered rows back into one.

var result = filteredRows.Any()
    ? filteredRows.CopyToDataTable()
    : table.Clone();

That gives you the same schema with only matching rows. It is a common pattern when exporting or handing data to reporting code.

Choose Based on the Output You Need

A simple rule:

• use DataView.RowFilter for display and binding scenarios
• use LINQ for application logic and reusable filtering rules

Both are valid. The mistake is forcing one style everywhere even when the output need is different.

Another practical difference is debuggability. LINQ conditions can be stepped through in a debugger like normal C# code, while a malformed RowFilter expression often fails at runtime with a less obvious message.

Common Pitfalls

• Writing SQL syntax into RowFilter and expecting the full SQL language to work.
• Forgetting to escape quotes when the search value comes from user input.
• Assuming RowFilter is automatically case-insensitive across all environments and data settings.
• Calling CopyToDataTable() on an empty LINQ result without handling that case first.
• Using string-based filter expressions for complex business logic that would be clearer in LINQ.

Summary

• In .NET, filter a DataTable by name with either DataView.RowFilter or LINQ.
• 'RowFilter is good for exact matches and LIKE patterns in UI-oriented code.'
• LINQ is better when the logic is more complex or should stay in normal C#.
• Use CopyToDataTable() only after checking that the filtered sequence has rows.
• Pick the filtering style that matches whether you need a view, a sequence, or a new table.