C# Distinct Dictionary

In C#, a dictionary is a data structure that stores key-value pairs. Each key in the dictionary must be unique. However, what if you have a scenario where you want to ensure the uniqueness of both keys and values in a dictionary? This is where the concept of a "distinct dictionary" can be useful.

A distinct dictionary in C# is a custom implementation of a dictionary that enforces both key and value uniqueness. In other words, each key-value pair in a distinct dictionary is unique and cannot be duplicated. This can be particularly useful when you need to perform lookups based on both keys and values.

Implementation

To create a distinct dictionary in C#, you can start by defining a custom class that represents a key-value pair with distinct properties. The class should override the Equals and GetHashCode methods to provide custom equality and hash code generation logic based on both key and value. Here's an example implementation:

public class DistinctKeyValuePair<TKey, TValue>
{
    public TKey Key { get; }
    public TValue Value { get; }

    public DistinctKeyValuePair(TKey key, TValue value)
    {
        Key = key;
        Value = value;
    }

    public override bool Equals(object obj)
    {
        if (obj is DistinctKeyValuePair<TKey, TValue> other)
        {
            return Key.Equals(other.Key) && Value.Equals(other.Value);
        }
        return false;
    }

    public override int GetHashCode()
    {
        unchecked
        {
            int hash = 17;
            hash = hash * 23 + Key.GetHashCode();
            hash = hash * 23 + Value.GetHashCode();
            return hash;
        }
    }
}

With the DistinctKeyValuePair class defined, you can then use it as the type for your distinct dictionary. Here's an example of how you can create and use a distinct dictionary:

using System;
using System.Collections.Generic;

public class DistinctDictionary<TKey, TValue> : Dictionary<DistinctKeyValuePair<TKey, TValue>, TValue>
{
    public void Add(TKey key, TValue value)
    {
        var pair = new DistinctKeyValuePair<TKey, TValue>(key, value);
        base.Add(pair, value);
    }
}

public class Program
{
    public static void Main()
    {
        var distinctDict = new DistinctDictionary<string, int>();
        
        distinctDict.Add("one", 1);
        distinctDict.Add("two", 2);
        distinctDict.Add("one", 3); // Error: Duplicate key-value pair

        foreach (var pair in distinctDict)
        {
            Console.WriteLine($"Key: {pair.Key.Key}, Value: {pair.Key.Value}");
        }
    }
}

In this example, the DistinctDictionary class extends the built-in Dictionary class and overrides the Add method to create and add a DistinctKeyValuePair object to the dictionary. Any attempt to add a duplicate key-value pair will result in an error.

Conclusion

A distinct dictionary in C# provides a way to ensure uniqueness of both keys and values in a dictionary. By defining a custom class for key-value pairs and overriding the equality and hash code methods, you can enforce the uniqueness constraint. This can be useful in various scenarios where you need to perform lookups based on both keys and values.