Array as reference type behavior in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Array as reference type behavior

Create array object in heap

↓

Variable holds reference to array

↓

Assign variable to another variable

↓

Both variables point to same array

↓

Change array via one variable

↓

Change visible via other variable

Arrays in C# are stored in the heap. Variables hold references to the array object. Assigning one variable to another copies the reference, not the array. Changes via one variable affect the same array seen by the other.

Execution Sample

C Sharp (C#)

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;
arr2[0] = 10;
Console.WriteLine(arr1[0]);

This code shows that changing the array through arr2 also changes arr1 because both refer to the same array.

Execution Table

Step	Action	arr1	arr2	Array Content	Output
1	Create arr1 with {1,2,3}	ref#100	null	[1, 2, 3]
2	Assign arr2 = arr1	ref#100	ref#100	[1, 2, 3]
3	Set arr2[0] = 10	ref#100	ref#100	[10, 2, 3]
4	Print arr1[0]	ref#100	ref#100	[10, 2, 3]	10

💡 Program ends after printing value 10, showing arr1 reflects change made via arr2.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
arr1	null	ref#100	ref#100	ref#100	ref#100
arr2	null	null	ref#100	ref#100	ref#100
Array Content	N/A	[1, 2, 3]	[1, 2, 3]	[10, 2, 3]	[10, 2, 3]

Key Moments - 3 Insights

Why does changing arr2[0] also change arr1[0]?

Because arr1 and arr2 both hold references to the same array object (see execution_table step 2). Changing the array via arr2 changes the single shared array.

Does assigning arr2 = arr1 create a new array?

No, it copies the reference only. Both variables point to the same array in memory (execution_table step 2).

What would happen if we changed arr2 to a new array?

Then arr2 would reference a different array, and changes to arr2 would not affect arr1. This is not shown here but is important to understand.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the content of the array?

A [1, 2, 3]

B [10, 2, 3]

C [0, 2, 3]

D [10, 10, 3]

💡 Hint

Check the 'Array Content' column at step 3 in execution_table.

At which step do arr1 and arr2 first point to the same array reference?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'arr1' and 'arr2' columns in execution_table to see when they share the same reference.

If we changed arr2 to a new array after step 2, what would happen to arr1?

A arr1 would become null

B arr1 would also change to the new array

C arr1 would remain unchanged

D arr1 would throw an error

💡 Hint

Remember that assigning a new array to arr2 changes only arr2's reference, not arr1's.

Concept Snapshot

Arrays in C# are reference types.
Variables hold references to arrays in heap.
Assigning one array variable to another copies reference.
Changes via one variable affect the same array.
To avoid shared changes, create a new array copy.

Full Transcript

In C#, arrays are stored in the heap and variables hold references to them. When you create an array and assign it to a variable, that variable points to the array object. If you assign that variable to another variable, both variables point to the same array. Changing the array through one variable changes it for the other as well. This is because only the reference is copied, not the array itself. To have independent arrays, you must create a new array object.

Practice

1. In C#, what happens when you assign one array variable to another, like int[] a = {1, 2}; int[] b = a;?

easy

A. Both variables refer to the same array in memory.

B. A new copy of the array is created and assigned to b.

C. The array elements are copied individually to b.

D. The assignment causes a compile-time error.

Solution

1. Step 1: Understand array assignment in C#

   Arrays are reference types, so assigning one array variable to another copies the reference, not the data.

2. Step 2: Effect of assignment on variables

   Both variables point to the same array object in memory, so changes via one affect the other.

3. Final Answer:

   Both variables refer to the same array in memory. -> Option A

4. Quick Check:

   Array assignment copies reference, not data [OK]

Hint: Remember: arrays are references, assignment copies reference [OK]

Common Mistakes:

• Thinking assignment copies array elements
• Assuming a new array is created automatically
• Confusing arrays with value types

2. Which of the following is the correct syntax to declare and assign an integer array with values 5, 10, 15 in C#?

easy

A. int arr = {5, 10, 15};

B. int[] arr = new int[3] {5, 10, 15};

C. int[] arr = new int {5, 10, 15};

D. int arr[] = new int[] {5, 10, 15};

Solution

1. Step 1: Review array declaration syntax

   In C#, arrays are declared with the type followed by square brackets, and initialized with new and size or values.

2. Step 2: Check each option

   int[] arr = new int[3] {5, 10, 15}; uses correct syntax with size and initializer. int arr = {5, 10, 15}; misses array brackets. int[] arr = new int {5, 10, 15}; misses the square brackets after int. int arr[] = new int[] {5, 10, 15}; uses C-style syntax which is invalid in C#.

3. Final Answer:

   int[] arr = new int[3] {5, 10, 15}; -> Option B

4. Quick Check:

   Correct array declaration uses new int[size] {values} [OK]

Hint: Use int[] arr = new int[size] {values}; for arrays [OK]

Common Mistakes:

• Omitting square brackets in declaration
• Using C-style array syntax
• Missing new keyword with size

3. What is the output of the following C# code?

int[] a = {1, 2, 3};
int[] b = a;
b[0] = 10;
Console.WriteLine(a[0]);

medium

A. Compilation error

B. 1

C. 0

D. 10

Solution

1. Step 1: Understand reference assignment

   Variable b is assigned the reference of array a, so both point to the same array.

2. Step 2: Effect of modifying b[0]

   Changing b[0] to 10 changes the first element of the shared array.

3. Step 3: Output of a[0]

   Since a and b reference the same array, a[0] is now 10.

4. Final Answer:

   10 -> Option D

5. Quick Check:

   Arrays share reference, so change reflects in both [OK]

Hint: Changing one reference changes the shared array [OK]

Common Mistakes:

• Expecting original array to remain unchanged
• Confusing value copy with reference copy
• Assuming separate arrays after assignment

4. Consider this code snippet:

int[] x = {4, 5, 6};
int[] y = new int[3];
y = x;
y[1] = 20;
Console.WriteLine(x[1]);

What is the output and why?

medium

A. 5, because y was a new array and changes don't affect x.

B. 0, because y was initialized with zeros.

C. 20, because y references the same array as x after assignment.

D. Compilation error due to invalid assignment.

Solution

1. Step 1: Analyze array assignment

   Initially, y points to a new array, but then y = x; makes y reference the same array as x.

2. Step 2: Effect of modifying y[1]

   Changing y[1] to 20 modifies the shared array, so x[1] also becomes 20.

3. Final Answer:

   20, because y references the same array as x after assignment. -> Option C

4. Quick Check:

   Reference assignment means both variables share array [OK]

Hint: Assignment copies reference, so changes affect original array [OK]

Common Mistakes:

• Thinking y remains a separate array after assignment
• Assuming array elements are copied automatically
• Confusing initialization with assignment

5. You want to create a copy of an integer array original so that modifying the copy does NOT affect the original. Which code correctly achieves this in C#?

hard

A. Both B and D

B. int[] copy = (int[])original.Clone();

C. int[] copy = original;

D. int[] copy = original.Select(x => x).ToArray();

Solution

1. Step 1: Understand reference vs copy

   Assigning copy = original; copies the reference, so changes affect both.

2. Step 2: Using Clone() and LINQ Select

   Clone() creates a shallow copy of the array, and Select with ToArray() creates a new array with copied elements.

3. Step 3: Confirm both methods create independent arrays

   Both Clone() and Select(...).ToArray() produce new arrays, so modifying the copy won't affect the original.

4. Final Answer:

   Both B and D -> Option A

5. Quick Check:

   Use Clone() or LINQ to copy arrays [OK]

Hint: Use Clone() or LINQ to copy arrays, not assignment [OK]

Common Mistakes:

• Using assignment instead of copying
• Assuming Clone() returns reference
• Not realizing LINQ creates new array