In this article, we will look at all the different ways we can clone a List in C# to another and what we should pay attention to when doing so.<\/p>\n
In C# we have ample ways of doing that, so let’s dive right in.<\/p>\n
A List<T><\/a>, which contains value types, is easy to clone as value types directly contain an instance of their type<\/strong>.\u00a0<\/p>\n As we all love pizza, we are going to be cloning a list of toppings with all the methods in this section. Now, we are going to use a string in the example even though it is not a value type but a reference type. On the other hand, it is immutable and behaves as a value type, <\/strong>so we can use it in this section:<\/p>\n Here, we define a Next, we’ll look at the options for cloning the values of that One of the overloads of the Here, we initialize a new One of those is the First, we initialize a Another method that takes in an The The Here, we directly initialize our Alternatively, we can use the We start by initializing a We don’t need a separate method to convert the element we pass in, so we simply use a lambda expression that returns the same value, hence the A bit more complex way of cloning a We create a generic Once we have done that, we go back to our With this, we create a Then we continue with:<\/p>\n We declare a To make sure that everything we have done to clone a List containing value types in C# works as intended, we can print all the results on the console:<\/p>\n And check the result:<\/p>\n Reference type variables, unlike value type ones, store a reference to the data and not the data itself<\/strong>. This means that when we work with reference types, two variables can reference the same data – the downside here is that operations on one variable can affect the data referenced by another<\/strong>.\u00a0<\/p>\n Building on the pizza trend from earlier, let’s expand on our example:<\/p>\n In a separate file, we declare a We are cloning lists, so we need one with reference types:<\/p>\n Here we declare a Now, let’s look into the two types of copying we have when dealing with reference types.<\/p>\n We can easily achieve a shallow copy of our Let’s illustrate this:<\/p>\n First, we create a Now, let’s see what happens:<\/p>\n We print the first pizza of each list to the console, which in both cases is the Margherita, using the We overrode the We can see that both the original and copied Margherita pizzas now have an empty list of This might cause serious problems for us, so let’s what we can do to prevent it.<\/p>\n The alternative is to create a<\/strong> deep copy<\/strong> – this means that<\/strong> we don’t just copy the references to the objects but create new, copied objects<\/strong>. This produces a different result than shallow copies as the objects referenced by the copied list are separate from those referenced in the original list<\/strong>.<\/p>\n We can also use the Let’s do the necessary updates:<\/p>\n We expand our Then we get on with the cloning:<\/p>\n To do this we create a A copy constructor is a constructor that takes an instance of the type as a parameter. Then the values of each property of that object are copied over to the newly created instance of that type:<\/p>\n In our Now, we can move back to our var toppings = new List<string>\r\n{\r\n \"Mozzarella\",\r\n \"Olive oil\",\r\n \"Basil\"\r\n};<\/pre>\ntoppings<\/code> variable of List<string><\/code> type, that holds the toppings for the classic Margherita pizza.<\/p>\nList<string><\/code> to another.<\/p>\n<\/a>Using the List\u2019s Constructor<\/h3>\n
List<T><\/code>‘s constructor takes in an IEnumerable<T><\/code>:<\/p>\nvar toppingsClonedWithConstructor = new List<string>(toppings);<\/code><\/p>\ntoppingsClonedWithConstructor<\/code> variable that contains the copied elements from our toppings<\/code> list.<\/p>\n<\/a>Using the List\u2019s CopyTo Method<\/h3>\n
List<T><\/code> has several methods that we can use to clone its contents to another list or collection.<\/p>\nCopyTo<\/code> method. The list inherits it from the ICollection<T><\/code> interface and it can be used to clone the List<T><\/code> to a T[]<\/code>:<\/p>\nvar toppingsClonedWithCopyTo = new string[toppings.Count];\r\ntoppings.CopyTo(toppingsClonedWithCopyTo);<\/pre>\n
toppingsClonedWithCopyTo<\/code> variable as a string[]<\/code> that has a length equal to the length of the toppings<\/code> list – hence the toppings.Count<\/code>. Then we use the CopyTo<\/code> method on the toppings<\/code> list and pass the newly initialized array as a parameter. This way its contents are copied over to toppingsClonedWithCopyTo<\/code>.<\/p>\n<\/a>Using the List\u2019s AddRange Method<\/h3>\n
IEnumerable<T><\/code> as a parameter is the AddRange<\/code> method:<\/p>\nvar toppingsClonedWithAddRange = new List<string>();\r\ntoppingsClonedWithAddRange.AddRange(toppings);<\/pre>\n
AddRange<\/code> method needs a List<T><\/code> that is already initialized, so we declare the toppingsClonedWithAddRange<\/code> variable and assign an empty List<string><\/code> to it. Then we pass the toppings<\/code> as a parameter to the AddRange<\/code> method and it clones the contents for us.<\/p>\n<\/a>Using the Enumerable’s ToList Method<\/h3>\n
System.Linq<\/code> namespace provides us with the Enumerable.ToList<\/code> method:<\/p>\nvar toppingsClonedWithToList = toppings.ToList();<\/code><\/p>\ntoppingsClonedWithToList<\/code> variable by calling the ToList<\/code> method on our already existing toppings<\/code> variable, which clones its contents to our new list.<\/p>\nEnumerable.ToArray<\/code> method in the same way if we want to clone the contents of a List<T><\/code> to T[]<\/code>.<\/p>\n<\/a>Using the ConvertAll Method<\/h3>\n
List<T><\/code> has another useful method that might look a bit daunting on the surface – this is the ConvertAll<TOutput>(Converter<T, TOutput>)<\/code> method. It converts all the members of a list from one type to another and returns a list containing the converted members. We can even use it for cloning:<\/p>\nvar toppingsClonedWithConvertAll = toppings\r\n .ConvertAll(new Converter<string, string>(x => x));<\/pre>\n
toppingsClonedWithConvertAll<\/code> variable and assigning it the value returned from using the ConvertAll<\/code> method on our toppings<\/code> list. The method takes in a\u00a0Converter<TInput, TOutput><\/code>, which is just a delegate for a method that converts an element from one type to another. It takes in the name of a method used for the conversion, or we can pass an anonymous method as well.<\/p>\nx => x<\/code>.<\/p>\n<\/a>Using the ICloneable Interface<\/h3>\n
List<T><\/code> can be achieved using the ICloneable<\/code> interface. But before we can use the interface’s Clone<\/code> method, we need to set things up:<\/p>\npublic class ToppingsList<T> : List<T>, ICloneable\r\n{\r\n public object Clone()\r\n {\r\n return this.MemberwiseClone();\r\n }\r\n}<\/pre>\nToppingsList<T><\/code> class in a new file that inherits List<T><\/code> and ICloneable<\/code>. We also implement the Clone<\/code> method by just returning the result of the Object<\/code>‘s (the ultimate base class in .NET) MemberwiseClone<\/code> method which gives us a shallow copy of the object.<\/p>\nProgram<\/code> class:<\/p>\nvar customToppingsList = new ToppingsList<string>\r\n{\r\n \"Mozzarella\",\r\n \"Olive oil\",\r\n \"Basil\" \r\n};<\/pre>\ncustomToppingsList<\/code> variable of our new generic type as ToppingsList<string><\/code> and initialize it like a regular List<string><\/code>.\u00a0<\/p>\nvar toppingsClonedWithICloneable = (ToppingsList<string>)customToppingsList.Clone();<\/code><\/p>\ntoppingsClonedWithICloneable<\/code> variable and use the Clone<\/code> method on our customToppingsList<\/code>. We also cast the result to ToppingsList<string><\/code> as the method itself returns an object<\/code>.<\/p>\nConsole.WriteLine(\"Original list: \" + string.Join(\", \", toppings));\r\nConsole.WriteLine(\"Cloned with Constructor: \" + string.Join(\", \", toppingsClonedWithConstructor));\r\nConsole.WriteLine(\"Cloned with CopyTo: \" + string.Join(\", \", toppingsClonedWithCopyTo));\r\nConsole.WriteLine(\"Cloned with AddRange: \" + string.Join(\", \", toppingsClonedWithAddRange));\r\nConsole.WriteLine(\"Cloned with ToList: \" + string.Join(\", \", toppingsClonedWithToList));\r\nConsole.WriteLine(\"Cloned with ConverAll: \" + string.Join(\", \", toppingsClonedWithConvertAll));\r\nConsole.WriteLine(\"Cloned with ICloneable: \" + string.Join(\", \", toppingsClonedWithICloneable));<\/pre>\n
Original list: Mozzarella, Olive oil, Basil\r\nCloned with Constructor: Mozzarella, Olive oil, Basil\r\nCloned with CopyTo: Mozzarella, Olive oil, Basil\r\nCloned with AddRange: Mozzarella, Olive oil, Basil\r\nCloned with ToList: Mozzarella, Olive oil, Basil\r\nCloned with ConverAll: Mozzarella, Olive oil, Basil\r\nCloned with ICloneable: Mozzarella, Olive oil, Basil<\/pre>\n
<\/a>How to Clone a List in C# That Contains Reference Types<\/h2>\n
public class Pizza\r\n{\r\n public string Name { get; set; }\r\n public List<string> Toppings { get; set; }\r\n\r\n public override string ToString()\r\n {\r\n return $\"Pizza name: {Name}; Toppings: {string.Join(\", \", Toppings)}\";\r\n }\r\n}<\/pre>\nPizza<\/code> class with two simple properties – Name<\/code> and Toppings<\/code>. We also override the ToString<\/code> method for easy visualization.\u00a0<\/p>\nvar pizzas = new List<Pizza>\r\n{\r\n new Pizza\r\n {\r\n Name= \"Margherita\",\r\n Toppings = new List<string>\r\n {\r\n \"Mozzarella\",\r\n \"Olive oil\",\r\n \"Basil\"\r\n }\r\n },\r\n new Pizza\r\n {\r\n Name= \"Diavola\",\r\n Toppings = new List<string>\r\n {\r\n \"Mozzarella\",\r\n \"Ventricina\",\r\n \"Chili peppers\"\r\n }\r\n }\r\n};<\/pre>\npizzas<\/code> variable of type List<Pizza><\/code> and add two pizzas to it.<\/p>\n<\/a>Shallow Copy<\/h3>\n
pizzas<\/code> list with any of the methods from the previous section. But a shallow copy of a List<T><\/code>, where T<\/code> is a reference type, copies only the structure of the collection and references to its elements, not the elements themselves<\/strong>. This means that changes to the elements in any of the two lists will be reflected in both the original and copied lists.<\/p>\nvar clonedPizzas = pizzas.ToList();\r\n\r\nvar margherita = pizzas\r\n .FirstOrDefault(x => x.Name == \"Margherita\");\r\n\r\nmargherita.Toppings.Clear();<\/pre>\n
clonedPizzas<\/code> variable and clone the contents of pizzas<\/code> to it using the ToList<\/code> method (using any of the other methods used earlier will produce the same result). Then we get the Margherita pizza from the original list using the FirstOrDefault<\/code> method. Finally, we use the Clear<\/code> method to empty the list of Toppings<\/code> for that pizza.<\/p>\nConsole.WriteLine($\"Original Margherita: {pizzas.First()}\");\r\nConsole.WriteLine($\"Cloned with ToList: {clonedPizzas.First()}\");<\/pre>\nFirst<\/code> method.<\/p>\nToString<\/code> method which will give us an easy-to-read representation of each pizza. Now, we can check the result:<\/p>\nOriginal Margherita: Pizza name: Margherita; Toppings:\r\nCloned with ToList: Pizza name: Margherita; Toppings:<\/pre>\n
Toppings<\/code>. This is because when creating a shallow copy, we only clone the references to the objects, not the actual objects. This is not ideal because when we change elements in one list, we change the elements everywhere we have copied that list.<\/p>\n<\/a>Deep Copy\u00a0<\/h3>\n
<\/a>Clone a List Using the ICloneable Interface<\/h3>\n
Clone<\/code> method we get from inheriting the ICloneable<\/code> interface to create a deep copy.<\/p>\npublic class Pizza : ICloneable\r\n{\r\n public string Name { get; set; }\r\n public List<string> Toppings { get; set; }\r\n\r\n public object Clone()\r\n {\r\n return new Pizza\r\n {\r\n Name = Name,\r\n Toppings = Toppings.ToList(),\r\n };\r\n }\r\n\r\n public override string ToString()\r\n {\r\n return $\"Pizza name: {Name}; Toppings: {string.Join(\", \", Toppings)}\";\r\n }\r\n}<\/pre>\nPizza<\/code> class by inheriting ICloneable<\/code> and implementing the Clone<\/code> method. This time we create our implementation where we return a new Pizza<\/code> object and copy the parameters of the current instance – we assign Name<\/code> directly as it is a string<\/code> and then we use the ToList<\/code> method we learned earlier to get a clone of the Toppings<\/code> list.<\/p>\nvar pizzasClonedWithICloneable = new List<Pizza>();\r\n \r\nforeach(var pizza in pizzas)\r\n{\r\n pizzasClonedWithICloneable.Add((Pizza)pizza.Clone());\r\n}<\/pre>\npizzasClonedWithICloneable<\/code> variable as an empty List<Pizza><\/code>. Then, in a foreach<\/code> loop iterating over our initial pizzas<\/code> list, we get a new copy of the current pizza using the Clone<\/code> method and add it to our new list.<\/p>\n<\/a>Clone a List Using a Copy Constructor<\/h3>\n
public Pizza(Pizza pizza)\r\n{\r\n Name = pizza.Name;\r\n Toppings = pizza.Toppings.ToList();\r\n}<\/pre>\nPizza<\/code> class, we create a new constructor that takes in a Pizza<\/code> as a parameter. In it, we assign the Name<\/code> and Toppings<\/code> properties the values of the passed-in object, keeping in mind that we need to pass a copy of the Toppings<\/code>, done with pizza.Toppings.ToList()<\/code>, and not just assign the value.<\/p>\nProgram<\/code> class and do the cloning:<\/p>\nvar pizzasClonedWithCopyConstructor = new List<Pizza>();\r\n\r\nforeach (var pizza in pizzas)\r\n{\r\n pizzasClonedWithCopyConstructor.Add(new Pizza(pizza));\r\n}<\/pre>\n