public void GetCacheTemplateFromReflectionType()
{
var reflectionType = typeof(IProductRepository);
var cacheConfiguration = new InterfaceCacheConfiguration();
var template = reflectionType.GetCacheTemplateFromReflectionType(cacheConfiguration);
Assert.Equal(reflectionType.FullName, template.InterfaceName);
}
private static void DecorateWithCacheProxy(this IServiceCollection services, InterfaceCacheConfiguration repositoryInterface)
{
var serviceMatched = services.FirstOrDefault(x => x.ServiceType.Name == repositoryInterface.Name);
if (serviceMatched == null)
{
return;
}
var typeService = serviceMatched.ServiceType;
services.Decorate(typeService, (service, provider) =>
{
return(CreateCacheProxy(provider, typeService, service, repositoryInterface));
});
}
private static IEnumerable <InterfaceCacheConfiguration> GetInterfaceCacheConfigurations(this IConfiguration configuration, string keyConfiguration)
{
var dynamicServices = configuration.GetSection(keyConfiguration).GetChildren();
foreach (var serviceConfiguration in dynamicServices)
{
var interfaceCacheConfiguration = new InterfaceCacheConfiguration(serviceConfiguration.Key);
var methodsConfiguration = serviceConfiguration.GetChildren();
foreach (var methodConfiguration in methodsConfiguration)
{
var methodName = methodConfiguration.Key;
var methodCacheConfiguration = methodConfiguration.Get <MethodCacheConfiguration>();
interfaceCacheConfiguration
.AddMethod(methodName, methodCacheConfiguration.KeyTemplate, methodCacheConfiguration.ExpirationSeconds);
}
yield return(interfaceCacheConfiguration);
}
}
private static dynamic CreateCacheProxy(
IServiceProvider services,
Type typeService,
dynamic decoratedService,
InterfaceCacheConfiguration repositoryInterface)
{
var nameCreateMethod = nameof(DispatchProxy.Create);
var dispatchProxyMethod = typeof(DispatchProxy).GetMethod(nameCreateMethod);
var cacheRepositoryProxy = typeof(DefensiveCacheProxy <>).MakeGenericType(typeService);
dynamic proxy = dispatchProxyMethod.MakeGenericMethod(typeService, cacheRepositoryProxy).Invoke(null, null);
var typeLogger = typeof(ILogger <>).MakeGenericType(typeService);
var logger = (ILogger)services.GetService(typeLogger);
var cacheSerializer = services.GetService <ICacheSerializer>();
proxy.Decorated = decoratedService;
proxy.Logger = logger;
proxy.CacheSerializer = cacheSerializer;
proxy.RepositoryInterface = repositoryInterface;
return(proxy);
}
public static CacheTemplate GetCacheTemplateFromReflectionType(this Type type, InterfaceCacheConfiguration cacheConfiguration)
{
if (type == null)
{
throw new Exception("Service type is no defined.");
}
if (!type.IsInterface)
{
throw new Exception("Only service interfaces are allowed for cache code generation.");
}
var cacheTemplate = new CacheTemplate(type);
foreach (var method in type.GetAllMethods())
{
var methodConfiguration = cacheConfiguration.Methods.FirstOrDefault(x => x.Name == method.Name);
var cacheMethod = new CacheMethodTemplate(method, methodConfiguration);
cacheTemplate.AddMethod(cacheMethod);
}
;
foreach (var property in type.GetProperties())
{
cacheTemplate.AddProperty(property);
}
var methodNamesCacheTemplate = cacheTemplate.Methods.Select(m => m.Name);
var methodNamesCacheConfiguration = cacheConfiguration.Methods.Select(m => m.Name);
var methodsNotMatched = methodNamesCacheConfiguration?.Where(x => !methodNamesCacheTemplate?.Contains(x) ?? false);
if (methodsNotMatched?.Any() ?? false)
{
var methodName = methodsNotMatched.FirstOrDefault();
throw new Exception($"Method '{methodName}' not found in interface {type.Name}.");
}
return(cacheTemplate);
}
public static string GenerateCacheCodeFromType(this Type type, InterfaceCacheConfiguration cacheConfiguration)
{
var cacheTemplate = type.GetCacheTemplateFromReflectionType(cacheConfiguration);
return(GenerateCacheCode(cacheTemplate));
}
public static void DecorateWithCacheDynamicService(this IServiceCollection services, InterfaceCacheConfiguration cacheConfiguration)
{
var serviceMatched = services.FirstOrDefault(x => x.ServiceType.Name == cacheConfiguration.Name);
if (serviceMatched == null)
{
return;
}
var typeService = serviceMatched.ServiceType;
var cacheTemplate = typeService.GetCacheTemplateFromReflectionType(cacheConfiguration);
var cacheCode = TemplateService.GenerateCacheCode(cacheTemplate);
var assemblyCache = CompilerService.GenerateAssemblyFromCode(typeService.Assembly, cacheTemplate.Name, cacheCode);
var typeCache = assemblyCache.GetTypes().FirstOrDefault();
services.Decorate(typeService, typeCache);
}
public static void DecorateWithCacheGeneratedService(this IServiceCollection services, Assembly assembly, InterfaceCacheConfiguration cacheConfiguration)
{
var serviceMatched = services.FirstOrDefault(x => x.ServiceType.Name == cacheConfiguration.Name);
if (serviceMatched == null)
{
return;
}
var typeService = serviceMatched.ServiceType;
var generatedType = assembly.GetTypes().FirstOrDefault(x => x.Name == cacheConfiguration.Name + CacheTemplate.NameSuffix);
if (generatedType == null)
{
return;
}
services.Decorate(typeService, generatedType);
}