Hashtable.ContainsKey(Object) Method in C#

In this article, we will discuss the Hashtable.ContainsKey(Object) method in C# with its syntax, parameters, and examples.

The Hashtable is a non-generic collection that stores key-value pairs, which is similar to the generic Dictionary collection. It calculates each key's hash code to optimise lookups, stores it in an internal bucket, and compares it to the supplied key's hash code when values are accessed.

The Hashtable class, which is a collection of key/value pairs organised according to the hash code of the key, includes the "Hashtable.ContainsKey(Object)" method in C#. This method is used to determine whether a given key is present in the Hashtable.

Use the C# "Hashtable.ContainsKey(Object)" method to determine if a given key is present in the Hashtable. It accepts an object as input and outputs a Boolean value that indicates whether or not the element with the given key exists in the Hashtable. This method performs a lookup operation based on the hash code of the provided key, offering efficient key-based retrieval. Before retrieving or modifying related information, it is frequently used to verify the existence of the key. Implementing this method ensures reliable key validation, preventing potential errors or exceptions when accessing Hashtable elements. Overall, it's a fundamental tool for key-based operations, offering efficient and straightforward key existence checks in C#.

Hashtable Properties

Key-value pairs are stored in a hashtable.
It falls under the Collections namespace.
The IDictionary interface is implemented.
Keys can't be null and must be distinct.
Null or duplicate values are possible.
Values may be retrieved by providing the indexer with the relevant key, for example, my_Hashtable[key].
DictionaryEntry objects are used to store elements.

Syntax:

It has the following syntax:

Parameters:

key: An object that indicates the hashtable key that has to be searched for.

Return Value:

true: If an element with the given key is present in the Hashtable.
false: If an element is not in the Hashtable with the given key, it returns false.

Example:

Let us take an example to illustrate the Hashtable.ContainsKey(Object) method in C#.

using System;
using System.Collections;
class Demo
{
    static void Main()
    {
        //Creating a Hashtable instance
        Hashtable employee_details = new Hashtable();
        // Add employee IDs and names to the Hashtable
        employee_details.Add(1, "Saahas Prince");
        employee_details.Add(2, "Suhaas Prince");
        employee_details.Add(3, "Raj Prakash");
        employee_details.Add(4, "Jessy Paul");
        // Prompt the user to input an employee ID to check
        Console.WriteLine("Please Enter an employee ID to check:");
        int inputId;
        if (!int.TryParse(Console.ReadLine(), out inputId))
        {
            Console.WriteLine("Invalid input. Please enter a valid employee ID.");
            return;
        }
        // Check if the Hashtable contains the input ID
        if (employee_details.ContainsKey(inputId))
        {
            string employeeName = (string)employee_details[inputId];
            Console.WriteLine($"Employee ID {inputId} belongs to {employeeName}");
        }
        else
        {
            Console.WriteLine($"Employee ID {inputId} not found.");
        }
    }
}

Output:

Please Enter an employee ID to check:
4
Employee ID 4 belongs to Jessy Paul

Explanation:

The employee IDs as keys and the names that correspond to them as values are stored in a hashtable called employee_details, which is created by this C# code. The Add method is used to add employee details to the Hashtable. It prompts for the employee ID and uses the ContainsKey method to check if the Hashtable has the provided ID. The corresponding employee name is retrieved and demonstrated if the ID is found. If not, a message stating that the employee ID was not found. The program ensures input validity by utilising "int.TryParse" to parse user input as an integer.

Advantages:

There are several advantages of this method. Some main advantages are as follows:

Efficient Key Lookup: By using the hash code of the designated item, the technique offers quick key-based retrieval.
Boolean Result: By returning a Boolean value, it is simple to verify that a key exists before performing additional operations.
Versatile Usage: It allows programmers to quickly and effectively verify the existence of keys, avoiding mistakes or exceptions during key-based activities.
Simplifies Conditional Logic: It improves Code Readability and Clarity by Enabling Conditional Branching Based on Key Existence.
Supports Arbitrary Objects: It accepts any object type as input, enabling flexibility in key validation across different data types.

Disadvantages:

There are several disadvantages of this method. Some main disadvantages are as follows:

Limited error Handling: It provides a Boolean result without providing great detail about the problem, which might make debugging more difficult.
No Key Retrieval: This method simply checks for the presence of the key. It doesn't give an immediate way to obtain the associated value, requiring additional steps to retrieve it.
Hash Collision Concerns: Lookup times may get longer, and collisions may occur if several keys hash to the same value.
Not Type-Safe: It accepts objects of any type; if the wrong object types are supplied as arguments, this may result in runtime issues.
Hashtable Dependency: It requires the use of the Hashtable data structure, which has limitations compared to more modern alternatives like Dictionary<TKey, TValue>.

Next TopicHow to get Synchronize access to the ListDictionary in C#

← prev next →