C# Pair Class (How It Works For Developers)

A pair is a simple data structure that holds two related values. It provides a convenient way to bundle two distinct pieces of data together. Pairs are commonly used when a method needs to return two values or when working with key-value associations.

In C#, developers often resort to using tuples (Tuple<T1, T2>) for pairing values. However, tuples are immutable, and their elements are accessed via properties like Item1 and Item2, which can lead to less readable code when used extensively. This is where a custom Pair class comes in handy.

If you require a structure to hold two related objects and data hiding is not a priority, you can utilize the Pair class in your code. The Pair class does not encapsulate its object references. Instead, it exposes them directly to all calling codes as public class fields.

This design choice allows for straightforward access to the contained objects without the overhead of encapsulation. Also, at the end of the article, we will explore how IronPDF for PDF Generation from Iron Software Overview can be used to generate a PDF document.

Tuples

C# 7.0 introduced tuple syntax improvements, making tuples even easier to work with. Here's how you can declare and initialize tuples:

// Tuple declaration
var person = (name: "John", age: 30);

// Accessing tuple elements using named properties
Console.WriteLine($"Name: {person.name}, Age: {person.age}");

// Tuple deconstruction
var (name, age) = person;
Console.WriteLine($"Name: {name}, Age: {age}");

// Tuple declaration
var person = (name: "John", age: 30);

// Accessing tuple elements using named properties
Console.WriteLine($"Name: {person.name}, Age: {person.age}");

// Tuple deconstruction
var (name, age) = person;
Console.WriteLine($"Name: {name}, Age: {age}");

Benefits of Tuples

Concise Syntax

Tuples allow you to express complex data structures using a concise syntax without the need for defining custom classes or structs.

Lightweight

Tuples are lightweight data structures, making them suitable for scenarios where you need temporary or intermediate storage of data.

Implicit Naming

With tuple syntax, you can implicitly name tuple elements, enhancing code readability and reducing the need for comments.

Returning Multiple Values from Methods

public (int Quotient, int Remainder) Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return (quotient, remainder);
}

var result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.Quotient}, Remainder: {result.Remainder}");

public (int Quotient, int Remainder) Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return (quotient, remainder);
}

var result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.Quotient}, Remainder: {result.Remainder}");

Simplifying Method Signatures

public (string Name, string Surname) GetNameAndSurname()
{
    // Retrieve name and surname from a data source
    return ("John", "Doe");
}

var (name, surname) = GetNameAndSurname();
Console.WriteLine($"Name: {name}, Surname: {surname}");

public (string Name, string Surname) GetNameAndSurname()
{
    // Retrieve name and surname from a data source
    return ("John", "Doe");
}

var (name, surname) = GetNameAndSurname();
Console.WriteLine($"Name: {name}, Surname: {surname}");

Grouping Related Data

var point = (x: 10, y: 20);
var color = (r: 255, g: 0, b: 0);
var person = (name: "Alice", age: 25);

var point = (x: 10, y: 20);
var color = (r: 255, g: 0, b: 0);
var person = (name: "Alice", age: 25);

Limitations and Considerations

While C# 7.0 tuples provide significant benefits, there are some limitations and considerations to keep in mind:

• Tuples are limited in terms of expressiveness compared to custom classes or structs.
• Tuple elements are accessed using Item1, Item2, etc. when explicit names are not provided, which can reduce code readability.

Pair Custom Class

public class Pair<T1, T2>
{
    public T1 First { get; set; }
    public T2 Second { get; set; }

    // Constructor to initialize the pair
    public Pair(T1 first, T2 second)
    {
        First = first;
        Second = second;
    }
}

public class Pair<T1, T2>
{
    public T1 First { get; set; }
    public T2 Second { get; set; }

    // Constructor to initialize the pair
    public Pair(T1 first, T2 second)
    {
        First = first;
        Second = second;
    }
}

In this class, the types are defined at the time of usage, and the two properties are exposed as public properties.

Using the Pair Class

Now, let's explore some common use cases where the Pair class can be beneficial:

1. Storing Coordinates

// Creating a new instance of the Pair class to store coordinates
Pair<int, int> coordinates = new Pair<int, int>(10, 20);
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");

// Creating a new instance of the Pair class to store coordinates
Pair<int, int> coordinates = new Pair<int, int>(10, 20);
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");

2. Returning Multiple Values from a Method

// Method returning a Pair, representing both quotient and remainder
public Pair<int, int> Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return new Pair<int, int>(quotient, remainder);
}

// Usage
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");

// Method returning a Pair, representing both quotient and remainder
public Pair<int, int> Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return new Pair<int, int>(quotient, remainder);
}

// Usage
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");

3. Storing Key-Value Pairs

// Storing a key-value pair
Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");

// Storing a key-value pair
Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");

Key-Value Pairs

Key-value pairs provide a simple and efficient way to associate data. In C#, the primary tool for working with key-value pairs is the Dictionary<TKey, TValue> class, a versatile and powerful collection type.

Understanding Key-Value Pairs

A key-value pair is a data structure that associates a unique key with a value. This association allows for efficient retrieval and manipulation of data based on its unique identifier. In C#, key-value pairs are commonly used for tasks such as caching, configuration management, and data storage.

Dictionary<TKey, TValue> in C#

The Dictionary<TKey, TValue> class in C# is a generic collection that stores key-value pairs. It provides fast lookups based on the keys and is widely used for managing associative data.

