Collection API in C# - ItTechGenie

What is the Collection API in C#?

The Collection API in C# refers to the set of classes and interfaces provided in the System.Collections and System.Collections.Generic namespaces. These APIs allow developers to manage data structures efficiently, supporting operations like adding, removing, sorting, and searching elements.

Key Features of Collection API

Provides dynamic and flexible data structures.
Supports both generic (List<T>) and non-generic (ArrayList) collections.
Includes advanced operations like sorting, searching, and filtering.
Optimized for performance and memory efficiency.

Categories of Collections in C#

The C# Collection API includes different types of collections for various use cases:

Category	Example Collection	Use Case
List-Based Collections	`List<T>`, `ArrayList`	Storing an ordered list of items with dynamic resizing.
Dictionary-Based Collections	`Dictionary<TKey, TValue>`, `Hashtable`	Storing key-value pairs for fast lookups.
Queue-Based Collections	`Queue<T>`, `ConcurrentQueue<T>`	Processing items in First-In-First-Out (FIFO) order.
Stack-Based Collections	`Stack<T>`, `ConcurrentStack<T>`	Processing items in Last-In-First-Out (LIFO) order.
Set-Based Collections	`HashSet<T>`, `SortedSet<T>`	Ensuring unique elements in a collection.

Example: Using List<T>

The List<T> class is a resizable array that supports dynamic storage.

Example: List Operations

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List names = new List { "Alice", "Bob", "Charlie" };
        names.Add("David");

        Console.WriteLine($"Count: {names.Count}");
        Console.WriteLine($"Contains 'Bob': {names.Contains("Bob")}");

        names.Remove("Bob");

        Console.WriteLine("Updated List:");
        foreach (var name in names)
        {
            Console.WriteLine(name);
        }
    }
}

// Output:
// Count: 4
// Contains 'Bob': True
// Updated List:
// Alice
// Charlie
// David

The List<T> class provides easy manipulation of dynamic lists.

Example: Using Dictionary<TKey, TValue>

The Dictionary<TKey, TValue> class allows fast retrieval of values based on unique keys.

Example: Dictionary Key-Value Storage

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Dictionary employees = new Dictionary
        {
            { 101, "Alice" },
            { 102, "Bob" },
            { 103, "Charlie" }
        };

        employees[104] = "David"; // Adding a new entry

        Console.WriteLine("Employees:");
        foreach (var pair in employees)
        {
            Console.WriteLine($"ID: {pair.Key}, Name: {pair.Value}");
        }
    }
}

// Output:
// Employees:
// ID: 101, Name: Alice
// ID: 102, Name: Bob
// ID: 103, Name: Charlie
// ID: 104, Name: David

The Dictionary class allows efficient key-based retrieval of values.

Best Practices for Using Collection API

Use List<T> for dynamic lists that require frequent modifications.
Use Dictionary<TKey, TValue> for fast key-based lookups.
Use Queue<T> for FIFO-based task processing.
Use Stack<T> for operations requiring LIFO ordering.
Use HashSet<T> to store unique elements efficiently.
Use generic collections over non-generic ones for type safety and performance.