Like Math.Max but takes 3 or params of int?

thanks

Well, you can just call it twice:

```
int max3 = Math.Max(x, Math.Max(y, z));
```

If you find yourself doing this a lot, you could always write your own helper method… I would be happy enough seeing this in my code base *once*, but not regularly.

(Note that this is likely to be more efficient than Andrew’s LINQ-based answer – but obviously the more elements you have the more appealing the LINQ approach is.)

EDIT: A “best of both worlds” approach might be to have a custom set of methods either way:

```
public static class MoreMath
{
// This method only exists for consistency, so you can *always* call
// MoreMath.Max instead of alternating between MoreMath.Max and Math.Max
// depending on your argument count.
public static int Max(int x, int y)
{
return Math.Max(x, y);
}
public static int Max(int x, int y, int z)
{
// Or inline it as x < y ? (y < z ? z : y) : (x < z ? z : x);
// Time it before micro-optimizing though!
return Math.Max(x, Math.Max(y, z));
}
public static int Max(int w, int x, int y, int z)
{
return Math.Max(w, Math.Max(x, Math.Max(y, z)));
}
public static int Max(params int[] values)
{
return Enumerable.Max(values);
}
}
```

That way you can write `MoreMath.Max(1, 2, 3)`

or `MoreMath.Max(1, 2, 3, 4)`

without the overhead of array creation, but still write `MoreMath.Max(1, 2, 3, 4, 5, 6)`

for nice readable and consistent code when you don’t mind the overhead.

I personally find that more readable than the *explicit* array creation of the LINQ approach.

You could use `Enumerable.Max`

:

```
new [] { 1, 2, 3 }.Max();
```

Linq has a Max function.

If you have an `IEnumerable<int>`

you can call this directly, but if you require these in separate parameters you could create a function like this:

```
using System.Linq;
...
static int Max(params int[] numbers)
{
return numbers.Max();
}
```

Then you could call it like this: `max(1, 6, 2)`

, it allows for an arbitrary number of parameters.

As generic

```
public static T Min<T>(params T[] values) {
return values.Min();
}
public static T Max<T>(params T[] values) {
return values.Max();
}
```

off topic but here is the formula for middle value.. just in case someone is looking for it

```
Math.Min(Math.Min(Math.Max(x,y), Math.Max(y,z)), Math.Max(x,z));
```

Let’s assume that You have a `List<int> intList = new List<int>{1,2,3}`

if You want to get a max value You could do

```
int maxValue = intList.Max();
```

If, for whatever reason (e.g. Space Engineers API), System.array has no definition for Max nor do you have access to Enumerable, a solution for Max (or Min) of *n* values is:

```
public int Max(int[] values) {
if(values.Length < 1) {
return 0;
}
if(values.Length < 2) {
return values[0];
}
if(values.Length < 3) {
return Math.Max(values[0], values[1]);
}
int runningMax = values[0];
for(int i=1; i<values.Length - 1; i++) {
runningMax = Math.Max(runningMax, values[i]);
}
return runningMax;
}
```

Tags: c++