Array as reference type behavior in C Sharp (C#) - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean that arrays are reference types in C#?

Arrays store a reference (or address) to the actual data in memory, not the data itself. When you assign one array variable to another, both variables point to the same array in memory.

beginner

What happens if you change an element of an array through one variable when arrays are reference types?

The change is visible through all variables that reference the same array because they all point to the same data in memory.

intermediate

How can you create a copy of an array to avoid reference sharing?

You can create a new array and copy elements manually or use methods like Array.Copy or the Clone method to create a separate copy in memory.

beginner

Consider this code:

int[] a = {1, 2, 3};
int[] b = a;
b[0] = 10;

What is the value of a[0] after this code runs?

The value of a[0] is 10 because both a and b reference the same array. Changing b[0] changes the array itself.

intermediate

Why is understanding array reference behavior important in programming?

It helps avoid bugs caused by unintended changes to shared data and allows you to manage memory and data flow correctly.

In C#, what happens when you assign one array variable to another?

A The array elements are copied one by one.

B A new copy of the array is created automatically.

C The array is converted to a list.

D Both variables point to the same array in memory.

Arrays are reference types, so assignment copies the reference, not the data.

If you modify an element of an array through one variable, what happens to other variables referencing the same array?

A They throw an error.

B They keep the old value.

C They see the updated value.

D They create a new array automatically.

Since all variables reference the same array, changes are visible through all references.

Which method can you use to create a separate copy of an array in C#?

A Array.Copy

B Array.ReferenceEquals

C Array.Clear

D Array.Resize

Array.Copy copies elements to a new array, creating a separate copy.

What is the type of an array in C#?

A Reference type

B Value type

C Primitive type

D Interface type

Arrays are reference types in C#.

Why might unintended sharing of arrays cause bugs?

A Because arrays cannot be modified.

B Because changes through one variable affect all references.

C Because arrays are immutable.

D Because arrays are copied automatically.

Unintended sharing means one change affects all references, which can cause unexpected behavior.

Explain how arrays behave as reference types in C# and what happens when you assign one array variable to another.

Think about how memory addresses work for arrays.

Describe how to create a separate copy of an array to avoid shared reference issues.

Consider methods that duplicate array data.

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