C# Array vs List: When should you use an array or a List in C#?

Last updated on March 27th, 2024 at 12:08 pm

C# Array vs List:

• A List<T> is a collection that can change its size dynamically when items are added or removed, whereas an array is a sequential collection of a fixed size that is set when created.
• Accessing elements in an array is faster, whereas adding or deleting elements from a List is faster.

Array VS List in C#

Parameters	C# List	C# Array
Size:	A list in C# can adjust its size dynamically when items are added or removed	An array has a fixed size and can only store a specific number of elements of the same data type.
Namespace:	The C# List class is a part of the System.Collections.Generic namespace,	whereas the Array class belongs to the System.Array namespace.
Memory:	List memory is dynamic and random. A list occupies more memory than an Array since each node defined in the List has its own memory set.	Array memory is static and continuous. So, Arrays are more memory efficient than a List.
Usage:	A List<T> is useful when elements need to be frequently inserted or removed,	, while arrays are handy when you have a fixed number of elements that are unlikely to change and want to access them frequently in a non-sequential way.
Performance:	Accessing items in an array is faster than in a list because arrays have a fixed size and contiguous memory storage.	However, inserting or deleting items in an array can be slower than in a list because it requires shifting all subsequent items. On the other hand, lists are better at inserting or deleting items at any position within the list.
Memory management:	The List data structure allocates memory dynamically as required, which means that it can resize itself without needing contiguous memory. This makes it more efficient in terms of memory usage.	On the other hand, Arrays require contiguous memory allocation, which results in a fixed size and the potential for memory wastage if not fully utilized.
Type Safety:	In C#, both arrays and lists are designed to be type-safe. This means that only elements of the specified type can be added to them. However, lists provide enhanced type safety through the use of generics. This allows for compile-time enforcement of type compatibility,	whereas arrays rely on the type system to check for type compatibility during runtime.

Example:

using System;
using System.Collections.Generic;
public class Program {
  public static void Main(string[] args) {

    // Initialize an array with a fixed size of 2 elements
    int[] array = new int[2];

    // Initialize a list with no elements
    List<int> list = new List<int>();

    // Display the initial length/count

    Console.WriteLine("Initial length of array: " + array.Length); 
    Console.WriteLine("Initial count of list: " + list.Count); 

    // Reassign the array with a new size of 5 elements
    array = new int[5];

    // Add elements to the list
    list.Add(1);
    list.Add(2);
    list.Add(3);
    list.Add(4);

    // Display the updated length/count
    Console.WriteLine("Updated length of array: " + array.Length); 
    Console.WriteLine("Updated count of list: " + list.Count); 
  }
}

Output:

Initial length of array: 2
Initial count of list: 0
Updated length of array: 5
Updated count of list: 4

What is an Array?

An array in C# is a collection of data with the same data type and fixed length. Once an array is created, its size cannot be changed.
The Array class is available in the System.Array namespace.

You can access elements in an array using numeric indexes, starting from 0 (zero). The first item in the array is at index 0, the second is at index 1, and so on.

Numeric array items have a default value of zero, while reference array elements have a default value of null.
You can define an array by using square brackets “[]” and specifying the type of data it will hold (e.g., integers or strings) along with a name.

Creating an Array:

Let’s create an array of integers called intArray:

// Create an integer array called 'intArray' with a length of 5
int[] intArray = new int[5];

// Alternatively, you can initialize the array with specific values like this:


int[] intArray = new int[] {10, 20, 30, 40, 50};


// Now, 'intArray' contains the following values at different indexes:
// Index 0: 10
// Index 1: 20
// Index 2: 30
// Index 3: 40
// Index 4: 50

In this example, we created an array of integers called intArray with a capacity of 5 items. IntArray can hold five integers, and we can access each element using the indexes 0 to 4.

Accessing the elements of an Array:

You can create a string array with the following syntax:

using System;
namespace CSharpArrayExample
{
    public class CSharpArrayExample
    {   
        static void Main(string[] args)
        {
            // Declare an array
            string[] fruitsName = { "Apple", "Orange", "Banana", "Grapes"};

            // Access the elements of an Array using index
            Console.WriteLine(fruitsName[0]); // Output: Apple

            // Access the elements using for loop
            for(int index = 0; index < fruitsName.Length; index ++)
            {
                Console.WriteLine(fruitsName[index]);
            }

            Console.ReadKey();
        }
        //Output:
        // Apple
        // Orange
        // Banana
        // Grapes
    }
}

Array memory allocation:

C# List

In C#, the List is a generic collection of strongly typed objects that can change its size dynamically when items are added or removed. It is available in the System.Collection.Generic namespace.

You can access the List elements using index or loops. This class enables you to perform different operations, such as sorting, searching, adding, and removing elements from the collection.

If you want to know more about the List class and how to use it in C#, you can check out my previous article, “C# List Class“.

