From 7a73a04b049fe2cab0332c497195e94f7eec66fc Mon Sep 17 00:00:00 2001 From: Vladimir Pecanac Date: Sun, 8 Nov 2026 14:53:35 +0100 Subject: [PATCH] Update CopyArrayElements to .NET 10 and add span, collection expression and partial copy samples --- .../BenchmarkRunner/BenchmarkRunner.csproj | 4 +- .../BenchmarkRunner/ElementCopierBenchmark.cs | 88 ++++--- .../BenchmarkRunner/Program.cs | 14 +- .../CopyArrayElements/Article.cs | 17 +- .../CopyArrayElements.csproj | 6 +- .../CopyArrayElements/ElementCopier.cs | 134 ++++++---- .../CopyArrayElements/Program.cs | 100 ++++---- .../CopyArrayElements/Tests/Tests.cs | 234 ++++++++++-------- .../CopyArrayElements/Tests/Tests.csproj | 11 +- 9 files changed, 341 insertions(+), 267 deletions(-) diff --git a/collections-arrays/CopyArrayElements/BenchmarkRunner/BenchmarkRunner.csproj b/collections-arrays/CopyArrayElements/BenchmarkRunner/BenchmarkRunner.csproj index 0bc90ec6e8..6604b9fc15 100644 --- a/collections-arrays/CopyArrayElements/BenchmarkRunner/BenchmarkRunner.csproj +++ b/collections-arrays/CopyArrayElements/BenchmarkRunner/BenchmarkRunner.csproj @@ -2,13 +2,13 @@ Exe - net6.0 + net10.0 enable enable - + diff --git a/collections-arrays/CopyArrayElements/BenchmarkRunner/ElementCopierBenchmark.cs b/collections-arrays/CopyArrayElements/BenchmarkRunner/ElementCopierBenchmark.cs index fcd1f20a2b..2012a0175f 100644 --- a/collections-arrays/CopyArrayElements/BenchmarkRunner/ElementCopierBenchmark.cs +++ b/collections-arrays/CopyArrayElements/BenchmarkRunner/ElementCopierBenchmark.cs @@ -1,53 +1,49 @@ using BenchmarkDotNet.Attributes; using CopyArrayElements; -namespace BenchmarkRunner +namespace BenchmarkRunner; + +[MemoryDiagnoser] +public class ElementCopierBenchmark { - public class ElementCopierBenchmark + private static readonly ElementCopier elementCopier = new(); + private Article[] benchMarkSourceArray = []; + + [Params(1000, 10000)] + public int Size { get; set; } + + [GlobalSetup] + public void Setup() { - Article[] benchMarkSourceArray = Enumerable.Repeat(new Article { Title = "Title", LastUpdate = DateTime.Now }, 10000).ToArray(); - private static readonly ElementCopier elementCopier = new ElementCopier(); - - [Benchmark] - public void CopyUsingAssignment() - { - elementCopier.CopyUsingAssignment(benchMarkSourceArray); - } - - [Benchmark] - public void CopyUsingArrayClass() - { - elementCopier.CopyUsingArrayClass(benchMarkSourceArray); - } - - [Benchmark] - public void CopyUsingClone() - { - elementCopier.CopyUsingClone(benchMarkSourceArray); - } - - [Benchmark] - public void CopyUsingCopyTo() - { - elementCopier.CopyUsingCopyTo(benchMarkSourceArray); - } - - [Benchmark] - public void CopyUsingRange() - { - elementCopier.CopyUsingRange(benchMarkSourceArray); - } - - [Benchmark] - public void CopyUsingLinq() - { - elementCopier.CopyUsingLinq(benchMarkSourceArray); - } - - [Benchmark] - public void ManuallyCopy() - { - elementCopier.ManuallyCopy(benchMarkSourceArray); - } + benchMarkSourceArray = Enumerable + .Repeat(new Article { Title = "Title", LastUpdate = DateTime.Now }, Size) + .ToArray(); } + + [Benchmark] + public Article[] CopyUsingAssignment() => elementCopier.CopyUsingAssignment(benchMarkSourceArray); + + [Benchmark] + public Article[] CopyUsingArrayClass() => elementCopier.CopyUsingArrayClass(benchMarkSourceArray); + + [Benchmark] + public Article[] CopyUsingClone() => elementCopier.CopyUsingClone(benchMarkSourceArray); + + [Benchmark] + public Article[] CopyUsingCopyTo() => elementCopier.CopyUsingCopyTo(benchMarkSourceArray); + + [Benchmark] + public Article[] CopyUsingRange() => elementCopier.CopyUsingRange(benchMarkSourceArray); + + [Benchmark] + public Article[] CopyUsingSpan() => elementCopier.CopyUsingSpan(benchMarkSourceArray); + + [Benchmark] + public Article[] CopyUsingCollectionExpression() => elementCopier.CopyUsingCollectionExpression(benchMarkSourceArray); + + [Benchmark] + public Article[] CopyUsingLinq() => elementCopier.CopyUsingLinq(benchMarkSourceArray); + + [Benchmark] + public Article[] ManuallyCopy() => elementCopier.ManuallyCopy(benchMarkSourceArray); } diff --git a/collections-arrays/CopyArrayElements/BenchmarkRunner/Program.cs b/collections-arrays/CopyArrayElements/BenchmarkRunner/Program.cs index 21b2fc9682..6587d0bd98 100644 --- a/collections-arrays/CopyArrayElements/BenchmarkRunner/Program.cs +++ b/collections-arrays/CopyArrayElements/BenchmarkRunner/Program.cs @@ -1,12 +1,4 @@ -using BenchmarkRunner; +using BenchmarkDotNet.Running; +using BenchmarkRunner; -namespace BenchmarkRunner -{ - public class Program - { - static void Main(string[] args) - { - BenchmarkDotNet.Running.BenchmarkRunner.Run(); - } - } -} \ No newline at end of file +BenchmarkSwitcher.FromAssembly(typeof(ElementCopierBenchmark).Assembly).Run(args); diff --git a/collections-arrays/CopyArrayElements/CopyArrayElements/Article.cs b/collections-arrays/CopyArrayElements/CopyArrayElements/Article.cs index a8d6a9e0d4..dc4c27aa32 100644 --- a/collections-arrays/CopyArrayElements/CopyArrayElements/Article.cs +++ b/collections-arrays/CopyArrayElements/CopyArrayElements/Article.cs @@ -1,13 +1,12 @@ -namespace CopyArrayElements +namespace CopyArrayElements; + +public class Article { - public class Article - { - public string? Title { get; set; } - public DateTime LastUpdate { get; set; } + public string? Title { get; set; } + public DateTime LastUpdate { get; set; } - public override string ToString() - { - return $" Title: { Title} | Last update:{LastUpdate}"; - } + public override string ToString() + { + return $" Title: {Title} | Last update: {LastUpdate:yyyy-MM-dd}"; } } diff --git a/collections-arrays/CopyArrayElements/CopyArrayElements/CopyArrayElements.csproj b/collections-arrays/CopyArrayElements/CopyArrayElements/CopyArrayElements.csproj index 79e7148fd0..dfb40caafc 100644 --- a/collections-arrays/CopyArrayElements/CopyArrayElements/CopyArrayElements.csproj +++ b/collections-arrays/CopyArrayElements/CopyArrayElements/CopyArrayElements.csproj @@ -2,13 +2,9 @@ Exe - net6.0 + net10.0 enable enable - - - - diff --git a/collections-arrays/CopyArrayElements/CopyArrayElements/ElementCopier.cs b/collections-arrays/CopyArrayElements/CopyArrayElements/ElementCopier.cs index f713bc8829..3d4cf2a91f 100644 --- a/collections-arrays/CopyArrayElements/CopyArrayElements/ElementCopier.cs +++ b/collections-arrays/CopyArrayElements/CopyArrayElements/ElementCopier.cs @@ -1,61 +1,109 @@ -namespace CopyArrayElements +namespace CopyArrayElements; + +public class ElementCopier { - public class ElementCopier + public Article[] CopyUsingAssignment(Article[] initialArray) { - public Article[] CopyUsingAssignment(Article[] initialArray) - { - var destinationArray = initialArray; + var destinationArray = initialArray; - return destinationArray; - } + return destinationArray; + } - public Article[] CopyUsingArrayClass(Article[] initialArray) - { - var destinationArray = new Article[initialArray.Length]; - Array.Copy(initialArray, destinationArray, initialArray.Length); + public Article[] CopyUsingArrayClass(Article[] initialArray) + { + var destinationArray = new Article[initialArray.Length]; + Array.Copy(initialArray, destinationArray, initialArray.Length); - return destinationArray; - } + return destinationArray; + } - public Article[] CopyUsingClone(Article[] initialArray) - { - var destinationArray = initialArray.Clone(); + public Article[] CopyPartUsingArrayClass(Article[] initialArray) + { + var destinationArray = new Article[initialArray.Length]; + Array.Copy(initialArray, 1, destinationArray, 0, initialArray.Length - 1); - return (Article[])destinationArray; - } + return destinationArray; + } - public Article[] CopyUsingCopyTo(Article[] initialArray) - { - var destinationArray = new Article[initialArray.Length]; - initialArray.CopyTo(destinationArray, 0); + public Article[] CopyPartUsingRange(Article[] initialArray) + { + var destinationArray = initialArray[1..3]; - return (Article[])destinationArray; - } + return destinationArray; + } - public Article[] CopyUsingRange(Article[] initialArray) - { - var destinationArray = initialArray[..]; + public Article[] CopyUsingClone(Article[] initialArray) + { + var destinationArray = (Article[])initialArray.Clone(); - return destinationArray; - } + return destinationArray; + } - public Article[] CopyUsingLinq(Article[] initialArray) - { - var destinationArray = initialArray - .Select(x => new Article { Title = x.Title, LastUpdate = x.LastUpdate }) - .ToArray(); + public Article[] CopyUsingCopyTo(Article[] initialArray) + { + var destinationArray = new Article[initialArray.Length]; + initialArray.CopyTo(destinationArray, 0); - return destinationArray; - } + return destinationArray; + } - public Article[] ManuallyCopy(Article[] initialArray) - { - var destinationArray = new Article[initialArray.Length]; + public Article[] CopyUsingRange(Article[] initialArray) + { + var destinationArray = initialArray[..]; + + return destinationArray; + } + + public Article[] CopyUsingSpan(Article[] initialArray) + { + var destinationArray = new Article[initialArray.Length]; + initialArray.AsSpan().CopyTo(destinationArray); + + return destinationArray; + } + + public Article[] CopyPartUsingSpan(Article[] initialArray) + { + var destinationArray = new Article[initialArray.Length]; + initialArray.AsSpan(1, 2).CopyTo(destinationArray); + + return destinationArray; + } + + public Article[] CopyUsingCollectionExpression(Article[] initialArray) + { + Article[] destinationArray = [.. initialArray]; + + return destinationArray; + } + + public Article[] CopyUsingToArray(Article[] initialArray) + { + var destinationArray = initialArray.ToArray(); + + return destinationArray; + } + + public Article[] CopyUsingLinq(Article[] initialArray) + { + var destinationArray = initialArray + .Select(x => new Article { Title = x.Title, LastUpdate = x.LastUpdate }) + .ToArray(); + + return destinationArray; + } + + public Article[] ManuallyCopy(Article[] initialArray) + { + var destinationArray = new Article[initialArray.Length]; - for (int index = 0; index < initialArray.Length; index++) - destinationArray[index] = new Article { Title = initialArray[index].Title, LastUpdate = initialArray[index].LastUpdate }; + for (int index = 0; index < initialArray.Length; index++) + destinationArray[index] = new Article + { + Title = initialArray[index].Title, + LastUpdate = initialArray[index].LastUpdate + }; - return destinationArray; - } + return destinationArray; } } diff --git a/collections-arrays/CopyArrayElements/CopyArrayElements/Program.cs b/collections-arrays/CopyArrayElements/CopyArrayElements/Program.cs index 999198f4a6..243bbe76b5 100644 --- a/collections-arrays/CopyArrayElements/CopyArrayElements/Program.cs +++ b/collections-arrays/CopyArrayElements/CopyArrayElements/Program.cs @@ -1,58 +1,74 @@ -using CopyArrayElements; +namespace CopyArrayElements; -namespace CopyArrayElements +public class Program { - public class Program + public static readonly ElementCopier elementCopier = new(); + public static int OutputResult = 0; + + public static void Main(string[] args) { - public static readonly ElementCopier elementCopier = new ElementCopier(); - public static int OutputResult = 0; - public static void Main(string[] args) - { - Console.WriteLine("-------------------- Copying array Elements"); - Console.WriteLine("-------------------------------------------"); + Console.WriteLine("-------------------- Copying array Elements"); + Console.WriteLine("-------------------------------------------"); + Console.WriteLine(); + + Console.WriteLine("---------- Assignment approach"); + PrintArticlesTitle(elementCopier.CopyUsingAssignment(InstantiateInitialArray())); + + Console.WriteLine("---------- Array Class Approach"); + PrintArticlesTitle(elementCopier.CopyUsingArrayClass(InstantiateInitialArray())); + + Console.WriteLine("---------- Array Class Partial Copy"); + PrintArticlesTitle(elementCopier.CopyPartUsingArrayClass(InstantiateInitialArray())); + + Console.WriteLine("---------- Clone approach"); + PrintArticlesTitle(elementCopier.CopyUsingClone(InstantiateInitialArray())); - Console.WriteLine(); - - Console.WriteLine("---------- Assignment approach"); - PrintArticlesTitle(elementCopier.CopyUsingAssignment(InstantiateInitialArray())); + Console.WriteLine("---------- CopyTo Approach"); + PrintArticlesTitle(elementCopier.CopyUsingCopyTo(InstantiateInitialArray())); - Console.WriteLine("---------- Array Class Approach"); - PrintArticlesTitle(elementCopier.CopyUsingArrayClass(InstantiateInitialArray())); + Console.WriteLine("---------- Copy Using Range Approach"); + PrintArticlesTitle(elementCopier.CopyUsingRange(InstantiateInitialArray())); - Console.WriteLine("---------- Clone approach"); - PrintArticlesTitle(elementCopier.CopyUsingClone(InstantiateInitialArray())); + Console.WriteLine("---------- Copy Part Using Range Approach"); + PrintArticlesTitle(elementCopier.CopyPartUsingRange(InstantiateInitialArray())); - Console.WriteLine("---------- CopyTo Approach"); - PrintArticlesTitle(elementCopier.CopyUsingCopyTo(InstantiateInitialArray())); + Console.WriteLine("---------- Copy Using Span Approach"); + PrintArticlesTitle(elementCopier.CopyUsingSpan(InstantiateInitialArray())); - Console.WriteLine("---------- Copy Using Range Approach"); - PrintArticlesTitle(elementCopier.CopyUsingRange(InstantiateInitialArray())); + Console.WriteLine("---------- Copy Using Collection Expression Approach"); + PrintArticlesTitle(elementCopier.CopyUsingCollectionExpression(InstantiateInitialArray())); - Console.WriteLine("---------- Copy Using Linq Approach"); - PrintArticlesTitle(elementCopier.CopyUsingLinq(InstantiateInitialArray())); + Console.WriteLine("---------- Copy Using Linq Approach"); + PrintArticlesTitle(elementCopier.CopyUsingLinq(InstantiateInitialArray())); - Console.WriteLine("---------- For Statement Approach"); - PrintArticlesTitle(elementCopier.ManuallyCopy(InstantiateInitialArray())); + Console.WriteLine("---------- For Statement Approach"); + PrintArticlesTitle(elementCopier.ManuallyCopy(InstantiateInitialArray())); - Console.WriteLine("-------------------------------------------"); - OutputResult = 1; - } + Console.WriteLine("---------- Shallow copy check"); + var source = InstantiateInitialArray(); + var copy = elementCopier.CopyUsingArrayClass(source); + copy[0].Title = "Changed through the copy"; + Console.WriteLine($" -{source[0]}"); + Console.WriteLine(); - public static Article[] InstantiateInitialArray() - { - var article1 = new Article { Title = "C# Intermediate – Delegates", LastUpdate = new DateTime(2022, 11, 07) }; - var article2 = new Article { Title = "Events in C#", LastUpdate = new DateTime(2022, 01, 22) }; - var article3 = new Article { Title = "Selection Sort in C#", LastUpdate = new DateTime(2022, 01, 13) }; + Console.WriteLine("-------------------------------------------"); + OutputResult = 1; + } - return new Article[] { article1, article2, article3 }; - } + public static Article[] InstantiateInitialArray() + { + var article1 = new Article { Title = "C# Intermediate - Delegates", LastUpdate = new DateTime(2022, 11, 07) }; + var article2 = new Article { Title = "Events in C#", LastUpdate = new DateTime(2022, 01, 22) }; + var article3 = new Article { Title = "Selection Sort in C#", LastUpdate = new DateTime(2022, 01, 13) }; - public static void PrintArticlesTitle(Article[] array) - { - foreach (var item in array) - Console.WriteLine($" -{item}"); + return [article1, article2, article3]; + } + + public static void PrintArticlesTitle(Article[] array) + { + foreach (var item in array) + Console.WriteLine($" -{item?.ToString() ?? " (empty slot)"}"); - Console.WriteLine(); - } + Console.WriteLine(); } -} \ No newline at end of file +} diff --git a/collections-arrays/CopyArrayElements/Tests/Tests.cs b/collections-arrays/CopyArrayElements/Tests/Tests.cs index 93b1dad04a..9ac07f6ba5 100644 --- a/collections-arrays/CopyArrayElements/Tests/Tests.cs +++ b/collections-arrays/CopyArrayElements/Tests/Tests.cs @@ -1,110 +1,136 @@ using CopyArrayElements; using Microsoft.VisualStudio.TestTools.UnitTesting; -namespace Tests +namespace Tests; + +[TestClass] +public class Tests { - [TestClass] - public class Tests + private readonly ElementCopier _elementCopier = new(); + + [TestMethod] + public void GivenTheClassProgram_ThenRunTheMainMethodAndWriteResultsAtTheConsole() + { + Program.Main([]); + + Assert.AreEqual(1, Program.OutputResult); + } + + [TestMethod] + public void GivenAnInitialArray_ThenReturnSameArrayUsingTheMethodCopyUsingAssignment() + { + var initialArray = Program.InstantiateInitialArray(); + + var destinationArray = _elementCopier.CopyUsingAssignment(initialArray); + + Assert.AreSame(initialArray, destinationArray); + } + + [TestMethod] + public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingArrayClass() + => AssertShallowCopy(_elementCopier.CopyUsingArrayClass); + + [TestMethod] + public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingClone() + => AssertShallowCopy(_elementCopier.CopyUsingClone); + + [TestMethod] + public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingCopyTo() + => AssertShallowCopy(_elementCopier.CopyUsingCopyTo); + + [TestMethod] + public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingRange() + => AssertShallowCopy(_elementCopier.CopyUsingRange); + + [TestMethod] + public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingSpan() + => AssertShallowCopy(_elementCopier.CopyUsingSpan); + + [TestMethod] + public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingCollectionExpression() + => AssertShallowCopy(_elementCopier.CopyUsingCollectionExpression); + + [TestMethod] + public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingToArray() + => AssertShallowCopy(_elementCopier.CopyUsingToArray); + + [TestMethod] + public void GivenAnInitialArray_ThenCopyLastTwoElementsUsingTheMethodCopyPartUsingArrayClass() { - private readonly ElementCopier _elementCopier; - - public Tests() - { - _elementCopier = new ElementCopier(); - } - - [TestMethod] - public void GivenTheClassProgram_ThenRunTheMainMethodAndWriteResultsAtTheConsole() - { - Program.Main(new string[]{ }); - - Assert.AreEqual(1, Program.OutputResult); - } - - [TestMethod] - public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingAssignment() - { - var initialArray = Program.InstantiateInitialArray(); - - var destinationArray = _elementCopier.CopyUsingAssignment(initialArray); - - Assert.AreSame(initialArray, destinationArray); - } - - [TestMethod] - public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingArrayClass() - { - var initialArray = Program.InstantiateInitialArray(); - - var destinationArray = _elementCopier.CopyUsingArrayClass(initialArray); - - //Not returning the same array - Assert.AreNotSame(initialArray, destinationArray); - //The size of both array are equals - Assert.AreEqual(initialArray.Length, destinationArray.Length); - //It made a shallow Copy - Assert.AreSame(initialArray[0], destinationArray[0]); - } - - [TestMethod] - public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingClone() - { - var initialArray = Program.InstantiateInitialArray(); - - var destinationArray = _elementCopier.CopyUsingClone(initialArray); - - Assert.AreNotSame(initialArray, destinationArray); - Assert.AreEqual(initialArray.Length, destinationArray.Length); - Assert.AreSame(initialArray[0], destinationArray[0]); - } - - [TestMethod] - public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingCopyTo() - { - var initialArray = Program.InstantiateInitialArray(); - - var destinationArray = _elementCopier.CopyUsingCopyTo(initialArray); - - Assert.AreNotSame(initialArray, destinationArray); - Assert.AreEqual(initialArray.Length, destinationArray.Length); - Assert.AreSame(initialArray[0], destinationArray[0]); - } - - [TestMethod] - public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingRange() - { - var initialArray = Program.InstantiateInitialArray(); - - var destinationArray = _elementCopier.CopyUsingRange(initialArray); - - Assert.AreNotSame(initialArray, destinationArray); - Assert.AreEqual(initialArray.Length, destinationArray.Length); - Assert.AreSame(initialArray[0], destinationArray[0]); - } - - [TestMethod] - public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodCopyUsingLinq() - { - var initialArray = Program.InstantiateInitialArray(); - - var destinationArray = _elementCopier.CopyUsingLinq(initialArray); - - Assert.AreNotSame(initialArray, destinationArray); - Assert.AreEqual(initialArray.Length, destinationArray.Length); - //In this case, we are not doing shallow copy, but deep copy - Assert.AreNotSame(initialArray[0], destinationArray[0]); - } - - [TestMethod] - public void GivenAnInitialArray_ThenReturnNewArrayUsingTheMethodManuallyCopy() - { - var initialArray = Program.InstantiateInitialArray(); - - var destinationArray = _elementCopier.ManuallyCopy(initialArray); - - Assert.AreNotSame(initialArray, destinationArray); - Assert.AreEqual(initialArray.Length, destinationArray.Length); - Assert.AreNotSame(initialArray[0], destinationArray[0]); - } + var initialArray = Program.InstantiateInitialArray(); + + var destinationArray = _elementCopier.CopyPartUsingArrayClass(initialArray); + + Assert.AreEqual(initialArray.Length, destinationArray.Length); + Assert.AreSame(initialArray[1], destinationArray[0]); + Assert.AreSame(initialArray[2], destinationArray[1]); + Assert.IsNull(destinationArray[2]); + } + + [TestMethod] + public void GivenAnInitialArray_ThenCopyIndexOneAndTwoUsingTheMethodCopyPartUsingRange() + { + var initialArray = Program.InstantiateInitialArray(); + + var destinationArray = _elementCopier.CopyPartUsingRange(initialArray); + + Assert.AreEqual(2, destinationArray.Length); + Assert.AreSame(initialArray[1], destinationArray[0]); + Assert.AreSame(initialArray[2], destinationArray[1]); + } + + [TestMethod] + public void GivenAnInitialArray_ThenCopyIndexOneAndTwoUsingTheMethodCopyPartUsingSpan() + { + var initialArray = Program.InstantiateInitialArray(); + + var destinationArray = _elementCopier.CopyPartUsingSpan(initialArray); + + Assert.AreEqual(initialArray.Length, destinationArray.Length); + Assert.AreSame(initialArray[1], destinationArray[0]); + Assert.AreSame(initialArray[2], destinationArray[1]); + Assert.IsNull(destinationArray[2]); + } + + [TestMethod] + public void GivenAnInitialArray_ThenReturnDeepCopyUsingTheMethodCopyUsingLinq() + => AssertDeepCopy(_elementCopier.CopyUsingLinq); + + [TestMethod] + public void GivenAnInitialArray_ThenReturnDeepCopyUsingTheMethodManuallyCopy() + => AssertDeepCopy(_elementCopier.ManuallyCopy); + + [TestMethod] + public void GivenAShallowCopy_WhenAnElementChangesThroughTheCopy_ThenTheSourceSeesTheChange() + { + var initialArray = Program.InstantiateInitialArray(); + var destinationArray = _elementCopier.CopyUsingArrayClass(initialArray); + + destinationArray[0].Title = "Changed through the copy"; + + Assert.AreEqual("Changed through the copy", initialArray[0].Title); + } + + private static void AssertShallowCopy(Func copy) + { + var initialArray = Program.InstantiateInitialArray(); + + var destinationArray = copy(initialArray); + + Assert.AreNotSame(initialArray, destinationArray); + Assert.AreEqual(initialArray.Length, destinationArray.Length); + Assert.AreSame(initialArray[0], destinationArray[0]); + } + + private static void AssertDeepCopy(Func copy) + { + var initialArray = Program.InstantiateInitialArray(); + + var destinationArray = copy(initialArray); + + Assert.AreNotSame(initialArray, destinationArray); + Assert.AreEqual(initialArray.Length, destinationArray.Length); + Assert.AreNotSame(initialArray[0], destinationArray[0]); + Assert.AreEqual(initialArray[0].Title, destinationArray[0].Title); } -} \ No newline at end of file +} diff --git a/collections-arrays/CopyArrayElements/Tests/Tests.csproj b/collections-arrays/CopyArrayElements/Tests/Tests.csproj index 7b46e2321f..d53e4de1b3 100644 --- a/collections-arrays/CopyArrayElements/Tests/Tests.csproj +++ b/collections-arrays/CopyArrayElements/Tests/Tests.csproj @@ -1,17 +1,18 @@  - net6.0 + net10.0 + enable enable false - - - - + + + +