Added NoCache attribute, closes #1

Author: pergerch

src/SpatialFocus.MethodCache.Fody/Extensions/MethodDefinitionExtension.cs

@@ -28,6 +28,24 @@ public static bool HasCacheAttribute(this MethodDefinition methodDefinition, Ref
 				classAttribute => classAttribute.AttributeType.Resolve().Equals(cacheAttributeType));
 		}
 
+		public static bool HasNoCacheAttribute(this MethodDefinition methodDefinition, References references)
+		{
+			if (methodDefinition == null)
+			{
+				throw new ArgumentNullException(nameof(methodDefinition));
+			}
+
+			if (references == null)
+			{
+				throw new ArgumentNullException(nameof(references));
+			}
+
+			TypeReference noCacheAttributeType = references.NoCacheAttributeType.Resolve();
+
+			return methodDefinition.CustomAttributes.Any(classAttribute =>
+				classAttribute.AttributeType.Resolve().Equals(noCacheAttributeType));
+		}
+
 		public static bool IsEligibleForWeaving(this MethodDefinition methodDefinition, References references)
 		{
 			if (methodDefinition == null)

src/SpatialFocus.MethodCache.Fody/ModuleWeaver.cs

@@ -12,23 +12,27 @@ namespace SpatialFocus.MethodCache.Fody
 
 	public partial class ModuleWeaver : BaseModuleWeaver
 	{
-		public override bool ShouldCleanReference => true;
+		public override bool ShouldCleanReference => false;
 
 		public override void Execute()
 		{
 			References references = Fody.References.Init(this);
 
 			foreach (WeavingCandidate weavingCandidate in ModuleDefinition.GetWeavingCandidates(references))
 			{
-				if (weavingCandidate.ClassDefinition.HasCacheAttribute(references) && !weavingCandidate.MethodDefinitions.Any(x => x.IsEligibleForWeaving(references)))
+				if (weavingCandidate.ClassDefinition.HasCacheAttribute(references) && !weavingCandidate.MethodDefinitions
+					.Where(x => !x.HasNoCacheAttribute(references))
+					.Any(x => x.IsEligibleForWeaving(references)))
 				{
-					WriteWarning($"Class {weavingCandidate.ClassDefinition.Resolve().FullName} contains [Cache] attribute but does not contain eligible methods for caching");
+					WriteWarning(
+						$"Class {weavingCandidate.ClassDefinition.Resolve().FullName} contains [Cache] attribute but does not contain eligible methods for caching");
 					continue;
 				}
 
 				if (!weavingCandidate.ClassDefinition.IsEligibleForWeaving(references))
 				{
-					WriteWarning($"Class {weavingCandidate.ClassDefinition.Name} contains [Cache] attribute but does not contain a single non-inherited property implementing IMemoryCache interface");
+					WriteWarning(
+						$"Class {weavingCandidate.ClassDefinition.Name} contains [Cache] attribute but does not contain a single non-inherited property implementing IMemoryCache interface");
 					continue;
 				}
 
@@ -49,6 +53,11 @@ public override void Execute()
 						continue;
 					}
 
+					if (methodDefinition.HasNoCacheAttribute(references))
+					{
+						continue;
+					}
+
 					MethodWeavingContext methodWeavingContext = new MethodWeavingContext(classWeavingContext, methodDefinition);
 
 					MemoryCache.AddMethodVariables(methodWeavingContext);

src/SpatialFocus.MethodCache.Fody/References.cs

@@ -29,6 +29,8 @@ protected References(ModuleWeaver moduleWeaver)
 
 		public TypeReference MemoryCacheInterface { get; protected set; }
 
+		public TypeReference NoCacheAttributeType { get; set; }
+
 		public MethodReference SetMethod { get; protected set; }
 
 		public MethodReference TryGetValueMethod { get; protected set; }
@@ -49,6 +51,9 @@ public static References Init(ModuleWeaver moduleWeaver)
 			TypeDefinition cacheAttributeType = moduleWeaver.FindTypeDefinition("SpatialFocus.MethodCache.CacheAttribute");
 			references.CacheAttributeType = moduleWeaver.ModuleDefinition.ImportReference(cacheAttributeType);
 
+			TypeDefinition noCacheAttributeType = moduleWeaver.FindTypeDefinition("SpatialFocus.MethodCache.NoCacheAttribute");
+			references.NoCacheAttributeType = moduleWeaver.ModuleDefinition.ImportReference(noCacheAttributeType);
+
 			TypeDefinition type = moduleWeaver.FindTypeDefinition(typeof(Type).FullName);
 			references.TypeType = moduleWeaver.ModuleDefinition.ImportReference(type);
 
@@ -67,7 +72,9 @@ public static References Init(ModuleWeaver moduleWeaver)
 			references.TryGetValueMethod =
 				moduleWeaver.ModuleDefinition.ImportReference(cacheExtensions.Methods.Single(x => x.Name == "TryGetValue"));
 
-			references.SetMethod = moduleWeaver.ModuleDefinition.ImportReference(cacheExtensions.Methods.Single(x => x.Name == "Set" && x.HasParameters && x.Parameters.Count == 3));
+			references.SetMethod =
+				moduleWeaver.ModuleDefinition.ImportReference(cacheExtensions.Methods.Single(x =>
+					x.Name == "Set" && x.HasParameters && x.Parameters.Count == 3));
 
 			return references;
 		}

src/SpatialFocus.MethodCache.Sample.Library/BasicSample.cs

@@ -4,6 +4,7 @@
 
 namespace SpatialFocus.MethodCache.Sample.Library
 {
+	using System;
 	using Microsoft.Extensions.Caching.Memory;
 
 	// MethodCache.Fody will look for classes and methods decorated with the Cache attribute
@@ -18,11 +19,19 @@ public BasicSample(IMemoryCache memoryCache)
 		// MethodCache.Fody will look for a property implementing the IMemoryCache
 		protected IMemoryCache MemoryCache { get; }
 
+#pragma warning disable CA1062 // Validate arguments of public methods
 #pragma warning disable CA1822 // Mark members as static
 		public int Add(int a, int b)
 		{
 			return a + b;
 		}
+
+		[NoCache]
+		public int GetRandomNumber(Random random)
+		{
+			return random.Next();
+		}
+#pragma warning restore CA1062 // Validate arguments of public methods
 #pragma warning restore CA1822 // Mark members as static
 	}
 }

src/SpatialFocus.MethodCache.Sample.Library/BasicSampleWeaved.cs

@@ -33,5 +33,11 @@ public int Add(int a, int b)
 			MemoryCache.Set<int>(key, value);
 			return value;
 		}
