Open sandboxFocusImprove this doc
  • TOC
  • Article

Troubleshooting Metalama Caching

If you need to troubleshoot the caching feature, you can enable verbose logging.

With dependency injection

If your application utilizes dependency injection, add the .NET logging service as usual using the AddLogging extension method. The the AddMetalamaCaching extension method automatically uses logging when available.

Therefore, to troubleshoot caching, just set the minimum caching level to Debug using the SetMinimumLevel method.

The following code snippet illustrates this:

15        // Add logging.
16        builder.ConfigureLogging(
17            logging =>
18                logging.SetMinimumLevel( LogLevel.Debug ) );

Example: Logging of caching with dependency injection

The following is an update to the getting started example, with logging enabled. You can observe detailed logging in the program output.

See on GitHub | Full screen
Source Code
1using Metalama.Patterns.Caching.Aspects;
2using System;

3

4namespace Doc.Logging;

5
6public sealed class CloudCalculator
7{
8    public int OperationCount { get; private set; }
9
10    [Cache]
11    public int Add( int a, int b )
12    {
13        Console.WriteLine( "Doing some very hard work." );
14










15        this.OperationCount++;
16
17        return a + b;
18    }
19}
Transformed Code
1using Metalama.Patterns.Caching;
2using Metalama.Patterns.Caching.Aspects;
3using Metalama.Patterns.Caching.Aspects.Helpers;
4using System;
5using System.Reflection;
6
7namespace Doc.Logging;
8
9public sealed class CloudCalculator
10{
11    public int OperationCount { get; private set; }
12
13    [Cache]
14    public int Add(int a, int b)
15    {
16        static object? Invoke(object? instance, object?[] args)
17        {
18            return ((CloudCalculator)instance).Add_Source((int)args[0], (int)args[1]);
19        }
20
21        return _cachingService.GetFromCacheOrExecute<int>(_cacheRegistration_Add, this, new object[] { a, b }, Invoke);
22    }
23
24    private int Add_Source(int a, int b)
25    {
26        Console.WriteLine("Doing some very hard work.");
27
28        this.OperationCount++;
29
30        return a + b;
31    }
32
33    private static readonly CachedMethodMetadata _cacheRegistration_Add;
34    private ICachingService _cachingService;
35
36    static CloudCalculator()
37    {
38        _cacheRegistration_Add = CachedMethodMetadata.Register(typeof(CloudCalculator).GetMethod("Add", BindingFlags.Public | BindingFlags.Instance, null, new[] { typeof(int), typeof(int) }, null).ThrowIfMissing("CloudCalculator.Add(int, int)"), new CachedMethodConfiguration() { AbsoluteExpiration = null, AutoReload = null, IgnoreThisParameter = null, Priority = null, ProfileName = (string?)null, SlidingExpiration = null }, false);
39    }
40
41    public CloudCalculator(ICachingService? cachingService = null)
42    {
43        this._cachingService = cachingService ?? throw new System.ArgumentNullException(nameof(cachingService));
44    }
45}

Without dependency injection

The CachingService object and other components of Metalama Caching acquire the IFlashtraceLoggerFactory interface through the IServiceProvider. To enable logging, you must provide an implementation of IServiceProvider that supports the IFlashtraceLoggerFactory interface. Then, pass this IServiceProvider to the CachingService.Create method. You can use the TraceSourceLoggerFactory class, which relies on the TraceSource system class.

If you plan to implement the IFlashtraceLoggerFactory yourself, you may find the SimpleFlashtraceLogger useful.

  • Navigation