C#: When adding the same object to two List<object> variables, is the object cloned in the process?

Question

I have something similar to this:

// Declarations:
List<SomeType> list1 = new List<SomeType>();
List<SomeType> list2 = new List<SomeType>();

...

SomeType something = new SomeType("SomeName");
list1.Add(something);
list2.Add(something);

...

list1[indexOfSomething] = new SomeType("SomeOtherName");

And the object in list2 isn't changed... Is that the expected result?

Answer 1

Yes, you're not cloning the object. The object is being added to both lists originally by reference, and then subsequently you're assigned a reference in the list to the new object you're creating.

That is definitely the expected result.

Answer 2

You are not cloning the object; you are adding a reference to the same object in the two lists. However, your code replaces the reference in one of the lists with a reference to another object, so yes, this is the expected behaviour.

Answer 3

Yes that is expected. Only the reference to the object is added. Not the reference itself or a copy.

Answer 4

Yes, but nothing's cloned. Before the assignment, the same object is in both lists. After the assignment, you have two unique objects in two lists.

Do This:

list1[indexOfSomething].name = "SomeOtherName";

and the object in list2 will change, too.

Answer 5

When you pass the 'something' object to Add you are passing by value (c# default), not by reference

Answer 6

You're replacing the reference in one list with a reference to a new object. If you were to instead change a property of that object, you would see it changed in both places, since the reference would remain the same.

Answer 7

// Declarations:
List<SomeType> list1 = new List<SomeType>();
List<SomeType> list2 = new List<SomeType>();

...

SomeType something = new SomeType("SomeName");
list1.Add(something);
list2.Add(something);

Remember, when you add an object to a list, you're really just adding a pointer to the object. In this case, list1 and list2 both point to the same address in memory.

list1[indexOfSomething] = new SomeType("SomeOtherName");

Now you've assigned the element list1 to a different pointer.

You're not really cloning objects themselves, you're copying the pointers which just happen to be pointing at the same object. If you need proof, do the following:

SomeType something = new SomeType("SomeName");
list1.Add(something);
list2.Add(something);

list1[someIndex].SomeProperty = "Kitty";

bool areEqual = list1[someIndex].SomeProperty == list2[someIndex].SomeProperty;

areEqual should be true. Pointers rock!