Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -1,4 +1,21 @@
using BenchmarkDotNet.Running;
using RandomizeGenericListsInCSharp;

var summary = BenchmarkRunner.Run<RandomizeGenericListsMethods>();
if (args.Length > 0)
{
BenchmarkSwitcher.FromAssembly(typeof(RandomizeGenericListsBenchmarks).Assembly).Run(args);
return;
}

var methods = new RandomizeGenericListsMethods();
string[] orders = ["123", "132", "213", "231", "312", "321"];

PrintCounts("Fisher-Yates", methods.CountOrders(methods.GenerateRandomLoop, 60_000));
PrintCounts("Random.Shuffle", methods.CountOrders(methods.GenerateRandomShuffle, 60_000));
PrintCounts("Biased loop", methods.CountOrders(methods.GenerateBiasedLoop, 60_000));

void PrintCounts(string name, Dictionary<string, int> counts)
{
var line = string.Join(" ", orders.Select(o => $"{o}: {counts.GetValueOrDefault(o),6}"));
Console.WriteLine($"{name,-15}{line}");
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,43 @@
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Order;

namespace RandomizeGenericListsInCSharp;

[InProcess]
[MemoryDiagnoser]
[Orderer(SummaryOrderPolicy.FastestToSlowest)]
[RankColumn]
public class RandomizeGenericListsBenchmarks
{
private readonly RandomizeGenericListsMethods _methods = new();
private List<int> _orderedList = [];
private List<int> _listToShuffle = [];

[GlobalSetup]
public void GlobalSetup()
{
_orderedList = _methods.OrderedInts(1_000_000);
}

// The in-place shuffles change the list they get, so each iteration starts from a fresh ordered copy.
[IterationSetup(Targets = [nameof(GenerateRandomLoop), nameof(GenerateRandomShuffle)])]
public void ResetList()
{
_listToShuffle = new List<int>(_orderedList);
}

[Benchmark]
public List<int> GenerateRandomLoop() => _methods.GenerateRandomLoop(_listToShuffle);

[Benchmark]
public List<int> GenerateRandomShuffle() => _methods.GenerateRandomShuffle(_listToShuffle);

[Benchmark]
public List<int> GenerateLinqShuffle() => _methods.GenerateLinqShuffle(_orderedList);

[Benchmark]
public List<int> GenerateRandomOrderBy() => _methods.GenerateRandomOrderBy(_orderedList);

[Benchmark]
public List<int> GenerateRandomOrderByGuid() => _methods.GenerateRandomOrderByGuid(_orderedList);
}
Original file line number Diff line number Diff line change
Expand Up @@ -2,13 +2,13 @@

<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net7.0</TargetFramework>
<TargetFramework>net11.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>

<ItemGroup>
<PackageReference Include="BenchmarkDotNet" Version="0.13.2" />
<PackageReference Include="BenchmarkDotNet" Version="0.15.8" />
</ItemGroup>

</Project>
Original file line number Diff line number Diff line change
@@ -1,66 +1,93 @@
using BenchmarkDotNet.Attributes;
using System.Runtime.InteropServices;

namespace RandomizeGenericListsInCSharp
namespace RandomizeGenericListsInCSharp;

public class RandomizeGenericListsMethods
{
[MemoryDiagnoser]
[Orderer(BenchmarkDotNet.Order.SummaryOrderPolicy.FastestToSlowest)]
[RankColumn]
public class RandomizeGenericListsMethods
private readonly Random _rand;

public RandomizeGenericListsMethods()
{
private readonly Random _rand;
_rand = new Random();
}

public RandomizeGenericListsMethods()
{
_rand = new Random();
}
public IEnumerable<List<int>> SampleList()
public List<int> GenerateRandomLoop(List<int> listToShuffle)
{
for (int i = listToShuffle.Count - 1; i > 0; i--)
{
yield return OrderedInts(1000000);
var k = _rand.Next(i + 1);
var value = listToShuffle[k];
listToShuffle[k] = listToShuffle[i];
listToShuffle[i] = value;
}

[ArgumentsSource(nameof(SampleList))]
[Benchmark]
public List<int> GenerateRandomLoop(List<int> listToShuffle)
return listToShuffle;
}

public List<int> GenerateRandomShuffle(List<int> listToShuffle)
{
_rand.Shuffle(CollectionsMarshal.AsSpan(listToShuffle));

return listToShuffle;
}

public List<int> GenerateLinqShuffle(List<int> listToShuffle)
{
var shuffledList = listToShuffle.Shuffle().ToList();

return shuffledList;
}

public List<int> GenerateRandomOrderBy(List<int> listToShuffle)
{
var shuffledList = listToShuffle.OrderBy(_ => _rand.Next()).ToList();

return shuffledList;
}

public List<int> GenerateRandomOrderByGuid(List<int> listToShuffle)
{
var shuffledList = listToShuffle.OrderBy(_ => Guid.NewGuid()).ToList();

return shuffledList;
}

// Don't do this: it picks k from the entire list, so some orders come up more often than others.
public List<int> GenerateBiasedLoop(List<int> listToShuffle)
{
for (int i = listToShuffle.Count - 1; i >= 0; i--)
{
for (int i = listToShuffle.Count - 1; i > 0; i--)
{
var k = _rand.Next(i + 1);
var value = listToShuffle[k];
listToShuffle[k] = listToShuffle[i];
listToShuffle[i] = value;
}

return listToShuffle;
var k = _rand.Next(listToShuffle.Count);
var value = listToShuffle[k];
listToShuffle[k] = listToShuffle[i];
listToShuffle[i] = value;
}

[ArgumentsSource(nameof(SampleList))]
[Benchmark]
public List<int> GenerateRandomOrderBy(List<int> listToShuffle)
{
var shuffledList = listToShuffle.OrderBy(_ => _rand.Next()).ToList();
return listToShuffle;
}

return shuffledList;
}
public Dictionary<string, int> CountOrders(Func<List<int>, List<int>> shuffle, int runs)
{
var counts = new Dictionary<string, int>();

[ArgumentsSource(nameof(SampleList))]
[Benchmark]
public List<int> GenerateRandomOrderByGuid(List<int> listToShuffle)
for (int run = 0; run < runs; run++)
{
var shuffledList = listToShuffle.OrderBy(_ => Guid.NewGuid()).ToList();

return shuffledList;
var order = string.Concat(shuffle([1, 2, 3]));
counts[order] = counts.GetValueOrDefault(order) + 1;
}

public List<int> OrderedInts(int size)
{
var numbers = new List<int>();
return counts;
}

for (int i = 0; i < size; i++)
{
numbers.Add(i);
}
public List<int> OrderedInts(int size)
{
var numbers = new List<int>();

return numbers;
for (int i = 0; i < size; i++)
{
numbers.Add(i);
}

return numbers;
}
}
}
Original file line number Diff line number Diff line change
@@ -1,18 +1,18 @@
<Project Sdk="Microsoft.NET.Sdk">

<PropertyGroup>
<TargetFramework>net7.0</TargetFramework>
<TargetFramework>net11.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>

<IsPackable>false</IsPackable>
</PropertyGroup>

<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
<PackageReference Include="MSTest.TestAdapter" Version="2.2.10" />
<PackageReference Include="MSTest.TestFramework" Version="2.2.10" />
<PackageReference Include="coverlet.collector" Version="3.1.2" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.12.0" />
<PackageReference Include="MSTest.TestAdapter" Version="4.5.3" />
<PackageReference Include="MSTest.TestFramework" Version="4.5.3" />
<PackageReference Include="coverlet.collector" Version="10.1.0" />
</ItemGroup>

<ItemGroup>
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -15,49 +15,73 @@ public RandomizeGenericListsUnitTests()
}