Creating and Populating a Dictionary

Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 30 },
    { "Bob", 35 },
    { "Charlie", 25 }
};

Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 30 },
    { "Bob", 35 },
    { "Charlie", 25 }
};

Accessing Values by Key

// Directly access a value by its key
Console.WriteLine($"Alice's age: {ages["Alice"]}");

// Directly access a value by its key
Console.WriteLine($"Alice's age: {ages["Alice"]}");

Iterating Over Key-Value Pairs

// Iterate over all key-value pairs in the dictionary
foreach (var pair in ages)
{
    Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}

// Iterate over all key-value pairs in the dictionary
foreach (var pair in ages)
{
    Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}

Advanced Scenarios

Handling Missing Keys

if (ages.TryGetValue("David", out int age))
{
    Console.WriteLine($"David's age: {age}");
}
else
{
    Console.WriteLine("David's age is not available.");
}

if (ages.TryGetValue("David", out int age))
{
    Console.WriteLine($"David's age: {age}");
}
else
{
    Console.WriteLine("David's age is not available.");
}

Removing Entries

// Remove an entry given its key
ages.Remove("Charlie");

// Remove an entry given its key
ages.Remove("Charlie");

Dictionary Initialization

// Initialize a dictionary with color codes
var colors = new Dictionary<string, string>
{
    { "red", "#FF0000" },
    { "green", "#00FF00" },
    { "blue", "#0000FF" }
};

// Initialize a dictionary with color codes
var colors = new Dictionary<string, string>
{
    { "red", "#FF0000" },
    { "green", "#00FF00" },
    { "blue", "#0000FF" }
};

Beyond Dictionary: Alternatives and Considerations

While Dictionary<TKey, TValue> is a powerful tool, alternative approaches, and considerations depend on the specific requirements of your application:

• ConcurrentDictionary<TKey, TValue>: If your application requires thread-safe access to the dictionary from multiple threads, consider using ConcurrentDictionary<TKey, TValue>.
• ImmutableDictionary<TKey, TValue>: For scenarios where immutability is desired, ImmutableDictionary<TKey, TValue> from the System.Collections.Immutable namespace provides immutable key-value collections.
• Custom Key-Value Pair Classes: In situations where you need additional functionality or specific behavior, consider creating custom key-value pair classes tailored to your requirements.

IronPDF Library

IronPDF by Iron Software Products is an excellent library for generating PDF documents. Its ease of use and efficiency are second to none.

IronPDF excels in HTML to PDF conversion, ensuring precise preservation of original layouts and styles. It's perfect for creating PDFs from web-based content such as reports, invoices, and documentation. With support for HTML files, URLs, and raw HTML strings, IronPDF easily produces high-quality PDF documents.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

IronPDF can be installed from the NuGet package manager:

Install-Package IronPdf

Or from Visual Studio like this:

To generate a document with a tuple example, we can use the following code:

using IronPdf;

namespace IronPatterns
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("-----------Iron Software-------------");
            var renderer = new ChromePdfRenderer(); // var pattern
            var content = "<h1>Iron Software is Awesome</h1> Made with IronPDF!";
            content += "<h2>Demo C# Pair with Tuples</h2>";

            var result = Divide(10, 3);
            Console.WriteLine($"Quotient: {result.Item1}, Remainder: {result.Item2}");
            content += $"<p>When we divide 10 by 3:</p>";
            content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";

            var pdf = renderer.RenderHtmlAsPdf(content);
            pdf.SaveAs("output.pdf"); // Saves PDF
        }

        // Method to demonstrate division using tuples
        public static (int Quotient, int Remainder) Divide(int dividend, int divisor)
        {
            int quotient = dividend / divisor;
            int remainder = dividend % divisor;
            return (quotient, remainder);
        }
    }
}

using IronPdf;

namespace IronPatterns
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("-----------Iron Software-------------");
            var renderer = new ChromePdfRenderer(); // var pattern
            var content = "<h1>Iron Software is Awesome</h1> Made with IronPDF!";
            content += "<h2>Demo C# Pair with Tuples</h2>";

            var result = Divide(10, 3);
            Console.WriteLine($"Quotient: {result.Item1}, Remainder: {result.Item2}");
            content += $"<p>When we divide 10 by 3:</p>";
            content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";

            var pdf = renderer.RenderHtmlAsPdf(content);
            pdf.SaveAs("output.pdf"); // Saves PDF
        }

        // Method to demonstrate division using tuples
        public static (int Quotient, int Remainder) Divide(int dividend, int divisor)
        {
            int quotient = dividend / divisor;
            int remainder = dividend % divisor;
            return (quotient, remainder);
        }
    }
}

Output

Trial License for IronPDF

Get your IronPDF Trial License and place the license in the appsettings.json.

{
    "IronPDF.LicenseKey": "<Your Key>"
}

Conclusion

In this article, we've explored the concept of pairs and the importance of having a Pair class in C#. We've provided a simple implementation of the Pair custom class along with various use cases demonstrating its versatility and utility in everyday programming tasks.

Whether you're working with coordinates, returning multiple values from a method, or storing key-value associations, the Pair class can be a valuable addition to your programming skill set.

In addition to this, the IronPDF library functionality is a great combination skill set to have for developers to generate PDF documents on the fly as required in applications.