How do you choose between an array, List<T>, and LinkedList<T> in C#?

Choose between an array, List<T>, and LinkedList<T> in C#

Chooses a sequential collection from size, mutation, access pattern, memory locality, and the behavior callers actually need.

1Say itAnswer out loud first

2CompareCompare with Core answer

3RefineRefine with Stronger and Advanced

TL;DR

I use an array when the size is fixed or when an API specifically needs contiguous storage. I use List<T> for most growable ordered collections because it gives fast indexed access, append, and iteration over a contiguous backing array. I reserve LinkedList<T> for cases where I already have a node and need frequent insertion or removal around it. It is not automatically faster for general insertion because finding the position still costs time.

Full answer below

Practice focus

Fixed and dynamic size, indexed access, insertion cost, memory locality, allocation overhead, APIs, and measured workloads.

Answer first

Answer path

Core answer first, then checkpoints toward a stronger answer.

Start
Core answer
Start here. This is the direct spoken answer to practice first.
Why this question matters
The three types all hold ordered values, but their storage and mutation models differ enough to affect both API design and runtime behavior.
I use an array when the size is fixed or when an API specifically needs contiguous storage. I use List<T> for most growable ordered collections because it gives fast indexed access, append, and iteration over a contiguous backing array. I reserve LinkedList<T> for cases where I already have a node and need frequent insertion or removal around it. It is not automatically faster for general insertion because finding the position still costs time.
Checkpoint
Stronger answer
Optional upgrade with examples, trade-offs, and sharper phrasing.
List<T> is the practical default because its contiguous storage has good cache locality and a compact representation. Appending is amortized O(1), while inserting near the front shifts later elements. An array avoids list growth and exposes a fixed-length contract, but callers can still replace its elements. avoids shifting after the target node is known, yet every element needs a node object with links, indexed lookup is O(n), and traversal usually touches scattered memory. I choose from the operations the code actually performs rather than from one complexity-table row.

Review signals

Use these to catch weak phrasing, shallow reasoning, and risky claims.

Common mistakesCandidateCommon mistakesMistakes that weaken the answer or signal shallow understanding.Open details

Details

Choosing LinkedList<T> from insertion complexity without counting lookup cost.
Calling arrays immutable because their length is fixed.
Exposing List<T> when callers only need to iterate.
Optimizing for data sizes that never occur.

How do you choose between an array, List<T>, and LinkedList<T> in C#?

Practice focus

Answer path

Why this question matters

Review signals

Follow-up prompts

Continue practice

Go deeper

Tech stacks

Skill areas

Suggest an improvement