using System;

using System.Collections.Generic;

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Text;

using System.Collections.Concurrent;

using System.Security.Cryptography;

using Testing.Two;

​

public class Program

{

    public static void Main()

    {

        var generator = new CacheKeyGenerator();

        for(var i = 0; i <1000; i++)

        {

            Console.WriteLine($"cache key: {generator.GenerateCacheKey<Program, List<TestThree<TestEnum, Test>>>(9999)}");

            Console.WriteLine($"cache key: {generator.GenerateCacheKey<Program, Test>(0)}");

            Console.WriteLine($"cache key: {generator.GenerateCacheKey<Program, TestEnum>(0)}");

        }

​

    }

}

​

   public class CacheKeyGenerator

  {

    private static readonly ConcurrentDictionary<Type, string> ReturnTypePropertyString = new ConcurrentDictionary<Type, string>();

    private static readonly ConcurrentDictionary<Type, IEnumerable<PropertyInfo>> TypeProperties = new ConcurrentDictionary<Type, IEnumerable<PropertyInfo>>();

    /// <summary>

    /// Generates a cache key based on dealer id and caller info.

    /// </summary>

    /// <typeparam name="TCaller">The caller type</typeparam>

    /// <typeparam name="TReturn">The caller's return type</typeparam>

    /// <param name="dealerId">The current dealer's id</param>

    /// <param name="memberName">Calling member's name. DON'T SET THIS UNLESS YOU KNOW WHAT YOU'RE DOING. The compiler will do some magic and fill it in for us :)</param>

    /// <returns>CacheKey</returns>

    public string GenerateCacheKey<TCaller, TReturn>(int dealerId, [CallerMemberName] string memberName = "")

    {

      var propertyString = ReturnTypePropertyString.GetOrAdd(typeof(TReturn), CreatePropertyString);

      // We want cache keys to change per dealer, per different calling type and calling member, and we also want the key to change if the shape of the caller return type changes.

      var key = $"(dealer:{dealerId})_(caller:{GetName(typeof(TCaller))}.{memberName})_(return-type:{GetName(typeof(TReturn))})_(property-hash:{propertyString})";

​

      return key;

​

      string GetName(Type type)

      {

        var nameBuilder = new StringBuilder();

        if (!type.IsGenericType)

        {

          return type.FullName;

        }

​

        var position = 0;

        type.GenericTypeArguments.ForEach(t =>  nameBuilder.Append($"{(position == 0 ? $"{type.Name}<" : string.Empty)}{(position >= 1 ? "," : string.Empty)}T{++position}:{(t.IsGenericType ? GetName(t) : t.FullName)}"));

        nameBuilder.Append(">");

        return nameBuilder.ToString();

​

      }

    }

​

    /// <summary>

    /// Generates a cache key based on caller info.

    /// </summary>

    /// <typeparam name="TCaller">The caller type</typeparam>

    /// <typeparam name="TReturn">The caller's return type</typeparam>

    /// <param name="memberName">Calling member's name. DON'T SET THIS UNLESS YOU KNOW WHAT YOU'RE DOING. The compiler will do some magic and fill it in for us :)</param>

    /// <returns>CacheKey</returns>

    public string GenerateGlobalCacheKey<TCaller, TReturn>([CallerMemberName] string memberName = "")

    {

      // Global cache keys will be denoted by a '0' prefix.

      return GenerateCacheKey<TCaller, TReturn>(0, memberName);

    }

​

    private static string CreatePropertyString(Type type)

    {

      var properties = new List<PropertyInfo>();

      if (type.IsGenericType)

      {

        type.GetGenericArguments().ForEach(GetProperties);

      }

      else

      {

        GetProperties(type);

      }

​

      var propertyStringBuilder = new StringBuilder();

      foreach (var property in properties)

      {

        propertyStringBuilder.Append($"({property.Name}:{property.PropertyType.FullName})");

      }

​

      return GetHashFromPropertyString();

​

      #region Local functions

      void GetProperties(Type typeWithProperties)

      {

        var typeProperties = TypeProperties.GetOrAdd(typeWithProperties, t => t.GetProperties());

        foreach (var typeProperty in typeProperties)

        {

          if (TypeIsNotPrimitiveOrString(typeProperty.PropertyType))

          {

            if (typeProperty.PropertyType.IsGenericType)

            {

              typeProperty.PropertyType.GetGenericArguments().ForEach(GetProperties);

            }

            else

            {

              GetProperties(typeProperty.PropertyType);

            }

          }

​

          properties.Add(typeProperty);

        }

​

        bool TypeIsNotPrimitiveOrString(Type t) => !t.IsPrimitive && t != typeof(string);

      }

​

      string GetHashFromPropertyString()

      {

        using (var sha256Hash = SHA256.Create())

        {

          var bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(propertyStringBuilder.ToString()));

​

          var builder = new StringBuilder();

          foreach (var @byte in bytes)

          {

            builder.Append(@byte.ToString("x2"));

          }

​

          return builder.ToString();

        }

      }

      #endregion

    }

  }

namespace Testing.Two{

public class Test

{

  public TestTwo TestTwo {get;}

}

}

public class TestTwo

{

    public string MessageTwo {get;}

}

​

public class TestThree<T, T2>

{

    public int Property {get;}

    public Test PropertyTwo {get;}

}

​

public enum TestEnum

{

    Testing = 1

}

​

public static class Extensions

{

    public static void ForEach<T>(this IEnumerable<T> ie, Action<T> action)

    {

      foreach (var i in ie)

      {

        action(i);

      }

    }

}