Merge branch 'master' of https://github.com/Dresel/MethodCache.git

Dresel · Dresel · commit 0112a546eb85 · 2016-11-03T11:27:47.000+01:00
diff --git a/MethodCache.Attributes/Properties/AssemblyInfo.cs b/MethodCache.Attributes/Properties/AssemblyInfo.cs
@@ -22,5 +22,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.4.1.0")]
-[assembly: AssemblyFileVersion("1.4.1.0")]
+[assembly: AssemblyVersion("1.5.0.0")]
+[assembly: AssemblyFileVersion("1.5.0.0")]
diff --git a/MethodCache.Fody/CecilHelper.cs b/MethodCache.Fody/CecilHelper.cs
@@ -48,7 +48,7 @@ public static Instruction AppendLd(this Instruction instruction, ILProcessor pro
 			// System.Type
 			// An enum type, provided it has public accessibility and the types in which it is nested (if any) also have public accessibility (§17.2)
 			// Single-dimensional arrays of the above types
-			var argumentType = argument.Type;
+			TypeReference argumentType = argument.Type;
 
 			switch (argumentType.MetadataType)
 			{
@@ -72,7 +72,7 @@ public static Instruction AppendLd(this Instruction instruction, ILProcessor pro
 						.AppendLdcI4(processor, values.Length)
 						.Append(processor.Create(OpCodes.Newarr, argument.Type.GetElementType()), processor);
 
-					var arrayType = argument.Type.GetElementType();
+					TypeReference arrayType = argument.Type.GetElementType();
 
 					for (int i = 0; i < values.Length; i++)
 					{
@@ -330,19 +330,19 @@ public static MethodReference MakeGeneric(this MethodReference method, params Ty
 
 		public static MethodReference MakeHostInstanceGeneric(this MethodReference self, params TypeReference[] args)
 		{
-			var reference = new MethodReference(self.Name, self.ReturnType, self.DeclaringType.MakeGenericInstanceType(args))
+			MethodReference reference = new MethodReference(self.Name, self.ReturnType, self.DeclaringType.MakeGenericInstanceType(args))
 			{
 				HasThis = self.HasThis,
 				ExplicitThis = self.ExplicitThis,
 				CallingConvention = self.CallingConvention
 			};
 
-			foreach (var parameter in self.Parameters)
+			foreach (ParameterDefinition parameter in self.Parameters)
 			{
 				reference.Parameters.Add(new ParameterDefinition(parameter.ParameterType));
 			}
 
-			foreach (var genericParam in self.GenericParameters)
+			foreach (GenericParameter genericParam in self.GenericParameters)
 			{
 				reference.GenericParameters.Add(new GenericParameter(genericParam.Name, reference));
 			}
diff --git a/MethodCache.Fody/ModuleWeaver.cs b/MethodCache.Fody/ModuleWeaver.cs
@@ -179,7 +179,7 @@ private MethodDefinition CacheTypeGetRetrieveMethod(TypeDefinition cacheType, st
 		private MethodDefinition CacheTypeGetStoreMethod(TypeDefinition cacheInterface, string cacheTypeStoreMethodName)
 		{
 			// Prioritize Store methods with parameters Dictionary
-			var methodDefinition = cacheInterface.GetMethod(cacheTypeStoreMethodName, ModuleDefinition.TypeSystem.Void,
+			MethodDefinition methodDefinition = cacheInterface.GetMethod(cacheTypeStoreMethodName, ModuleDefinition.TypeSystem.Void,
 				new[]
 				{
 					ModuleDefinition.TypeSystem.String, ModuleDefinition.TypeSystem.Object,
@@ -590,7 +590,7 @@ private void WeaveMethod(MethodDefinition methodDefinition, CustomAttribute attr
 						.Append(processor.Create(OpCodes.Newobj,
 							methodDefinition.Module.Import(References.DictionaryConstructor)), processor);
 
-					foreach (CustomAttributeNamedArgument property in attribute.Properties)
+					foreach (CustomAttributeNamedArgument property in attribute.Properties.Union(attribute.Fields))
 					{
 						returnInstruction.Previous
 							.AppendDup(processor)
diff --git a/MethodCache.Fody/Properties/AssemblyInfo.cs b/MethodCache.Fody/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.4.1.0")]
-[assembly: AssemblyFileVersion("1.4.1.0")]
+[assembly: AssemblyVersion("1.5.0.0")]
+[assembly: AssemblyFileVersion("1.5.0.0")]
diff --git a/MethodCache.Fody/ReferenceFinder.cs b/MethodCache.Fody/ReferenceFinder.cs
@@ -34,15 +34,15 @@ public class References
 
 		public void LoadReferences()
 		{
-			var coreTypes = new List<TypeDefinition>();
+			List<TypeDefinition> coreTypes = new List<TypeDefinition>();
 
 			AppendTypes("System.Runtime.Extensions", coreTypes);
 			AppendTypes("System", coreTypes);
 			AppendTypes("mscorlib", coreTypes);
 			AppendTypes("System.Runtime", coreTypes);
 			AppendTypes("System.Reflection", coreTypes);
 
-			var debugType = GetDebugType(coreTypes);
+			TypeDefinition debugType = GetDebugType(coreTypes);
 
 			DebugWriteLineMethod =
 				debugType.Methods.First(
@@ -90,7 +90,7 @@ public void LoadReferences()
 
 		private void AppendTypes(string name, List<TypeDefinition> coreTypes)
 		{
-			var definition = AssemblyResolver.Resolve(name);
+			AssemblyDefinition definition = AssemblyResolver.Resolve(name);
 			if (definition != null)
 			{
 				coreTypes.AddRange(definition.MainModule.Types);
@@ -99,14 +99,14 @@ private void AppendTypes(string name, List<TypeDefinition> coreTypes)
 
 		private TypeDefinition GetDebugType(List<TypeDefinition> coreTypes)
 		{
-			var debugType = coreTypes.FirstOrDefault(x => x.Name == "Debug");
+			TypeDefinition debugType = coreTypes.FirstOrDefault(x => x.Name == "Debug");
 
 			if (debugType != null)
 			{
 				return debugType;
 			}
 
-			var systemDiagnosticsDebug = AssemblyResolver.Resolve("System.Diagnostics.Debug");
+			AssemblyDefinition systemDiagnosticsDebug = AssemblyResolver.Resolve("System.Diagnostics.Debug");
 
 			if (systemDiagnosticsDebug != null)
 			{
@@ -123,7 +123,7 @@ private TypeDefinition GetDebugType(List<TypeDefinition> coreTypes)
 
 		private TypeDefinition GetDictionaryInterface(List<TypeDefinition> coreTypes)
 		{
-			var dictionaryType = coreTypes.FirstOrDefault(x => x.Name == "IDictionary`2");
+			TypeDefinition dictionaryType = coreTypes.FirstOrDefault(x => x.Name == "IDictionary`2");
 
 			if (dictionaryType != null)
 			{
@@ -135,7 +135,7 @@ private TypeDefinition GetDictionaryInterface(List<TypeDefinition> coreTypes)
 
 		private TypeDefinition GetDictionaryType(List<TypeDefinition> coreTypes)
 		{
-			var dictionaryType = coreTypes.FirstOrDefault(x => x.Name == "Dictionary`2");
+			TypeDefinition dictionaryType = coreTypes.FirstOrDefault(x => x.Name == "Dictionary`2");
 
 			if (dictionaryType != null)
 			{
@@ -147,7 +147,7 @@ private TypeDefinition GetDictionaryType(List<TypeDefinition> coreTypes)
 
 		private TypeDefinition GetSystemRuntimeTypeHandleType(List<TypeDefinition> coreTypes)
 		{
-			var runtimeTypeHandle = coreTypes.FirstOrDefault(x => x.Name == "RuntimeTypeHandle");
+			TypeDefinition runtimeTypeHandle = coreTypes.FirstOrDefault(x => x.Name == "RuntimeTypeHandle");
 
 			if (runtimeTypeHandle != null)
 			{
@@ -159,7 +159,7 @@ private TypeDefinition GetSystemRuntimeTypeHandleType(List<TypeDefinition> coreT
 
 		private TypeDefinition GetSystemTypeType(List<TypeDefinition> coreTypes)
 		{
-			var systemType = coreTypes.FirstOrDefault(x => x.Name == "Type");
+			TypeDefinition systemType = coreTypes.FirstOrDefault(x => x.Name == "Type");
 
 			if (systemType != null)
 			{
diff --git a/MethodCache.Nuget/MethodCache.nuspec b/MethodCache.Nuget/MethodCache.nuspec
@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
     <metadata>
         <id>MethodCache.Fody</id>
-        <version>1.4.1</version>
+        <version>1.5.0-alpha1</version>
         <title>MethodCache.Fody</title>
         <authors>Christopher Dresel</authors>
         <owners>Christopher Dresel</owners>
diff --git a/MethodCache.Nuget/readme.txt b/MethodCache.Nuget/readme.txt
@@ -1,3 +1,5 @@
+Since 1.5.0.0 it is now possible to use custom CacheAttribute parameters for fine-grained cache control (see https://github.com/Dresel/MethodCache section "CacheAttribute Parameters Support" for details).
+
 Since 1.4.0.0 it is now possible to also cache properties (see https://github.com/Dresel/MethodCache for details).
 
 If you want this package to behave as previous packages (let class level [Cache] attribute only cache methods), modify ModuleWeavers.xml to:
diff --git a/MethodCache.Tests.TestAssembly/Cache/CacheAttribute.cs b/MethodCache.Tests.TestAssembly/Cache/CacheAttribute.cs
@@ -9,5 +9,7 @@ public class CacheAttribute : Attribute
 		public int Parameter2 { get; set; }
 
 		public bool Parameter3 { get; set; }
+
+		public double parameter3;
 	}
 }
diff --git a/MethodCache.Tests.TestAssembly/Properties/AssemblyInfo.cs b/MethodCache.Tests.TestAssembly/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.4.1.0")]
-[assembly: AssemblyFileVersion("1.4.1.0")]
+[assembly: AssemblyVersion("1.5.0.0")]
+[assembly: AssemblyFileVersion("1.5.0.0")]
diff --git a/MethodCache.Tests.TestAssembly/TestClassWithParameterizedCacheAttribute.cs b/MethodCache.Tests.TestAssembly/TestClassWithParameterizedCacheAttribute.cs
@@ -20,6 +20,12 @@ public string CacheParameterMethod(string argument1, int argument2)
 			return argument1 + argument2;
 		}
 
+		[Cache.Cache(Parameter3 = true, parameter3 = 0)]
+		public string CacheParameterMethodWithField(string argument1, int argument2)
+		{
+			return argument1 + argument2;
+		}
+
 		[Cache.ComplexCacheAttribute.Cache(ParameterBoolArray = new bool[] { false, true },
 			ParameterByteArray = new byte[] { Byte.MinValue, Byte.MaxValue },
 			ParameterCharacterArray = new char[] { Char.MinValue, Char.MaxValue },
diff --git a/MethodCache.Tests/AssemblyResolverMock.cs b/MethodCache.Tests/AssemblyResolverMock.cs
@@ -20,12 +20,12 @@ public AssemblyDefinition Resolve(string fullName)
 		{
 			if (fullName == "System")
 			{
-				var codeBase = typeof(Debug).Assembly.CodeBase.Replace("file:///", "");
+				string codeBase = typeof(Debug).Assembly.CodeBase.Replace("file:///", "");
 				return AssemblyDefinition.ReadAssembly(codeBase);
 			}
 			else
 			{
-				var codeBase = typeof(string).Assembly.CodeBase.Replace("file:///", "");
+				string codeBase = typeof(string).Assembly.CodeBase.Replace("file:///", "");
 				return AssemblyDefinition.ReadAssembly(codeBase);
 			}
 		}
diff --git a/MethodCache.Tests/ParameterizedCacheAttributeWithParameterTests.cs b/MethodCache.Tests/ParameterizedCacheAttributeWithParameterTests.cs
@@ -105,7 +105,7 @@ public void TestClassWithParameterizedCacheAttributeComplexCacheAttributePassesP
 			Assert.IsTrue(cache.NumStoreParameterCalls == 1);
 			Assert.IsTrue(cache.ParametersPassedToLastStoreCall.Count == 1);
 
-			var type = (dynamic)WeaverHelper.CreateType<EnumType>(Assembly);
+			dynamic type = WeaverHelper.CreateType<EnumType>(Assembly);
 
 			Assert.IsInstanceOfType(type, cache.ParametersPassedToLastStoreCall["ParameterEnum"]);
 			Assert.IsTrue(cache.ParametersPassedToLastStoreCall["ParameterEnum"] ==
@@ -126,8 +126,8 @@ public void TestClassWithParameterizedCacheAttributeComplexCacheAttributePassesP
 			Assert.IsTrue(cache.NumStoreParameterCalls == 1);
 			Assert.IsTrue(cache.ParametersPassedToLastStoreCall.Count == 1);
 
-			var type = (dynamic)WeaverHelper.CreateType<EnumType>(Assembly);
-			var typeArray = (dynamic)WeaverHelper.CreateType<EnumType[]>(Assembly);
+			dynamic type = WeaverHelper.CreateType<EnumType>(Assembly);
+			dynamic typeArray = WeaverHelper.CreateType<EnumType[]>(Assembly);
 
 			Assert.IsInstanceOfType(typeArray, cache.ParametersPassedToLastStoreCall["ParameterEnumArray"]);
 			Assert.IsTrue(cache.ParametersPassedToLastStoreCall["ParameterEnumArray"][0] ==
@@ -200,7 +200,7 @@ public void TestClassWithParameterizedCacheAttributeComplexCacheAttributePassesP
 			testClass1.ComplexCacheParameterMethodObjectArray();
 
 			// Assert
-			var type = (dynamic)WeaverHelper.CreateType<EnumType>(Assembly);
+			dynamic type = WeaverHelper.CreateType<EnumType>(Assembly);
 
 			Assert.IsTrue(cache.NumStoreParameterCalls == 1);
 			Assert.IsTrue(cache.ParametersPassedToLastStoreCall.Count == 1);
@@ -247,7 +247,7 @@ public void TestClassWithParameterizedCacheAttributeComplexCacheAttributePassesP
 			Assert.IsTrue(cache.NumStoreParameterCalls == 1);
 			Assert.IsTrue(cache.ParametersPassedToLastStoreCall.Count == 1);
 
-			var type = (dynamic)WeaverHelper.CreateType<EnumType>(Assembly);
+			dynamic type = WeaverHelper.CreateType<EnumType>(Assembly);
 
 			Assert.IsInstanceOfType(type, cache.ParametersPassedToLastStoreCall["ParameterObject"]);
 			Assert.IsTrue(cache.ParametersPassedToLastStoreCall["ParameterObject"] ==
@@ -342,6 +342,25 @@ public void TestClassWithParameterizedCacheAttributeComplexCacheAttributePassesP
 			Assert.IsTrue((Type)cache.ParametersPassedToLastStoreCall["ParameterTypeArray"][1] == typeof(List<string>));
 		}
 
+		[Test]
+		public void TestClassWithParameterizedCacheAttributeMethodLevelCacheAttributeAlsoWorksForFields()
+		{
+			// Arrange
+			dynamic cache = WeaverHelper.CreateInstance<DictionaryCache>(Assembly);
+			dynamic testClass1 = WeaverHelper.CreateInstance<TestClassWithParameterizedCacheAttribute>(Assembly, cache);
+
+			// Act
+			testClass1.CacheParameterMethodWithField("1", 2);
+			testClass1.CacheParameterMethodWithField("1", 2);
+
+			// Assert
+			Assert.IsTrue(cache.NumStoreParameterCalls == 1);
+			Assert.IsTrue(cache.NumRetrieveCalls == 1);
+			Assert.IsTrue(cache.ParametersPassedToLastStoreCall.Count == 2);
+			Assert.IsTrue(cache.ParametersPassedToLastStoreCall["Parameter3"] == true);
+			Assert.IsTrue(cache.ParametersPassedToLastStoreCall["parameter3"] == 0);
+		}
+
 		[Test]
 		public void TestClassWithParameterizedCacheAttributeMethodLevelCacheAttributeOverridesParameters()
 		{
diff --git a/MethodCache.Tests/Properties/AssemblyInfo.cs b/MethodCache.Tests/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.4.1.0")]
-[assembly: AssemblyFileVersion("1.4.1.0")]
+[assembly: AssemblyVersion("1.5.0.0")]
+[assembly: AssemblyFileVersion("1.5.0.0")]
diff --git a/README.md b/README.md

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public static Instruction AppendLd(this Instruction instruction, ILProcessor pro`
`48`	`48`	`// System.Type`
`49`	`49`	`// An enum type, provided it has public accessibility and the types in which it is nested (if any) also have public accessibility (§17.2)`
`50`	`50`	`// Single-dimensional arrays of the above types`
`51`		`- var argumentType = argument.Type;`
	`51`	`+ TypeReference argumentType = argument.Type;`
`52`	`52`
`53`	`53`	`switch (argumentType.MetadataType)`
`54`	`54`	`{`
`@@ -72,7 +72,7 @@ public static Instruction AppendLd(this Instruction instruction, ILProcessor pro`
`72`	`72`	`.AppendLdcI4(processor, values.Length)`
`73`	`73`	`.Append(processor.Create(OpCodes.Newarr, argument.Type.GetElementType()), processor);`
`74`	`74`
`75`		`- var arrayType = argument.Type.GetElementType();`
	`75`	`+ TypeReference arrayType = argument.Type.GetElementType();`
`76`	`76`
`77`	`77`	`for (int i = 0; i < values.Length; i++)`
`78`	`78`	`{`
`@@ -330,19 +330,19 @@ public static MethodReference MakeGeneric(this MethodReference method, params Ty`
`330`	`330`
`331`	`331`	`public static MethodReference MakeHostInstanceGeneric(this MethodReference self, params TypeReference[] args)`
`332`	`332`	`{`
`333`		`- var reference = new MethodReference(self.Name, self.ReturnType, self.DeclaringType.MakeGenericInstanceType(args))`
	`333`	`+ MethodReference reference = new MethodReference(self.Name, self.ReturnType, self.DeclaringType.MakeGenericInstanceType(args))`
`334`	`334`	`{`
`335`	`335`	`HasThis = self.HasThis,`
`336`	`336`	`ExplicitThis = self.ExplicitThis,`
`337`	`337`	`CallingConvention = self.CallingConvention`
`338`	`338`	`};`
`339`	`339`
`340`		`- foreach (var parameter in self.Parameters)`
	`340`	`+ foreach (ParameterDefinition parameter in self.Parameters)`
`341`	`341`	`{`
`342`	`342`	`reference.Parameters.Add(new ParameterDefinition(parameter.ParameterType));`
`343`	`343`	`}`
`344`	`344`
`345`		`- foreach (var genericParam in self.GenericParameters)`
	`345`	`+ foreach (GenericParameter genericParam in self.GenericParameters)`
`346`	`346`	`{`
`347`	`347`	`reference.GenericParameters.Add(new GenericParameter(genericParam.Name, reference));`
`348`	`348`	`}`
Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,7 @@ private MethodDefinition CacheTypeGetRetrieveMethod(TypeDefinition cacheType, st`
`179`	`179`	`private MethodDefinition CacheTypeGetStoreMethod(TypeDefinition cacheInterface, string cacheTypeStoreMethodName)`
`180`	`180`	`{`
`181`	`181`	`// Prioritize Store methods with parameters Dictionary`
`182`		`- var methodDefinition = cacheInterface.GetMethod(cacheTypeStoreMethodName, ModuleDefinition.TypeSystem.Void,`
	`182`	`+ MethodDefinition methodDefinition = cacheInterface.GetMethod(cacheTypeStoreMethodName, ModuleDefinition.TypeSystem.Void,`
`183`	`183`	`new[]`
`184`	`184`	`{`
`185`	`185`	`ModuleDefinition.TypeSystem.String, ModuleDefinition.TypeSystem.Object,`
`@@ -590,7 +590,7 @@ private void WeaveMethod(MethodDefinition methodDefinition, CustomAttribute attr`
`590`	`590`	`.Append(processor.Create(OpCodes.Newobj,`
`591`	`591`	`methodDefinition.Module.Import(References.DictionaryConstructor)), processor);`
`592`	`592`
`593`		`- foreach (CustomAttributeNamedArgument property in attribute.Properties)`
	`593`	`+ foreach (CustomAttributeNamedArgument property in attribute.Properties.Union(attribute.Fields))`
`594`	`594`	`{`
`595`	`595`	`returnInstruction.Previous`
`596`	`596`	`.AppendDup(processor)`
Original file line number	Diff line number	Diff line change
`@@ -34,15 +34,15 @@ public class References`
`34`	`34`
`35`	`35`	`public void LoadReferences()`
`36`	`36`	`{`
`37`		`- var coreTypes = new List<TypeDefinition>();`
	`37`	`+ List<TypeDefinition> coreTypes = new List<TypeDefinition>();`
`38`	`38`
`39`	`39`	`AppendTypes("System.Runtime.Extensions", coreTypes);`
`40`	`40`	`AppendTypes("System", coreTypes);`
`41`	`41`	`AppendTypes("mscorlib", coreTypes);`
`42`	`42`	`AppendTypes("System.Runtime", coreTypes);`
`43`	`43`	`AppendTypes("System.Reflection", coreTypes);`
`44`	`44`
`45`		`- var debugType = GetDebugType(coreTypes);`
	`45`	`+ TypeDefinition debugType = GetDebugType(coreTypes);`
`46`	`46`
`47`	`47`	`DebugWriteLineMethod =`
`48`	`48`	`debugType.Methods.First(`
`@@ -90,7 +90,7 @@ public void LoadReferences()`
`90`	`90`
`91`	`91`	`private void AppendTypes(string name, List<TypeDefinition> coreTypes)`
`92`	`92`	`{`
`93`		`- var definition = AssemblyResolver.Resolve(name);`
	`93`	`+ AssemblyDefinition definition = AssemblyResolver.Resolve(name);`
`94`	`94`	`if (definition != null)`
`95`	`95`	`{`
`96`	`96`	`coreTypes.AddRange(definition.MainModule.Types);`
`@@ -99,14 +99,14 @@ private void AppendTypes(string name, List<TypeDefinition> coreTypes)`
`99`	`99`
`100`	`100`	`private TypeDefinition GetDebugType(List<TypeDefinition> coreTypes)`
`101`	`101`	`{`
`102`		`- var debugType = coreTypes.FirstOrDefault(x => x.Name == "Debug");`
	`102`	`+ TypeDefinition debugType = coreTypes.FirstOrDefault(x => x.Name == "Debug");`
`103`	`103`
`104`	`104`	`if (debugType != null)`
`105`	`105`	`{`
`106`	`106`	`return debugType;`
`107`	`107`	`}`
`108`	`108`
`109`		`- var systemDiagnosticsDebug = AssemblyResolver.Resolve("System.Diagnostics.Debug");`
	`109`	`+ AssemblyDefinition systemDiagnosticsDebug = AssemblyResolver.Resolve("System.Diagnostics.Debug");`
`110`	`110`
`111`	`111`	`if (systemDiagnosticsDebug != null)`
`112`	`112`	`{`
`@@ -123,7 +123,7 @@ private TypeDefinition GetDebugType(List<TypeDefinition> coreTypes)`
`123`	`123`
`124`	`124`	`private TypeDefinition GetDictionaryInterface(List<TypeDefinition> coreTypes)`
`125`	`125`	`{`
`126`		- var dictionaryType = coreTypes.FirstOrDefault(x => x.Name == "IDictionary`2");
	`126`	+ TypeDefinition dictionaryType = coreTypes.FirstOrDefault(x => x.Name == "IDictionary`2");
`127`	`127`
`128`	`128`	`if (dictionaryType != null)`
`129`	`129`	`{`
`@@ -135,7 +135,7 @@ private TypeDefinition GetDictionaryInterface(List<TypeDefinition> coreTypes)`
`135`	`135`
`136`	`136`	`private TypeDefinition GetDictionaryType(List<TypeDefinition> coreTypes)`
`137`	`137`	`{`
`138`		- var dictionaryType = coreTypes.FirstOrDefault(x => x.Name == "Dictionary`2");
	`138`	+ TypeDefinition dictionaryType = coreTypes.FirstOrDefault(x => x.Name == "Dictionary`2");
`139`	`139`
`140`	`140`	`if (dictionaryType != null)`
`141`	`141`	`{`
`@@ -147,7 +147,7 @@ private TypeDefinition GetDictionaryType(List<TypeDefinition> coreTypes)`
`147`	`147`
`148`	`148`	`private TypeDefinition GetSystemRuntimeTypeHandleType(List<TypeDefinition> coreTypes)`
`149`	`149`	`{`
`150`		`- var runtimeTypeHandle = coreTypes.FirstOrDefault(x => x.Name == "RuntimeTypeHandle");`
	`150`	`+ TypeDefinition runtimeTypeHandle = coreTypes.FirstOrDefault(x => x.Name == "RuntimeTypeHandle");`
`151`	`151`
`152`	`152`	`if (runtimeTypeHandle != null)`
`153`	`153`	`{`
`@@ -159,7 +159,7 @@ private TypeDefinition GetSystemRuntimeTypeHandleType(List<TypeDefinition> coreT`
`159`	`159`
`160`	`160`	`private TypeDefinition GetSystemTypeType(List<TypeDefinition> coreTypes)`
`161`	`161`	`{`
`162`		`- var systemType = coreTypes.FirstOrDefault(x => x.Name == "Type");`
	`162`	`+ TypeDefinition systemType = coreTypes.FirstOrDefault(x => x.Name == "Type");`
`163`	`163`
`164`	`164`	`if (systemType != null)`
`165`	`165`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+Since 1.5.0.0 it is now possible to use custom CacheAttribute parameters for fine-grained cache control (see https://github.com/Dresel/MethodCache section "CacheAttribute Parameters Support" for details).`
	`2`	`+`
`1`	`3`	`Since 1.4.0.0 it is now possible to also cache properties (see https://github.com/Dresel/MethodCache for details).`
`2`	`4`
`3`	`5`	`If you want this package to behave as previous packages (let class level [Cache] attribute only cache methods), modify ModuleWeavers.xml to:`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,7 @@ public class CacheAttribute : Attribute`
`9`	`9`	`public int Parameter2 { get; set; }`
`10`	`10`
`11`	`11`	`public bool Parameter3 { get; set; }`
	`12`	`+`
	`13`	`+ public double parameter3;`
`12`	`14`	`}`
`13`	`15`	`}`