C#  

Collections in .Net (C# Guide for Beginners)

Introduction

When we start learning .NET (especially with C#), one of the most important concepts you’ll come across is collections. Collections help us to store and manage groups of data efficiently.

What is Collection?

A collection is simply a group of objects. Instead of storing one value in a variable, collections allow you to store multiple values in a single structure.

For example:

  • A list of student names

  • A group of numbers

  • A set of unique items

Why Use Collections?

Collections are useful because they:

  • Store multiple values dynamically

  • Automatically resize when needed

  • Provide built-in methods for sorting, searching, and filtering

Types of Collections in .NET

1. Generic Collections (Recommended)

Generic collections are type-safe and offer better performance. They are the preferred choice in modern .NET applications.

  • List<T> – Represents an ordered collection of items

  • Dictionary<TKey, TValue> – Stores key-value pairs for fast lookups

  • Queue<T> – Follows First-In-First-Out (FIFO) order

  • Stack<T> – Follows Last-In-First-Out (LIFO) order

2. Non-Generic Collections (Legacy)

These collections are older and not type-safe. Their use is generally discouraged in modern development.

  • ArrayList

  • Hashtable

3. Specialized / Concurrent Collections

These are designed for multi-threaded and high-performance scenarios.

  • ConcurrentDictionary<TKey, TValue>

  • ConcurrentQueue<T>

In real-time .NET projects, collections are used everywhere—basically anytime you need to store, manage, or process groups of data efficiently during execution.

Instead of thinking of them as a theoretical concept, it’s better to see how they show up in actual applications.

1. Handling API Data (Web APIs / Microservices)

In ASP.NET Core applications, collections are commonly used to handle incoming and outgoing data.

  • Receive lists from client requests (e.g., items in a shopping cart)

  • Return data as JSON arrays in API responses

List<Order> orders = GetOrdersFromDatabase();
return Ok(orders);

2. Database Operations

When working with ORMs such as Entity Framework Core:

  • Query results are typically returned as collections (List<T>, IEnumerable<T>)

One-to-many relationships are represented using collections

var customers = dbContext.Customers.ToList();

3. Caching and In-Memory Storage

Collections like Dictionary<TKey, TValue> are commonly used for caching frequently accessed data.

They act as fast in-memory lookup tables:

  • Key → Unique identifier (e.g., UserId)

  • Value → Associated object (e.g., User)

Dictionary<int, User> userCache = new Dictionary<int, User>();

if (!userCache.ContainsKey(userId))
{
    var user = GetUserFromDatabase(userId);
    userCache[userId] = user; // Store in cache
}

return userCache[userId];

How it works:

  • First request → Data is retrieved from the database

  • Subsequent requests → Data is served from memory (much faster)

4. Real-Time Systems (SignalR, Messaging)

In real-time applications (e.g., using SignalR), collections are used to:

  • Track connected users

  • Store active connections

  • Manage messages or notifications

ConcurrentDictionary<string, string> connections = new();

Why use ConcurrentDictionary instead of Dictionary?

  • Multiple threads may access data simultaneously

  • A standard Dictionary is not thread-safe and may cause race conditions

  • ConcurrentDictionary ensures safe concurrent access

5. Background Jobs and Queues

Collections such as Queue<T> and ConcurrentQueue<T> are used in:

  • Task scheduling systems

  • Message processing pipelines

  • Background job execution

Queue<string> tasks = new Queue<string>();

Conclusion

we learned about collection and saw the what are the cases we have to use .

In real applications, we use them for handling API data, database results, caching, real-time features, and background tasks.

Hope this helps you!

Membership not found