[TestMethod]
public void GivenAnOrderedList_WhenNotEmpty_VerifyShuffleGuid()
public void GivenAnOrderedList_WhenNotEmpty_VerifyShuffleLoop()
{
var shuffledList = _randomizeListObj.GenerateRandomOrderByGuid(_orderedList);
var listToShuffle = new List<int>(_orderedList);

var firstVal = shuffledList.First();
var lastVal = shuffledList.Last();

Assert.AreNotEqual(firstVal, 0);
Assert.AreNotEqual(lastVal, 999999);
var shuffledList = _randomizeListObj.GenerateRandomLoop(listToShuffle);

Assert.AreSame(listToShuffle, shuffledList);
CollectionAssert.AreEquivalent(_orderedList, shuffledList);
CollectionAssert.AreNotEqual(_orderedList, shuffledList);
}

[TestMethod]
public void GivenAnOrderedList_WhenNotEmpty_VerifyShuffleLoop()
public void GivenAnOrderedList_WhenNotEmpty_VerifyRandomShuffle()
{
var shuffledList = _randomizeListObj.GenerateRandomLoop(_orderedList);
var listToShuffle = new List<int>(_orderedList);

var firstVal = shuffledList.First();
var lastVal = shuffledList.Last();
var shuffledList = _randomizeListObj.GenerateRandomShuffle(listToShuffle);

Assert.AreNotEqual(firstVal, 0);
Assert.AreNotEqual(lastVal, 999999);
Assert.AreSame(listToShuffle, shuffledList);
CollectionAssert.AreEquivalent(_orderedList, shuffledList);
CollectionAssert.AreNotEqual(_orderedList, shuffledList);
}

