C# Data Structures (How It Works For Developers)

Arrays: The Basics of Data Organization

Arrays are among the most basic and widely used data structures in C#. They store elements of the same data type in contiguous memory locations, allowing for efficient access to elements via an index. Arrays are ideal for situations where the number of elements is known in advance and does not change.

int[] numbers = new int[5] {1, 2, 3, 4, 5};

int[] numbers = new int[5] {1, 2, 3, 4, 5};

By accessing elements through their index, arrays make it easy to retrieve data, with the initial item located at index 0. For instance, numbers[0] would access the first element of the numbers array, which is 1.

Lists: Dynamic Data Collections

Unlike arrays, lists in C# provide dynamic resizing, making them suitable for scenarios where the number of elements may change over time. C# supports various data types, and through data structures like lists, it allows for type-safe storage.

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
numbers.Add(6); // Adds a new element to the list

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
numbers.Add(6); // Adds a new element to the list

Lists are versatile, enabling you to add, remove, and access elements freely without concern for the underlying data size.

Dictionaries: Key-Value Associations

Dictionaries store associations in the form of key-value pairs, making them ideal for situations where you need to access values based on a unique key. This is especially useful in managing user sessions, configurations, or any scenario requiring a lookup by key.

Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 30);
ages.Add("Bob", 25);

Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 30);
ages.Add("Bob", 25);

In this example, each person's name is associated with their age, allowing for quick access to an individual's age based on their name.

Stacks and Queues: Managing Collections

Stacks operate on a last in, first out (LIFO) principle, making them perfect for managing collections where you need to access the most recently added element first, such as in undo mechanisms or task scheduling systems.

Stack<string> books = new Stack<string>();
books.Push("Book 1");
books.Push("Book 2");
string lastAddedBook = books.Pop(); // Removes and returns "Book 2"

Stack<string> books = new Stack<string>();
books.Push("Book 1");
books.Push("Book 2");
string lastAddedBook = books.Pop(); // Removes and returns "Book 2"

Queues, on the other hand, operate on a first-in, first-out (FIFO) basis. They are useful in scenarios like printer task scheduling or handling customer service requests.

Queue<string> customers = new Queue<string>();
customers.Enqueue("Customer 1");
customers.Enqueue("Customer 2");
string firstCustomer = customers.Dequeue(); // Removes and returns "Customer 1"

Queue<string> customers = new Queue<string>();
customers.Enqueue("Customer 1");
customers.Enqueue("Customer 2");
string firstCustomer = customers.Dequeue(); // Removes and returns "Customer 1"

Linked Lists: Custom Data Structures

Linked lists consist of nodes that contain data and a reference to the next node in the sequence, allowing for efficient insertion and removal of elements. They are especially useful in applications where the manipulation of individual elements is frequent, such as a contact list in a social media application.

public class Node
{
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList
{
    public Node head;

    // Adds a new node with the given data at the head of the list
    public void Add(int data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Displays the data for each node in the list
    public void Display()
    {
        Node current = head;
        while (current != null)
        {
            Console.WriteLine(current.data);
            current = current.next;
        }
    }
}

public class Node
{
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList
{
    public Node head;

    // Adds a new node with the given data at the head of the list
    public void Add(int data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Displays the data for each node in the list
    public void Display()
    {
        Node current = head;
        while (current != null)
        {
            Console.WriteLine(current.data);
            current = current.next;
        }
    }
}

Trees and Graphs: Complex Data Structures

Trees, such as binary trees, organize data in a hierarchical manner, allowing for operations like search, insertion, and deletion to be performed efficiently. Binary trees, for example, are fundamental in implementing algorithms like binary search and breadth-first search.

Graphs, consisting of nodes (vertices) and edges (connections), are used to represent networks, like social graphs or transportation maps. Both trees and graphs are important in solving complex problems involving hierarchical data or networked relationships.

Criteria for Choosing Data Structures

1. Operation Complexity: Consider how quickly you need to perform common operations. For instance, if frequent access to elements based on a key is required, a hash table (implemented in C# as a Dictionary) might be the most efficient choice.
2. Memory Efficiency: Evaluate how much memory the data structure consumes, especially if you're working with a large amount of data. Structures like linked lists can be more memory efficient for certain operations than arrays because they don't allocate memory for unused elements.
3. Ease of Implementation: Some data structures might offer more straightforward implementations for your specific use case. For example, if you need to frequently add and remove elements from only one end, a Stack or Queue could be simpler to use and understand than a LinkedList.
4. Data Size and Scalability: Consider whether your data size is fixed or dynamic. Arrays are ideal for fixed-size data collections, while lists or linked lists are better for data collections that need to grow or shrink dynamically.

Example: Generating a PDF from a List of Data

Consider a scenario where you need to generate a report from a list of customer names and emails. First, you would structure your data in a List of a custom class, Customer, then use IronPDF to create a PDF document from this list.

using IronPdf;
using System.Collections.Generic;

// Define a customer class with properties for name and email
public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key here. Replace "License-Key" with your actual key
        License.LicenseKey = "License-Key";

        // Create a list of customers
        List<Customer> customers = new List<Customer>
        {
            new Customer { Name = "Alice Johnson", Email = "alice@example.com" },
            new Customer { Name = "Bob Smith", Email = "bob@example.com" }
        };

        // Initialize the HTML to PDF converter
        var renderer = new ChromePdfRenderer();

        // Generate HTML content from the list of customers
        var htmlContent = "<h1>Customer List</h1><ul>";
        foreach (var customer in customers)
        {
            htmlContent += $"<li>{customer.Name} - {customer.Email}</li>";
        }
        htmlContent += "</ul>";

        // Convert HTML to PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document
        pdf.SaveAs("CustomerList.pdf");
    }
}

using IronPdf;
using System.Collections.Generic;

// Define a customer class with properties for name and email
public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key here. Replace "License-Key" with your actual key
        License.LicenseKey = "License-Key";

        // Create a list of customers
        List<Customer> customers = new List<Customer>
        {
            new Customer { Name = "Alice Johnson", Email = "alice@example.com" },
            new Customer { Name = "Bob Smith", Email = "bob@example.com" }
        };

        // Initialize the HTML to PDF converter
        var renderer = new ChromePdfRenderer();

        // Generate HTML content from the list of customers
        var htmlContent = "<h1>Customer List</h1><ul>";
        foreach (var customer in customers)
        {
            htmlContent += $"<li>{customer.Name} - {customer.Email}</li>";
        }
        htmlContent += "</ul>";

        // Convert HTML to PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document
        pdf.SaveAs("CustomerList.pdf");
    }
}

In this example, IronPDF works hand-in-hand with the List data structure, demonstrating the library's capability to transform structured C# data into professional-quality PDF documents.