1. IronPDF
  2. IronPDF Blog
  3. .NET Help
  4. C# Dictionary Trygetvalue

Published August 30, 2023

C# Dictionary Trygetvalue (How it Works for Developers)

C# is a versatile and powerful language that provides many functionalities. Among them is the C# Dictionary.

Understanding the Basics of C# Dictionary

Before diving into the TryGetValue method, it's crucial to understand what a Dictionary is in C#. In simple terms, a Dictionary is a collection of key/value pairs. For example, you may have a Dictionary where the keys are students' names (string values), and the values are their corresponding ages (integer values).


    Dictionary<string, int> studentAges = new Dictionary<string, int>
    {
        {"Alice", 20},
        {"Bob", 22},
        {"Charlie", 19}
    };


    Dictionary<string, int> studentAges = new Dictionary<string, int>
    {
        {"Alice", 20},
        {"Bob", 22},
        {"Charlie", 19}
    };

Dim studentAges As New Dictionary(Of String, Integer) From {
	{"Alice", 20},
	{"Bob", 22},
	{"Charlie", 19}
}
VB   C#

The keys in a Dictionary are unique. You can access keys to fetch the corresponding value, making Dictionaries incredibly efficient for lookup functionality.

The Conventional Approach: ContainsKey Method

When working with C# Dictionaries, a common task is to fetch a value associated with a particular key. However, directly accessing a key that doesn't exist can throw a KeyNotFoundException, interrupting the flow of your program. To avoid this, it is common practice to check if the specified key exists within the Dictionary. This is where the ContainsKey method comes into play.

The ContainsKey method is a straightforward and intuitive function that checks if a certain key is present in the Dictionary. Here is the basic syntax of the ContainsKey method:

Dictionary<TKey, TValue>.ContainsKey(TKey key)
Dictionary<TKey, TValue>.ContainsKey(TKey key)
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Dictionary<TKey, TValue>.ContainsKey(TKey key)
VB   C#

It takes the key as a parameter and returns a Boolean value. If the key is in the Dictionary, it will return true; if not, it will return false.

Consider the following example where we have a Dictionary with student names as keys and their corresponding ages as values.

Dictionary<string, int> studentAges = new Dictionary<string, int>
{
    {"Alice", 20},
    {"Bob", 22},
    {"Charlie", 19}
};
Dictionary<string, int> studentAges = new Dictionary<string, int>
{
    {"Alice", 20},
    {"Bob", 22},
    {"Charlie", 19}
};
Dim studentAges As New Dictionary(Of String, Integer) From {
	{"Alice", 20},
	{"Bob", 22},
	{"Charlie", 19}
}
VB   C#

Now, if you want to get the age of a student named "Alice", you would first use the ContainsKey method to check if "Alice" is a key in the Dictionary.

string student = "Alice";
if(studentAges.ContainsKey(student))
{
    int age = studentAges[student];
    Console.WriteLine($"{student} is {age} years old.");
}
else
{
    Console.WriteLine($"{student} does not exist in the dictionary.");
}
string student = "Alice";
if(studentAges.ContainsKey(student))
{
    int age = studentAges[student];
    Console.WriteLine($"{student} is {age} years old.");
}
else
{
    Console.WriteLine($"{student} does not exist in the dictionary.");
}
Dim student As String = "Alice"
If studentAges.ContainsKey(student) Then
	Dim age As Integer = studentAges(student)
	Console.WriteLine($"{student} is {age} years old.")
Else
	Console.WriteLine($"{student} does not exist in the dictionary.")
End If
VB   C#

In this case, the program will print "Alice is 20 years old." If you tried to get a student's age not present in the Dictionary, the ContainsKey method would prevent a KeyNotFoundException from being thrown and instead print a message that the student does not exist.

However, while the ContainsKey method can be useful, it's not always the most efficient. In the code snippet above, two lookup operations are performed on the Dictionary: one for the ContainsKey method and one to retrieve the value. This can be time-consuming, especially when dealing with large Dictionaries.

