Collections in C# provide powerful tools for managing and organising data efficiently. They enable developers to handle groups of objects with ease, whether you need fixed-size arrays or dynamic and flexible data structures like lists and dictionaries. In this article, we'll explore the primary types of collections in C#, their methods, and practical use cases.
1. Types of Collections in C
1.1 Arrays
An array is a fixed-size collection of elements of the same type. It’s useful for scenarios where the number of items is known and does not change.
Example:
int[] numbers = {1, 2, 3, 4, 5};
foreach (int number in numbers)
{
Console.WriteLine(number);
}
Key Methods and Properties:
Length: Returns the number of elements.
Array.Sort(array): Sorts the elements.
Array.Reverse(array): Reverses the order of elements.
1.2 Lists
A List is a dynamic collection that can grow or shrink in size. Lists are part of the System.Collections.Generic namespace and are more versatile than arrays.
Example:
List<string> names = new List<string> {"John", "Adrian", "Charlie"};
names.Add("Adrian");
foreach (string name in names)
{
Console.WriteLine(name);
}
Key Methods:
Add(item): Adds an item to the list.
Remove(item): Removes the first occurrence of an item.
Contains(item): Checks if an item exists in the list.
1.3 Dictionaries
A Dictionary is a collection of key-value pairs, where each key is unique. Dictionaries are ideal for scenarios where quick lookups are needed.
Example:
Dictionary<int, string> students = new Dictionary<int, string>
{
{1, "Adrian"},
{2, "John"},
{3, "Charlie"}
};
if (students.ContainsKey(2))
{
Console.WriteLine($"Student ID 2: {students[2]}");
}
Key Methods:
Add(key, value): Adds a new key-value pair.
Remove(key): Removes an item by key.
ContainsKey(key): Checks if a specific key exists.
Performance Note: Dictionaries provide fast lookups due to their hashing mechanism, making them suitable for scenarios where keys are frequently searched.
1.4 Sets
A HashSet is a collection that contains unique elements and does not allow duplicates. It’s optimised for fast lookups.
Example:
HashSet<int> uniqueNumbers = new HashSet<int> {1, 2, 3, 3, 4};
foreach (int number in uniqueNumbers)
{
Console.WriteLine(number);
}
Key Methods:
Add(item): Adds an item if it doesn’t already exist.
Remove(item): Removes an item.
Contains(item): Checks if an item exists.
Performance Note: Use HashSet when you need to ensure uniqueness in your collection.
2. Methods of Collections and Their Uses
Common Methods Across Collections:
(LINQ will be discussed in the following articles)
Iteration: Useforeachto iterate through items in a collection.
Sorting: UseSort()in lists orOrderBy()in LINQ for advanced sorting.
Filtering: LINQ methods likeWhere()allow filtering based on conditions.
Conversion: Convert between collections usingToArray(),ToList(), etc.
Example of LINQ Filtering:
List<int> numbers = new List<int> {1, 2, 3, 4, 5};
var evenNumbers = numbers.Where(n => n % 2 == 0);
foreach (int number in evenNumbers)
{
Console.WriteLine(number);
}
3. Practical Example: Data Management with Collections
Scenario: Managing a Student Roster
This example demonstrates how to use multiple types of collections to manage student data.
Example:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// Store student data
Dictionary<int, string> students = new Dictionary<int, string>
{
{1, "Adrian"},
{2, "John"},
{3, "Charlie"}
};
// Add new students
students.Add(4, "Diana");
// All students
Console.WriteLine("Student Roster:");
foreach (var student in students)
{
Console.WriteLine($"ID: {student.Key}, Name: {student.Value}");
}
// Check if a student exists
if (students.ContainsKey(2))
{
Console.WriteLine("Student ID 2 is in the roster.");
}
// Remove a student
students.Remove(3);
Console.WriteLine("Updated Roster:");
foreach (var student in students)
{
Console.WriteLine($"ID: {student.Key}, Name: {student.Value}");
}
}
}
/*
Student Roster:
ID: 1, Name: Adrian
ID: 2, Name: John
ID: 3, Name: Charlie
ID: 4, Name: Diana
Student ID 2 is in the roster.
Updated Roster:
ID: 1, Name: Adrian
ID: 2, Name: John
ID: 4, Name: Diana
*/
4. Advanced Topics
Thread-Safe Collections
For applications requiring thread-safe operations, consider using ConcurrentDictionary or other thread-safe collections from the System.Collections.Concurrent namespace.
Example:
using System;
using System.Collections.Concurrent;
class Program
{
static void Main()
{
ConcurrentDictionary<int, string> safeDict = new ConcurrentDictionary<int, string>();
safeDict.TryAdd(1, "Adrian");
safeDict.TryAdd(2, "John");
foreach (var item in safeDict)
{
Console.WriteLine($"Key: {item.Key}, Value: {item.Value}");
}
}
}
Immutable Collections
To ensure the collection cannot be modified after creation, use immutable collections from System.Collections.Immutable.
Example:
using System.Collections.Immutable;
ImmutableList<string> immutableNames = ImmutableList.Create("Adrian", "John", "Charlie");
foreach (var name in immutableNames)
{
Console.WriteLine(name);
}
SOCIAL SHARE CARD GENERATOR