Hashtable.Containskey(Object) Method In C#

In this post, we are going to explore the Hashtable.ContainsKey(Object) method in C# along with its syntax, parameters, and illustrations.

The Hashtable is a non-generic container that holds key-value pairs, resembling the generic Dictionary collection. It computes the hash code for each key to streamline retrieval, saves it in an internal bucket, and matches it against the hash code of the provided key during value retrieval.

The Hashtable class in C# consists of key/value pairs organized based on the key's hash code. One of the methods available in this class is "Hashtable.ContainsKey(Object)", designed to check if a specific key exists within the Hashtable.

Utilize the C# "Hashtable.ContainsKey(Object)" method to check for the presence of a specific key within the Hashtable data structure. This method requires an object input and returns a Boolean value indicating whether the key exists in the Hashtable. By leveraging the hash code of the key, this method efficiently locates the associated element. It is commonly employed to confirm the presence of a key before performing any operations on related data. Incorporating this method into your code ensures accurate key validation, reducing the risk of errors or exceptions during Hashtable access. In essence, it serves as a crucial tool for conducting key-centric tasks, providing a reliable and streamlined approach to verifying key existence 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:

Example


public virtual bool ContainsKey(object key);

Parameters:

✅ key: An entity that specifies the specific key within the hashtable to be queried.

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's consider a scenario to demonstrate the Hashtable.ContainsKey(Object) function in C#.

Example


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:

Output


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

Explanation:

The hashtable named employee_details holds employee IDs as keys and their corresponding names as values in this C# implementation. The Add function is employed to insert new employee details into the Hashtable. It requests the employee ID and verifies its existence in the Hashtable using the ContainsKey method. If the ID is located, the associated employee name is fetched and displayed; otherwise, a notification is shown indicating that the employee ID was not found. To guarantee the correctness of input, the program utilizes "int.TryParse" to convert user input into 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> .