Checking if a property in a list of objects is equal for all items

Question

This question is quite similar to this C# question, but rather than them all being equal to a particular known value, I want to know if they are all the same as each other no matter what that value is.

My list contains numerous objects such as:

public MyClass {
    public int Id { get; set; }
    public string MyProperty { get; set;}
}

My initial approach was:

List<MyClass> MyList = new List<MyClass>();
//... Add some values

string firstResult = MyList.First().MyProperty;
return MyList.All(x => x.MyProperty.Equals(firstResult))

But I feel there is a more elegant way to do this?

Answer 1

What you have is fine. It's essentially equivalent to:

var firstResult = MyList[0].MyProperty;
bool allSame = true;
foreach (var entry in MyList)
{
    if (!entry.MyProperty.Equals(firstResult)
    {
        allSame = false;
        break;
    }
}

...just with much less code.

In order to test that they all have the same value you need to know what one of the object's value is, which is why you'll always need to get the "first" value and use that as the comparison (though, obviously, it doesn't matter if it's the first, last, middle, etc, as long as it's an index that exists).

Depending on your need, you could use either GroupBy or DistinctBy. When you're dealing with Lists this is less of a concern, but if you're using regular IEnumerables it means you need to compute the source multiple times.

var countOfMyProperties = MyList.GroupBy(x => x.MyProperty).Count();
// 1 = all the same
// >1 = not all the same

Using GroupBy allows you to ask the natural follow-up question "well, if not all of my objects have the same MyProperty value, how many distinct values are there (a "group"), and how many objects are in each group?"

Also, I'd recommend using x.MyProperty == firstResult rather than x.MyProperty.Equals(firstResult), if possible.

Answer 2

(Just summing up, please give credit to the orginal answer ;-) )

In C#, you can use LINQ to check if all elements in a list have the same property value. Here are three different ways to do it:

1. Using the All method:

   The All method checks whether all elements in a collection satisfy a condition. In this case, the condition is that the property of each element is equal to the property of the first element.

   bool are_all_properties_same<T, TProp>(List<T> items, Func<T, TProp> propertySelector)
   {
       var first_property_value = propertySelector(items[0]);
       return items.All(item => propertySelector(item).Equals(first_property_value));
   }
   

2. Using the GroupBy method:

   The GroupBy method groups elements in a collection by a key. In this case, the key is the property of each element. If there is only one group, it means all properties are the same.

   bool are_all_properties_same<T, TProp>(List<T> items, Func<T, TProp> propertySelector)
   {
       return items.GroupBy(propertySelector).Count() == 1;
   }
   

3. Using the Distinct method:

   The Distinct method returns distinct elements from a collection. In this case, it returns distinct properties. If there is only one distinct property, it means all properties are the same.

   bool are_all_properties_same<T, TProp>(List<T> items, Func<T, TProp> propertySelector)
   {
       return items.Select(propertySelector).Distinct().Count() == 1;
   }
   

You can use these methods like this:

List<MyObject> myObjects = ...;
bool are_all_properties_same = are_all_properties_same(myObjects, myObject => myObject.MyProperty);

Keep in mind that only the 1. ("All") method stops at the first mismatch. The other two will go through the whole list!