Coder Legion - Recent posts tagged linq

Sequence contains no elements

Thu, 02 Jul 2026 06:40:00 +0000

Today, we're going to fix a LINQ Error: Sequence contains no elements which the programmers encounter in daily life. It usually happens when we're using the Single() or First() method to retrieve a value from a dataset. In this study blog, we'll explore why it happens and how to resolve it.

What is "Sequence contains no elements" #

This error happens we use Single() or First() to retrieve a value but the value doesn't exist in the dataset. Let's look an example:


internal class Student
    {
        private string name;
        private int age;
        private string gender;
        private string hobby;

        public Student(string name, int age, string gender, string hobby)
        {
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.hobby = hobby;
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        public string Gender
        {
            get { return gender; }
            set { gender = value; }
        }
        public string Hobby
        {
            get { return hobby; }
            set { hobby = value; }
        }
    }

First, I create a Student class with some properties.


List students = new List()
{
      new Student("Alex", 22, "Male", "Basketball"),
      new Student("Cindy", 20, "Female", "Badminton"),
      new Student("Joshua", 20, "Male", "Swimming"),
      new Student("Emily", 21, "Female", "Basketball"),
      new Student("Josely", 22, "Female", "Jogging"),
};

var result = students.Where(student => student.Name == "Alex").Single();
Console.WriteLine($"Here is the result:\n {Newtonsoft.Json.JsonConvert.SerializeObject(result)}");

Then, I create a list of Student objects in my program.cs and use the Single() to get the only Student with name Alex.

Note We need to install Newtonsoft library in the Nuget Package so that we can use it to print out the JSON string of our Student object result.

This is the result:


Here is the result:
 {"Name":"Alex","Age":22,"Gender":"Male","Hobby":"Basketball"}

Look, now we didn't get any errow because there's one Student with name Alex. Let's see another example:


List students = new List()
{
      new Student("Alex", 22, "Male", "Basketball"),
      new Student("Cindy", 20, "Female", "Badminton"),
      new Student("Joshua", 20, "Male", "Swimming"),
      new Student("Emily", 21, "Female", "Basketball"),
      new Student("Josely", 22, "Female", "Jogging"),
};

var result = students.Where(student => student.Name == "Clarence").Single();
Console.WriteLine($"Here is the result:\n {Newtonsoft.Json.JsonConvert.SerializeObject(result)}");

This is the result:


System.InvalidOperationException: 'Sequence contains no elements'

Now, the Sequence contains no elements error occurs. Let's look at another example using First() method:


List students = new List()
{
      new Student("Alex", 22, "Male", "Basketball"),
      new Student("Cindy", 20, "Female", "Badminton"),
      new Student("Joshua", 20, "Male", "Swimming"),
      new Student("Emily", 21, "Female", "Basketball"),
      new Student("Josely", 22, "Female", "Jogging"),
};

var result = students.Where(student => student.Name == "Clarence").First();
Console.WriteLine($"Here is the result:\n {Newtonsoft.Json.JsonConvert.SerializeObject(result)}");

This is the result:


System.InvalidOperationException: 'Sequence contains no elements'

Same error occurs. Why? we'll see that next.

Causes #

Let's see the different types of errors that will be thrown while using Single() or First() method:

Single():

ArgumentNullException: Thrown when the source sequence is null.
InvalidOperationException: Thrown when the no element satisfies the condition OR more than one element satisfies the condition OR the source sequence is empty.

First():

ArgumentNullException: Thrown when the source sequence is null.
InvalidOperationException: Thrown when no element satisfies the condition OR the source sequence is empty.

According to the example on previous section, both Single() and First() method are getting the same error, that's System.InvalidOperationException: 'Sequence contains no elements'. This is because both of them can't find a value that meets the condition stated in the statement! So, how can we allow our program to run while this error is catched without being thrown at the output? Let's go to the next section.

Solution #

The solution is pretty simple, that's: instead of Single() or First(), use SingleOrDefault() or FirstOrDefault(). Instead of throwing the error "Sequence contains no elements", they will return a null value if no result found. Let's say:


List students = new List()
{
      new Student("Alex", 22, "Male", "Basketball"),
      new Student("Cindy", 20, "Female", "Badminton"),
      new Student("Joshua", 20, "Male", "Swimming"),
      new Student("Emily", 21, "Female", "Basketball"),
      new Student("Josely", 22, "Female", "Jogging"),
};

var result = students.Where(student => student.Name == "Clarence").SingleOrDefault();
Console.WriteLine($"Here is the result:\n {Newtonsoft.Json.JsonConvert.SerializeObject(result)}");

This is the result:


Here is the result:
 null

and for FirstOrDefault():


List students = new List()
{
      new Student("Alex", 22, "Male", "Basketball"),
      new Student("Cindy", 20, "Female", "Badminton"),
      new Student("Joshua", 20, "Male", "Swimming"),
      new Student("Emily", 21, "Female", "Basketball"),
      new Student("Josely", 22, "Female", "Jogging"),
};

var result = students.Where(student => student.Name == "Clarence").FirstOrDefault();
Console.WriteLine($"Here is the result:\n {Newtonsoft.Json.JsonConvert.SerializeObject(result)}");

This is the result:


Here is the result:
 null

Now, we can run our program without the error: Sequence contains no elements in the output. Although the condition is not met, we still can get a default object, which is null. Looks, the solution is pretty simple right?

Tip You can also execute some codes based on the object returned or return NotFound() if you're using ControllerBase.

For instance:


List students = new List()
{
      new Student("Alex", 22, "Male", "Basketball"),
      new Student("Cindy", 20, "Female", "Badminton"),
      new Student("Joshua", 20, "Male", "Swimming"),
      new Student("Emily", 21, "Female", "Basketball"),
      new Student("Josely", 22, "Female", "Jogging"),
};

var result = students.Where(student => student.Name == "Clarence").FirstOrDefault();
if(result != null)
{
    Console.WriteLine($"Here is the result:\n {Newtonsoft.Json.JsonConvert.SerializeObject(result)}");
}
else
{
    Console.WriteLine("The student is not found in the record!");
}

This is the result:


The student is not found in the record!

The Conclusion #

In this study blog, we've learned what is Sequence contains no elements in LINQ, why it happens and how to resolve it. Note that using SingleOrDefault() or FirstOrDefault() is always better as they will not throw exception and terminate the program. Instead, they can help the programmers to check the output while executing the statement. Thank you and enjoy your day! :)

The Reference #

For further information, please visit:

Serialization: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/serialization/
Single() in LINQ: https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.single?view=net-7.0
First() in LINQ: https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.first?view=net-7.0
SingleOrDefault() in LINQ: https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.singleordefault?view=net-7.0
FirstOrDefault() in LINQ: https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.firstordefault?view=net-7.0

The Architectural Friction of LINQ to DataTables

Wed, 10 Jun 2026 16:52:38 +0000

Developers frequently bridge paradigms when working with legacy systems or enterprise reporting engines. A common intersection is executing modern language-integrated queries and streaming those results back into legacy tabular memory models. Directly casting a LINQ result set into a DataSet or DataTable is not natively supported out of the box, creating an immediate architectural hurdle for developers who assume fluid interoperability within the .NET ecosystem.

Architectural Breakdown & Challenges
Lack of Direct Type Alignment: Traditional DataTables require explicit schema definitions, whereas LINQ queries frequently yield anonymous types or strongly-typed generic collections. This structural disconnect prevents direct assignment.

The CopyToDataTable Limitation: The standard .CopyToDataTable() extension method is strictly bound to IEnumerable. When your LINQ query projects customized object shapes or specific property subsets, this method throws compilation errors.

Performance and Memory Overhead: Forcing structural conversion requires iterating through objects, parsing metadata via reflection, and manually mapping fields into data rows. This execution path risks high CPU utilization and heavy garbage collection pressure when processing massive datasets.

Implementing the Optimal Solution
To solve this friction, developers must implement custom reflection-driven mapping utilities or leverage standard dynamic data tables. The modern, efficient way to bridge this gap involves creating a generic extension method that dynamically builds a schema from any collection of objects.

C#
using System;
using System.Collections.Generic;
using System.Data;
using System.Reflection;

public static class DataTableExtensions
{

public static DataTable ToDataTable<T>(this IEnumerable<T> items)
{
    DataTable dataTable = new DataTable(typeof(T).Name);

    // Get all public properties of the type
    PropertyInfo[] Props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);

    // Define table schema based on property types
    foreach (PropertyInfo prop in Props)
    {
        // Handling nullable types correctly
        Type propType = prop.PropertyType;
        if (propType.IsGenericType && propType.GetGenericTypeDefinition() == typeof(Nullable<>))
        {
            propType = Nullable.GetUnderlyingType(propType);
        }
        dataTable.Columns.Add(prop.Name, propType);
    }

    // Hydrate data table rows
    foreach (T item in items)
    {
        var values = new object[Props.Length];
        for (int i = 0; i < Props.Length; i++)
        {
            values[i] = Props[i].GetValue(item, null) ?? DBNull.Value;
        }
        dataTable.Rows.Add(values);
    }
    
    return dataTable;
}

}
Dynamic Schema Generation: The generic extension reads object property metadata at runtime, ensuring your DataTable mirrors your LINQ projection perfectly without manual column definitions.

