Collections in C#

Collections in C# are specialized classes used to store, manage, and manipulate groups of objects dynamically. Collections in C# provide greater flexibility than arrays because they can grow and shrink automatically as data changes. Every .NET developer uses Collections in C# extensively while building Console Applications, ASP.NET Core Applications, MVC Projects, Web APIs, Desktop Applications, Entity Framework Applications, and Enterprise Software Solutions.

Modern applications frequently work with large volumes of dynamic data such as customers, products, students, employees, orders, transactions, and reports. Collections in C# provide efficient ways to manage such data.

What are Collections in C#?

Collections in C# are data structures that store multiple objects in a single container.

Unlike arrays, Collections in C# can automatically adjust their size during program execution.

Example:

List<string> students =
new List<string>();

The collection can grow as new elements are added.

Collections simplify data management and improve application scalability.

Why are Collections in C# Important?

Collections in C# help developers:

• Store dynamic data
• Manage large datasets
• Improve application flexibility
• Simplify data manipulation
• Increase productivity
• Improve code readability
• Build scalable applications

Most enterprise applications rely heavily on collections.

Collections vs Arrays

Collections in C# are generally preferred for modern application development.

Collection Namespace

Collections are available through:

using System.Collections.Generic;

This namespace provides many useful collection classes.

Examples include:

• List
• Dictionary
• Queue
• Stack
• HashSet

These are commonly used in professional .NET applications.

List Collection

The List collection is the most frequently used collection in C#.

Creating a List

Example:

List<string> students =
new List<string>();

Adding Items

Example:

students.Add("Rahul");
students.Add("Amit");
students.Add("Neha");

Displaying Items

Example:

foreach(string student in students)
{
    Console.WriteLine(student);
}

Output:

Rahul
Amit
Neha

Lists are widely used because they are simple and flexible.

Removing Items from a List

Example:

students.Remove("Amit");

Updated List:

Rahul
Neha

The Remove method deletes specific items.

Accessing List Elements

Example:

Console.WriteLine(students[0]);

Output:

Rahul

Lists support index-based access similar to arrays.

List Count Property

Example:

Console.WriteLine(students.Count);

Output:

2

Count returns the total number of elements.

Dictionary Collection

The Dictionary collection stores data as key-value pairs.

Example:

Dictionary<int, string> students =
new Dictionary<int, string>();

Adding Data

Example:

students.Add(1, "Rahul");
students.Add(2, "Amit");
students.Add(3, "Neha");

Retrieving Data

Example:

Console.WriteLine(students[2]);

Output:

Amit

Dictionaries provide fast lookups and are heavily used in enterprise software.

Looping Through a Dictionary

Example:

foreach(var student in students)
{
    Console.WriteLine(
        student.Key + " " +
        student.Value
    );
}

Output:

1 Rahul
2 Amit
3 Neha

This allows easy processing of key-value data.

Queue Collection

The Queue collection follows the FIFO principle.

FIFO means:

First In First Out

Creating a Queue

Example:

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

Adding Items

Example:

customers.Enqueue("Rahul");
customers.Enqueue("Amit");
customers.Enqueue("Neha");

Removing Items

Example:

customers.Dequeue();

Output:

Rahul Removed

Queues are useful for processing tasks in order.

Queue Real-World Uses

Examples include:

• Customer Support Systems
• Print Queues
• Order Processing
• Ticket Booking Systems

FIFO processing is common in business applications.

Stack Collection

The Stack collection follows the LIFO principle.

LIFO means:

Last In First Out

Creating a Stack

Example:

Stack<string> books =
new Stack<string>();

Adding Items

Example:

books.Push("Book1");
books.Push("Book2");
books.Push("Book3");

Removing Items

Example:

books.Pop();

Output:

Book3 Removed

The last inserted item is removed first.

Stack Real-World Uses

Examples include:

• Browser History
• Undo Functionality
• Application Navigation
• Expression Evaluation

Stacks are useful when reverse processing is required.

HashSet Collection

A HashSet stores unique values only.

Example:

HashSet<string> cities =
new HashSet<string>();

Adding Data:

cities.Add("Jaipur");
cities.Add("Delhi");
cities.Add("Jaipur");

Output:

Jaipur
Delhi

Duplicate values are automatically ignored.

Benefits of HashSet

Advantages:

• Fast searching
• No duplicates
• Efficient memory usage
• Improved performance

HashSet collections are useful when uniqueness is important.

Generic Collections

Most modern C# applications use Generic Collections.

Example:

List<int> numbers =
new List<int>();

Benefits:

• Type Safety
• Better Performance
• Compile-Time Checking
• Improved Readability

Generic Collections are preferred over older collection types.

Common Collection Methods

Add

Adds an item.

students.Add("Rahul");

Remove

Removes an item.

students.Remove("Rahul");

Clear

Removes all items.

students.Clear();

Contains

Checks existence.

students.Contains("Rahul");

These methods simplify collection management.

Real-World Applications of Collections in C#

Student Management System

List<Student> students;

E-Commerce Application

List<Product> products;

Banking Application

List<Transaction> transactions;

Hospital Management System

Dictionary<int, Patient> patients;

Collections in C# are used extensively in real-world business applications.

Best Practices for Collections in C#

• Choose the correct collection type.
• Use Generic Collections whenever possible.
• Avoid unnecessary duplication.
• Use Dictionary for fast lookups.
• Use Queue for FIFO processing.
• Use Stack for LIFO processing.
• Optimize large collections for performance.

Importance of Collections in C#

Collections in C# are heavily used in:

• ASP.NET Core Applications
• MVC Projects
• Web APIs
• Entity Framework
• Cloud Applications
• Database Systems
• Enterprise Software

A strong understanding of Collections in C# helps developers build scalable and efficient applications.

Key Takeaways

• Collections in C# store dynamic data efficiently.
• Lists are the most commonly used collections.
• Dictionaries store key-value pairs.
• Queues follow FIFO processing.
• Stacks follow LIFO processing.
• HashSets prevent duplicate values.
• Collections are essential in modern .NET development.

Frequently Asked Questions (FAQs)

What are Collections in C#?

Collections in C# are dynamic data structures used to store and manage groups of objects.

Why use Collections instead of Arrays?

Collections provide dynamic sizing and easier data management.

What is a List in C#?

A List is a flexible collection that automatically adjusts its size.

What is a Dictionary in C#?

A Dictionary stores data as key-value pairs for fast retrieval.

What is the difference between Queue and Stack?

Queue follows FIFO processing, while Stack follows LIFO processing.

Why are Collections in C# important?

Collections simplify data management and are widely used in professional .NET applications.

Internal Link

Click here for more free courses