Checking if List<T> Contains Elements with Specific Property Values in C#

Introduction

In C# programming, List<T> stands as one of the most commonly used collection types. Practical development frequently requires checking whether elements satisfying specific conditions exist within lists, particularly conditions based on object properties. This article uses the PricePublicModel class as an example to thoroughly examine the implementation principles and application scenarios of various checking methods.

Problem Context and Data Model

Consider the following business scenario: we have a list of price public models and need to check whether any element exists with a Size property equal to 200. The PricePublicModel class is defined as follows:

public class PricePublicModel
{
    public PricePublicModel() { }

    public int PriceGroupID { get; set; }
    public double Size { get; set; }
    public double Size2 { get; set; }
    public int[] PrintType { get; set; }
    public double[] Price { get; set; }
}

List<PricePublicModel> pricePublicList = new List<PricePublicModel>();

FindIndex Method: Locating Element Index

The FindIndex method provides a powerful search capability within the List<T> class, returning the index of the first element satisfying the specified condition. If a matching element is found, it returns its index (starting from 0); if no match is found, it returns -1.

int index = pricePublicList.FindIndex(item => item.Size == 200);
if (index >= 0) 
{
    // Element exists, perform corresponding operations
    PricePublicModel foundItem = pricePublicList[index];
    Console.WriteLine($"Element found at index position: {index}");
}

The advantage of FindIndex lies in它不仅 confirming element existence but also providing specific positional information. This proves particularly useful when subsequent operations (such as modification, deletion, or position-based logic processing) are required.

Any Method: Concise Existence Checking

LINQ's Any method offers a more concise approach to existence checking, especially suitable for scenarios where only existence confirmation is needed without concern for specific positions.

bool contains = pricePublicList.Any(p => p.Size == 200);
if (contains)
{
    Console.WriteLine("List contains element with Size equal to 200");
}

Any method returns a boolean value, making the code more straightforward and clear. As a LINQ extension method, it requires importing the System.Linq namespace.

Exists Method: Traditional Existence Checking

Exists is an instance method of the List<T> class, functionally similar to Any but without requiring additional LINQ references.

if (pricePublicList.Exists(x => x.Size == 200))
{
    Console.WriteLine("Element exists");
}

Performance Analysis and Method Selection

All three methods share O(n) time complexity but offer distinct advantages in different scenarios:

• FindIndex: Optimal choice when index information is needed, providing the richest information set
• Any: Pure boolean checking, most concise code, part of the LINQ ecosystem
• Exists: Traditional approach, LINQ-independent, suitable for simple scenarios

Advanced Applications: Complex Condition Queries

In practical applications, query conditions often become more complex. Multiple conditions can be combined for comprehensive searching:

// Multi-condition query
int index = pricePublicList.FindIndex(item => 
    item.Size == 200 && 
    item.PriceGroupID == 1 &&
    item.PrintType != null && 
    item.PrintType.Length > 0);

// Range query
bool hasLargeSize = pricePublicList.Any(p => p.Size > 150 && p.Size < 250);

// Array property query
bool hasSpecificPrintType = pricePublicList.Exists(x => 
    x.PrintType != null && 
    x.PrintType.Contains(1));

Error Handling and Edge Cases

Various edge cases must be considered in practical usage:

try
{
    // Empty list check
    if (pricePublicList == null || !pricePublicList.Any())
    {
        Console.WriteLine("List is empty or uninitialized");
        return;
    }
    
    // Safe query operation
    int index = pricePublicList.FindIndex(item => 
        item != null && item.Size == 200);
        
    if (index >= 0)
    {
        // Process found element
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error occurred during query: {ex.Message}");
}

Comparison with Dictionary Structure

Although Dictionary was mentioned as a potential alternative, the two serve different purposes:

• List<T>: Suitable for sequential access, range queries, complex condition searches
• Dictionary: Ideal for fast lookups based on unique keys, O(1) time complexity

If frequent lookups based on Size are required and Size values are unique, consider using Dictionary for performance optimization:

Dictionary<double, PricePublicModel> sizeDictionary = 
    pricePublicList.ToDictionary(item => item.Size);

if (sizeDictionary.TryGetValue(200, out PricePublicModel foundItem))
{
    // Quickly locate element
}

Best Practices Summary

Based on the above analysis, the following best practices can be summarized:

1. Use FindIndex when index information is required
2. Use Any (LINQ projects) or Exists (non-LINQ projects) for pure existence checking
3. Employ Lambda expression combinations for complex query conditions
4. Consider null reference and edge case handling
5. Select appropriate data structures based on access patterns

By judiciously selecting search methods, developers can create C# code that is both efficient and maintainable.