+
+		public int GetRandomNumber(Random random)
+		{
+			// The NoCache attribute was specified for this method, hence no additional code weaved
+			return random.Next();
+		}
 	}
 }

src/SpatialFocus.MethodCache.TestAssembly/BasicTestClass.cs

@@ -21,6 +21,12 @@ public int Add(int a, int b)
 		{
 			return a + b;
 		}
+
+		[NoCache]
+		public int UncachedAdd(int a, int b)
+		{
+			return a + b;
+		}
 #pragma warning restore CA1822 // Mark members as static
 	}
 }

src/SpatialFocus.MethodCache.Tests/MemoryCacheBasicTests.cs

@@ -67,5 +67,21 @@ public void BasicTest3Create2AndGet2()
 			Assert.Equal(2, mockMemoryCache.CountSets);
 			Assert.Equal(2, mockMemoryCache.CountGets);
 		}
+
+		[Fact]
+		public void BasicTest4NoCache()
+		{
+			using MockMemoryCache mockMemoryCache = new MockMemoryCache();
+
+			dynamic instance = TestHelpers.CreateInstance<BasicTestClass>(MemoryCacheBasicTests.TestResult.Assembly, mockMemoryCache);
+
+			dynamic result1 = instance.UncachedAdd(1, 2);
+			dynamic result2 = instance.UncachedAdd(2, 2);
+
+			Assert.Equal(3, result1);
+			Assert.Equal(4, result2);
+			Assert.Equal(0, mockMemoryCache.CountSets);
+			Assert.Equal(0, mockMemoryCache.CountGets);
+		}
 	}
 }

src/SpatialFocus.MethodCache/NoCacheAttribute.cs

@@ -0,0 +1,16 @@
+// <copyright file="NoCacheAttribute.cs" company="Spatial Focus GmbH">
+// Copyright (c) Spatial Focus GmbH. All rights reserved.
+// </copyright>
+
+namespace SpatialFocus.MethodCache
+{
+	using System;
+
+	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
+	public sealed class NoCacheAttribute : Attribute
+	{
+		public NoCacheAttribute()
+		{
+		}
+	}
+}