Array as reference type behavior in C Sharp (C#)

Introduction

Arrays in C# are special because they are stored as references. This means when you change an array through one variable, other variables pointing to the same array see the change too.

When you want to share a list of items between different parts of your program without copying it.

When you want to understand why changing an array in one place affects it in another.

When you want to pass an array to a method and have the method modify the original array.

When you want to avoid making extra copies of large arrays to save memory.

Syntax

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
        int[] originalArray = {1, 2, 3};
        int[] referenceToArray = originalArray; // Both variables point to the same array

        referenceToArray[0] = 10; // Change affects originalArray too

        Console.WriteLine(originalArray[0]); // Prints 10
    }
}

Arrays are reference types in C#, so variables hold references (addresses) to the actual array data.

Assigning one array variable to another copies the reference, not the array contents.

Examples

Shows that assigning a new array to the second variable breaks the link to the original array.

C Sharp (C#)

int[] emptyArray = new int[0];
int[] anotherReference = emptyArray;
anotherReference = new int[5]; // Now points to a new array, original emptyArray unchanged

Even with one element, changing through one reference changes the original array.

C Sharp (C#)

int[] singleElementArray = {5};
int[] referenceCopy = singleElementArray;
referenceCopy[0] = 20;
// singleElementArray[0] is now 20 too

Changing the last element through the reference affects the original array.

C Sharp (C#)

int[] array = {1, 2, 3};
int[] reference = array;
reference[2] = 99;
// array[2] is now 99

Sample Program

This program shows that changing the array through one variable changes it for the other because both point to the same array.

C Sharp (C#)

using System;

class Program
{
    static void PrintArray(string label, int[] array)
    {
        Console.Write(label + ": ");
        foreach (int item in array)
        {
            Console.Write(item + " ");
        }
        Console.WriteLine();
    }

    static void Main()
    {
        int[] originalArray = {1, 2, 3};
        Console.WriteLine("Before change:");
        PrintArray("originalArray", originalArray);

        int[] referenceToArray = originalArray; // reference copy
        referenceToArray[1] = 20; // change through reference

        Console.WriteLine("After change through referenceToArray:");
        PrintArray("originalArray", originalArray);
        PrintArray("referenceToArray", referenceToArray);
    }
}

Important Notes

Time complexity: Access and modification by index is O(1).

Space complexity: No extra space used when copying references.

Common mistake: Expecting that assigning one array variable to another copies the array contents, but it only copies the reference.

Use this behavior when you want multiple parts of your program to work on the same array data without copying.

Summary

Arrays in C# are reference types, so variables hold references to the actual array.

Assigning one array variable to another copies the reference, not the array itself.

Changing the array through any reference changes the original 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