What is ArrayList in C#?

ArrayList is a non-generic collection class from the early .NET Framework (pre-2005) that can store objects of any type. It lives in the System.Collections namespace and was designed before generics were introduced to handle dynamic collections of mixed types.

Why should I avoid using ArrayList in modern C#?

ArrayList should be avoided because it causes boxing/unboxing performance penalties when working with value types, lacks compile-time type safety leading to runtime exceptions, requires explicit casting, and provides poor IntelliSense support. Generic collections like List<T> offer better performance and type safety.

What is boxing and unboxing in C# and why is it a performance concern?

Boxing occurs when a value type is converted to an object type by wrapping it in a heap-allocated object, while unboxing extracts the value type from an object. This process creates garbage collection pressure and degrades performance. When using ArrayList with value types like integers, each addition requires boxing and each retrieval requires unboxing and casting.

What is the difference between ArrayList and List in C#?

ArrayList stores elements as object type requiring boxing/unboxing and explicit casting, while List<T> stores elements as their declared type. List provides compile-time type safety, better performance without boxing/unboxing overhead, stronger IntelliSense support, and reduced memory usage compared to ArrayList.

When was ArrayList replaced with generic collections in .NET?

ArrayList was effectively replaced when generics were introduced in .NET 2.0 (released in 2005). Since then, List<T> and other generic collections in the System.Collections.Generic namespace have become the standard approach for collection management in C#.

How do runtime errors occur with ArrayList?

Runtime errors occur with ArrayList when attempting to cast an element to the wrong type. For example, if you store different types in an ArrayList and later attempt to cast an integer to a string, it will compile successfully but throw an InvalidCastException at runtime. Generic collections prevent this by enforcing type safety at compile time.

How much performance impact does ArrayList have compared to List?

ArrayList runs much slower than List<T> when working with value types, often 10x slower in loops that do lots of calculations. This happens because of the overhead from boxing and unboxing operations. Real-world data processing using ArrayList for number crunching is dramatically slower than using typed collections.

What alternatives should I use instead of ArrayList?

Use List<T> for general-purpose collections of a specific type. For more specialized needs, consider other generic collections like Dictionary<TKey, TValue>, HashSet<T>, or Queue<T>. For read-only scenarios, use IEnumerable<T> or IReadOnlyList<T> interfaces.

Is there any scenario where ArrayList is still appropriate?

ArrayList is rarely appropriate in modern C# code. Even when you need to store heterogeneous types, better alternatives exist like creating a common base class or interface, using dynamic, or leveraging object explicitly with a List<object>. In legacy code maintenance scenarios, it might be necessary to work with ArrayList temporarily.

How does ArrayList affect code maintainability?

ArrayList makes code harder to maintain because it pushes type errors to runtime instead of catching them when you compile. You need more defensive code and explicit casting. It also gives you less help from your IDE with weaker IntelliSense. Code with ArrayList tends to be wordier, more likely to have bugs, and tougher for your team to work with.

Why You Should Avoid ArrayList in Modern C#

TL;DR

ArrayList is an obsolete non-generic collection from pre-2005 .NET that stores everything as object
Using ArrayList causes performance issues due to boxing/unboxing of value types
ArrayList lacks compile-time type safety, leading to runtime exceptions
List<T> and other generic collections offer superior performance, type safety, and developer experience
Boxing/unboxing with ArrayList can make code up to 10x slower in computation-heavy scenarios
Modern C# code should always use strongly-typed collections like List<T>, Dictionary<TKey,TValue>, etc.
Even when storing mixed types, prefer List<object> over ArrayList for consistency

If you’re still using ArrayList in your C# projects, you’re basically driving a horse-drawn carriage on a highway. Sure, it’ll get you there, but everyone’s zooming past you with better tools. Here’s why ArrayList belongs in the .NET history books and what you should use instead.

What is ArrayList and Why Did It Exist?

Back when .NET was new (before 2005), we didn’t have generics. ArrayList was the standard way to create dynamic collections for mixed types. It lives in the System.Collections namespace and can hold any object, strings, integers, custom classes, whatever you need.

// The old way - ArrayList can hold anything
ArrayList oldList = new ArrayList();
oldList.Add("Hello");
oldList.Add(42);
oldList.Add(new DateTime(2024, 1, 1));
// This compiles fine, but creates problems later

The Modern Alternative: List

When generics arrived in .NET 2.0, List<T> changed everything. Instead of storing everything as object, you specify exactly what type you want to store.

// The modern way - type-safe and performant
List<string> modernList = new List<string>();
modernList.Add("Hello");
// modernList.Add(42); // Compile error - can't add int to List<string>

Why ArrayList Hurts Your Code

1. Boxing and Unboxing Performance Hit

Every time you add a value type to an ArrayList, .NET boxes it into an object. When you retrieve it, you need to unbox it. This creates extra work for garbage collection and tanks your performance.

// ArrayList boxes integers - expensive!
ArrayList numbers = new ArrayList();
numbers.Add(1); // Boxing happens here
int first = (int)numbers[0]; // Unboxing and casting required

// List<T> stores values directly - fast!
List<int> betterNumbers = new List<int>();
betterNumbers.Add(1); // No boxing
int first = betterNumbers[0]; // Direct access, no casting

2. Runtime Errors from Type Confusion

ArrayList compiles successfully but can explode at runtime when you cast to the wrong type.

ArrayList mixed = new ArrayList();
mixed.Add("text");
mixed.Add(123);

// This compiles but crashes at runtime
string text = (string)mixed[1]; // InvalidCastException!

3. No IntelliSense Love

Since ArrayList returns object, you lose all type information and IntelliSense support.

ArrayList vs List: The Comparison

Feature	ArrayList	List
Type Safety	Runtime only	Compile-time
Performance	Boxing/unboxing overhead	Direct storage
IntelliSense	Limited (returns object)	Full type support
Casting Required	Always	Never
Memory Usage	Higher (boxing)	Lower
Runtime Errors	Common	Rare

See here the detailed comparison of ArrayList and List<T>.

Common Pitfalls I’ve Seen

I’ve fixed so many bugs where developers mixed types in ArrayList and got crashes when casting at runtime. The worst part? These bugs sneak into production because they compile without errors.

Another problem: loops get super slow when boxing/unboxing happens thousands of times. I once worked on a data processing app that ran 10x slower just because it used ArrayList for number crunching.

The Bottom Line

Using ArrayList in modern C# is like watching VHS tapes in a streaming world. The old tech still works, but you’re missing out on huge improvements in safety, speed, and coding experience.

Don’t use ArrayList in modern C#. Go with List<T>, IEnumerable<T>, or other generic collections instead. Your future self (and your teammates) will thank you for writing code that’s type-safe, fast, and clearly shows what it does.

Generics changed C# for a reason, use them.

TL;DR#

What is ArrayList and Why Did It Exist?#

The Modern Alternative: List#

Why ArrayList Hurts Your Code#

1. Boxing and Unboxing Performance Hit#

2. Runtime Errors from Type Confusion#

3. No IntelliSense Love#

ArrayList vs List: The Comparison#

Common Pitfalls I’ve Seen#

The Bottom Line#

Related Posts