If you have a collection of objects and you want to find the object with the maximum value of a specific property, you can use the `.Max()`

method in C#. However, the `.Max()`

method only returns the maximum value, not the entire object. In this blog post, we will explore different approaches to perform `.Max()`

on a property of all objects in a collection and return the object with the maximum value.

## Approach 1: Using the `.Max()`

Method and a Lambda Expression

The simplest approach is to use the `.Max()`

method along with a lambda expression to specify the property on which you want to find the maximum value. Here’s an example:

```
var item = items.Max(x => x.Height);
```

In this example, `items`

is the collection of objects, and `Height`

is the property on which we want to find the maximum value. The `.Max()`

method will iterate through the collection and return the maximum value of the `Height`

property.

However, this approach only gives us the maximum value, not the object itself. To get the object with the maximum value, we need to use a different approach.

## Approach 2: Using the MoreLINQ Library

If you want to get the object with the maximum value, you can use the MoreLINQ library, which provides an extension method called `.MaxBy()`

. This method allows you to specify a projection that determines the value to compare for finding the maximum.

To use the `.MaxBy()`

method, you need to install the MoreLINQ library via NuGet. Once installed, you can use the following code:

```
var item = items.MaxBy(x => x.Height);
```

In this example, `items`

is the collection of objects, and `Height`

is the property on which we want to find the maximum value. The `.MaxBy()`

method will iterate through the collection, remember the maximum element seen so far, and return the object with the maximum value of the `Height`

property.

Compared to other solutions, using the `.MaxBy()`

method from MoreLINQ has several advantages:

- It has a time complexity of O(n), which means it is more efficient than other solutions that have a time complexity of O(n^2) or O(n log n).
- It evaluates the projection only once per element, making it more efficient than solutions that iterate over the sequence multiple times.
- It is simpler to read and understand compared to the aggregate version.

## Example Scenario

Let’s consider an example scenario to illustrate how to use the `.MaxBy()`

method. Suppose we have a collection of `Person`

objects, and we want to find the person with the maximum age.

```
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
var people = new List<Person>
{
new Person { Name = "John", Age = 25 },
new Person { Name = "Jane", Age = 30 },
new Person { Name = "Mike", Age = 28 }
};
var personWithMaxAge = people.MaxBy(x => x.Age);
```

In this example, we have a collection of `Person`

objects with their names and ages. By using the `.MaxBy()`

method, we can find the person with the maximum age. The `personWithMaxAge`

variable will contain the `Person`

object with the maximum age.

## Conclusion

Performing `.Max()`

on a property of all objects in a collection and returning the object with the maximum value can be achieved using the `.MaxBy()`

method from the MoreLINQ library. This method provides a simple and efficient way to find the object with the maximum value of a specific property. By using this approach, you can easily solve similar problems in your C# projects.