Introduction
Collection expressions are one of the most exciting and productivity-focused features introduced in modern C#. They simplify how developers create and initialize collections like arrays, lists, and spans. Instead of writing long and repetitive initialization code, you can now use a clean, short, and readable syntax.
In C# 13 and C# 14, collection expressions continue to improve developer experience by making code more concise, reducing boilerplate, and improving readability. This feature is especially useful in real-world applications where collections are used frequently, such as APIs, data processing, and business logic.
In this article, we will understand how collection expressions work, explore practical examples, and learn when to use them in real projects.
What Are Collection Expressions in C#?
Collection expressions allow you to create and initialize collections using a simplified syntax with square brackets [].
Instead of writing:
var numbers = new List<int> { 1, 2, 3, 4 };
You can now write:
List<int> numbers = [1, 2, 3, 4];
This syntax is shorter, cleaner, and easier to read.
Collection expressions work with multiple collection types such as:
Key Benefits of Collection Expressions
Cleaner and More Readable Code
The biggest advantage is readability. Developers can quickly understand what the collection contains without scanning complex initialization logic.
Reduced Boilerplate Code
You no longer need to repeatedly write new List<T>() or similar constructors. This reduces unnecessary code and improves maintainability.
Better Developer Productivity
Writing less code means fewer chances of mistakes. It also speeds up development, especially when dealing with multiple collections.
Consistent Syntax Across Collection Types
The same syntax can be used for arrays, lists, and spans, making the language more consistent.
How Collection Expressions Work Internally
Collection expressions are not just syntax sugar; the compiler translates them into appropriate collection creation logic.
For example:
int[] numbers = [1, 2, 3];
This is internally similar to:
int[] numbers = new int[] { 1, 2, 3 };
For lists:
List<int> numbers = [1, 2, 3];
The compiler converts it into a list initialization with elements added efficiently.
Using Collection Expressions with Different Types
Arrays
int[] values = [10, 20, 30];
This is the simplest and most common use case.
Lists
List<string> names = ["Aman", "Rahul", "Priya"];
This improves readability compared to traditional list initialization.
Span and ReadOnlySpan
Span<int> numbers = [1, 2, 3];
This is useful in high-performance scenarios where memory allocation matters.
Mixing Existing Collections
You can also combine collections using the spread operator (..).
int[] first = [1, 2];
int[] second = [3, 4];
int[] combined = [..first, ..second, 5];
This creates a new collection by merging existing ones.
What’s New or Improved in C# 14
C# 14 improves collection expressions by making them more flexible and usable in more scenarios.
Better Type Inference
The compiler can now better understand the target type, reducing the need for explicit type declarations.
var numbers = [1, 2, 3];
The compiler automatically determines the type based on context.
Improved Performance Handling
In many cases, the compiler generates more optimized code, especially when working with spans and arrays.
Wider Framework Compatibility
More collection types and scenarios are supported compared to earlier versions.
When Should You Use Collection Expressions?
When You Want Cleaner Code
If your goal is to make your code easy to read and maintain, collection expressions are a great choice.
When Initializing Small to Medium Collections
They work best when initializing collections with a known set of values.
When Working with Immutable or Temporary Data
Collection expressions are ideal for temporary data structures or read-only scenarios.
When Combining Collections
Using the spread operator makes merging collections simple and elegant.
When Performance Matters (Span Usage)
In performance-critical applications, using collection expressions with Span can help reduce allocations.
When You Should Avoid Collection Expressions
Very Large or Dynamic Data
If your collection is built dynamically using loops or external data sources, traditional approaches may be clearer.
Complex Initialization Logic
If initialization involves conditions, transformations, or multiple steps, using standard code is more readable.
Legacy Codebases
If your project uses an older C# version, this feature may not be available.
Best Practices for Using Collection Expressions
Use collection expressions for simple and clear initialization
Avoid overusing them in complex scenarios
Prefer them in modern .NET applications
Combine with var when type is obvious
Use spread operator carefully to maintain readability
Real-World Example
public List<string> GetTopTechnologies()
{
var backend = [".NET", "Java", "Node.js"];
var frontend = ["React", "Angular"];
return [..backend, ..frontend, "AI"];
}
This example shows how easily you can build and combine collections.
Difference Between Traditional Initialization and Collection Expressions
| Feature | Traditional Approach | Collection Expressions |
|---|
| Syntax | Verbose | Short and clean |
| Readability | Moderate | High |
| Boilerplate | More | Less |
| Performance | Good | Optimized in many cases |
Summary
Collection expressions in C# 13 and C# 14 are a powerful feature that simplifies how developers create and manage collections. They reduce code complexity, improve readability, and increase productivity. By using a clean and consistent syntax, developers can focus more on logic rather than boilerplate code. However, like any feature, they should be used wisely in appropriate scenarios to maintain code clarity and performance.