I'm having trouble writing a method that returns true if the elements of an array (numbers) are in sorted order, ascending or descending, and false, if they are not in any sorted order. I can return a correct boolean value if the array is ascending but i do not know how to check for descending order as well in the same method. I currently have:

```
public static bool IsArraySorted(int[] numbers)
{
for (int i = 1; i < numbers.Length; i++)
{
if (numbers[i - 1] > numbers[i])
{
return false;
}
}
return true;
}
```

Anyone able to offer help on how to check for a sorted descending array as well? Cheers!

# Best How To :

It should be something like:

```
public static bool IsArraySorted(int[] numbers)
{
bool? ascending = null;
for (int i = 1; i < numbers.Length; i++)
{
if (numbers[i - 1] != numbers[i])
{
bool ascending2 = numbers[i - 1] < numbers[i];
if (ascending == null)
{
ascending = ascending2;
}
else if (ascending.Value != ascending2)
{
return false;
}
}
}
return true;
}
```

Note the use of the `ascending`

variable to save the "direction" of the array. It is initialized the first time two elements that are different are found.

Note that if you want, you can even return the "direction" of the array:

```
public static bool IsArraySorted(int[] numbers, out bool isAscending)
{
isAscending = true;
bool? ascending = null;
```

and inside the `if (ascending == null)`

```
if (ascending == null)
{
ascending = ascending2;
isAscending = ascending2;
}
```

This is a generic version based on `IEnumerable<TSource>`

:

```
public static bool IsSorted<TSource>(IEnumerable<TSource> source, out bool isAscending, Comparer<TSource> comparer = null)
{
isAscending = true;
if (comparer == null)
{
comparer = Comparer<TSource>.Default;
}
bool first = true;
TSource previous = default(TSource);
bool? ascending = null;
foreach (TSource current in source)
{
if (!first)
{
int cmp = comparer.Compare(previous, current);
if (cmp != 0)
{
bool ascending2 = cmp < 0;
if (ascending == null)
{
ascending = ascending2;
isAscending = ascending2;
}
else if (ascending.Value != ascending2)
{
return false;
}
}
}
first = false;
previous = current;
}
return true;
}
```

Note the use of `bool first`

/`TSource previous`

to handle the `i - 1`

(and the fact that the `for`

cycle was able to "skip" the first element)