Elegant Implementation and Performance Analysis for Checking Uniform Values in C# Lists

Problem Background and Requirements Analysis

In C# programming, it is often necessary to check the consistency of collection data. A common scenario is: given a list, if all elements have the same value, return that value; otherwise, return a specified "other value". Additionally, when the list is empty, it should also return the "other value". While this problem seems simple, implementation requires consideration of code conciseness, readability, and performance.

Core Solution: Combining LINQ's All and First Methods

Based on the highly-rated Stack Overflow answer, the most elegant solution combines LINQ's All and First methods. Here is the refactored code implementation:

public T GetUniformValueOrOther<T>(IEnumerable<T> collection, T otherValue)
{
    if (collection == null || !collection.Any())
        return otherValue;

    T firstValue = collection.First();
    return collection.All(item => EqualityComparer<T>.Default.Equals(item, firstValue)) 
           ? firstValue 
           : otherValue;
}

The core logic of this implementation consists of three steps: first, check if the collection is empty or null and directly return otherValue; then, obtain the first element as a reference value; finally, use the All method to check if all elements are equal to the reference value. Here, EqualityComparer<T>.Default is used to ensure correct comparison for generic types, enhancing the code's versatility.

Performance Optimization and Execution Details

The original answer highlights an important performance consideration: if the First() call is inlined into the All expression, it will be executed multiple times, significantly degrading performance. By explicitly storing the firstValue variable, we ensure that First() is called only once. This optimization is particularly important for large collections, as the First() method needs to traverse the collection until the first element is found.

Alternative Approach: Analysis of the Distinct Method

Another common solution uses the Distinct method:

collection.Distinct().Count() == 1

This method determines whether all elements are the same by checking if the count of unique elements after deduplication is 1. While the code is more concise, it has two potential issues: first, the Distinct method requires creating an additional hash table to store unique elements, increasing memory overhead; second, for large collections, the complete deduplication operation may be less efficient than the short-circuit evaluation of the All method (which stops upon finding a mismatch). Therefore, in performance-sensitive scenarios, the All-First combination is usually the better choice.

Edge Case Handling

This solution fully addresses various edge cases:

• Empty Collection: Through the !collection.Any() check, it ensures that an empty collection returns otherValue.
• Null Reference: Explicitly checks collection == null to avoid null reference exceptions.
• Single-Element Collection: When the collection has only one element, the All method directly returns true, which is logically correct.
• Generic Support: Uses EqualityComparer<T>.Default to ensure correct comparison for various data types, including custom types.

Practical Applications and Extensions

This pattern can be extended to more complex scenarios. For example, if checking whether a specific property is consistent across a collection of objects:

public TProperty GetUniformPropertyOrOther<TItem, TProperty>(IEnumerable<TItem> items, 
                                                           Func<TItem, TProperty> selector, 
                                                           TProperty otherValue)
{
    if (items == null || !items.Any())
        return otherValue;

    TProperty firstProperty = selector(items.First());
    return items.All(item => EqualityComparer<TProperty>.Default.Equals(selector(item), firstProperty))
           ? firstProperty 
           : otherValue;
}

This extended version uses a selector function to extract property values, enabling more flexible consistency checks.

Conclusion

By combining LINQ's All and First methods, we can implement a solution that is both concise and efficient for checking collection element consistency. Key optimizations include: avoiding repeated calls to First(), correctly handling empty collections and null references, and using generic comparators to ensure type safety. While the Distinct method offers more concise syntax, the All-First combination is generally superior in performance-critical applications. This pattern demonstrates how careful API selection and micro-optimizations can balance code conciseness with execution efficiency.