Syntax:

The following is the syntax for declaring a generic List<T>. The parameter T in the List represents the type of item in the list, which can be int, long, string, or any user-defined object.

List<T> myList = new List<T>();

C# List<T> example:

The following is an example of a List in C#.

using System;
using System.Collections.Generic;
namespace CSharpListExample
{
    public class CSharpArrayExample
    {   
        static void Main(string[] args)
        {
            // Declare a generic List of string type
            List<string> fruitsName = new List<string>();
           // Add items in the List

            fruitsName.Add("Apple");
            fruitsName.Add("Orange");
            fruitsName.Add("Banana");
            fruitsName.Add("Grapes");
            
            // Access the elements of a List using index
            Console.WriteLine(fruitsName[0]); // Output: Apple

            // Access the list elements using for loop
            for(int index = 0; index < fruitsName.Count; index ++)
            {
                Console.WriteLine(fruitsName[index]);
            }

            Console.ReadKey();
        }
        //Output:
        // Apple
        // Orange
        // Banana
        // Grapes
    }
}

Difference between C# Arrays and Lists:

Definition:

• An array is a fixed-size collection that stores elements of the same data type in contiguous memory locations.
• A list is a dynamic-size collection that can store elements of the same data type and automatically resizes itself as elements are added or removed.

Flexibility:

• An array is less flexible, as its size cannot be changed after creation. You need to create a new array with a different size if you want to change it.
• The list is more flexible, as you can add or remove elements without worrying about the size.

Performance:

• Arrays generally perform better for fixed-size collections due to contiguous memory and direct indexing.
• Lists might have a slight performance overhead due to dynamic resizing, but for most use cases, the difference is negligible.

Initialization:

• Elements in an array can be directly initialized during declaration.
• Elements in a list need to be added one by one, or you can initialize it with an existing collection.

Namespace:

• Arrays are part of the C# language and don’t require any additional namespace.
• Lists are part of the System.Collections.Generic namespace, so you need to import it.

Index Access: 

• You can access elements in an array using index notation (e.g., array[index]).
• Like arrays, you can access elements in a list using index notation (e.g., list[index]).

Element Types: 

• Arrays can only hold elements of the same type (homogeneous).
• Lists can also hold elements of the same type (homogeneous) but can also hold different types using generics.

When to Use:

• Use Arrays when you know the exact size of the collection in advance and don’t need to change it frequently.
• Use Lists when you want a flexible collection that can grow or shrink as needed or when you need additional methods for data manipulation.

C# list vs array performance

Arrays allocate a fixed-size block of memory when initialized, making them suitable for scenarios where the size of the collection is known in advance. Lists, on the other hand, dynamically allocate memory, allowing them to grow or shrink as needed. Let’s explore this through code:

Array Example:

int[] integerArray = new int[5]; // Allocates memory for 5 integers

List Example:

List<int> integerList = new List<int>(); // Dynamically allocates memory

• Performance in Adding Elements:

Adding elements to a collection is a common operation, and the performance can vary between arrays and lists.

Array Example:

int[] integerArray = new int[5];
for (int i = 0; i < 5; i++)
{
    integerArray[i] = i;
}

List Example:

List<int> integerList = new List<int>();
for (int i = 0; i < 5; i++)
{
    integerList.Add(i);
}

Comparison:

Adding elements to a list is generally faster than resizing an array. Lists automatically handle resizing, resulting in better performance for dynamic collections.

• Accessing Elements:

Accessing elements by index is a fundamental operation. Let’s compare the syntax and performance for arrays and lists.

Array Example:

int value = integerArray[2]; // Accessing element at index 2

List Example:

int value = integerList[2]; // Accessing element at index 2

Comparison: Array access is marginally faster since arrays have a contiguous block of memory, allowing for direct indexing. Lists, being dynamic, may involve additional checks.

• Memory Overhead:

Lists have some memory overhead due to their dynamic nature and additional features. This can impact performance in scenarios where memory efficiency is important.

Array Memory Overhead: Arrays have minimal memory overhead, as they only store the elements and the necessary metadata.

List Memory Overhead: Lists carry additional metadata, such as capacity and count, leading to slightly higher memory overhead compared to arrays.

Summary:

The decision of whether to use arrays or lists in C# largely depends on the needs of your application. If you require a collection of a fixed size with faster access times, then arrays are the way to go. In contrast, if you need to frequently resize the collection or perform efficient insertion and deletion operations, then lists offer a more flexible solution.

References: C# Array, C# List

I hope you enjoyed reading this article “C# array vs list“. If you find something incorrect or wish to offer more information regarding the topic addressed here, please leave a comment below.

FAQs:

Articles to Check Out:

• C# Tutorial
• C# Dictionary
• C# Hashtable
• Collections in C#
• C# Hashtable vs Dictionary vs HashSet
• C# Program asked in Interviews