Shallow Copy
We can easily achieve a shallow copy of our pizzas list with any of the methods from the previous section. But a shallow copy of a List<T>, where T is a reference type, copies only the structure of the collection and references to its elements, not the elements themselves. This means that changes to the elements in any of the two lists will be reflected in both the original and copied lists.
Let’s illustrate this:
var clonedPizzas = pizzas.ToList();
var margherita = pizzas
.FirstOrDefault(x => x.Name == "Margherita");
margherita.Toppings.Clear();
First, we create a clonedPizzas variable and clone the contents of pizzas to it using the ToList 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 method. Finally, we use the Clear method to empty the list of Toppings for that pizza.
Now, let’s see what happens:
Console.WriteLine($"Original Margherita: {pizzas.First()}");
Console.WriteLine($"Cloned with ToList: {clonedPizzas.First()}");
We print the first pizza of each list to the console, which in both cases is the Margherita, using the First method.
We overrode the ToString method which will give us an easy-to-read representation of each pizza. Now, we can check the result:
Original Margherita: Pizza name: Margherita; Toppings:
Cloned with ToList: Pizza name: Margherita; Toppings:
We can see that both the original and copied Margherita pizzas now have an empty list of Toppings. 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.
This might cause serious problems for us, so let’s what we can do to prevent it. Read more here.