How to Randomize a List<T> in C#

By the end of this page, you will understand how to shuffle a List<T> in C# using the correct approach, why some randomization techniques are biased or inefficient, and how to apply a proper shuffle in real applications such as games, lotteries, quizzes, and randomized processing.

Randomizing a list means reordering its elements so the order is unpredictable. In C#, this is commonly called shuffling a list.

The most important idea is that not all “random-looking” solutions are equally correct. A good shuffle should:

• Move every item exactly once into a new random position
• Give all possible orderings a fair chance
• Run efficiently, especially for larger lists

The standard algorithm for this is the Fisher-Yates shuffle. It works by walking backward through the list and swapping each element with a randomly chosen earlier element, including itself.

Why this matters:

• In a lottery-style app, you want each number to be equally likely to appear first, second, third, and so on.
• In games, biased shuffling can make results unfair.
• In testing or data processing, predictable or poor randomization can produce misleading outcomes.

A common beginner mistake is to sort by a random key, such as using OrderBy(x => random.Next()). This may look convenient, but it is not the best tool for a true shuffle and can be less efficient and potentially biased depending on collisions and implementation details.

So the core concept behind this question is not just “how do I randomize a list,” but how do I shuffle a list correctly and fairly in C#.

Imagine you have a deck of numbered cards.

You start at the last card position and say:

• "Pick any card from position 0 to this position."
• Swap it into the current spot.
• Move one position left and repeat.

This is like filling the list from the end backward, choosing a random remaining item each time.

Why this model is useful:

• At each step, you only choose from items not already locked into place.
• Once a position is filled, you never disturb it again.
• This guarantees a fair shuffle when done correctly.

So instead of “mixing everything around randomly,” think of shuffling as placing one random remaining item into each final position.

The classic way to shuffle a List<T> in C# is to use the Fisher-Yates algorithm.

using System;
using System.Collections.Generic;

public static class ListExtensions
{
    public static void Shuffle<T>(this List<T> list, Random rng)
    {
        for (int i = list.Count - 1; i > 0; i--)
        {
            int j = rng.Next(i + 1);
            (list[i], list[j]) = (list[j], list[i]);
        }
    }
}

Example usage:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var numbers = new List<int>();

        for (int i = 1; i <= 75; i++)
        {
            numbers.Add(i);
        }

        var rng =  Random();
        numbers.Shuffle(rng);

         ( number  numbers)
        {
            Console.WriteLine(number);
        }
    }
}

Consider this small list:

var numbers = new List<int> { 10, 20, 30, 40 };
var rng = new Random();
numbers.Shuffle(rng);

Using the shuffle method:

public static void Shuffle<T>(this List<T> list, Random rng)
{
    for (int i = list.Count - 1; i > 0; i--)
    {
        int j = rng.Next(i + 1);
        (list[i], list[j]) = (list[j], list[i]);
    }
}

Let’s trace one possible run.

Initial list:

[10, 20, 30, 40]

Step 1

i = 3

• Randomly pick j from 0 to 3

Shuffling a list is useful in many real applications:

• Lottery or bingo apps
  • Randomize a fixed set of numbers and draw them one at a time.
• Card games
  • Shuffle a deck before dealing cards.
• Quiz applications
  • Randomize question order or answer choices.
• Music playlists
  • Play songs in a random order.
• Load balancing or task processing
  • Randomize work items to avoid fixed processing order.
• Testing and simulations
  • Randomize data to test behavior under different input sequences.

Example: drawing lottery numbers one by one

var numbers = Enumerable.Range(1, 75).ToList();
numbers.Shuffle(new Random());

foreach (var draw in numbers)
{
    Console.WriteLine($"Drawn: {draw}");
}

This approach is simple because the list is shuffled once, then consumed in order.

In real codebases, developers usually wrap shuffling logic in a reusable method or extension method so it can be applied anywhere.

Common patterns include:

Reusable extension method

This is the most common style for List<T>:

public static class ListExtensions
{
    public static void Shuffle<T>(this List<T> list, Random rng)
    {
        for (int i = list.Count - 1; i > 0; i--)
        {
            int j = rng.Next(i + 1);
            (list[i], list[j]) = (list[j], list[i]);
        }
    }
}

Validation and guard clauses

In production code, you often validate inputs early:

public static void Shuffle<T>(this List<T> list, Random rng)
{
    if (list == null)
        throw new ArgumentNullException((list));

     (rng == )
          ArgumentNullException((rng));

     ( i = list.Count - ; i > ; i--)
    {
         j = rng.Next(i + );
        (list[i], list[j]) = (list[j], list[i]);
    }
}

Here are the most common mistakes beginners make when randomizing a list in C#.

1. Creating Random repeatedly

Broken approach:

for (int i = 0; i < 10; i++)
{
    var rng = new Random();
    Console.WriteLine(rng.Next());
}

Problem:

• If Random is created many times in quick succession, it may use similar seeds.
• That can produce repeated or low-quality results.

Better:

var rng = new Random();
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(rng.Next());
}

2. Using OrderBy(x => rng.Next()) as a shuffle

Example:

var shuffled = numbers.OrderBy(x => rng.Next()).ToList();

Why this is not ideal:

• It is less direct than Fisher-Yates.
• It depends on sorting instead of true in-place shuffling.
• Random key collisions can affect fairness.

Here is how common approaches compare.

public static void Shuffle<T>(this List<T> list, Random rng)
{
    for (int i = list.Count - 1; i > 0; i--)
    {
        int j = rng.Next(i + 1);
        (list[i], list[j]) = (list[j], list[i]);
    }
}

Rules

• Use Fisher-Yates to shuffle a List<T> fairly.
• Loop from list.Count - 1 down to 1.
• Pick j with rng.Next(i + 1).
• Swap list[i] and list[j].
• Reuse a single Random instance when possible.

Preserve the original list

var copy = new List<int>(original);
copy.Shuffle(rng);

Create a list of 1 through 75

How do I shuffle a List<T> in C#?

Use the Fisher-Yates algorithm. It swaps each item with a randomly chosen earlier item, producing an efficient and fair shuffle.

Is OrderBy(x => random.Next()) a good way to randomize a list?

It may appear to work, but it is not the preferred method for a proper shuffle. Fisher-Yates is more efficient and more reliable for fair randomization.

Does shuffling a list change the original list?

Yes, if you shuffle in place. If you want to keep the original order, create a copy first and shuffle the copy.

Why should I reuse the same Random object?

Creating many Random instances quickly can lead to repeated or poor-quality random values. Reusing one instance avoids that problem.

Can I shuffle a list of any type, not just numbers?

Yes. A generic method like Shuffle<T> works with strings, objects, custom classes, and numbers.

What algorithm is typically used to shuffle a list?

The standard answer is the Fisher-Yates shuffle, sometimes called the Knuth shuffle.

How can I draw lottery numbers one at a time after shuffling?

Shuffle the list once, then read items from the beginning to the end. Each next item is the next draw.

Do I need LINQ to shuffle a list?

No. A loop with swaps is enough, and it is usually the better approach for this task.

• Random class in C# — needed to generate random indices for the shuffle.
• List<T> — the collection type being shuffled.
• Extension methods — a clean way to add Shuffle() behavior to List<T>.
• Generics — allows one shuffle method to work for any element type.
• Swapping values — the core operation used inside the shuffle.
• IEnumerable<T> vs List<T> — important because indexed collections are easier to shuffle.
• LINQ OrderBy — often used incorrectly as a shuffle substitute, so it is useful to compare.
• Algorithm complexity (O(n) vs O(n log n)) — helps explain why Fisher-Yates is preferred.