哈希由两个值组成的哈希元素中的查找元素

Question

I have to retrieve from database the following structure:

    User ID
    User Name
    First Name
    Last Name
    Employee Number

These fields I will store them in memory for fast access, in other words a cache. We are talking about 300,000 records in average.

My problem is that I have to create a structure for fast querying sometimes by User Name and some times by Employee Number. NEVER by User ID, only by the two aforementioned fields.

In a Dictionary I am bounded to the ONLY ONE KEY principle, so ...

- Is there a way to create a key that sort of combines User Name and Employee Number to use in a Dictionary?

The issue in here is that SOMETIMES I will have the User Name given by the user for lookup and sometimes I will have the Employee Number, but never both at the same time.

So this key, lets say MyKey("user-name", "") and MyKey("", "employee-number") should retrieve the same registry from the map.

I want to avoid creating two Dictionaries in memory, one to search through User Name and other through Employee Number?

An alternative could be to store the result from the DB in a big list and then query with Linq. This however will be a search of O(n) and we are talking about performance here.

Answer 1

You have the following choices:

1. Two dictionaries
2. A multidictionary (never used this but it looks very useful)
3. Access the database directly

Choice may be down to testing each solution in a typical scenario. It needs the effort of come experimention.

Answer 2

so I solved my problem creating a Key object with a Type and a Value.

/// <summary>
/// Represents a composite key for cached objects
/// </summary>
public class MultiKey
{
    /// <summary>
    /// The type of key
    /// </summary>
    public enum Type
    {
        /// <summary>
        /// The key represents a User Name
        /// </summary>
        UserName,

        /// <summary>
        /// The key represents an Employee Number
        /// </summary>
        EmployeeNumber
    }

    /// <summary>
    /// Gets or sets the Type of the Key.
    /// </summary>
    public Type KeyType { get; set; }

    /// <summary>
    /// Gets or sets the value of the Key
    /// </summary>
    public string Key { get; set; }

    /// <summary>
    /// Compare based on hash code
    /// </summary>
    /// <param name="obj">the object to compare against</param>
    /// <returns>true if both objects are equals, false otherwise</returns>
    public override bool Equals(object obj)
    {
        if (obj is FormCacheKey)
        {
            return (obj as FormCacheKey).GetHashCode() == this.GetHashCode();
        }

        return false;
    }

    /// <summary>
    /// Compares based on hash code
    /// </summary>
    /// <param name="p1">left side of the operator</param>
    /// <param name="p2">right side of the operator</param>
    /// <returns>true if both items are equal, false otherwise</returns>
    public static bool operator ==(FormCacheKey p1, FormCacheKey p2)
    {
        if ((object)p1 == null && (object)p2 == null)
        {
            return true;
        }
        if ((object)p1 == null || (object)p2 == null)
        {
            return false;
        }
        return p1.Equals(p2);
    }

    /// <summary>
    /// Compares based on hash code
    /// </summary>
    /// <param name="p1">left side of the operator</param>
    /// <param name="p2">right side of the operator</param>
    /// <returns>true if both items are different, false otherwise</returns>
    public static bool operator !=(FormCacheKey p1, FormCacheKey p2)
    {
        return !(p1 == p2);
    }

    /// <summary>
    /// Returns a hash key code that identifies this object
    /// </summary>
    /// <returns>The hash code.</returns>
    public override int GetHashCode()
    {
        const int CoPrimeNumber = 37;
        var finalHashCode = 17;

        finalHashCode = (finalHashCode * CoPrimeNumber) + this.KeyType.GetHashCode();
        finalHashCode = (finalHashCode * CoPrimeNumber) + this.Key.GetHashCode();

        return finalHashCode;
    }
}

After that I created a dictionary like

var cache = new Dictionary<MultiKey, User>();

And finally I added my keys and values to the dictionary like this:

foreach (var user in users)
{
    var userNameKey = new MultiKey { KeyType = MultiKey.Type.UserName, Key = user.UserName };
    cache.Add(userNameKey, user);
    var employeeNumberKey = new MultiKey { KeyType = MultiKey.Type.EmployeeNumber, Key = user.EmployeeNumber };
    cache.Add(employeeNumberKey, user);
}

notes on performance Talking to a colleague, he was defending the two hash table technique instead of the approach I used with the MultiKey. He was arguing that performance during search (access) with a string keys in two spearated hashes was 'faster' or 'more performant' than a single cache with a complex key. His argument was that collisions tend to happen more ofthen when the cache is bigger/complex. I would like to hear your opinion. In the end I used this approach and it works.

For accessing items in the cahe it is necessary to provide the MultiKey object or a means to recreate it. In that sense I created the following helper method

private T GetFromCache<T>(CacheKey.Type type, string key)
{
    var cKey = new MultiKey { KeyType = type, Key = key };
    T item;
    cache.TryGetValue(cKey, out item);

    return item;
}

And I use it like this:

public User GetUserByUserName(string userName)
{
    return this.GetFromDictionary<User>(MultiKey.Type.UserName, userName);
}

public User GetIndividualByEmployeeNumber(string employeeNumber)
{
    return this.GetFromDictionary<User>(MultiKey.Type.EmployeeNumber, employeeNumber);
}