C#, generate a constant Key for an array of object

Question

I would like to save in Cache an object with a constant Key.

    public TItem Set<TItem>(string key, TItem value)
    {
        return = _memoryCache.Set(key, value);
    }

I get my object with a function like:

    public TItem Get(
        TPrimaryKey id,
        params object[] args,
        bool byPassCaching = false
    )
    {
        if (byPassCaching || !_cacheManager.TryGetValue<TItem>(GetKey(id, args), out TItem result)){
           item = [FUNCTION TO GET ITEM];
           _cacheManager.Set(GetKey(id, args), item)
        }
        return item;
    }

I would like to generate a constant key for a TItem, Id (int) and some params (object[] args).

Here is my function to generate the constant key:

    internal static string GetKey<TItem>(int id, params object[] args)
    {
        return string.Format("{0}#{1}[{2}]", typeof(TItem).FullName, id, args?[FUNCTION TO CALL]);
    }

[FUNCTION TO CALL] is the function I m looking for.

So next time I call the function with the same parameter, I will have the same key.

For exemple

GetKey<MyClass>(1, null) => "MyApp.MyClass#1[]"
GetKey<MyClass>(1, "Hello", "World") => "MyApp.MyClass#1[sdas5d1as5d4sd8]"
GetKey<MyClass>(1, "Hello", "World") => "MyApp.MyClass#1[sdas5d1as5d4sd8]"
GetKey<MyClass>(1, item => item.Include(s => s.Categories)) => "MyApp.MyClass#1[asdasdasd87wqw]"

At the beginning, I thought to use GetHashCode, but the int generated is always different.

How can I do that?

Answer 1

I think GetHashCode is what you need; were you calling GetHashCode on the array, or calling it on each member of the array? You want to do the latter.

The following should be similar to what you want; if the params is null or empty, or full of null objects, then the code will be 00000000.

Otherwise, if the params are the same, then the resulting hash will be the same. And if the params are in a different order or different values, then the hash will be different.

internal static string GetKey<TEntity>(int id, params object[] args)
{
    return string.Format("{0}#{1}[{2}]", typeof(TEntity).FullName, id, ArrayHash(args));
}

static string ArrayHash(params object[] values)
{
    return BitConverter.ToString(BitConverter.GetBytes(ArrayHashCode(values))).Replace("-", "").ToLowerInvariant();
}

static int ArrayHashCode(params object[] values)
{
    if (values == null || values.Length == 0) return 0;
    var value = values[0];
    int hashCode = value == null ? 0 : value.GetHashCode();
    for (int i = 1; i < values.Length; i++)
    {
        value = values[i];
        unchecked
        {
            hashCode = (hashCode * 397) ^ (value == null ? 0 : value.GetHashCode());
        }
    }
    return hashCode;
}

Note that 397 is a prime number that I picked up from ReSharper's GetHashCode implementation, allowing a nice distribution of hash codes through the overflow (gracefully allowed with the unchecked block).

An example of the hashed params would be like so:

ArrayHash( 1, null, "test" )     => "dee9e1ea"
ArrayHash( 1, null, "test" )     => "dee9e1ea"
ArrayHash( null, 1, "test" )     => "fa8fe3ea"
ArrayHash("one", "two", "three") => "8841b2be"
ArrayHash()                      => "00000000"
ArrayHash(null)                  => "00000000"
ArrayHash(new object[] {})       => "00000000"

Note that if the params array contains objects, they need to have a proper GetHashCode implementation too.