KeyNotFoundException: The given key was not present in the dictionary

This exception is typically thrown when you access a non-existing key in a dictionary.

In the following example, a dictionary is initialized with some key-value pairs, and then the code attempts to access keys that may not exist:

static void Main(string[] args)
{
    Dictionary<string, string> managerMap = new Dictionary<string, string>()
    {
        { "Los Angeles", "Samantha" },
        { "Houston", "John" }
    };

    string citySearch = "";
    while (citySearch != "exit")
    {
        Console.Write("Enter a city name to find the manager: ");
        citySearch = Console.ReadLine();
        Console.WriteLine($"The manager for {citySearch} is {managerMap[citySearch]}");
    }
    Console.ReadKey();
}

In this code, if the user enters a city like "Miami," which is not in the dictionary, it will throw a KeyNotFoundException.

Solution:

To handle this, the solution depends on whether you expect the key to always be present in the dictionary.

Scenario 1 - The Key Might Not Exist:

In this case, the user provides a key, and there’s a possibility it may not be in the dictionary. We can handle this gracefully by using the TryGetValue method, which attempts to get the value for a given key, and if the key is not found, it avoids throwing an exception.

string manager;
if (managerMap.TryGetValue(citySearch, out manager))
{
    Console.WriteLine($"The manager for {citySearch} is {manager}");
}
else
{
    Console.WriteLine($"No manager found for {citySearch}");
}

If the key is not found, the program outputs a message without causing an exception.

Scenario 2 - The Key Must Exist:

If the key must always exist in the dictionary, it’s important that the code is trying to access a known key, and a missing key would be an unexpected scenario.

This scenario commonly arises when populating a dictionary with data from external sources like a database. For instance, you may retrieve the dictionary keys from a query result, and if a key is missing, you want to handle it gracefully rather than throwing an exception.

For example, suppose you are querying a database to populate the dictionary:

SELECT City, Manager FROM CityManagers

In your result set, if a city does not have a manager, the dictionary would be missing that city as a key. Instead of using TryGetValue, you could initialize your dictionary with default values to handle missing keys more predictably.

Let’s say you're using a SQL query with a LEFT JOIN to ensure every city is represented, even if no manager is assigned:

SELECT c.City, m.Manager
FROM Cities c
LEFT JOIN Managers m
ON c.City = m.City

Now the result will include rows for cities with no managers, as shown here:

Now when populating the dictionary, you can check if the manager is null and assign a default value, depending on your application’s needs (e.g., a placeholder value or null).

The key takeaway is that if your code expects certain keys to always be in the dictionary, it’s best to initialize the dictionary with all known keys and use sensible default values for missing entries, instead of relying on KeyNotFoundException.