Handling Nullable Types: The implementation explicitly checks for nullable value types, preventing standard initialization crashes when database fields contain missing or optional data.

Streamlined Dataset Population: By calling .ToDataTable() directly on your LINQ query variable, the resulting standalone data table can be cleanly added to a broader DataSet container using standard .Tables.Add() methods.

Visit our official site: www.nextbigcreative.com

Filling a DataSet or a DataTable from a LINQ Query Result Set

Tue, 09 Jun 2026 04:50:51 +0000

Modern .NET development often relies on LINQ (Language Integrated Query) to retrieve, filter, and transform data efficiently. LINQ provides a clean and readable way to work with collections, databases, XML files, and many other data sources. However, there are situations where applications still require traditional ADO.NET objects such as DataSet and DataTable for reporting, legacy integrations, or data binding purposes.

Understanding how to fill a DataSet or DataTable from a LINQ query result set is an important skill when working with both modern and legacy .NET applications.

Why Convert LINQ Results to DataTable or DataSet?

LINQ queries typically return collections such as IEnumerable, IQueryable, or List. While these structures are excellent for application logic, some components require DataTable or DataSet objects.

Common scenarios include:

Reporting tools that accept DataTable as a data source.
Legacy applications built around ADO.NET.
Exporting data to Excel or CSV.
Binding data to older UI controls.
Data exchange between different application layers.