While the ContainsKey method is a simple and intuitive way to handle exceptions when a specified key is not found in a Dictionary, it's worth considering alternative methods like TryGetValue, which can achieve similar functionality with better performance. We will discuss TryGetValue in more detail in the following sections.

Combining Verification and Retrieval with TryGetValue

This is where the TryGetValue method comes in handy. The TryGetValue method combines the verification and value retrieval in a single step, offering nearly identical code functionality but with enhanced performance.

The TryGetValue method requires two parameters:

  1. The key you're looking for.
  2. An out parameter that will hold the value if the key exists.

Here's the syntax:

Dictionary<TKey, TValue>.TryGetValue(TKey key, out TValue value)
Dictionary<TKey, TValue>.TryGetValue(TKey key, out TValue value)
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Dictionary<TKey, TValue>.TryGetValue(TKey key, out TValue value)
VB   C#

The out keyword is used to signify that this method will change the value parameter. The out value will be the default value of the value type if the specified key is not found (0 for integers, null for reference types). Otherwise, it will hold the value that corresponds to the provided key.

Here is how to use TryGetValue:

string student = "Alice";
if(studentAges.TryGetValue(student, out int age))
{
    Console.WriteLine($"{student} is {age} years old.");
}
else
{
    Console.WriteLine($"{student} does not exist in the dictionary.");
}
string student = "Alice";
if(studentAges.TryGetValue(student, out int age))
{
    Console.WriteLine($"{student} is {age} years old.");
}
else
{
    Console.WriteLine($"{student} does not exist in the dictionary.");
}
Dim student As String = "Alice"
Dim age As Integer
If studentAges.TryGetValue(student, age) Then
	Console.WriteLine($"{student} is {age} years old.")
Else
	Console.WriteLine($"{student} does not exist in the dictionary.")
End If
VB   C#

This code provides nearly identical functionality to the ContainsKey method example, but it's more efficient because it only looks up the key once.

TryGetValue In Action Code Example

To better understand the TryGetValue method, let's explore a practical code example. Consider a school database where each student has a unique ID and corresponding name. This data is stored in a Dictionary with the student ID as the key and the name as the value.

Dictionary<int, string> studentNames = new Dictionary<int, string>
{
    {1, "Alice"},
    {2, "Bob"},
    {3, "Charlie"}
};
Dictionary<int, string> studentNames = new Dictionary<int, string>
{
    {1, "Alice"},
    {2, "Bob"},
    {3, "Charlie"}
};
Dim studentNames As New Dictionary(Of Integer, String) From {
	{1, "Alice"},
	{2, "Bob"},
	{3, "Charlie"}
}
VB   C#

In this case, let's say you want to retrieve the student's name with ID 2, but you also want to ensure that the student with this ID exists in the database.

Traditionally, you might first use the ContainsKey method to check if the key (student ID 2) exists and then access the Dictionary to get the corresponding value (student name). However, with the TryGetValue method, you can accomplish this in a single step.

The TryGetValue method takes two arguments: the key you're looking for and an out parameter that will hold the value associated with that key if it exists. If the key is found, the method will return true and assign the corresponding value to the out parameter. If not, it will return false, and the out parameter will take the default value for its type.

int i = 2; // Student ID
if (studentNames.TryGetValue(i, out string value))
{
    Console.WriteLine($"The name of the student with ID {i} is {value}.");
}
else
{
    Console.WriteLine($"No student with ID {i} exists in the dictionary.");
}
int i = 2; // Student ID
if (studentNames.TryGetValue(i, out string value))
{
    Console.WriteLine($"The name of the student with ID {i} is {value}.");
}
else
{
    Console.WriteLine($"No student with ID {i} exists in the dictionary.");
}
Dim i As Integer = 2 ' Student ID
Dim value As String
If studentNames.TryGetValue(i, value) Then
	Console.WriteLine($"The name of the student with ID {i} is {value}.")
