C# | How to Check Whether a List Contains a Specified Element

In C#, the List<T> class is a commonly used data structure for storing and managing collections of elements. One of the frequently required operations is to determine whether a specific element exists within a List. This blog post will explore different ways to achieve this in C#, along with best practices and example usage.

Table of Contents#

Using the Contains Method#

The simplest and most straightforward way to check if a List contains an element is by using the Contains method.

How it Works#

The Contains method of the List<T> class takes an element as an argument and returns a bool value (true if the element is found in the list, false otherwise). It uses the default equality comparer for the type T (for reference types, it checks for reference equality; for value types, it checks for value equality).

Example#

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
bool containsThree = numbers.Contains(3);
Console.WriteLine(containsThree); // Output: True

Using the Exists Method#

The Exists method is another option. It takes a Predicate<T> (a delegate that represents a method that defines a set of criteria and returns bool) as an argument.

How it Works#

It iterates through each element in the list and applies the provided predicate. If the predicate returns true for any element, the Exists method returns true; otherwise, it returns false. This is useful when you need to perform more complex checks, like checking properties of an object (if T is a custom class).

Example#

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
 
List<Person> people = new List<Person>
{
    new Person { Name = "Alice", Age = 25 },
    new Person { Name = "Bob", Age = 30 }
};
 
bool existsAlice = people.Exists(p => p.Name == "Alice");
Console.WriteLine(existsAlice); // Output: True

Using LINQ's Any Method#

If you have the LINQ (Language Integrated Query) namespace (System.Linq) included, you can use the Any method.

How it Works#

Similar to the Exists method, Any can take a lambda expression (or a method that can be converted to a Func<T, bool>). It returns true if at least one element in the sequence (the List in this case) satisfies the condition specified in the lambda expression.

Example#

List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
bool hasApple = fruits.Any(f => f == "Apple");
Console.WriteLine(hasApple); // Output: True

Best Practices#

  • For Simple Equality Checks: Use the Contains method when you just need to check for the presence of an element based on the default equality comparison (e.g., for simple value types like int, string in basic scenarios).
  • For Complex Conditions: When dealing with custom objects and more elaborate checks (like checking multiple properties), prefer the Exists or Any methods. The Any method is especially handy when you're already using LINQ in other parts of your codebase as it integrates well with LINQ's query syntax.
  • Performance Considerations: For very large lists, if you find yourself doing a lot of containment checks, you might consider using a HashSet<T> instead (it has an O(1) average time complexity for Contains operations compared to List<T>'s O(n) in the worst case). But if you need the ordered nature and other list-specific features, stick with List<T> and choose the appropriate method.

Example Usage#

Let's create a more comprehensive example that demonstrates all three methods in a single scenario.

using System;
using System.Collections.Generic;
using System.Linq;
 
class Program
{
    static void Main()
    {
        List<int> numbersList = new List<int> { 10, 20, 30, 40, 50 };
 
        // Using Contains
        bool containsTwenty = numbersList.Contains(20);
        Console.WriteLine($"Contains (20): {containsTwenty}");
 
        // Using Exists (with a lambda for a custom check - let's say check if number is even)
        bool existsEven = numbersList.Exists(n => n % 2 == 0);
        Console.WriteLine($"Exists (even number): {existsEven}");
 
        // Using Any (with LINQ - check if number is greater than 45)
        bool anyGreaterThan45 = numbersList.Any(n => n > 45);
        Console.WriteLine($"Any (greater than 45): {anyGreaterThan45}");
    }
}

References#

2026-06