Converting LINQ results into DataTable structures bridges the gap between modern querying techniques and traditional data handling mechanisms.

Understanding LINQ Query Results

Consider a simple list of employees:

var employees = new List
{

new Employee { Id = 1, Name = "John", Department = "IT" },
new Employee { Id = 2, Name = "Sarah", Department = "HR" },
new Employee { Id = 3, Name = "David", Department = "IT" }

};

A LINQ query might look like:

var result = from emp in employees

         where emp.Department == "IT"
         select emp;

This query returns a collection of Employee objects. To use this data in older systems, we may need to populate a DataTable.

Creating a DataTable from LINQ Results

The first step is creating the structure of the DataTable.

DataTable dt = new DataTable();

dt.Columns.Add("Id", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));

After defining the columns, populate rows from the LINQ result.

foreach (var employee in result)
{

dt.Rows.Add(
    employee.Id,
    employee.Name,
    employee.Department
);

}

This approach gives complete control over the schema and data population process.

Using CopyToDataTable()

When LINQ operates directly on DataTable rows, .NET provides a built-in extension method called CopyToDataTable().

Example:

DataTable employeesTable = GetEmployeesTable();

var filteredRows =

from row in employeesTable.AsEnumerable()
where row.Field<string>("Department") == "IT"
select row;

