Reading original[0] now gives you one.

• A Second Variable Can Reach the Same Object
  The assignment copies the reference to the list. It does not construct another list. The name alias helps describe the relationship: another way to reach the same object.
• Mutation Is Visible Through Both References
  Changing alias[0] updates an element inside that shared list. Reading it through original observes the same updated element.
• Reference Types Are Not Necessarily Mutable
  Sharing a reference does not guarantee that the object can be changed. C# strings, for example, are immutable reference types.

See Microsoft’s reference-types guide and string documentation.

Mutation and Reassignment: Two Different Operations

Continue from the list example:

alias = new List<int> { 9 };

Now alias refers to a new list containing nine. original still refers to the earlier list containing one.

• Mutation Changes an Object
  alias[0] = 1 edits the list reached through that variable.
• Reassignment Changes a Variable’s Reference
  alias = new List<int> { 9 } gives that variable a different reference. It does not redirect every variable that previously shared the old object.

Picture two arrows leading to one box. Editing the box is mutation. Moving one arrow to a new box is reassignment. That small drawing often explains a surprising result faster than rereading the code.

Method Parameters: A Reference Type Is Not a ref Parameter

Consider this method:

static void Change(List<int> items)
{
    items[0] = 2;
    items = new List<int> { 9 };
}

Call Change(original) with the earlier list. Afterward, original[0] is two, not nine.

• The Method Receives a Copied Reference
  C# passes arguments by value by default. Here, the value being copied is a reference to the list.
• The Method Can Mutate the Shared Object
  Its first statement reaches the same list and updates its first element.
• Local Reassignment Does Not Replace the Caller’s Reference
  Its second statement gives the local parameter a new reference. The caller’s variable still refers to the earlier list. An explicit ref parameter would introduce different behavior by allowing access to the caller’s variable itself.

Microsoft’s method-parameter documentation explains this distinction.

Shallow Copies: A New Outer Container May Still Share Its Contents

Suppose an array contains a mutable list. Cloning that array creates another outer array, but both arrays can still refer to the same inner list.

var original = new List<int>[] { new List<int> { 1 } };
var copy = (List<int>[])original.Clone();
copy[0].Add(2);

The inner list reached through original[0] now contains one and two.

• Outer Independence Does Not Imply Nested Independence
  The arrays are separate, but their first elements contain references to the same list.
• Choose the Copy Boundary Deliberately
  Replacing an element in the copied array affects its own slot. Editing the shared list affects the object both arrays reach. Decide which objects must be independent for the operation you are building.

Array.Clone creates a shallow copy. Its behavior becomes easier to predict when you distinguish containers, elements, and referenced objects.

A Small Exercise Before You Move On

Predict the three values before running this code:

int[] original = { 3 };
int[] alias = original;
int[] copy = (int[])original.Clone();

alias[0] = 7;
copy[0] = 9;

The results are original[0] = 7, alias[0] = 7, and copy[0] = 9. The first two variables reach one array. The clone is a separate array containing copied integers.

Draw the two arrays and the three references. Then replace the integers with mutable objects and ask what would remain shared after a shallow copy.

Why This Matters Across the Stack

On the frontend, shared objects matter when you update application state. React’s state-update guidance explains why existing state objects should be treated as read-only and how copying must account for the path you change.

On the backend, the same reasoning helps you investigate a service unexpectedly changing an object another part of the application still uses. When the browser sends JSON to an API, however, it sends serialized data—not a live C# object reference. Shared in-process state and communication between processes are separate topics.

Before changing a value, ask what your variable holds, what assignment copies, and which other code can reach the same mutable object. Those questions turn a surprising update into behavior you can explain—and eventually design more carefully.