C# List.Shuffle方法代码示例

        public void ShuffleTest()
        {
            List<int> orderedNumbers = new List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            List<int> unorderedNumbers = orderedNumbers.Shuffle().ToList();

            Assert.AreNotEqual(orderedNumbers, unorderedNumbers);
        }

        public void GetRandomElementsFromListShufflingTest()
        {
            List<int> l = new List<int>(10);
            for (int i = 0; i < 10; i++)
                l.Add(i);

            l.Shuffle();
        }

 public void TestShuffle()
 {
     var test = new List<int>() { 25, 67, 10, 88, 35124, 6524, 5, 125, 654, 56, 1, 5451, 15211, 22101, 65121, 1254, 15121, 210, 310, 510, 610, 710, 810, 910 };
     var r = test.Shuffle().ToList();
     var orderChanged = false;
     for(var i = 0; i < test.Count(); i++)
     {
         if (test[i] != r[i]) continue;
         orderChanged = true;
         break;
     }
     Assert.IsTrue(orderChanged);
 }

        public void TestShuffle3Items()
        {
            List<int> original = new List<int>() { 0, 1, 2 };

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();

            List<int> shuffled = original.Shuffle();

            stopwatch.Stop();
            Console.WriteLine(string.Format("Shuffling 3 items took {0} milliseconds or {1} ticks", stopwatch.ElapsedMilliseconds, stopwatch.ElapsedTicks));

            CollectionAssert.AllItemsAreUnique(shuffled);
            for (int index = 0; index < shuffled.Count; index++) {
                Assert.AreNotEqual(original[index], shuffled[index]);
            }
        }

        public void EnumerableExtensionsTests_Shuffle_OrderIsShuffled()
        {
            // Arrange
            var list = new List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

            // Act
            var result = list.Shuffle().ToList();

            // Assert
            for (var i = 0; i < result.Count; i++)
            {
                if (list[i] != result[i])
                {
                    return;
                }
            }

            Assert.Fail("List has not been shuffled.");
        }

        public void ResumeInAllDirections()
        {
            List<TransferItem> allItems = AllTransferDirectionTest.GetTransformItemsForAllDirections(resume: true);

            int fileCount = expectedFileNodes.Keys.Count;

            // Execution and store checkpoints
            CancellationTokenSource tokenSource = new CancellationTokenSource();

            var transferContext = new TransferContext();
            var progressChecker = new ProgressChecker(fileCount, 1024 * fileCount);
            transferContext.ProgressHandler = progressChecker.GetProgressHandler();
            allItems.ForEach(item =>
            {
                item.CancellationToken = tokenSource.Token;
                item.TransferContext = transferContext;
            });

            var options = new TestExecutionOptions<DMLibDataInfo>();
            options.DisableDestinationFetch = true;

            // Checkpoint names
            const string PartialStarted = "PartialStarted",
                         AllStarted = "AllStarted",
                         AllStartedAndWait = "AllStartedAndWait",
                         BeforeCancel = "BeforeCancel",
                         AfterCancel = "AfterCancel";
            Dictionary<string, TransferCheckpoint> checkpoints = new Dictionary<string, TransferCheckpoint>();

            TransferItem randomItem = allItems[random.Next(0, allItems.Count)];

            randomItem.AfterStarted = () =>
            {
                Test.Info("Store check point after transfer item: {0}.", randomItem.ToString());
                checkpoints.Add(PartialStarted, transferContext.LastCheckpoint);
            };

            options.AfterAllItemAdded = () =>
                {
                    progressChecker.DataTransferred.WaitOne();
                    checkpoints.Add(AllStarted, transferContext.LastCheckpoint);
                    Thread.Sleep(1000);
                    checkpoints.Add(AllStartedAndWait, transferContext.LastCheckpoint);
                    Thread.Sleep(1000);
                    checkpoints.Add(BeforeCancel, transferContext.LastCheckpoint);
                    tokenSource.Cancel();
                    checkpoints.Add(AfterCancel, transferContext.LastCheckpoint);
                };

            var result = this.RunTransferItems(allItems, options);

            // Resume with stored checkpoints in random order
            var checkpointList = new List<KeyValuePair<string,TransferCheckpoint>>();
            checkpointList.AddRange(checkpoints);
            checkpointList.Shuffle();

            foreach(var pair in checkpointList)
            {
                Test.Info("===Resume with checkpoint '{0}'===", pair.Key);
                options = new TestExecutionOptions<DMLibDataInfo>();
                options.DisableDestinationFetch = true;

                progressChecker.Reset();
                transferContext = new TransferContext(DMLibTestHelper.RandomReloadCheckpoint(pair.Value))
                {
                    ProgressHandler = progressChecker.GetProgressHandler(),

                    // The checkpoint can be stored when DMLib doesn't check overwrite callback yet.
                    // So it will case an skip file error if the desination file already exists and 
                    // We don't have overwrite callback here.
                    OverwriteCallback = DMLibInputHelper.GetDefaultOverwiteCallbackY()
                };

                TransferEventChecker eventChecker = new TransferEventChecker();
                eventChecker.Apply(transferContext);

                List<TransferItem> itemsToResume = allItems.Select(item =>
                {
                    TransferItem itemToResume = item.Clone();
                    itemToResume.TransferContext = transferContext;
                    return itemToResume;
                }).ToList();

                result = this.RunTransferItems(itemsToResume, options);

                foreach (DMLibDataType destDataType in DataTypes)
                {
                    DataAdaptor<DMLibDataInfo> destAdaptor = GetSourceAdaptor(destDataType);
                    DMLibDataInfo destDataInfo = destAdaptor.GetTransferDataInfo(string.Empty);

                    foreach (FileNode destFileNode in destDataInfo.EnumerateFileNodes())
                    {
                        string fileName = destFileNode.Name;
                        FileNode sourceFileNode = expectedFileNodes[fileName];
                        Test.Assert(DMLibDataHelper.Equals(sourceFileNode, destFileNode), "Verify transfer result.");
                    }
                }

                Test.Assert(result.Exceptions.Count == 0, "Verify no error happens. Actual: {0}", result.Exceptions.Count);
            }
//.........这里部分代码省略.........

 public void Test_Shuffle()
 {
     var list = new List<int> { 1, 2, 3 };
     var newList = list.Shuffle().ToList();
     Assert.IsFalse((newList[0] == list[0]).And(newList[1] == list[1]).And(newList[2] == list[2]));
 }

 public void ShuffleTestNull()
 {
     var nulls = new List<string> { null, null, null };
     nulls.Shuffle();
 }

 public void ShuffleTestEmpty()
 {
     var ints = new List<int>();
     ints.Shuffle();
 }

        public void VoxelMaterialAssetsGenerateFixed()
        {
            SpaceEngineersCore.LoadDefinitions();
            var materials = SpaceEngineersCore.Resources.GetMaterialList();
            Assert.IsTrue(materials.Count > 0, "Materials should exist. Has the developer got Space Engineers installed?");

            var files = new[] { @".\TestAssets\Arabian_Border_7.vx2", @".\TestAssets\cube_52x52x52.vx2" };

            foreach (var fileOriginal in files)
            {
                foreach (var material in materials)
                {
                    var fileNewVoxel =
                        Path.Combine(Path.GetDirectoryName(Path.GetFullPath(fileOriginal)),
                            Path.GetFileNameWithoutExtension(fileOriginal) + "_" + material.Id.SubtypeId + ".vx2").ToLower();

                    var voxelMap = new MyVoxelMap();
                    voxelMap.Load(fileOriginal, materials[0].Id.SubtypeId);

                    IList<byte> materialAssets;
                    Dictionary<byte, long> materialVoxelCells;
                    voxelMap.CalculateMaterialCellAssets(out materialAssets, out materialVoxelCells);

                    var distribution = new[] { Double.NaN, .99, };
                    var materialSelection = new byte[] { 0, SpaceEngineersCore.Resources.GetMaterialIndex(material.Id.SubtypeId) };

                    var newDistributiuon = new List<byte>();
                    int count;
                    for (var i = 1; i < distribution.Count(); i++)
                    {
                        count = (int)Math.Floor(distribution[i] * materialAssets.Count); // Round down.
                        for (var j = 0; j < count; j++)
                        {
                            newDistributiuon.Add(materialSelection[i]);
                        }
                    }
                    count = materialAssets.Count - newDistributiuon.Count;
                    for (var j = 0; j < count; j++)
                    {
                        newDistributiuon.Add(materialSelection[0]);
                    }

                    newDistributiuon.Shuffle();

                    voxelMap.SetMaterialAssets(newDistributiuon);
                    voxelMap.Save(fileNewVoxel);
                }
            }
        }

        public void VoxelMaterialAssetsRandom()
        {
            SpaceEngineersCore.LoadDefinitions();
            var materials = SpaceEngineersCore.Resources.GetMaterialList();
            Assert.IsTrue(materials.Count > 0, "Materials should exist. Has the developer got Space Engineers installed?");

            var stoneMaterial = materials.FirstOrDefault(m => m.Id.SubtypeId.Contains("Stone_05"));
            Assert.IsNotNull(stoneMaterial, "Stone material should exist.");
            var goldMaterial = materials.FirstOrDefault(m => m.Id.SubtypeId.Contains("Gold"));
            Assert.IsNotNull(goldMaterial, "Gold material should exist.");
            var uraniumMaterial = materials.FirstOrDefault(m => m.Id.SubtypeId.Contains("Uraninite_01"));
            Assert.IsNotNull(uraniumMaterial, "Uranium material should exist.");

            const string fileOriginal = @".\TestAssets\Arabian_Border_7.vx2";
            const string fileNewVoxel = @".\TestOutput\Arabian_Border_7_mixed.vx2";

            var voxelMap = new MyVoxelMap();
            voxelMap.Load(fileOriginal, materials[0].Id.SubtypeId);
            IList<byte> materialAssets;
            Dictionary<byte, long> materialVoxelCells;
            voxelMap.CalculateMaterialCellAssets(out materialAssets, out materialVoxelCells);

            Assert.AreEqual(35465, materialAssets.Count, "Asset count should be equal.");

            var distribution = new[] { Double.NaN, .5, .25 };
            var materialSelection = new[] { SpaceEngineersCore.Resources.GetMaterialIndex(stoneMaterial.Id.SubtypeId), SpaceEngineersCore.Resources.GetMaterialIndex(goldMaterial.Id.SubtypeId), SpaceEngineersCore.Resources.GetMaterialIndex(uraniumMaterial.Id.SubtypeId) };

            var newDistributiuon = new List<byte>();
            int count;
            for (var i = 1; i < distribution.Count(); i++)
            {
                count = (int)Math.Floor(distribution[i] * materialAssets.Count); // Round down.
                for (var j = 0; j < count; j++)
                {
                    newDistributiuon.Add(materialSelection[i]);
                }
            }
            count = materialAssets.Count - newDistributiuon.Count;
            for (var j = 0; j < count; j++)
            {
                newDistributiuon.Add(materialSelection[0]);
            }

            newDistributiuon.Shuffle();

            var assetNameCount = voxelMap.CountAssets(newDistributiuon);

            Assert.AreEqual(3, assetNameCount.Count, "Asset Mertials count should be equal.");
            Assert.AreEqual(8867, assetNameCount[stoneMaterial.Id.SubtypeId], "Asset Mertials count should be equal.");
            Assert.AreEqual(17732, assetNameCount[goldMaterial.Id.SubtypeId], "Asset Mertials count should be equal.");
            Assert.AreEqual(8866, assetNameCount[uraniumMaterial.Id.SubtypeId], "Asset Mertials count should be equal.");

            voxelMap.SetMaterialAssets(newDistributiuon);

            voxelMap.CalculateMaterialCellAssets(out materialAssets, out materialVoxelCells);
            var cellCount = voxelMap.SumVoxelCells();

            voxelMap.Save(fileNewVoxel);
        }

        private void PrepareCloudFileWithDifferentSizeRange(CloudFile cloudFile)
        {
            List<int> ranges = new List<int>();
            List<int> gaps = new List<int>();

            // Add one 4MB - 16MB range
            ranges.Add(random.Next(4 * 1024 * 1024, 16 * 1024 * 1024));

            // Add one 1B range
            ranges.Add(1);

            int remainingPageNumber = random.Next(10, 20);

            // Add ten - twenty 1B - 4MB range
            for (int i = 0; i < remainingPageNumber; ++i)
            {
                ranges.Add(random.Next(1, 4 * 1024 * 1024));
            }

            // Add one 4M - 8M gap
            gaps.Add(random.Next(4 * 1024 * 1024, 8 * 1024 * 1024));

            // Add 512B - 2048B gaps
            for (int i = 1; i < ranges.Count - 1; ++i)
            {
                gaps.Add(random.Next(1, 512 * 4));
            }

            if (DMLibTestContext.DestType == DMLibDataType.PageBlob)
            {
                int totalSize = ranges.Sum() + gaps.Sum();
                int remainder = totalSize % 512;

                if (remainder != 0)
                {
                    ranges[ranges.Count - 1] += 512 - remainder;
                }
            }

            ranges.Shuffle();
            gaps.Shuffle();

            CloudFileHelper.GenerateCloudFileWithRangedData(cloudFile, ranges, gaps);
        }

        private void PreparePageBlobWithDifferenSizePage(CloudPageBlob pageBlob)
        {
            List<int> ranges = new List<int>();
            List<int> gaps = new List<int>();

            // Add one 4MB - 16MB page, align with 512 byte
            ranges.Add(random.Next(4 * 2 * 1024, 16 * 2 * 1024) * 512);

            // Add one 512B page
            ranges.Add(512);

            int remainingPageNumber = random.Next(10, 20);

            // Add ten - twenty 512B - 4MB page, align with 512 byte
            for (int i = 0; i < remainingPageNumber; ++i)
            {
                ranges.Add(random.Next(1, 4 * 2 * 1024) * 512);
            }

            // Add one 4M - 8M gap, align with 512 byte
            gaps.Add(random.Next(4 * 2 * 1024, 8 * 2 * 1024) * 512);

            // Add 512B - 2048B gaps, align with 512 byte
            for (int i = 1; i < ranges.Count - 1; ++i)
            {
                gaps.Add(random.Next(1, 5) * 512);
            }

            ranges.Shuffle();
            gaps.Shuffle();

            CloudBlobHelper.GeneratePageBlobWithRangedData(pageBlob, ranges, gaps);
        }

 public void Shuffle()
 {
     var items = new List<string> { "a", "b", "c", "d", "e" };
     items.Shuffle();
 }

        public void ShuffleWithProvidedRandomGenerator()
        {
            var items = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };

            using(var random = (new MockSecureRandomForShuffle()))
            {
                items.Shuffle(random);
            }

            CollectionAssert.AreEqual(new List<int> { 7, 5, 4, 3, 1, 8, 2, 6 }, items);
        }