How to Convert Lists to Dictionaries in C#

[Linux Hint]

Type casting is probably one of the most common tasks for any developer. In C#, you will often encounter yourself needing to convert a list into a dictionary.

In this tutorial, we will show you all the methods and techniques that we can use to convert a list into a dictionary in C#. We will also cover lots of examples to ensure that the illustrations make sense.

The Basics

Like all good tutorial, let us start with the basics and define a list and dictionary in C#.

In C#, a list refers to a dynamic and ordered collection of elements of the same data type which allow for easy access, modification, and manipulation of the elements that are stored in the array.

A list in C# is implemented as a resizable array which can provide flexibility by allowing a quick addition or removal of the elements. They are part of the “System.Collections.Generic” namespace.

Dictionaries, on the other hand, is a data structure that allows us to store a collection of elements in key-value pairs. In other programming languages, a dictionary is also known as a hash or associative array.

Each key in a dictionary is unique and is mapped to a given value. This ensures for a quick and efficient data retrieval based on the key. As you can guess, dictionaries are a part of the “System.Collections.Generic” namespace as well.

Convert a C# List to Dictionary

The first and most basic method of converting a list into a dictionary is using a “for” loop. We can then iterate over each element in the array and add each element as a key-value pair in the dictionary.

Consider an example as follows:

using System;
class Program
{
    static void Main()
    {
        // list
        List<string> databases = new List<string> { "MySQL", "PostgreSQL", "Oracle" };
        // empty dict
        Dictionary<string, int> db_dict = new Dictionary<string, int>();
        // Convert the list to a dictionary
        foreach (string item in databases)
        {
            // Define a key and a value
            db_dict[item] = item.Length;
        }
        // Display the resulting dictionary
        foreach (var kvp in db_dict)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

In the given example, we start by defining a new list that contains the string values. We then create an empty dictionary which allows us to append the list elements into the dictionary.

Finally, we use a “for” loop to iterate through the list and add each item to the dictionary where the item itself represents the key of the dictionary and the length of the element works as the value.

Running the previous code should return the following:

MySQL: 5
PostgreSQL: 10
Oracle: 6

Convert a C# List to an Array Using LINQ

The second and most elegant method that we can use to convert a list to a dictionary is using the Language Integrated Query which is also known as LINQ.

LINQ is a C# feature that allows us to write the queries directly to retrieve, manipulate, or transform the data from various sources.

Using the C# LINQ feature, we can use the ToDictionary method to quickly convert a list into a dictionary as follows:

using System.Linq;
class Program
{
    static void Main()
    {
        // list
        List<string> databases = new List<string> { "MySQL", "PostgreSQL", "Oracle" };
        // convert list to dict
        Dictionary<string, int> db_dict = databases.ToDictionary(item => item, item =>
        // Display the resulting dictionary
        foreach (var kvp in db_dict)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

As you can see, this provides a more elegant and readable format of converting a list into a dictionary.

NOTE: We use a lambda expression to specify how the key and value for each item is translated into the dictionary.

How to Handle the Duplicate Keys

Unlike sets, lists can contain duplicate values which can cause values when you need to convert them into a dictionary. To avoid errors from duplicate keys when converting a list to a dictionary, you can create a mechanism to handle the duplicate values.

Take into consideration the following provided example:

using System.Linq;
class Program
{
    static void Main()
    {
        // list
        List<string> databases = new List<string> { "MySQL", "PostgreSQL", "Oracle", "MySQL" };

        // Convert to dict
        Dictionary<string, int> db_dict = databases
            .GroupBy(item => item)
            .ToDictionary(group => group.Key, group => group.Count());
        // Display the resulting dictionary
        foreach (var kvp in db_dict)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

In this example, we perform a similar operation as a typical LINQ conversion. However, we use the GroupBy method to group the items of the list by their values before converting them to a dictionary.

This quickly removes the potential conflicts from duplicate records since each the GroupBy method returns a single instance of each unique value.

How to Set the Key and Value Data Types

As you can guess, you may come across an instance where you need to choose the data type of the keys and values of the resulting dictionary.

Consider an example as follows:

using System;
using System.Collections.Generic;
using System.Linq;
class Databases
{
    public int Port { get; set; }
    public string Name { get; set; }
}

class Program
{
    static void Main()
    {
        List<Databases> db_list = new List<Databases>
        {
            new Databases { Port = 3306, Name = "MySQL" },
            new Databases { Port = 5432, Name = "PostgreSQL" },
            new Databases { Port = 9002, Name = "Elastic" }
        };

        // Convert the list to a dictionary
        Dictionary<int, Databases> db_dict = db_list
            .ToDictionary(db => db.Port, db => db);

        // Display the resulting dictionary
        foreach (var kvp in db_dict)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value.Name}");
        }
    }
}

In the given example code, we converted a list of custom database objects into a dictionary with the “Port” property as the key and the “Database” object itself as the value.

Running the previous code should return the following:

3306: MySQL
5432: PostgreSQL
9002: Elastic

There you have it! A method to control the key and value data types during conversion.

Conclusion

In this tutorial, you learned how to perform type casting in C# by learning how to convert a list into a dictionary using various methods and techniques.

View the full article