DataTable resultTable = filteredRows.CopyToDataTable();

This method automatically creates a new DataTable and copies matching rows.

Benefits include:

Less code.
Faster implementation.
Preserves schema automatically.

CopyToDataTable() is often the easiest solution when querying existing DataTable objects.

Filling a DataSet with LINQ Results

A DataSet can contain multiple DataTables.

Create a DataSet:

DataSet ds = new DataSet();

Add the DataTable:

ds.Tables.Add(dt);

You can also add multiple tables:

DataTable employeeTable = GetEmployeeData();
DataTable departmentTable = GetDepartmentData();

DataSet companyDataSet = new DataSet();

companyDataSet.Tables.Add(employeeTable);
companyDataSet.Tables.Add(departmentTable);

DataSets are useful when managing related tables and complex reporting structures.

Generic Method for Converting LINQ Results to DataTable

A reusable generic solution can save development time.

public static DataTable ToDataTable(IEnumerable data)
{

DataTable table = new DataTable(typeof(T).Name);

PropertyInfo[] properties =
    typeof(T).GetProperties();

foreach (PropertyInfo property in properties)
{
    table.Columns.Add(
        property.Name,
        Nullable.GetUnderlyingType(property.PropertyType)
        ?? property.PropertyType);
}

foreach (T item in data)
{
    DataRow row = table.NewRow();

    foreach (PropertyInfo property in properties)
    {
        row[property.Name] =
            property.GetValue(item) ?? DBNull.Value;
    }

    table.Rows.Add(row);
}

return table;

}

Usage:

var employeesDataTable = ToDataTable(result);

This generic approach works with virtually any LINQ result collection.

Performance Considerations

When dealing with large datasets, performance becomes important.

Best practices include:

Filter data at the database level whenever possible.
Avoid unnecessary DataTable conversions.
Use projections to select only required columns.
Minimize reflection usage in high-performance scenarios.
Cache metadata when repeatedly converting objects.

Example projection:

var result =

employees.Select(e => new
{
    e.Id,
    e.Name
});

This reduces memory consumption and processing overhead.

Common Challenges

Developers often encounter issues such as:

Empty Query Results
if(result.Any())
{

DataTable table = result.CopyToDataTable();

}

Calling CopyToDataTable() on an empty collection can throw an exception.

Null Values

Always handle null values properly:

row["Name"] =

employee.Name ?? DBNull.Value;

Data Type Mismatches

Ensure DataTable column types match source object properties to prevent runtime errors.

Careful validation helps maintain data integrity and application stability.

Real-World Applications

Many enterprise applications still rely heavily on DataTables and DataSets.

Typical use cases include:

Financial reporting systems.
Inventory management platforms.
Business intelligence dashboards.
Legacy Windows Forms applications.
Data export utilities.
Integration with third-party reporting engines.

LINQ provides modern querying capabilities, while DataTable and DataSet maintain compatibility with established enterprise workflows.

Conclusion

Filling a DataSet or DataTable from a LINQ query result set allows developers to combine the readability and flexibility of LINQ with the compatibility and structure of ADO.NET. Whether using manual row population, CopyToDataTable(), or generic conversion methods, understanding these techniques can significantly improve data processing workflows.

As organizations continue modernizing their applications, developers frequently encounter environments where both LINQ and traditional ADO.NET coexist. Mastering the conversion between these technologies ensures smoother integrations, cleaner code, and more maintainable enterprise applications.

Sumita
Web Developer

Coder Legion - Recent posts tagged linq

Sequence contains no elements

Table of Contents:

What is "Sequence contains no elements" #

Causes #

Single():

First():

Solution #

The Conclusion #

The Reference #

The Architectural Friction of LINQ to DataTables

Filling a DataSet or a DataTable from a LINQ Query Result Set