Else
	Console.WriteLine($"No student with ID {i} exists in the dictionary.")
End If
VB   C#

In this case, the TryGetValue method looks for the key 2 in the studentNames Dictionary. If it finds the key, it assigns the corresponding value to the value variable (the student's name), and the method returns true. Then, the program prints out, "The name of the student with ID 2 is Bob."

If the TryGetValue method doesn't find the key 2, it will assign the default value for a string (which is null) to the value variable, and the method will return false. The code then goes to the else block, printing out, "No student with ID 2 exists in the dictionary."

TryGetValue streamlines your code by combining the key existence check and value retrieval into a single step. Moreover, it provides a performance boost, particularly with larger Dictionaries, by eliminating the need for multiple key lookup operations.

Introducing Iron Suite

As you continue to advance in your C# journey, you'll find many tools and libraries at your disposal that can significantly enhance your programming capabilities. Among these are the Iron libraries, a suite of tools specifically designed to extend the functionality of C# applications. They include IronPDF, IronXL, IronOCR, and IronBarcode. Each of these libraries has a unique set of functionalities, and they all provide significant advantages when used in conjunction with standard C#.

IronPDF

C# Dictionary `TryGetValue` (How It Works For Developers) Figure 1

IronPDF is a C# library designed to create PDF files from HTML, edit, and extract PDF content in .NET applications. With IronPDF, you can programmatically generate PDF reports, fill PDF forms, and manipulate PDF documents. The library also provides features for HTML to PDF conversion, making it easy to convert existing HTML content into PDFs.

In the context of our topic, imagine a scenario where you're retrieving student data from a Dictionary and want to generate a PDF report. TryGetValue could fetch the necessary data efficiently and then leverage IronPDF to create the PDF document.

IronXL

C# Dictionary `TryGetValue` (How It Works For Developers) Figure 2

IronXL is an Excel library for C# and .NET. It enables developers to read, write, and create Excel files in .NET applications without Interop. It's perfect for scenarios where you need to export or import data from an Excel spreadsheet.

About TryGetValue, suppose you have a Dictionary where keys represent product IDs and values represent their quantities. You could use TryGetValue to retrieve the quantity of a specific product and then use IronXL to update that quantity in an Excel inventory management spreadsheet.

IronOCR

C# Dictionary `TryGetValue` (How It Works For Developers) Figure 3

IronOCR is an advanced OCR (Optical Character Recognition) & Barcode reading library for .NET and C#. It allows developers to read text and barcodes from images and PDFs in .NET applications. This can be particularly useful when you need to extract data from scanned documents or images and work with it in your code.

Consider a scenario where you've used IronOCR to extract student IDs from scanned documents. After processing, you store the IDs and corresponding student details in a Dictionary. When retrieving a particular student's details, TryGetValue could be used to fetch the data from the Dictionary efficiently.

IronBarcode

C# Dictionary `TryGetValue` (How It Works For Developers) Figure 4

IronBarcode is a barcode reading and writing library for .NET. With IronBarcode, developers can generate and read various barcode and QR code formats. It's a powerful tool for encoding and decoding data in a compact, machine-readable format.

In a practical scenario, imagine you're using barcodes to store product information in a retail system. Each barcode could correspond to a unique product ID stored as a key in a Dictionary. When a barcode is scanned, you could use TryGetValue to quickly fetch and display the associated product details from the Dictionary.

Conclusion

As we've explored the functionalities of the Iron libraries in conjunction with standard C# features like the TryGetValue method, it's clear that these tools can significantly enhance your development process. Whether you're working with PDFs, Excel files, OCR, or Barcodes, the Iron Suite has a solution tailored to your needs.

What's more enticing is that each of these products offers a free trial, allowing you to explore and experiment with the features at no cost. If you decide to continue using the libraries, the license starts from $749 for each product. However, there's even more value to be found if you're interested in multiple Iron libraries, as you can purchase the full Iron Suite at the price of just two individual products.