var s = new[] {1, 3, 3, 7, 9};
var r = s.Aggregate(new {V=int.MinValue, C=0}, (a, val) => a.V < val ? new {V=val, C=a.C+1} : a).C == s.Length;

var ascending = Enumerate()
                .Memoize(1)
                .Let(e => e.Zip(e.Skip(1), (a, b) => a < b))
                .All(x => x);

var isAscending = xs.OrderBy(x => x).SequenceEqual(xs);

var isAscending = xs.Replay(ys => ys.Zip(ys.Skip(1), (x, y) => x <= y), 1).All(x => x);

var numbers = new[] {1, 3, 5, 7, 9};
bool isAscending = true;

int temp = numbers[0];

for (int i = 1; i < numbers.Length; i++)
{
    if (temp > numbers[i])
    {
        isAscending = false;
        break;
    }

    temp = numbers[i];
}

let rec f = function 
  | a::b::_  when a > b   -> false
  | h::t                  -> f t
  | _                     -> true

Помня одно предыдущее значение, соедини последовательность с самой собой, смещённой с на один элемент вперёд, и проверь, что во всех парах левое значение меньше или равно правому.

0K>var numbers = new[] {1, 3, 5, 7, 9};
0K>bool isAscending = true;

0K>int temp = numbers[0];

0K>for (int i = 1; i < numbers.Length; i++)
0K>{
0K>    if (temp > numbers[i])
0K>    {
0K>        isAscending = false;
0K>        break;
0K>    }

0K>    temp = numbers[i];
0K>}
0K>

var e = true; for (var i = 1; i < xs.Length; i++) if (xs[i-1] > xs[i]) e = false;
var isAscending = e;

pure auto f(int Arr[])
{
    if(Arr.length < 2)
        return true;
    
    if(Arr[0] > Arr[1])
        return false;
    
    return f(Arr[1 .. $]);
}

    if(Arr.length < 2)
00402017  push        ebx  
00402018  push        esi  
00402019  mov         esi,dword ptr [esp+2Ch] 
0040201D  cmp         esi,2 
00402020  push        edi  
00402021  jae         main@f+21h (402031h) 
        return true;
00402023  pop         edi  
00402024  mov         eax,1 
00402029  pop         esi  
0040202A  pop         ebx  
0040202B  add         esp,20h 
0040202E  ret         8    
    
    if(Arr[0] > Arr[1])
00402031  mov         edx,ecx 
00402033  mov         ebx,dword ptr [edx] 
00402035  mov         eax,esi 
00402037  cmp         ebx,dword ptr [edx+4] 
0040203A  jle         main@f+37h (402047h) 
        return false;
0040203C  pop         edi  
0040203D  xor         eax,eax 
0040203F  pop         esi  
00402040  pop         ebx  
00402041  add         esp,20h 
00402044  ret         8    
    
    return f(Arr[1 .. $]);
00402047  lea         edi,[esi-1] 
0040204A  add         edx,4 
0040204D  mov         ecx,edx 
0040204F  mov         dword ptr [esp+0Ch],edi 
00402053  mov         esi,edi 
00402055  mov         dword ptr [esp+10h],edx 
00402059  cmp         dword ptr [esp+0Ch],2 
0040205E  jb          main@f+13h (402023h) 
00402060  jmp         main@f+21h (402031h)

bool isOrdered = true;

enumerator.MoveNext();
var temp = enumerator.Current;

while (enumerator.MoveNext())
{
    if (temp > enumerator.Current)
    {
        isOrdered = false;
        break;
    }

    temp = enumerator.Current;
}

bool o = true; e.MoveNext();
var temp = e.Current;
while (e.MoveNext()){ if (temp > e.Current) { o = false; break; } temp = e.Current; }