List.Sort also requires stable ordering, if once you have said a>b it must always return that. Linqs OrderBy(x=>random.Next()) will work however. Fisher-Yates is useful if you just want n random elements from a list that is much larger than n elements.

I realize this is quick-and-dirty and broken code, but I still think there are few things worth pointing out about it:

1. Repeatedly calling new Random() will work fine on .Net Core 2.0+, but not on older frameworks (including .Net Framework).
2. Providing a non-deterministic delegate to List<T>.Sort() can cause all sorts of problems and does not guarantee a reasonable result.
3. Fisher-Yates is the optimal solution, but assigning a random number to each value and sorting by that will also work and is easier to implement and understand: list.OrderBy(_ => new Random().Next()). (And non-deterministic delegate is okay in this case, because Enumerable.OrderBy caches the keys, while List<T>.Sort does not cache the results of the comparison.)

The reverse for for Fisher-Yates, you picked as an example, is such a weird implementation. Works perfectly fine with an increasing for:

public static void Shuffle<T>(List<T> list)
{
    var rnd = new Random();
    for (int i = 0; i < list.Count; i++)
    {
        var ri = rnd.Next(i, list.Count);
        T val = list[i];
        list[i] = list[ri];
        list[ri] = val;
    }
}

The stack overflow example you are pointing to is quite badly broken. It used to be correct implementation, but as of the last edit on Nov 18, 2019 it's completely broken. What's especially funny, "Try this code" link contains test case which does a nice job to hide the problem with the code.

In the linked code, after 1 shuffle last element of the array will be either N with probability of (N-1)/N) or 1 (1/N)

list = list.OrderBy(_ => Guid.NewGuid()).ToList()