[TestMethod]
public void GivenAnOrderedList_WhenNotEmpty_VerifyLinqShuffle()
{
var shuffledList = _randomizeListObj.GenerateLinqShuffle(_orderedList);

Assert.AreNotSame(_orderedList, shuffledList);
CollectionAssert.AreEquivalent(_orderedList, shuffledList);
CollectionAssert.AreNotEqual(_orderedList, shuffledList);
}

[TestMethod]
public void GivenAnOrderedList_WhenNotEmpty_VerifyRandomOrderby()
{
var shuffledList = _randomizeListObj.GenerateRandomOrderBy(_orderedList);

var firstVal = shuffledList.First();
var lastVal = shuffledList.Last();
Assert.AreNotSame(_orderedList, shuffledList);
CollectionAssert.AreEquivalent(_orderedList, shuffledList);
CollectionAssert.AreNotEqual(_orderedList, shuffledList);
}

[TestMethod]
public void GivenAnOrderedList_WhenNotEmpty_VerifyShuffleGuid()
{
var shuffledList = _randomizeListObj.GenerateRandomOrderByGuid(_orderedList);

Assert.AreNotEqual(firstVal, 0);
Assert.AreNotEqual(lastVal, 999999);
Assert.AreNotSame(_orderedList, shuffledList);
CollectionAssert.AreEquivalent(_orderedList, shuffledList);
CollectionAssert.AreNotEqual(_orderedList, shuffledList);
}

[TestMethod]
public void GivenAnInteger_WhenListIsEmpty_VerifyOrderedListGenerated()
public void GivenAThreeElementList_WhenShuffledManyTimes_VerifyFisherYatesProducesEveryOrder()
{
var firstVal = _orderedList.First();
var lastVal = _orderedList.Last();
var counts = _randomizeListObj.CountOrders(_randomizeListObj.GenerateRandomLoop, 60_000);

Assert.AreEqual(firstVal, 0);
Assert.AreEqual(lastVal, 999999);
Assert.IsInstanceOfType(_orderedList, typeof(List<int>));
Assert.HasCount(6, counts);
Assert.AreEqual(60_000, counts.Values.Sum());
}

[TestMethod]
public void GivenAnInteger_WhenListIsEmpty_VerifyOrderedListGenerated()
{
Assert.AreEqual(0, _orderedList.First());
Assert.AreEqual(999999, _orderedList.Last());
Assert.HasCount(1000000, _orderedList);
}
}
}
Loading