diff --git a/Harmony/Extras/DelegateTypeFactory.cs b/Harmony/Extras/DelegateTypeFactory.cs
index a6ff5e22..ff8ad130 100644
--- a/Harmony/Extras/DelegateTypeFactory.cs
+++ b/Harmony/Extras/DelegateTypeFactory.cs
@@ -15,9 +15,9 @@ public class DelegateTypeFactory
 		public DelegateTypeFactory()
 		{
 			counter++;
-			var name = "HarmonyDTFAssembly" + counter;
+			var name = $"HarmonyDTFAssembly{counter}";
 			var assembly = PatchTools.DefineDynamicAssembly(name);
-			module = assembly.DefineDynamicModule("HarmonyDTFModule" + counter);
+			module = assembly.DefineDynamicModule($"HarmonyDTFModule{counter}");
 		}
 
 		/// <summary>Creates a delegate type for a method</summary>
@@ -27,7 +27,7 @@ public DelegateTypeFactory()
 		public Type CreateDelegateType(MethodInfo method)
 		{
 			var attr = TypeAttributes.Sealed | TypeAttributes.Public;
-			var typeBuilder = module.DefineType("HarmonyDTFType" + counter, attr, typeof(MulticastDelegate));
+			var typeBuilder = module.DefineType($"HarmonyDTFType{counter}", attr, typeof(MulticastDelegate));
 
 			var constructor = typeBuilder.DefineConstructor(
 				 MethodAttributes.RTSpecialName | MethodAttributes.HideBySig | MethodAttributes.Public,
diff --git a/Harmony/Extras/FastAccess.cs b/Harmony/Extras/FastAccess.cs
index 46605558..613824ab 100644
--- a/Harmony/Extras/FastAccess.cs
+++ b/Harmony/Extras/FastAccess.cs
@@ -48,7 +48,7 @@ public static InstantiationHandler<T> CreateInstantiationHandler<T>()
 					typeof(T)));
 			}
 
-			var dynamicMethod = new DynamicMethod("InstantiateObject_" + typeof(T).Name,
+			var dynamicMethod = new DynamicMethod($"InstantiateObject_{typeof(T).Name}",
 				MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, typeof(T), null, typeof(T),
 				true);
 			var generator = dynamicMethod.GetILGenerator();
@@ -159,12 +159,12 @@ public static InstantiationHandler<T> CreateInstantiationHandler<T>()
 
 		static DynamicMethod CreateGetDynamicMethod<T, S>(Type type)
 		{
-			return new DynamicMethod("DynamicGet_" + type.Name, typeof(S), new Type[] { typeof(T) }, type, true);
+			return new DynamicMethod($"DynamicGet_{type.Name}", typeof(S), new Type[] { typeof(T) }, type, true);
 		}
 
 		static DynamicMethod CreateSetDynamicMethod<T, S>(Type type)
 		{
-			return new DynamicMethod("DynamicSet_" + type.Name, typeof(void), new Type[] { typeof(T), typeof(S) }, type,
+			return new DynamicMethod($"DynamicSet_{type.Name}", typeof(void), new Type[] { typeof(T), typeof(S) }, type,
 				true);
 		}
 	}
diff --git a/Harmony/Extras/MethodInvoker.cs b/Harmony/Extras/MethodInvoker.cs
index 3678be09..959b3ad9 100644
--- a/Harmony/Extras/MethodInvoker.cs
+++ b/Harmony/Extras/MethodInvoker.cs
@@ -75,7 +75,7 @@ public MethodInvoker(bool directBoxValueAccess = false)
 		/// <returns>The fast invocation handler</returns>
 		public FastInvokeHandler Handler(MethodInfo methodInfo, Module module)
 		{
-			var dynamicMethod = new DynamicMethod("FastInvoke_" + methodInfo.Name + "_" + (directBoxValueAccess ? "direct" : "indirect"), typeof(object), new Type[] { typeof(object), typeof(object[]) }, module, true);
+			var dynamicMethod = new DynamicMethod($"FastInvoke_{methodInfo.Name}_{(directBoxValueAccess ? "direct" : "indirect")}", typeof(object), new Type[] { typeof(object), typeof(object[]) }, module, true);
 			var il = dynamicMethod.GetILGenerator();
 
 			if (!methodInfo.IsStatic)
diff --git a/Harmony/Internal/Emitter.cs b/Harmony/Internal/Emitter.cs
index 5cf8f9ba..184e6331 100644
--- a/Harmony/Internal/Emitter.cs
+++ b/Harmony/Internal/Emitter.cs
@@ -70,13 +70,13 @@ internal static string FormatArgument(object argument)
 				return ((MethodInfo)argument).FullDescription();
 
 			if (type == typeof(string))
-				return "\"" + argument + "\"";
+				return $"\"{argument}\"";
 			if (type == typeof(Label))
-				return "Label" + ((Label)argument).GetHashCode();
+				return $"Label{((Label)argument).GetHashCode()}";
 			if (type == typeof(Label[]))
-				return "Labels" + string.Join(",", ((Label[])argument).Select(l => l.GetHashCode().ToString()).ToArray());
+				return $"Labels{string.Join(",", ((Label[])argument).Select(l => l.GetHashCode().ToString()).ToArray())}";
 			if (type == typeof(LocalBuilder))
-				return ((LocalBuilder)argument).LocalIndex + " (" + ((LocalBuilder)argument).LocalType + ")";
+				return $"{((LocalBuilder)argument).LocalIndex} ({((LocalBuilder)argument).LocalType})";
 
 			return argument.ToString().Trim();
 		}
@@ -111,7 +111,7 @@ internal static void MarkBlockBefore(ILGenerator il, ExceptionBlock block, out L
 						FileLog.ChangeIndent(-1);
 						FileLog.LogBuffered("} // end try");
 
-						FileLog.LogBuffered(".catch " + block.catchType);
+						FileLog.LogBuffered($".catch {block.catchType}");
 						FileLog.LogBuffered("{");
 						FileLog.ChangeIndent(1);
 					}
diff --git a/Harmony/Internal/ILInstruction.cs b/Harmony/Internal/ILInstruction.cs
index 6cd43a80..f5efebc8 100644
--- a/Harmony/Internal/ILInstruction.cs
+++ b/Harmony/Internal/ILInstruction.cs
@@ -77,7 +77,7 @@ public override string ToString()
 			var instruction = "";
 
 			AppendLabel(ref instruction, this);
-			instruction = instruction + ": " + opcode.Name;
+			instruction += $": {opcode.Name}";
 
 			if (operand == null)
 				return instruction;
@@ -103,7 +103,7 @@ public override string ToString()
 					break;
 
 				case OperandType.InlineString:
-					instruction = instruction + "\"" + operand + "\"";
+					instruction += $"\"{operand}\"";
 					break;
 
 				default:
@@ -117,10 +117,7 @@ public override string ToString()
 		static void AppendLabel(ref string str, object argument)
 		{
 			var instruction = argument as ILInstruction;
-			if (instruction != null)
-				str = str + "IL_" + instruction.offset.ToString("X4");
-			else
-				str = str + "IL_" + argument;
+			str += $"IL_{instruction?.offset.ToString("X4") ?? argument}";
 		}
 	}
 }
\ No newline at end of file
diff --git a/Harmony/Internal/MethodCopier.cs b/Harmony/Internal/MethodCopier.cs
index 03546812..d89c2a46 100644
--- a/Harmony/Internal/MethodCopier.cs
+++ b/Harmony/Internal/MethodCopier.cs
@@ -66,11 +66,11 @@ internal MethodBodyReader(MethodBase method, ILGenerator generator)
 
 			var body = method.GetMethodBody();
 			if (body == null)
-				throw new ArgumentException("Method " + method.FullDescription() + " has no body");
+				throw new ArgumentException($"Method {method.FullDescription()} has no body");
 
 			var bytes = body.GetILAsByteArray();
 			if (bytes == null)
-				throw new ArgumentException("Can not get IL bytes of method " + method.FullDescription());
+				throw new ArgumentException($"Can not get IL bytes of method {method.FullDescription()}");
 			ilBytes = new ByteBuffer(bytes);
 			ilInstructions = new List<ILInstruction>((bytes.Length + 1) / 2);
 
@@ -338,8 +338,8 @@ internal void FinalizeILCodes(List<MethodInfo> transpilers, List<Label> endLabel
 							// TODO the following will fail because we do not convert the token (operand)
 							// All the decompilers can show the arguments correctly, we just need to find out how
 							//
-							if (operand == null) throw new Exception("Wrong null argument: " + codeInstruction);
-							if ((operand is int) == false) throw new Exception("Wrong Emit argument type " + operand.GetType() + " in " + codeInstruction);
+							if (operand == null) throw new Exception($"Wrong null argument: {codeInstruction}");
+							if ((operand is int) == false) throw new Exception($"Wrong Emit argument type {operand.GetType()} in {codeInstruction}");
 							Emitter.Emit(generator, code, (int)operand);
 
 							/*
@@ -357,10 +357,10 @@ internal void FinalizeILCodes(List<MethodInfo> transpilers, List<Label> endLabel
 							break;
 
 						default:
-							if (operand == null) throw new Exception("Wrong null argument: " + codeInstruction);
+							if (operand == null) throw new Exception($"Wrong null argument: {codeInstruction}");
 							var emitMethod = EmitMethodForType(operand.GetType());
-							if (emitMethod == null) throw new Exception("Unknown Emit argument type " + operand.GetType() + " in " + codeInstruction);
-							if (Harmony.DEBUG) FileLog.LogBuffered(Emitter.CodePos(generator) + code + " " + Emitter.FormatArgument(operand));
+							if (emitMethod == null) throw new Exception($"Unknown Emit argument type {operand.GetType()} in {codeInstruction}");
+							if (Harmony.DEBUG) FileLog.LogBuffered($"{Emitter.CodePos(generator)}{code} {Emitter.FormatArgument(operand)}");
 							_ = emitMethod.Invoke(generator, new object[] { code, operand });
 							break;
 					}
@@ -501,8 +501,8 @@ void ReadOperand(ILInstruction instruction)
 					var bytes = module.ResolveSignature(val);
 					instruction.operand = bytes;
 					instruction.argument = bytes;
-					Debugger.Log(0, "TEST", "METHOD " + method.FullDescription() + "\n");
-					Debugger.Log(0, "TEST", "Signature = " + bytes.Select(b => string.Format("0x{0:x02}", b)).Aggregate((a, b) => a + " " + b) + "\n");
+					Debugger.Log(0, "TEST", $"METHOD {method.FullDescription()}\n");
+					Debugger.Log(0, "TEST", $"Signature = {bytes.Select(b => string.Format("0x{0:x02}", b)).Aggregate((a, b) => a + " " + b)}\n");
 					Debugger.Break();
 					break;
 				}
@@ -603,7 +603,7 @@ ILInstruction GetInstruction(int offset, bool isEndOfInstruction)
 		{
 			var lastInstructionIndex = ilInstructions.Count - 1;
 			if (offset < 0 || offset > ilInstructions[lastInstructionIndex].offset)
-				throw new Exception("Instruction offset " + offset + " is outside valid range 0 - " + ilInstructions[lastInstructionIndex].offset);
+				throw new Exception($"Instruction offset {offset} is outside valid range 0 - {ilInstructions[lastInstructionIndex].offset}");
 
 			var min = 0;
 			var max = lastInstructionIndex;
@@ -629,7 +629,7 @@ ILInstruction GetInstruction(int offset, bool isEndOfInstruction)
 					min = mid + 1;
 			}
 
-			throw new Exception("Cannot find instruction for " + offset.ToString("X4"));
+			throw new Exception($"Cannot find instruction for {offset.ToString("X4")}");
 		}
 
 		static bool TargetsLocalVariable(OpCode opcode)
diff --git a/Harmony/Internal/MethodPatcher.cs b/Harmony/Internal/MethodPatcher.cs
index 3156a7d3..93d3e86c 100644
--- a/Harmony/Internal/MethodPatcher.cs
+++ b/Harmony/Internal/MethodPatcher.cs
@@ -29,7 +29,7 @@ public static DynamicMethod CreatePatchedMethod(MethodBase original, MethodBase
 
 				if (Harmony.DEBUG)
 				{
-					FileLog.LogBuffered("### Patch " + original.FullDescription());
+					FileLog.LogBuffered($"### Patch {original.FullDescription()}");
 					FileLog.FlushBuffer();
 				}
 
@@ -37,7 +37,7 @@ public static DynamicMethod CreatePatchedMethod(MethodBase original, MethodBase
 				var firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
 				var returnType = AccessTools.GetReturnedType(original);
 				var hasFinalizers = finalizers.Any();
-				var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
+				var patch = DynamicTools.CreateDynamicMethod(original, $"_Patch{idx}");
 				if (patch == null)
 					return null;
 
@@ -167,7 +167,7 @@ public static DynamicMethod CreatePatchedMethod(MethodBase original, MethodBase
 			}
 			catch (Exception ex)
 			{
-				var exceptionString = "Exception from HarmonyInstance \"" + harmonyInstanceID + "\" patching " + original.FullDescription() + ": " + ex;
+				var exceptionString = $"Exception from HarmonyInstance \"{harmonyInstanceID}\" patching {original.FullDescription()}: {ex}";
 				if (Harmony.DEBUG)
 				{
 					var savedIndentLevel = FileLog.indentLevel;
@@ -371,13 +371,13 @@ static void EmitCallParameter(ILGenerator il, MethodBase original, MethodInfo pa
 					{
 						fieldInfo = AccessTools.DeclaredField(original.DeclaringType, int.Parse(fieldName));
 						if (fieldInfo == null)
-							throw new ArgumentException("No field found at given index in class " + original.DeclaringType.FullName, fieldName);
+							throw new ArgumentException($"No field found at given index in class {original.DeclaringType.FullName}", fieldName);
 					}
 					else
 					{
 						fieldInfo = AccessTools.DeclaredField(original.DeclaringType, fieldName);
 						if (fieldInfo == null)
-							throw new ArgumentException("No such field defined in class " + original.DeclaringType.FullName, fieldName);
+							throw new ArgumentException($"No such field defined in class {original.DeclaringType.FullName}", fieldName);
 					}
 
 					if (fieldInfo.IsStatic)
@@ -406,12 +406,12 @@ static void EmitCallParameter(ILGenerator il, MethodBase original, MethodInfo pa
 				{
 					var returnType = AccessTools.GetReturnedType(original);
 					if (returnType == typeof(void))
-						throw new Exception("Cannot get result from void method " + original.FullDescription());
+						throw new Exception($"Cannot get result from void method {original.FullDescription()}");
 					var resultType = patchParam.ParameterType;
 					if (resultType.IsByRef)
 						resultType = resultType.GetElementType();
 					if (resultType.IsAssignableFrom(returnType) == false)
-						throw new Exception("Cannot assign method return type " + returnType.FullName + " to " + RESULT_VAR + " type " + resultType.FullName + " for method " + original.FullDescription());
+						throw new Exception($"Cannot assign method return type {returnType.FullName} to {RESULT_VAR} type {resultType.FullName} for method {original.FullDescription()}");
 					var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
 					Emitter.Emit(il, ldlocCode, variables[RESULT_VAR]);
 					continue;
@@ -430,14 +430,14 @@ static void EmitCallParameter(ILGenerator il, MethodBase original, MethodInfo pa
 				{
 					var val = patchParam.Name.Substring(PARAM_INDEX_PREFIX.Length);
 					if (!int.TryParse(val, out idx))
-						throw new Exception("Parameter " + patchParam.Name + " does not contain a valid index");
+						throw new Exception($"Parameter {patchParam.Name} does not contain a valid index");
 					if (idx < 0 || idx >= originalParameters.Length)
-						throw new Exception("No parameter found at index " + idx);
+						throw new Exception($"No parameter found at index {idx}");
 				}
 				else
 				{
 					idx = GetArgumentIndex(patch, originalParameterNames, patchParam);
-					if (idx == -1) throw new Exception("Parameter \"" + patchParam.Name + "\" not found in method " + original.FullDescription());
+					if (idx == -1) throw new Exception($"Parameter \"{patchParam.Name}\" not found in method {original.FullDescription()}");
 				}
 
 				//   original -> patch     opcode
@@ -482,7 +482,7 @@ static bool AddPrefixes(ILGenerator il, MethodBase original, List<MethodInfo> pr
 				if (fix.ReturnType != typeof(void))
 				{
 					if (fix.ReturnType != typeof(bool))
-						throw new Exception("Prefix patch " + fix + " has not \"bool\" or \"void\" return type: " + fix.ReturnType);
+						throw new Exception($"Prefix patch {fix} has not \"bool\" or \"void\" return type: {fix.ReturnType}");
 					Emitter.Emit(il, OpCodes.Brfalse, label);
 					canHaveJump = true;
 				}
@@ -506,9 +506,9 @@ static void AddPostfixes(ILGenerator il, MethodBase original, List<MethodInfo> p
 						if (!hasPassThroughResultParam)
 						{
 							if (firstFixParam != null)
-								throw new Exception("Return type of pass through postfix " + fix + " does not match type of its first parameter");
+								throw new Exception($"Return type of pass through postfix {fix} does not match type of its first parameter");
 
-							throw new Exception("Postfix patch " + fix + " must have a \"void\" return type");
+							throw new Exception($"Postfix patch {fix} must have a \"void\" return type");
 						}
 					}
 				});
diff --git a/Harmony/Internal/PatchFunctions.cs b/Harmony/Internal/PatchFunctions.cs
index f9734f13..6466c10a 100644
--- a/Harmony/Internal/PatchFunctions.cs
+++ b/Harmony/Internal/PatchFunctions.cs
@@ -151,11 +151,11 @@ internal static DynamicMethod UpdateWrapper(MethodBase original, PatchInfo patch
 			var sortedFinalizers = GetSortedPatchMethods(original, patchInfo.finalizers);
 
 			var replacement = MethodPatcher.CreatePatchedMethod(original, null, instanceID, sortedPrefixes, sortedPostfixes, sortedTranspilers, sortedFinalizers);
-			if (replacement == null) throw new MissingMethodException("Cannot create dynamic replacement for " + original.FullDescription());
+			if (replacement == null) throw new MissingMethodException($"Cannot create dynamic replacement for {original.FullDescription()}");
 
 			var errorString = Memory.DetourMethod(original, replacement);
 			if (errorString != null)
-				throw new FormatException("Method " + original.FullDescription() + " cannot be patched. Reason: " + errorString);
+				throw new FormatException($"Method {original.FullDescription()} cannot be patched. Reason: {errorString}");
 
 			PatchTools.RememberObject(original, replacement); // no gc for new value + release old value to gc
 
@@ -170,11 +170,11 @@ internal static void ReversePatch(MethodInfo standin, MethodBase original, strin
 				transpilers.Add(transpiler);
 
 			var replacement = MethodPatcher.CreatePatchedMethod(standin, original, instanceID, emptyFixes, emptyFixes, transpilers, emptyFixes);
-			if (replacement == null) throw new MissingMethodException("Cannot create dynamic replacement for " + standin.FullDescription());
+			if (replacement == null) throw new MissingMethodException($"Cannot create dynamic replacement for {standin.FullDescription()}");
 
 			var errorString = Memory.DetourMethod(standin, replacement);
 			if (errorString != null)
-				throw new FormatException("Method " + standin.FullDescription() + " cannot be patched. Reason: " + errorString);
+				throw new FormatException($"Method {standin.FullDescription()} cannot be patched. Reason: {errorString}");
 
 			PatchTools.RememberObject(standin, replacement);
 		}
diff --git a/Harmony/Internal/PatchModels.cs b/Harmony/Internal/PatchModels.cs
new file mode 100644
index 00000000..c2f27532
--- /dev/null
+++ b/Harmony/Internal/PatchModels.cs
@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace HarmonyLib
+{
+	// PatchJobs holds the information during correlation
+	// of methods and patches while processing attribute patches
+	//
+	internal class PatchJobs<T>
+	{
+		internal class Job
+		{
+			internal MethodBase original;
+			internal T replacement;
+			internal List<HarmonyMethod> prefixes = new List<HarmonyMethod>();
+			internal List<HarmonyMethod> postfixes = new List<HarmonyMethod>();
+			internal List<HarmonyMethod> transpilers = new List<HarmonyMethod>();
+			internal List<HarmonyMethod> finalizers = new List<HarmonyMethod>();
+
+			internal void AddPatch(AttributePatch patch)
+			{
+				switch (patch.type)
+				{
+					case HarmonyPatchType.Prefix:
+						prefixes.Add(patch.info);
+						break;
+					case HarmonyPatchType.Postfix:
+						postfixes.Add(patch.info);
+						break;
+					case HarmonyPatchType.Transpiler:
+						transpilers.Add(patch.info);
+						break;
+					case HarmonyPatchType.Finalizer:
+						finalizers.Add(patch.info);
+						break;
+				}
+			}
+		}
+
+		internal Dictionary<MethodBase, Job> state = new Dictionary<MethodBase, Job>();
+
+		internal Job GetJob(MethodBase method)
+		{
+			if (method == null) return null;
+			if (state.TryGetValue(method, out var job) == false)
+			{
+				job = new Job() { original = method };
+				state[method] = job;
+			}
+			return job;
+		}
+
+		internal List<Job> GetJobs()
+		{
+			return state.Values.Where(job =>
+				job.prefixes.Count +
+				job.postfixes.Count +
+				job.transpilers.Count +
+				job.finalizers.Count > 0
+			).ToList();
+		}
+
+		internal List<T> GetReplacements()
+		{
+			return state.Values.Select(job => job.replacement).ToList();
+		}
+	}
+
+	// AttributePatch contains all information for a patch defined by attributes
+	//
+	internal class AttributePatch
+	{
+		static readonly HarmonyPatchType[] allPatchTypes = new[] {
+			HarmonyPatchType.Prefix,
+			HarmonyPatchType.Postfix,
+			HarmonyPatchType.Transpiler,
+			HarmonyPatchType.Finalizer
+		};
+
+		internal HarmonyMethod info;
+		internal HarmonyPatchType? type;
+
+		internal static AttributePatch Create(MethodInfo patch)
+		{
+			if (patch == null)
+				throw new NullReferenceException("Patch method cannot be null");
+
+			if (patch.IsStatic == false)
+				throw new ArgumentException("Patch method " + patch.FullDescription() + " must be static");
+
+			var harmonyPatchName = typeof(HarmonyPatch).FullName;
+			var allAttributes = patch.GetCustomAttributes(true);
+			var methodName = patch.Name;
+
+			var typeAttributes = new HashSet<string>(allAttributes
+				.Select(attr => attr.GetType().FullName)
+				.Where(name => name.StartsWith("Harmony")));
+
+			HarmonyPatchType? type = null;
+			foreach (var patchType in allPatchTypes)
+			{
+				var name = patchType.ToString();
+				if (name == methodName || typeAttributes.Contains($"HarmonyLib.Harmony{name}"))
+				{
+					type = patchType;
+					break;
+				}
+			}
+			if (type == null)
+				return null;
+
+			var list = allAttributes
+				.Where(attr => attr.GetType().FullName == harmonyPatchName)
+				.Select(attr =>
+				{
+					var f_info = AccessTools.Field(attr.GetType(), nameof(HarmonyAttribute.info));
+					return f_info.GetValue(attr);
+				})
+				.Select(harmonyInfo => AccessTools.MakeDeepCopy<HarmonyMethod>(harmonyInfo))
+				.ToList();
+			var info = HarmonyMethod.Merge(list);
+			info.method = patch;
+
+			return new AttributePatch() { info = info, type = type };
+		}
+	}
+}
\ No newline at end of file
diff --git a/Harmony/Internal/PatchTools.cs b/Harmony/Internal/PatchTools.cs
index 67007dbc..eff32c1f 100644
--- a/Harmony/Internal/PatchTools.cs
+++ b/Harmony/Internal/PatchTools.cs
@@ -15,15 +15,15 @@ internal static void RememberObject(object key, object value)
 			objectReferences[key] = value;
 		}
 
-		internal static MethodInfo GetPatchMethod<T>(Type patchType, string name)
+		internal static MethodInfo GetPatchMethod(Type patchType, string attributeName)
 		{
-			var attributeType = typeof(T).FullName;
 			var method = patchType.GetMethods(AccessTools.all)
-				.FirstOrDefault(m => m.GetCustomAttributes(true).Any(a => a.GetType().FullName == attributeType));
+				.FirstOrDefault(m => m.GetCustomAttributes(true).Any(a => a.GetType().FullName == attributeName));
 			if (method == null)
 			{
 				// not-found is common and normal case, don't use AccessTools which will generate not-found warnings
-				method = patchType.GetMethod(name, AccessTools.all);
+				var methodName = attributeName.Replace("HarmonyLib.Harmony", "");
+				method = patchType.GetMethod(methodName, AccessTools.all);
 			}
 			return method;
 		}
@@ -38,12 +38,13 @@ internal static AssemblyBuilder DefineDynamicAssembly(string name)
 #endif
 		}
 
-		internal static void GetPatches(Type patchType, out MethodInfo prefix, out MethodInfo postfix, out MethodInfo transpiler, out MethodInfo finalizer)
+		internal static List<AttributePatch> GetPatchMethods(Type type)
 		{
-			prefix = GetPatchMethod<HarmonyPrefix>(patchType, "Prefix");
-			postfix = GetPatchMethod<HarmonyPostfix>(patchType, "Postfix");
-			transpiler = GetPatchMethod<HarmonyTranspiler>(patchType, "Transpiler");
-			finalizer = GetPatchMethod<HarmonyFinalizer>(patchType, "Finalizer");
+			var harmonyPatchName = typeof(HarmonyPatch).FullName;
+			return AccessTools.GetDeclaredMethods(type)
+				.Select(method => AttributePatch.Create(method))
+				.Where(attributePatch => attributePatch != null)
+				.ToList();
 		}
 
 		internal static List<MethodInfo> GetReversePatches(Type patchType)
diff --git a/Harmony/Internal/SelfPatching.cs b/Harmony/Internal/SelfPatching.cs
deleted file mode 100644
index e477fc2b..00000000
--- a/Harmony/Internal/SelfPatching.cs
+++ /dev/null
@@ -1,161 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Reflection;
-
-namespace HarmonyLib
-{
-	internal static class SelfPatching
-	{
-		static readonly string upgradeToLatestVersionFullName = typeof(UpgradeToLatestVersion).FullName;
-
-		static bool IsUpgrade(object attribute)
-		{
-			return attribute.GetType().FullName == upgradeToLatestVersionFullName;
-		}
-
-		static int GetVersion(MethodBase method)
-		{
-			var attribute = method.GetCustomAttributes(false)
-				.Where(attr => IsUpgrade(attr))
-				.FirstOrDefault();
-			if (attribute == null)
-				return -1;
-			return Traverse.Create(attribute).Field("version").GetValue<int>();
-		}
-
-		static Type[] GetGenericTypes(MethodBase method)
-		{
-			var attribute = method.GetCustomAttributes(false)
-				.Where(attr => attr.GetType().FullName == upgradeToLatestVersionFullName)
-				.FirstOrDefault();
-			if (attribute == null)
-				return null;
-			return Traverse.Create(attribute).Field("types").GetValue<Type[]>();
-		}
-
-		static string MethodKey(MethodBase method)
-		{
-			return method.FullDescription();
-		}
-
-		static bool IsHarmonyAssembly(Assembly assembly)
-		{
-			try
-			{
-				return assembly.ReflectionOnly == false && assembly.GetType(typeof(Harmony).FullName) != null;
-			}
-			catch
-			{
-				return false;
-			}
-		}
-
-		static List<MethodBase> GetAllMethods(Assembly assembly)
-		{
-			var types = assembly.GetTypes();
-			return types
-				.SelectMany(type => type.GetMethods(AccessTools.all).Cast<MethodBase>())
-				.Concat(types.SelectMany(type => type.GetConstructors(AccessTools.all)).Cast<MethodBase>())
-				.Concat(types.SelectMany(type => type.GetProperties(AccessTools.all)).Select(prop => prop.GetGetMethod()).Cast<MethodBase>())
-				.Concat(types.SelectMany(type => type.GetProperties(AccessTools.all)).Select(prop => prop.GetSetMethod()).Cast<MethodBase>())
-				.Where(method => method != null && method.DeclaringType.Assembly == assembly)
-				.OrderBy(method => method.FullDescription())
-				.ToList();
-		}
-
-		static string AssemblyInfo(Assembly assembly)
-		{
-			var version = assembly.GetName().Version;
-			var location = assembly.Location;
-			if (string.IsNullOrEmpty(location)) location = new Uri(assembly.CodeBase).LocalPath;
-			return location + "(v" + version + (assembly.GlobalAssemblyCache ? ", cached" : "") + ")";
-		}
-
-		internal static void PatchOldHarmonyMethods()
-		{
-			var watch = new Stopwatch();
-			watch.Start();
-
-			var ourAssembly = new StackTrace(true).GetFrame(1).GetMethod().DeclaringType.Assembly;
-			if (Harmony.DEBUG)
-			{
-				var originalVersion = ourAssembly.GetName().Version;
-				var runningVersion = typeof(SelfPatching).Assembly.GetName().Version;
-				if (runningVersion > originalVersion)
-				{
-					// log start because FileLog has not done it
-					FileLog.Log("### Harmony v" + originalVersion + " started");
-					FileLog.Log("### Self-patching unnecessary because we are already patched by v" + runningVersion);
-					FileLog.Log("### At " + DateTime.Now.ToString("yyyy-MM-dd hh.mm.ss"));
-					return;
-				}
-				FileLog.Log("Self-patching started (v" + originalVersion + ")");
-			}
-
-			var potentialMethodsToUpgrade = new Dictionary<string, MethodBase>();
-			GetAllMethods(ourAssembly)
-				.Where(method => method != null && method.GetCustomAttributes(false).Any(attr => IsUpgrade(attr)))
-				.Do(method => potentialMethodsToUpgrade.Add(MethodKey(method), method));
-
-			var otherHarmonyAssemblies = AppDomain.CurrentDomain.GetAssemblies()
-				.Where(a => a.FullName.StartsWith("Microsoft.VisualStudio") == false)
-				.Where(assembly => IsHarmonyAssembly(assembly) && assembly != ourAssembly)
-				.ToList();
-
-			if (Harmony.DEBUG)
-			{
-				otherHarmonyAssemblies.Do(assembly => FileLog.Log("Found Harmony " + AssemblyInfo(assembly)));
-
-				FileLog.Log("Potential methods to upgrade:");
-				potentialMethodsToUpgrade.Values.OrderBy(method => method.FullDescription()).Do(method => FileLog.Log("- " + method.FullDescription()));
-			}
-
-			var totalCounter = 0;
-			var potentialCounter = 0;
-			var patchedCounter = 0;
-			foreach (var assembly in otherHarmonyAssemblies)
-			{
-				foreach (var oldMethod in GetAllMethods(assembly))
-				{
-					totalCounter++;
-
-					if (potentialMethodsToUpgrade.TryGetValue(MethodKey(oldMethod), out var newMethod))
-					{
-						var newVersion = GetVersion(newMethod);
-						potentialCounter++;
-
-						var oldVersion = GetVersion(oldMethod);
-						if (oldVersion < newVersion)
-						{
-							var generics = GetGenericTypes(newMethod);
-							if (generics != null)
-							{
-								foreach (var generic in generics)
-								{
-									var oldMethodInfo = (oldMethod as MethodInfo).MakeGenericMethod(generic);
-									var newMethodInfo = (newMethod as MethodInfo).MakeGenericMethod(generic);
-									if (Harmony.DEBUG)
-										FileLog.Log("Self-patching " + oldMethodInfo.FullDescription() + " with <" + generic.FullName + "> in " + AssemblyInfo(assembly));
-									Memory.DetourMethod(oldMethodInfo, newMethodInfo);
-								}
-								patchedCounter++;
-							}
-							else
-							{
-								if (Harmony.DEBUG)
-									FileLog.Log("Self-patching " + oldMethod.FullDescription() + " in " + AssemblyInfo(assembly));
-								patchedCounter++;
-								Memory.DetourMethod(oldMethod, newMethod);
-							}
-						}
-					}
-				}
-			}
-
-			if (Harmony.DEBUG)
-				FileLog.Log("Self-patched " + patchedCounter + " out of " + totalCounter + " methods (" + (potentialCounter - patchedCounter) + " skipped) in " + watch.ElapsedMilliseconds + "ms");
-		}
-	}
-}
\ No newline at end of file
diff --git a/Harmony/Public/CodeInstruction.cs b/Harmony/Public/CodeInstruction.cs
index 58c263d8..6782fa10 100644
--- a/Harmony/Public/CodeInstruction.cs
+++ b/Harmony/Public/CodeInstruction.cs
@@ -78,11 +78,11 @@ public override string ToString()
 		{
 			var list = new List<string>();
 			foreach (var label in labels)
-				list.Add("Label" + label.GetHashCode());
+				list.Add($"Label{label.GetHashCode()}");
 			foreach (var block in blocks)
-				list.Add("EX_" + block.blockType.ToString().Replace("Block", ""));
+				list.Add($"EX_{block.blockType.ToString().Replace("Block", "")}");
 
-			var extras = list.Count > 0 ? " [" + string.Join(", ", list.ToArray()) + "]" : "";
+			var extras = list.Count > 0 ? $" [{string.Join(", ", list.ToArray())}]" : "";
 			var operandStr = Emitter.FormatArgument(operand);
 			if (operandStr.Length > 0) operandStr = " " + operandStr;
 			return opcode + operandStr + extras;
diff --git a/Harmony/Public/Harmony.cs b/Harmony/Public/Harmony.cs
index 755b3477..7caa8d27 100644
--- a/Harmony/Public/Harmony.cs
+++ b/Harmony/Public/Harmony.cs
@@ -19,15 +19,13 @@ public class Harmony
 		/// <summary>Set to false before instantiating Harmony to prevent Harmony from patching other older instances of itself</summary>
 		public static bool SELF_PATCHING = true;
 
-		static bool selfPatchingDone;
-
 		/// <summary>Creates a new Harmony instance</summary>
 		/// <param name="id">A unique identifier</param>
 		/// <returns>A Harmony instance</returns>
 		///
 		public Harmony(string id)
 		{
-			if (string.IsNullOrEmpty(id)) throw new ArgumentException(nameof(id) + " cannot be null or empty");
+			if (string.IsNullOrEmpty(id)) throw new ArgumentException($"{nameof(id)} cannot be null or empty");
 
 			if (DEBUG)
 			{
@@ -35,23 +33,16 @@ public Harmony(string id)
 				var version = assembly.GetName().Version;
 				var location = assembly.Location;
 				if (string.IsNullOrEmpty(location)) location = new Uri(assembly.CodeBase).LocalPath;
-				FileLog.Log("### Harmony id=" + id + ", version=" + version + ", location=" + location);
+				FileLog.Log($"### Harmony id={id}, version={version}, location={location}");
 				var callingMethod = AccessTools.GetOutsideCaller();
 				var callingAssembly = callingMethod.DeclaringType.Assembly;
 				location = callingAssembly.Location;
 				if (string.IsNullOrEmpty(location)) location = new Uri(callingAssembly.CodeBase).LocalPath;
-				FileLog.Log("### Started from " + callingMethod.FullDescription() + ", location " + location);
-				FileLog.Log("### At " + DateTime.Now.ToString("yyyy-MM-dd hh.mm.ss"));
+				FileLog.Log($"### Started from {callingMethod.FullDescription()}, location {location}");
+				FileLog.Log($"### At {DateTime.Now.ToString("yyyy-MM-dd hh.mm.ss")}");
 			}
 
 			Id = id;
-
-			if (!selfPatchingDone)
-			{
-				selfPatchingDone = true;
-				if (SELF_PATCHING)
-					SelfPatching.PatchOldHarmonyMethods();
-			}
 		}
 
 		/// <summary>Searches current assembly for Harmony annotations and uses them to create patches</summary>
@@ -66,15 +57,9 @@ public void PatchAll()
 		/// <summary>Create a patch processor from an annotated class</summary>
 		/// <param name="type">The class</param>
 		/// 
-		public PatchProcessor ProcessorForAnnotatedClass(Type type)
+		public PatchClassProcessor ProcessorForAnnotatedClass(Type type)
 		{
-			var parentMethodInfos = HarmonyMethodExtensions.GetFromType(type);
-			if (parentMethodInfos != null && parentMethodInfos.Any())
-			{
-				var info = HarmonyMethod.Merge(parentMethodInfos);
-				return new PatchProcessor(this, type, info);
-			}
-			return null;
+			return new PatchClassProcessor(this, type);
 		}
 
 		/// <summary>Searches an assembly for Harmony annotations and uses them to create patches</summary>
@@ -82,7 +67,7 @@ public PatchProcessor ProcessorForAnnotatedClass(Type type)
 		/// 
 		public void PatchAll(Assembly assembly)
 		{
-			assembly.GetTypes().Do(type => ProcessorForAnnotatedClass(type)?.Patch());
+			assembly.GetTypes().Do(type => ProcessorForAnnotatedClass(type).Patch());
 		}
 
 		/// <summary>Creates patches by manually specifying the methods</summary>
@@ -95,12 +80,12 @@ public void PatchAll(Assembly assembly)
 		///
 		public DynamicMethod Patch(MethodBase original, HarmonyMethod prefix = null, HarmonyMethod postfix = null, HarmonyMethod transpiler = null, HarmonyMethod finalizer = null)
 		{
-			var processor = new PatchProcessor(this, original);
+			var processor = this.CreateProcessor(original);
 			_ = processor.AddPrefix(prefix);
 			_ = processor.AddPostfix(postfix);
 			_ = processor.AddTranspiler(transpiler);
 			_ = processor.AddFinalizer(finalizer);
-			return processor.Patch().FirstOrDefault();
+			return processor.Patch();
 		}
 
 		/// <summary>Unpatches methods</summary>
@@ -129,7 +114,7 @@ public void UnpatchAll(string harmonyID = null)
 		///
 		public void Unpatch(MethodBase original, HarmonyPatchType type, string harmonyID = null)
 		{
-			var processor = new PatchProcessor(this, original);
+			var processor = this.CreateProcessor(original);
 			_ = processor.Unpatch(type, harmonyID);
 		}
 
@@ -139,7 +124,7 @@ public void Unpatch(MethodBase original, HarmonyPatchType type, string harmonyID
 		///
 		public void Unpatch(MethodBase original, MethodInfo patch)
 		{
-			var processor = new PatchProcessor(this, original);
+			var processor = this.CreateProcessor(original);
 			_ = processor.Unpatch(patch);
 		}
 
@@ -172,12 +157,12 @@ public IEnumerable<MethodBase> GetPatchedMethods()
 				.Where(original => GetPatchInfo(original).Owners.Contains(Id));
 		}
 
-		/// <summary>Gets all patched methods in the appdomain</summary>
-		/// <returns>An enumeration of original methods</returns>
+		/// <summary>Gets all patched original methods in the appdomain</summary>
+		/// <returns>An enumeration of patched original methods</returns>
 		///
 		public static IEnumerable<MethodBase> GetAllPatchedMethods()
 		{
-			return HarmonySharedState.GetPatchedMethods();
+			return PatchProcessor.GetAllPatchedMethods();
 		}
 
 		/// <summary>Gets Harmony version for all active Harmony instances</summary>
@@ -186,25 +171,7 @@ public static IEnumerable<MethodBase> GetAllPatchedMethods()
 		///
 		public static Dictionary<string, Version> VersionInfo(out Version currentVersion)
 		{
-			currentVersion = typeof(Harmony).Assembly.GetName().Version;
-			var assemblies = new Dictionary<string, Assembly>();
-			GetAllPatchedMethods().Do(method =>
-			{
-				var info = HarmonySharedState.GetPatchInfo(method);
-				info.prefixes.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
-				info.postfixes.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
-				info.transpilers.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
-				info.finalizers.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
-			});
-
-			var result = new Dictionary<string, Version>();
-			assemblies.Do(info =>
-			{
-				var assemblyName = info.Value.GetReferencedAssemblies().FirstOrDefault(a => a.FullName.StartsWith("0Harmony, Version", StringComparison.Ordinal));
-				if (assemblyName != null)
-					result[info.Key] = assemblyName.Version;
-			});
-			return result;
+			return PatchProcessor.VersionInfo(out currentVersion);
 		}
 	}
 }
\ No newline at end of file
diff --git a/Harmony/Public/HarmonyMethod.cs b/Harmony/Public/HarmonyMethod.cs
index bbb3d035..97f47e47 100644
--- a/Harmony/Public/HarmonyMethod.cs
+++ b/Harmony/Public/HarmonyMethod.cs
@@ -64,7 +64,7 @@ public HarmonyMethod(Type type, string name, Type[] parameters = null)
 		{
 			var result = AccessTools.Method(type, name, parameters);
 			if (result == null)
-				throw new ArgumentException("Cannot not find method for type " + type + " and name " + name + " and parameters " + parameters?.Description());
+				throw new ArgumentException($"Cannot not find method for type {type} and name {name} and parameters {parameters?.Description()}");
 			ImportMethod(result);
 		}
 
@@ -106,13 +106,24 @@ public static HarmonyMethod Merge(List<HarmonyMethod> attributes)
 		///
 		public override string ToString()
 		{
-			var result = "HarmonyMethod[";
+			var result = "";
 			var trv = Traverse.Create(this);
 			HarmonyFields().ForEach(f =>
 			{
-				result += f + '=' + trv.Field(f).GetValue();
+				if (result.Length > 0) result += ", ";
+				result += $"{f}={trv.Field(f).GetValue()}";
 			});
-			return result + "]";
+			return $"HarmonyMethod[{result}]";
+		}
+
+		// used for error reporting
+		internal string Description()
+		{
+			var cName = declaringType != null ? declaringType.FullName : "undefined";
+			var mName = methodName ?? "undefined";
+			var tName = methodType.HasValue ? methodType.Value.ToString() : "undefined";
+			var aName = argumentTypes != null ? argumentTypes.Description() : "undefined";
+			return $"(class={cName}, methodname={mName}, type={tName}, args={aName})";
 		}
 	}
 
@@ -128,7 +139,7 @@ internal static void SetValue(Traverse trv, string name, object val)
 				var enumType = Nullable.GetUnderlyingType(fld.GetValueType());
 				val = Enum.ToObject(enumType, (int)val);
 			}
-			fld.SetValue(val);
+			_ = fld.SetValue(val);
 		}
 
 		/// <summary>Copies annotation information</summary>
@@ -184,7 +195,7 @@ static HarmonyMethod GetHarmonyMethodInfo(object attribute)
 		{
 			var f_info = attribute.GetType().GetField(nameof(HarmonyAttribute.info), AccessTools.all);
 			if (f_info == null) return null;
-			if (f_info.FieldType.Name != nameof(HarmonyMethod)) return null;
+			if (f_info.FieldType.FullName != typeof(HarmonyMethod).FullName) return null;
 			var info = f_info.GetValue(attribute);
 			return AccessTools.MakeDeepCopy<HarmonyMethod>(info);
 		}
@@ -201,6 +212,15 @@ public static List<HarmonyMethod> GetFromType(Type type)
 						.ToList();
 		}
 
+		/// <summary>Gets all annotations on a class in merged form</summary>
+		/// <param name="type">The class</param>
+		/// <returns>The merged HarmonyMethod</returns>
+		///
+		public static HarmonyMethod GetMergedFromType(Type type)
+		{
+			return HarmonyMethod.Merge(GetFromType(type));
+		}
+
 		/// <summary>Gets all annotations on a method</summary>
 		/// <param name="method">The method</param>
 		/// <returns>All annotations</returns>
@@ -212,5 +232,14 @@ public static List<HarmonyMethod> GetFromMethod(MethodBase method)
 						.Where(info => info != null)
 						.ToList();
 		}
+
+		/// <summary>Gets all annotations on a method in merged form</summary>
+		/// <param name="method">The method</param>
+		/// <returns>The merged HarmonyMethod</returns>
+		///
+		public static HarmonyMethod GetMergedFromMethod(MethodBase method)
+		{
+			return HarmonyMethod.Merge(GetFromMethod(method));
+		}
 	}
 }
\ No newline at end of file
diff --git a/Harmony/Public/Patch.cs b/Harmony/Public/Patch.cs
index 97320d32..95461102 100644
--- a/Harmony/Public/Patch.cs
+++ b/Harmony/Public/Patch.cs
@@ -266,7 +266,7 @@ public class Patch : IComparable
 		///
 		public Patch(MethodInfo patch, int index, string owner, int priority, string[] before, string[] after)
 		{
-			if (patch is DynamicMethod) throw new Exception("Cannot directly reference dynamic method \"" + patch.FullDescription() + "\" in Harmony. Use a factory method instead that will return the dynamic method.");
+			if (patch is DynamicMethod) throw new Exception($"Cannot directly reference dynamic method \"{patch.FullDescription()}\" in Harmony. Use a factory method instead that will return the dynamic method.");
 
 			this.index = index;
 			this.owner = owner;
diff --git a/Harmony/Public/PatchClassProcessor.cs b/Harmony/Public/PatchClassProcessor.cs
new file mode 100644
index 00000000..65fb9ecb
--- /dev/null
+++ b/Harmony/Public/PatchClassProcessor.cs
@@ -0,0 +1,261 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace HarmonyLib
+{
+	/// <summary>A PatchClassProcessor handles patch annotation on a class</summary>
+	public class PatchClassProcessor
+	{
+		readonly Harmony instance;
+
+		readonly Type containerType;
+		readonly HarmonyMethod containerAttributes;
+		readonly Dictionary<Type, MethodInfo> auxilaryMethods;
+
+		readonly List<AttributePatch> patchMethods;
+		readonly List<MethodInfo> reversePatchMethods;
+		List<MethodBase> bulkOriginals;
+
+		static readonly List<Type> auxilaryTypes = new List<Type>() {
+			typeof(HarmonyPrepare),
+			typeof(HarmonyCleanup),
+			typeof(HarmonyTargetMethod),
+			typeof(HarmonyTargetMethods)
+		};
+
+		/// <summary>Creates an empty patch class processor</summary>
+		/// <param name="instance">The Harmony instance</param>
+		/// <param name="type">The class to process</param>
+		///
+		public PatchClassProcessor(Harmony instance, Type type)
+		{
+			if (instance == null)
+				throw new ArgumentNullException(nameof(instance));
+			if (type == null)
+				throw new ArgumentNullException(nameof(type));
+
+			this.instance = instance;
+			containerType = type;
+
+			var harmonyAttributes = HarmonyMethodExtensions.GetFromType(type);
+			if (harmonyAttributes == null || harmonyAttributes.Count == 0)
+				return;
+
+			containerAttributes = HarmonyMethod.Merge(harmonyAttributes);
+			if (containerAttributes.methodType == null) // MethodType default is Normal
+				containerAttributes.methodType = MethodType.Normal;
+
+			auxilaryMethods = new Dictionary<Type, MethodInfo>();
+			foreach (var auxType in auxilaryTypes)
+			{
+				var method = PatchTools.GetPatchMethod(containerType, auxType.FullName);
+				if (method != null) auxilaryMethods[auxType] = method;
+			}
+
+			patchMethods = PatchTools.GetPatchMethods(containerType);
+			foreach (var patchMethod in patchMethods)
+			{
+				var method = patchMethod.info.method;
+				patchMethod.info = containerAttributes.Merge(patchMethod.info);
+				patchMethod.info.method = method;
+			}
+
+			reversePatchMethods = PatchTools.GetReversePatches(containerType);
+		}
+
+		/// <summary>Applies the patches</summary>
+		/// <returns>A list of all created dynamic methods</returns>
+		///
+		public List<DynamicMethod> Patch()
+		{
+			var mainPrepareResult = RunMethod<HarmonyPrepare, bool>(true);
+			if (mainPrepareResult == false)
+			{
+				RunMethod<HarmonyCleanup>();
+				return null;
+			}
+
+			foreach (var reversePatchMethod in reversePatchMethods)
+			{
+				var originalMethod = GetReverseOriginal(reversePatchMethod);
+				var reversePatcher = instance.CreateReversePatcher(originalMethod, reversePatchMethod);
+				reversePatcher.Patch();
+			}
+
+			bulkOriginals = GetBulkMethods();
+			var replacements = bulkOriginals.Count > 0 ? BulkPatch() : PatchWithAttributes();
+			RunMethod<HarmonyCleanup>();
+			return replacements;
+		}
+
+		List<DynamicMethod> BulkPatch()
+		{
+			var jobs = new PatchJobs<DynamicMethod>();
+			foreach (var original in bulkOriginals)
+			{
+				var job = jobs.GetJob(original);
+				foreach (var patchMethod in patchMethods)
+				{
+					var note = "You cannot combine TargetMethod, TargetMethods or PatchAll with individual annotations";
+					var info = patchMethod.info;
+					if (info.declaringType != null)
+						throw new ArgumentException($"{note} [{info.declaringType.FullDescription()}]");
+					if (info.methodName != null)
+						throw new ArgumentException($"{note} [{info.methodName}]");
+					if (info.methodType.HasValue && info.methodType.Value != MethodType.Normal)
+						throw new ArgumentException($"{note} [{info.methodType}]");
+					if (info.argumentTypes != null)
+						throw new ArgumentException($"{note} [{info.argumentTypes.Description()}]");
+
+					job.AddPatch(patchMethod);
+				}
+			}
+			foreach (var job in jobs.GetJobs())
+				ProcessPatchJob(job);
+			return jobs.GetReplacements();
+		}
+
+		List<DynamicMethod> PatchWithAttributes()
+		{
+			var jobs = new PatchJobs<DynamicMethod>();
+			foreach (var patchMethod in patchMethods)
+			{
+				if (patchMethod.info.declaringType == null)
+					throw new ArgumentException($"Undefined class for method for patch method {patchMethod.info.method.FullDescription()}");
+				if (patchMethod.info.methodName == null)
+					throw new ArgumentException($"Undefined method name for patch method {patchMethod.info.method.FullDescription()}");
+
+				var original = AccessTools.Method(patchMethod.info.declaringType, patchMethod.info.methodName, patchMethod.info.argumentTypes);
+				if (original == null)
+					throw new ArgumentException($"Undefined target method for patch method {patchMethod.info.method.FullDescription()}");
+
+				var job = jobs.GetJob(original);
+				job.AddPatch(patchMethod);
+			}
+			foreach (var job in jobs.GetJobs())
+				ProcessPatchJob(job);
+			return jobs.GetReplacements();
+		}
+
+		void ProcessPatchJob(PatchJobs<DynamicMethod>.Job job)
+		{
+			DynamicMethod replacement = default;
+
+			var individualPrepareResult = RunMethod<HarmonyPrepare, bool>(true, job.original);
+			if (individualPrepareResult)
+			{
+				lock (PatchProcessor.locker)
+				{
+					var patchInfo = HarmonySharedState.GetPatchInfo(job.original);
+					if (patchInfo == null) patchInfo = new PatchInfo();
+
+					foreach (var prefix in job.prefixes)
+						PatchFunctions.AddPrefix(patchInfo, instance.Id, prefix);
+					foreach (var postfix in job.postfixes)
+						PatchFunctions.AddPostfix(patchInfo, instance.Id, postfix);
+					foreach (var transpiler in job.transpilers)
+						PatchFunctions.AddTranspiler(patchInfo, instance.Id, transpiler);
+					foreach (var finalizer in job.finalizers)
+						PatchFunctions.AddFinalizer(patchInfo, instance.Id, finalizer);
+
+					replacement = PatchFunctions.UpdateWrapper(job.original, patchInfo, instance.Id);
+					HarmonySharedState.UpdatePatchInfo(job.original, patchInfo);
+				}
+			}
+			RunMethod<HarmonyCleanup>(job.original);
+			job.replacement = replacement;
+		}
+
+		List<MethodBase> GetBulkMethods()
+		{
+			var isPatchAll = containerType.GetCustomAttributes(true).Any(a => a.GetType().FullName == typeof(HarmonyPatchAll).FullName);
+			if (isPatchAll)
+			{
+				var type = containerAttributes.declaringType;
+				if (type == null)
+					throw new ArgumentException($"Using {typeof(HarmonyPatchAll).FullName} requires an additional attribute for specifying the Class/Type");
+
+				var list = new List<MethodBase>();
+				list.AddRange(AccessTools.GetDeclaredConstructors(type).Cast<MethodBase>());
+				list.AddRange(AccessTools.GetDeclaredMethods(type).Cast<MethodBase>());
+				var props = AccessTools.GetDeclaredProperties(type);
+				list.AddRange(props.Select(prop => prop.GetGetMethod(true)).Where(method => method != null).Cast<MethodBase>());
+				list.AddRange(props.Select(prop => prop.GetSetMethod(true)).Where(method => method != null).Cast<MethodBase>());
+				return list;
+			}
+
+			var targetMethods = RunMethod<HarmonyTargetMethods, IEnumerable<MethodBase>>(null);
+			if (targetMethods != null)
+				return targetMethods.Where(method => method != null).ToList();
+
+			var result = new List<MethodBase>();
+			var targetMethod = RunMethod<HarmonyTargetMethod, MethodBase>(null);
+			if (targetMethod != null)
+				result.Add(targetMethod);
+			return result;
+		}
+
+		MethodBase GetReverseOriginal(MethodInfo standin)
+		{
+			var attr = containerAttributes.Merge(new HarmonyMethod(standin));
+			if (attr.declaringType == null) return null;
+			switch (attr.methodType)
+			{
+				case MethodType.Normal:
+					if (attr.methodName == null)
+						return null;
+					return AccessTools.DeclaredMethod(attr.declaringType, attr.methodName, attr.argumentTypes);
+
+				case MethodType.Getter:
+					if (attr.methodName == null)
+						return null;
+					return AccessTools.DeclaredProperty(attr.declaringType, attr.methodName).GetGetMethod(true);
+
+				case MethodType.Setter:
+					if (attr.methodName == null)
+						return null;
+					return AccessTools.DeclaredProperty(attr.declaringType, attr.methodName).GetSetMethod(true);
+
+				case MethodType.Constructor:
+					return AccessTools.DeclaredConstructor(attr.declaringType, attr.argumentTypes);
+
+				case MethodType.StaticConstructor:
+					return AccessTools.GetDeclaredConstructors(attr.declaringType)
+						.Where(c => c.IsStatic)
+						.FirstOrDefault();
+			}
+
+			return null;
+		}
+
+		T RunMethod<S, T>(T defaultIfNotExisting, params object[] parameters)
+		{
+			if (auxilaryMethods.TryGetValue(typeof(S), out var method))
+			{
+				var input = (parameters ?? new object[0]).Union(new object[] { instance }).ToArray();
+				var actualParameters = AccessTools.ActualParameters(method, input);
+
+				if (typeof(T).IsAssignableFrom(method.ReturnType))
+					return (T)method.Invoke(null, actualParameters);
+
+				_ = method.Invoke(null, actualParameters);
+				return defaultIfNotExisting;
+			}
+
+			return defaultIfNotExisting;
+		}
+
+		void RunMethod<S>(params object[] parameters)
+		{
+			if (auxilaryMethods.TryGetValue(typeof(S), out var method))
+			{
+				var input = (parameters ?? new object[0]).Union(new object[] { instance }).ToArray();
+				var actualParameters = AccessTools.ActualParameters(method, input);
+				_ = method.Invoke(null, actualParameters);
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/Harmony/Public/PatchProcessor.cs b/Harmony/Public/PatchProcessor.cs
index 1cd61c24..10cb1f72 100644
--- a/Harmony/Public/PatchProcessor.cs
+++ b/Harmony/Public/PatchProcessor.cs
@@ -12,74 +12,33 @@ static class PatchProcessorExtensions
 		/// <param name="instance">The Harmony instance</param>
 		/// <param name="original">An optional original method</param>
 		///
-		public static PatchProcessor CreateProcessor(this Harmony instance, MethodBase original = null)
+		public static PatchProcessor CreateProcessor(this Harmony instance, MethodBase original)
 		{
 			return new PatchProcessor(instance, original);
 		}
 	}
 
-	/// <summary>A patch processor</summary>
+	/// <summary>A PatchProcessor handles patches on a method/constructor</summary>
 	public class PatchProcessor
 	{
-		static readonly object locker = new object();
-
 		readonly Harmony instance;
+		readonly MethodBase original;
 
-		readonly Type container;
-		readonly HarmonyMethod containerAttributes;
-
-		readonly List<MethodBase> originals = new List<MethodBase>();
 		HarmonyMethod prefix;
 		HarmonyMethod postfix;
 		HarmonyMethod transpiler;
 		HarmonyMethod finalizer;
 
+		internal static readonly object locker = new object();
+
 		/// <summary>Creates an empty patch processor</summary>
 		/// <param name="instance">The Harmony instance</param>
 		/// <param name="original">An optional original method</param>
 		///
-		public PatchProcessor(Harmony instance, MethodBase original = null)
+		public PatchProcessor(Harmony instance, MethodBase original)
 		{
 			this.instance = instance;
-			if (original != null)
-				originals.Add(original);
-		}
-
-		/// <summary>Creates a patch processor</summary>
-		/// <param name="instance">The Harmony instance</param>
-		/// <param name="type">The patch class</param>
-		/// <param name="attributes">The Harmony attributes</param>
-		///
-		public PatchProcessor(Harmony instance, Type type, HarmonyMethod attributes)
-		{
-			this.instance = instance;
-			container = type;
-			containerAttributes = attributes ?? new HarmonyMethod();
-			prefix = containerAttributes.Clone();
-			postfix = containerAttributes.Clone();
-			transpiler = containerAttributes.Clone();
-			finalizer = containerAttributes.Clone();
-			PrepareType();
-		}
-
-		/// <summary>Add an original method</summary>
-		/// <param name="original">The method that will be patched.</param>
-		///
-		public PatchProcessor AddOriginal(MethodBase original)
-		{
-			if (originals.Contains(original) == false)
-				originals.Add(original);
-			return this;
-		}
-
-		/// <summary>Sets the original methods</summary>
-		/// <param name="originals">The methods that will be patched.</param>
-		///
-		public PatchProcessor SetOriginals(List<MethodBase> originals)
-		{
-			this.originals.Clear();
-			this.originals.AddRange(originals);
-			return this;
+			this.original = original;
 		}
 
 		/// <summary>Add a prefix</summary>
@@ -154,24 +113,10 @@ public PatchProcessor AddFinalizer(MethodInfo fixMethod)
 			return this;
 		}
 
-		/// <summary>Gets patch information</summary>
-		/// <param name="method">The original method</param>
-		/// <returns>The patch information</returns>
-		///
-		public static Patches GetPatchInfo(MethodBase method)
-		{
-			lock (locker)
-			{
-				var patchInfo = HarmonySharedState.GetPatchInfo(method);
-				if (patchInfo == null) return null;
-				return new Patches(patchInfo.prefixes, patchInfo.postfixes, patchInfo.transpilers, patchInfo.finalizers);
-			}
-		}
-
-		/// <summary>Gets all patched original methods</summary>
-		/// <returns>All patched original methods</returns>
+		/// <summary>Gets all patched original methods in the appdomain</summary>
+		/// <returns>An enumeration of patched original methods</returns>
 		///
-		public static IEnumerable<MethodBase> AllPatchedMethods()
+		public static IEnumerable<MethodBase> GetAllPatchedMethods()
 		{
 			lock (locker)
 			{
@@ -182,34 +127,30 @@ public static IEnumerable<MethodBase> AllPatchedMethods()
 		/// <summary>Applies the patch</summary>
 		/// <returns>A list of all created dynamic methods</returns>
 		///
-		public List<DynamicMethod> Patch()
+		public DynamicMethod Patch()
 		{
-			lock (locker)
-			{
-				var dynamicMethods = new List<DynamicMethod>();
-				foreach (var original in originals)
-				{
-					if (original == null)
-						throw new NullReferenceException("Null method for " + instance.Id);
+			if (original == null)
+				throw new NullReferenceException($"Null method for {instance.Id}");
 
-					var individualPrepareResult = RunMethod<HarmonyPrepare, bool>(true, original);
-					if (individualPrepareResult)
-					{
-						var patchInfo = HarmonySharedState.GetPatchInfo(original);
-						if (patchInfo == null) patchInfo = new PatchInfo();
+			if (original.IsDeclaredMember() == false)
+			{
+				var declaredMember = original.GetDeclaredMember();
+				throw new ArgumentException($"You can only patch implemented methods/constructors. Path the declared method {declaredMember.FullDescription()} instead.");
+			}
 
-						PatchFunctions.AddPrefix(patchInfo, instance.Id, prefix);
-						PatchFunctions.AddPostfix(patchInfo, instance.Id, postfix);
-						PatchFunctions.AddTranspiler(patchInfo, instance.Id, transpiler);
-						PatchFunctions.AddFinalizer(patchInfo, instance.Id, finalizer);
-						dynamicMethods.Add(PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id));
+			lock (locker)
+			{
+				var patchInfo = HarmonySharedState.GetPatchInfo(original);
+				if (patchInfo == null) patchInfo = new PatchInfo();
 
-						HarmonySharedState.UpdatePatchInfo(original, patchInfo);
+				PatchFunctions.AddPrefix(patchInfo, instance.Id, prefix);
+				PatchFunctions.AddPostfix(patchInfo, instance.Id, postfix);
+				PatchFunctions.AddTranspiler(patchInfo, instance.Id, transpiler);
+				PatchFunctions.AddFinalizer(patchInfo, instance.Id, finalizer);
+				var dynamicMethod = PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id);
 
-						RunMethod<HarmonyCleanup>(original);
-					}
-				}
-				return dynamicMethods;
+				HarmonySharedState.UpdatePatchInfo(original, patchInfo);
+				return dynamicMethod;
 			}
 		}
 
@@ -221,25 +162,22 @@ public PatchProcessor Unpatch(HarmonyPatchType type, string harmonyID)
 		{
 			lock (locker)
 			{
-				foreach (var original in originals)
-				{
-					var patchInfo = HarmonySharedState.GetPatchInfo(original);
-					if (patchInfo == null) patchInfo = new PatchInfo();
+				var patchInfo = HarmonySharedState.GetPatchInfo(original);
+				if (patchInfo == null) patchInfo = new PatchInfo();
 
-					if (type == HarmonyPatchType.All || type == HarmonyPatchType.Prefix)
-						PatchFunctions.RemovePrefix(patchInfo, harmonyID);
-					if (type == HarmonyPatchType.All || type == HarmonyPatchType.Postfix)
-						PatchFunctions.RemovePostfix(patchInfo, harmonyID);
-					if (type == HarmonyPatchType.All || type == HarmonyPatchType.Transpiler)
-						PatchFunctions.RemoveTranspiler(patchInfo, harmonyID);
-					if (type == HarmonyPatchType.All || type == HarmonyPatchType.Finalizer)
-						PatchFunctions.RemoveFinalizer(patchInfo, harmonyID);
-					PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id);
+				if (type == HarmonyPatchType.All || type == HarmonyPatchType.Prefix)
+					PatchFunctions.RemovePrefix(patchInfo, harmonyID);
+				if (type == HarmonyPatchType.All || type == HarmonyPatchType.Postfix)
+					PatchFunctions.RemovePostfix(patchInfo, harmonyID);
+				if (type == HarmonyPatchType.All || type == HarmonyPatchType.Transpiler)
+					PatchFunctions.RemoveTranspiler(patchInfo, harmonyID);
+				if (type == HarmonyPatchType.All || type == HarmonyPatchType.Finalizer)
+					PatchFunctions.RemoveFinalizer(patchInfo, harmonyID);
+				_ = PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id);
 
-					HarmonySharedState.UpdatePatchInfo(original, patchInfo);
-				}
+				HarmonySharedState.UpdatePatchInfo(original, patchInfo);
+				return this;
 			}
-			return this;
 		}
 
 		/// <summary>Unpatches the given patch</summary>
@@ -249,230 +187,55 @@ public PatchProcessor Unpatch(MethodInfo patch)
 		{
 			lock (locker)
 			{
-				foreach (var original in originals)
-				{
-					var patchInfo = HarmonySharedState.GetPatchInfo(original);
-					if (patchInfo == null) patchInfo = new PatchInfo();
-
-					PatchFunctions.RemovePatch(patchInfo, patch);
-					PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id);
-
-					HarmonySharedState.UpdatePatchInfo(original, patchInfo);
-				}
-			}
-			return this;
-		}
-
-		void PrepareType()
-		{
-			var mainPrepareResult = RunMethod<HarmonyPrepare, bool>(true);
-			if (mainPrepareResult == false)
-				return;
-
-			var originalMethodType = containerAttributes.methodType;
-
-			// MethodType default is Normal
-			if (containerAttributes.methodType == null)
-				containerAttributes.methodType = MethodType.Normal;
-
-			var reversePatchMethods = PatchTools.GetReversePatches(container);
-			foreach (var reversePatchMethod in reversePatchMethods)
-			{
-				var originalMethod = GetReverseOriginal(reversePatchMethod);
-				var reversePatcher = instance.CreateReversePatcher(originalMethod, reversePatchMethod);
-				reversePatcher.Patch();
-			}
-
-			var customOriginals = RunMethod<HarmonyTargetMethods, IEnumerable<MethodBase>>(null);
-			if (customOriginals != null)
-			{
-				originals.Clear();
-				originals.AddRange(customOriginals);
-			}
-			else
-			{
-				var isPatchAll = container.GetCustomAttributes(true).Any(a => a.GetType().FullName == typeof(HarmonyPatchAll).FullName);
-				if (isPatchAll)
-				{
-					var type = containerAttributes.declaringType;
-					originals.AddRange(AccessTools.GetDeclaredConstructors(type).Cast<MethodBase>());
-					originals.AddRange(AccessTools.GetDeclaredMethods(type).Cast<MethodBase>());
-					var props = AccessTools.GetDeclaredProperties(type);
-					originals.AddRange(props.Select(prop => prop.GetGetMethod(true)).Where(method => method != null).Cast<MethodBase>());
-					originals.AddRange(props.Select(prop => prop.GetSetMethod(true)).Where(method => method != null).Cast<MethodBase>());
-				}
-				else
-				{
-					var original = RunMethod<HarmonyTargetMethod, MethodBase>(null);
-
-					if (original == null)
-						original = GetOriginalMethod();
-
-					if (original == null)
-					{
-						var info = "(";
-						info += "declaringType=" + containerAttributes.declaringType + ", ";
-						info += "methodName =" + containerAttributes.methodName + ", ";
-						info += "methodType=" + originalMethodType + ", ";
-						info += "argumentTypes=" + containerAttributes.argumentTypes.Description();
-						info += ")";
-						throw new ArgumentException("No target method specified for class " + container.FullName + " " + info);
-					}
-
-					originals.Add(original);
-				}
-			}
-
-			PatchTools.GetPatches(container, out var prefixMethod, out var postfixMethod, out var transpilerMethod, out var finalizerMethod);
-			if (prefix != null)
-				prefix.method = prefixMethod;
-			if (postfix != null)
-				postfix.method = postfixMethod;
-			if (transpiler != null)
-				transpiler.method = transpilerMethod;
-			if (finalizer != null)
-				finalizer.method = finalizerMethod;
-
-			if (prefixMethod != null)
-			{
-				if (prefixMethod.IsStatic == false)
-					throw new ArgumentException("Patch method " + prefixMethod.FullDescription() + " must be static");
-
-				var prefixAttributes = HarmonyMethodExtensions.GetFromMethod(prefixMethod);
-				containerAttributes.Merge(HarmonyMethod.Merge(prefixAttributes)).CopyTo(prefix);
-			}
-
-			if (postfixMethod != null)
-			{
-				if (postfixMethod.IsStatic == false)
-					throw new ArgumentException("Patch method " + postfixMethod.FullDescription() + " must be static");
-
-				var postfixAttributes = HarmonyMethodExtensions.GetFromMethod(postfixMethod);
-				containerAttributes.Merge(HarmonyMethod.Merge(postfixAttributes)).CopyTo(postfix);
-			}
-
-			if (transpilerMethod != null)
-			{
-				if (transpilerMethod.IsStatic == false)
-					throw new ArgumentException("Patch method " + transpilerMethod.FullDescription() + " must be static");
-
-				var transpilerAttributes = HarmonyMethodExtensions.GetFromMethod(transpilerMethod);
-				containerAttributes.Merge(HarmonyMethod.Merge(transpilerAttributes)).CopyTo(transpiler);
-			}
-
-			if (finalizerMethod != null)
-			{
-				if (finalizerMethod.IsStatic == false)
-					throw new ArgumentException("Patch method " + finalizerMethod.FullDescription() + " must be static");
-
-				var finalizerAttributes = HarmonyMethodExtensions.GetFromMethod(finalizerMethod);
-				containerAttributes.Merge(HarmonyMethod.Merge(finalizerAttributes)).CopyTo(finalizer);
-			}
-		}
-
-		MethodBase GetOriginalMethod()
-		{
-			var attr = containerAttributes;
-			if (attr.declaringType == null) return null;
-
-			switch (attr.methodType)
-			{
-				case MethodType.Normal:
-					if (attr.methodName == null)
-						return null;
-					return AccessTools.DeclaredMethod(attr.declaringType, attr.methodName, attr.argumentTypes);
-
-				case MethodType.Getter:
-					if (attr.methodName == null)
-						return null;
-					return AccessTools.DeclaredProperty(attr.declaringType, attr.methodName).GetGetMethod(true);
+				var patchInfo = HarmonySharedState.GetPatchInfo(original);
+				if (patchInfo == null) patchInfo = new PatchInfo();
 
-				case MethodType.Setter:
-					if (attr.methodName == null)
-						return null;
-					return AccessTools.DeclaredProperty(attr.declaringType, attr.methodName).GetSetMethod(true);
+				PatchFunctions.RemovePatch(patchInfo, patch);
+				_ = PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id);
 
-				case MethodType.Constructor:
-					return AccessTools.DeclaredConstructor(attr.declaringType, attr.argumentTypes);
-
-				case MethodType.StaticConstructor:
-					return AccessTools.GetDeclaredConstructors(attr.declaringType)
-						.Where(c => c.IsStatic)
-						.FirstOrDefault();
+				HarmonySharedState.UpdatePatchInfo(original, patchInfo);
+				return this;
 			}
-
-			return null;
 		}
 
-		MethodBase GetReverseOriginal(MethodInfo standin)
+		/// <summary>Gets patch information</summary>
+		/// <param name="method">The original method</param>
+		/// <returns>The patch information</returns>
+		///
+		public static Patches GetPatchInfo(MethodBase method)
 		{
-			var attr = containerAttributes.Merge(new HarmonyMethod(standin));
-			if (attr.declaringType == null) return null;
-			switch (attr.methodType)
-			{
-				case MethodType.Normal:
-					if (attr.methodName == null)
-						return null;
-					return AccessTools.DeclaredMethod(attr.declaringType, attr.methodName, attr.argumentTypes);
-
-				case MethodType.Getter:
-					if (attr.methodName == null)
-						return null;
-					return AccessTools.DeclaredProperty(attr.declaringType, attr.methodName).GetGetMethod(true);
-
-				case MethodType.Setter:
-					if (attr.methodName == null)
-						return null;
-					return AccessTools.DeclaredProperty(attr.declaringType, attr.methodName).GetSetMethod(true);
-
-				case MethodType.Constructor:
-					return AccessTools.DeclaredConstructor(attr.declaringType, attr.argumentTypes);
-
-				case MethodType.StaticConstructor:
-					return AccessTools.GetDeclaredConstructors(attr.declaringType)
-						.Where(c => c.IsStatic)
-						.FirstOrDefault();
-			}
-
-			return null;
+			PatchInfo patchInfo;
+			lock (locker) { patchInfo = HarmonySharedState.GetPatchInfo(method); }
+			if (patchInfo == null) return null;
+			return new Patches(patchInfo.prefixes, patchInfo.postfixes, patchInfo.transpilers, patchInfo.finalizers);
 		}
 
-		T RunMethod<S, T>(T defaultIfNotExisting, params object[] parameters)
+		/// <summary>Gets Harmony version for all active Harmony instances</summary>
+		/// <param name="currentVersion">[out] The current Harmony version</param>
+		/// <returns>A dictionary containing assembly versions keyed by Harmony IDs</returns>
+		///
+		public static Dictionary<string, Version> VersionInfo(out Version currentVersion)
 		{
-			if (container == null)
-				return defaultIfNotExisting;
-
-			var methodName = typeof(S).Name.Replace("Harmony", "");
-			var method = PatchTools.GetPatchMethod<S>(container, methodName);
-			if (method != null)
+			currentVersion = typeof(Harmony).Assembly.GetName().Version;
+			var assemblies = new Dictionary<string, Assembly>();
+			GetAllPatchedMethods().Do(method =>
 			{
-				if (typeof(T).IsAssignableFrom(method.ReturnType))
-					return (T)method.Invoke(null, Type.EmptyTypes);
-
-				var input = (parameters ?? new object[0]).Union(new object[] { instance }).ToArray();
-				var actualParameters = AccessTools.ActualParameters(method, input);
-				method.Invoke(null, actualParameters);
-				return defaultIfNotExisting;
-			}
+				PatchInfo info;
+				lock (locker) { info = HarmonySharedState.GetPatchInfo(method); }
+				info.prefixes.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
+				info.postfixes.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
+				info.transpilers.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
+				info.finalizers.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
+			});
 
-			return defaultIfNotExisting;
-		}
-
-		void RunMethod<S>(params object[] parameters)
-		{
-			if (container == null)
-				return;
-
-			var methodName = typeof(S).Name.Replace("Harmony", "");
-			var method = PatchTools.GetPatchMethod<S>(container, methodName);
-			if (method != null)
+			var result = new Dictionary<string, Version>();
+			assemblies.Do(info =>
 			{
-				var input = (parameters ?? new object[0]).Union(new object[] { instance }).ToArray();
-				var actualParameters = AccessTools.ActualParameters(method, input);
-				method.Invoke(null, actualParameters);
-			}
-
-			return;
+				var assemblyName = info.Value.GetReferencedAssemblies().FirstOrDefault(a => a.FullName.StartsWith("0Harmony, Version", StringComparison.Ordinal));
+				if (assemblyName != null)
+					result[info.Key] = assemblyName.Version;
+			});
+			return result;
 		}
 	}
 }
\ No newline at end of file
diff --git a/Harmony/Public/ReversePatcher.cs b/Harmony/Public/ReversePatcher.cs
index 16ac30df..e5e5c76f 100644
--- a/Harmony/Public/ReversePatcher.cs
+++ b/Harmony/Public/ReversePatcher.cs
@@ -42,7 +42,7 @@ public ReversePatcher(Harmony instance, MethodBase original, MethodInfo standin)
 		public void Patch(HarmonyReversePatchType type = HarmonyReversePatchType.Original)
 		{
 			if (original == null)
-				throw new NullReferenceException("Null method for " + instance.Id);
+				throw new NullReferenceException($"Null method for {instance.Id}");
 
 			var transpiler = GetTranspiler(standin);
 			PatchFunctions.ReversePatch(standin, original, instance.Id, transpiler);
@@ -57,7 +57,7 @@ internal static MethodInfo GetTranspiler(MethodInfo method)
 			return methods.FirstOrDefault(m =>
 			{
 				if (m.ReturnType != ici) return false;
-				return m.Name.StartsWith('<' + methodName + '>');
+				return m.Name.StartsWith($"<{methodName }>");
 			});
 		}
 	}
diff --git a/Harmony/Tools/AccessTools.cs b/Harmony/Tools/AccessTools.cs
index fe603cb8..67fc1721 100644
--- a/Harmony/Tools/AccessTools.cs
+++ b/Harmony/Tools/AccessTools.cs
@@ -42,7 +42,7 @@ public static Type TypeByName(string name)
 					.SelectMany(a => GetTypesFromAssembly(a))
 					.FirstOrDefault(t => t.Name == name);
 			if (type == null && Harmony.DEBUG)
-				FileLog.Log("AccessTools.TypeByName: Could not find type named " + name);
+				FileLog.Log($"AccessTools.TypeByName: Could not find type named {name}");
 			return type;
 		}
 
@@ -121,7 +121,7 @@ public static FieldInfo DeclaredField(Type type, string name)
 			}
 			var field = type.GetField(name, allDeclared);
 			if (field == null && Harmony.DEBUG)
-				FileLog.Log("AccessTools.DeclaredField: Could not find field for type " + type + " and name " + name);
+				FileLog.Log($"AccessTools.DeclaredField: Could not find field for type {type} and name {name}");
 			return field;
 		}
 
@@ -146,7 +146,7 @@ public static FieldInfo Field(Type type, string name)
 			}
 			var field = FindIncludingBaseTypes(type, t => t.GetField(name, all));
 			if (field == null && Harmony.DEBUG)
-				FileLog.Log("AccessTools.Field: Could not find field for type " + type + " and name " + name);
+				FileLog.Log($"AccessTools.Field: Could not find field for type {type} and name {name}");
 			return field;
 		}
 
@@ -165,7 +165,7 @@ public static FieldInfo DeclaredField(Type type, int idx)
 			}
 			var field = GetDeclaredFields(type).ElementAtOrDefault(idx);
 			if (field == null && Harmony.DEBUG)
-				FileLog.Log("AccessTools.DeclaredField: Could not find field for type " + type + " and idx " + idx);
+				FileLog.Log($"AccessTools.DeclaredField: Could not find field for type {type} and idx {idx}");
 			return field;
 		}
 
@@ -190,7 +190,7 @@ public static PropertyInfo DeclaredProperty(Type type, string name)
 			}
 			var property = type.GetProperty(name, allDeclared);
 			if (property == null && Harmony.DEBUG)
-				FileLog.Log("AccessTools.DeclaredProperty: Could not find property for type " + type + " and name " + name);
+				FileLog.Log($"AccessTools.DeclaredProperty: Could not find property for type {type} and name {name}");
 			return property;
 		}
 
@@ -235,7 +235,7 @@ public static PropertyInfo Property(Type type, string name)
 			}
 			var property = FindIncludingBaseTypes(type, t => t.GetProperty(name, all));
 			if (property == null && Harmony.DEBUG)
-				FileLog.Log("AccessTools.Property: Could not find property for type " + type + " and name " + name);
+				FileLog.Log($"AccessTools.Property: Could not find property for type {type} and name {name}");
 			return property;
 		}
 
@@ -291,7 +291,7 @@ public static MethodInfo DeclaredMethod(Type type, string name, Type[] parameter
 			if (result == null)
 			{
 				if (Harmony.DEBUG)
-					FileLog.Log("AccessTools.DeclaredMethod: Could not find method for type " + type + " and name " + name + " and parameters " + parameters?.Description());
+					FileLog.Log($"AccessTools.DeclaredMethod: Could not find method for type {type} and name {name} and parameters {parameters?.Description()}");
 				return null;
 			}
 
@@ -344,7 +344,7 @@ public static MethodInfo Method(Type type, string name, Type[] parameters = null
 			if (result == null)
 			{
 				if (Harmony.DEBUG)
-					FileLog.Log("AccessTools.Method: Could not find method for type " + type + " and name " + name + " and parameters " + parameters?.Description());
+					FileLog.Log($"AccessTools.Method: Could not find method for type {type} and name {name} and parameters {parameters?.Description()}");
 				return null;
 			}
 
@@ -465,7 +465,7 @@ public static List<string> GetPropertyNames(object instance)
 		}
 
 		/// <summary>Gets the type of any member of a class</summary>
-		/// <param name="member">An EventInfo, FieldInfo, MethodInfo, or PropertyInfo</param>
+		/// <param name="member">An EventInfo, FieldInfo, MethodBase, PropertyInfo or TypeInfo</param>
 		/// <returns>The type that represents the output of this member</returns>
 		///
 		public static Type GetUnderlyingType(this MemberInfo member)
@@ -485,12 +485,39 @@ public static Type GetUnderlyingType(this MemberInfo member)
 			}
 		}
 
+		/// <summary>Test if a class member is actually an concrete implementation</summary>
+		/// <param name="member">An EventInfo, FieldInfo, MethodBase, PropertyInfo or TypeInfo</param>
+		/// <returns>True if the member is a declared</returns>
+		///
+		public static bool IsDeclaredMember<T>(this T member) where T : MemberInfo
+		{
+			return member.DeclaringType == member.ReflectedType;
+		}
+
+		/// <summary>Gets the real implementation of a class member</summary>
+		/// <param name="member">An EventInfo, FieldInfo, MethodBase, PropertyInfo or TypeInfo</param>
+		/// <returns>The member itself if its declared. Otherwise the member that is actually implemented in some base type</returns>
+		///
+		public static T GetDeclaredMember<T>(this T member) where T : MemberInfo
+		{
+			if (member.IsDeclaredMember())
+				return member;
+
+			var metaToken = member.MetadataToken;
+			foreach (var other in member.DeclaringType.GetMembers(all))
+				if (other.MetadataToken == metaToken)
+					return (T)other;
+
+			return member;
+		}
+
 		/// <summary>Gets the reflection information for a directly declared constructor</summary>
 		/// <param name="type">The class where the constructor is declared</param>
 		/// <param name="parameters">Optional parameters to target a specific overload of the constructor</param>
+		/// <param name="searchForStatic">Optional parameters to only consider static constructors</param>
 		/// <returns>A ConstructorInfo or null when type is null or when the constructor cannot be found</returns>
 		///
-		public static ConstructorInfo DeclaredConstructor(Type type, Type[] parameters = null)
+		public static ConstructorInfo DeclaredConstructor(Type type, Type[] parameters = null, bool searchForStatic = false)
 		{
 			if (type == null)
 			{
@@ -499,15 +526,17 @@ public static ConstructorInfo DeclaredConstructor(Type type, Type[] parameters =
 				return null;
 			}
 			if (parameters == null) parameters = new Type[0];
-			return type.GetConstructor(allDeclared, null, parameters, new ParameterModifier[] { });
+			var flags = searchForStatic ? allDeclared & ~BindingFlags.Instance : allDeclared & ~BindingFlags.Static;
+			return type.GetConstructor(flags, null, parameters, new ParameterModifier[] { });
 		}
 
 		/// <summary>Gets the reflection information for a constructor by searching the type and all its super types</summary>
 		/// <param name="type">The class where the constructor is declared</param>
 		/// <param name="parameters">Optional parameters to target a specific overload of the method</param>
+		/// <param name="searchForStatic">Optional parameters to only consider static constructors</param>
 		/// <returns>A ConstructorInfo or null when type is null or when the method cannot be found</returns>
 		///
-		public static ConstructorInfo Constructor(Type type, Type[] parameters = null)
+		public static ConstructorInfo Constructor(Type type, Type[] parameters = null, bool searchForStatic = false)
 		{
 			if (type == null)
 			{
@@ -516,14 +545,16 @@ public static ConstructorInfo Constructor(Type type, Type[] parameters = null)
 				return null;
 			}
 			if (parameters == null) parameters = new Type[0];
-			return FindIncludingBaseTypes(type, t => t.GetConstructor(all, null, parameters, new ParameterModifier[] { }));
+			var flags = searchForStatic ? all & ~BindingFlags.Instance : all & ~BindingFlags.Static;
+			return FindIncludingBaseTypes(type, t => t.GetConstructor(flags, null, parameters, new ParameterModifier[] { }));
 		}
 
 		/// <summary>Gets reflection information for all declared constructors</summary>
 		/// <param name="type">The class where the constructors are declared</param>
+		/// <param name="searchForStatic">Optional parameters to only consider static constructors</param>
 		/// <returns>A list of ConstructorInfo</returns>
 		///
-		public static List<ConstructorInfo> GetDeclaredConstructors(Type type)
+		public static List<ConstructorInfo> GetDeclaredConstructors(Type type, bool? searchForStatic = null)
 		{
 			if (type == null)
 			{
@@ -531,7 +562,10 @@ public static List<ConstructorInfo> GetDeclaredConstructors(Type type)
 					FileLog.Log("AccessTools.GetDeclaredConstructors: type is null");
 				return null;
 			}
-			return type.GetConstructors(allDeclared).Where(method => method.DeclaringType == type).ToList();
+			var flags = allDeclared;
+			if (searchForStatic.HasValue)
+				flags = searchForStatic.Value ? flags & ~BindingFlags.Instance : flags & ~BindingFlags.Static;
+			return type.GetConstructors(flags).Where(method => method.DeclaringType == type).ToList();
 		}
 
 		/// <summary>Gets reflection information for all declared methods</summary>
@@ -785,7 +819,7 @@ public static object[] ActualParameters(MethodBase method, object[] inputs)
 				if (fieldInfo.DeclaringType == null || !fieldInfo.DeclaringType.IsAssignableFrom(typeof(T)))
 					throw new MissingFieldException(typeof(T).Name, fieldInfo.Name);
 
-			var s_name = "__refget_" + typeof(T).Name + "_fi_" + fieldInfo.Name;
+			var s_name = $"__refget_{typeof(T).Name}_fi_{fieldInfo.Name}";
 
 			// workaround for using ref-return with DynamicMethod:
 			// a.) initialize with dummy return value
@@ -837,7 +871,7 @@ public static FieldRef<F> StaticFieldRefAccess<F>(FieldInfo fieldInfo)
 				throw new ArgumentNullException(nameof(fieldInfo));
 			var t = fieldInfo.DeclaringType;
 
-			var s_name = "__refget_" + t.Name + "_static_fi_" + fieldInfo.Name;
+			var s_name = $"__refget_{t.Name}_static_fi_{fieldInfo.Name}";
 
 			// workaround for using ref-return with DynamicMethod:
 			// a.) initialize with dummy return value
@@ -878,7 +912,7 @@ public static void ThrowMissingMemberException(Type type, params string[] names)
 		{
 			var fields = string.Join(",", GetFieldNames(type).ToArray());
 			var properties = string.Join(",", GetPropertyNames(type).ToArray());
-			throw new MissingMemberException(string.Join(",", names) + "; available fields: " + fields + "; available properties: " + properties);
+			throw new MissingMemberException($"{string.Join(",", names)}; available fields: {fields}; available properties: {properties}");
 		}
 
 		/// <summary>Gets default value for a specific type</summary>
@@ -970,7 +1004,7 @@ public static object MakeDeepCopy(object source, Type resultType, Func<string, T
 						var iStr = (i++).ToString();
 						var path = pathRoot.Length > 0 ? pathRoot + "." + iStr : iStr;
 						var newElement = MakeDeepCopy(element, newElementType, processor, path);
-						addInvoker(addableResult, new object[] { newElement });
+						_ = addInvoker(addableResult, new object[] { newElement });
 					}
 					return addableResult;
 				}
@@ -1003,7 +1037,7 @@ public static object MakeDeepCopy(object source, Type resultType, Func<string, T
 			{
 				var path = pathRoot.Length > 0 ? pathRoot + "." + name : name;
 				var value = processor != null ? processor(path, src, dst) : src.GetValue();
-				dst.SetValue(MakeDeepCopy(value, dst.GetValueType(), processor, path));
+				_ = dst.SetValue(MakeDeepCopy(value, dst.GetValueType(), processor, path));
 			});
 			return result;
 		}
diff --git a/Harmony/Tools/CodeMatcher.cs b/Harmony/Tools/CodeMatcher.cs
index 31e16ee0..00a63b9c 100644
--- a/Harmony/Tools/CodeMatcher.cs
+++ b/Harmony/Tools/CodeMatcher.cs
@@ -91,17 +91,17 @@ public override string ToString()
 			if (name != null)
 				result += name + ": ";
 			if (opcodes.Count > 0)
-				result += "opcodes=" + opcodes.Join() + " ";
+				result += $"opcodes={opcodes.Join()} ";
 			if (operands.Count > 0)
-				result += "operands=" + operands.Join() + " ";
+				result += $"operands={operands.Join()} ";
 			if (labels.Count > 0)
-				result += "labels=" + labels.Join() + " ";
+				result += $"labels={labels.Join()} ";
 			if (blocks.Count > 0)
-				result += "blocks=" + blocks.Join() + " ";
+				result += $"blocks={blocks.Join()} ";
 			if (jumpsFrom.Count > 0)
-				result += "jumpsFrom=" + jumpsFrom.Join() + " ";
+				result += $"jumpsFrom={jumpsFrom.Join()} ";
 			if (jumpsTo.Count > 0)
-				result += "jumpsTo=" + jumpsTo.Join() + " ";
+				result += $"jumpsTo={jumpsTo.Join()} ";
 			if (predicate != null)
 				result += "predicate=yes ";
 			return result.TrimEnd() + "]";
@@ -275,8 +275,7 @@ public static List<Label> DistinctLabels(IEnumerable<CodeInstruction> instructio
 		public bool ReportFailure(MethodBase method, Action<string> logger)
 		{
 			if (IsValid) return false;
-			var err = lastError ?? "Unexpected code";
-			logger(err + " in " + method);
+			logger($"{lastError ?? "Unexpected code"} in {method}");
 			return true;
 		}
 
@@ -320,7 +319,7 @@ public CodeMatcher Set(OpCode opcode, object operand)
 		///
 		public CodeMatcher SetAndAdvance(OpCode opcode, object operand)
 		{
-			Set(opcode, operand);
+			_ = Set(opcode, operand);
 			Pos++;
 			return this;
 		}
@@ -366,7 +365,7 @@ public CodeMatcher CreateLabel(out Label label)
 		public CodeMatcher CreateLabelAt(int position, out Label label)
 		{
 			label = generator.DefineLabel();
-			AddLabelsAt(position, new[] { label });
+			_ = AddLabelsAt(position, new[] { label });
 			return this;
 		}
 
@@ -399,8 +398,8 @@ public CodeMatcher AddLabelsAt(int position, IEnumerable<Label> labels)
 		///
 		public CodeMatcher SetJumpTo(OpCode opcode, int destination, out Label label)
 		{
-			CreateLabelAt(destination, out label);
-			Set(opcode, label);
+			_ = CreateLabelAt(destination, out label);
+			_ = Set(opcode, label);
 			return this;
 		}
 
@@ -431,7 +430,7 @@ public CodeMatcher Insert(IEnumerable<CodeInstruction> instructions)
 		///
 		public CodeMatcher InsertBranch(OpCode opcode, int destination)
 		{
-			CreateLabelAt(destination, out var label);
+			_ = CreateLabelAt(destination, out var label);
 			codes.Insert(Pos, new CodeInstruction(opcode, label));
 			return this;
 		}
@@ -444,7 +443,7 @@ public CodeMatcher InsertAndAdvance(params CodeInstruction[] instructions)
 		{
 			instructions.Do(instruction =>
 			{
-				Insert(instruction);
+				_ = Insert(instruction);
 				Pos++;
 			});
 			return this;
@@ -467,7 +466,7 @@ public CodeMatcher InsertAndAdvance(IEnumerable<CodeInstruction> instructions)
 		///
 		public CodeMatcher InsertBranchAndAdvance(OpCode opcode, int destination)
 		{
-			InsertBranch(opcode, destination);
+			_ = InsertBranch(opcode, destination);
 			Pos++;
 			return this;
 		}
@@ -510,7 +509,7 @@ public CodeMatcher RemoveInstructionsInRange(int start, int end)
 		///
 		public CodeMatcher RemoveInstructionsWithOffsets(int startOffset, int endOffset)
 		{
-			RemoveInstructionsInRange(Pos + startOffset, Pos + endOffset);
+			_ = RemoveInstructionsInRange(Pos + startOffset, Pos + endOffset);
 			return this;
 		}
 
@@ -622,7 +621,7 @@ public CodeMatcher Repeat(Action<CodeMatcher> matchAction, Action<string> notFou
 			while (IsValid)
 			{
 				matchAction(this);
-				MatchForward(lastUseEnd, lastCodeMatches);
+				_ = MatchForward(lastUseEnd, lastCodeMatches);
 				count++;
 			}
 			lastCodeMatches = null;
diff --git a/Harmony/Tools/Extensions.cs b/Harmony/Tools/Extensions.cs
index 3e9122f7..22cc198e 100644
--- a/Harmony/Tools/Extensions.cs
+++ b/Harmony/Tools/Extensions.cs
@@ -28,7 +28,7 @@ public static string Join<T>(this IEnumerable<T> enumeration, Func<T, string> co
 		public static string Description(this Type[] parameters)
 		{
 			if (parameters == null) return "NULL";
-			return "(" + parameters.Join(p => p.FullDescription()) + ")";
+			return $"({parameters.Join(p => p.FullDescription())})";
 		}
 
 		/// <summary>A full description of a type</summary>
@@ -66,9 +66,9 @@ public static string FullDescription(this Type type)
 		public static string FullDescription(this MethodBase method)
 		{
 			if (method == null) return "null";
-			var parameters = method.GetParameters().Select(p => p.ParameterType).ToArray();
+			var parameters = method.GetParameters().Types();
 			var returnType = AccessTools.GetReturnedType(method);
-			return returnType.FullDescription() + " " + method.DeclaringType.FullDescription() + "." + method.Name + parameters.Description();
+			return $"{returnType.FullDescription()} {method.DeclaringType.FullDescription()}.{method.Name}{parameters.Description()}";
 		}
 
 		/// <summary>A helper converting parameter infos to types</summary>
diff --git a/Harmony/Tools/FileLog.cs b/Harmony/Tools/FileLog.cs
index b61dbd58..e0476bc9 100644
--- a/Harmony/Tools/FileLog.cs
+++ b/Harmony/Tools/FileLog.cs
@@ -11,7 +11,7 @@ namespace HarmonyLib
 	public static class FileLog
 	{
 		/// <summary>Full pathname of the log file</summary>
-		public static string logPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + Path.DirectorySeparatorChar + "harmony.log.txt";
+		public static string logPath = $"{Environment.GetFolderPath(Environment.SpecialFolder.Desktop)}{Path.DirectorySeparatorChar}harmony.log.txt";
 
 		/// <summary>The indent character</summary>
 		public static char indentChar = '\t';
@@ -121,7 +121,7 @@ public static void Reset()
 		{
 			lock (logPath)
 			{
-				var path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + Path.DirectorySeparatorChar + "harmony.log.txt";
+				var path = $"{Environment.GetFolderPath(Environment.SpecialFolder.Desktop)}{Path.DirectorySeparatorChar}harmony.log.txt";
 				File.Delete(path);
 			}
 		}
@@ -139,7 +139,7 @@ public static unsafe void LogBytes(long ptr, int len)
 				for (var i = 1; i <= len; i++)
 				{
 					if (s.Length == 0) s = "#  ";
-					s = s + (*p).ToString("X2") + " ";
+					s += $"{(*p).ToString("X2")} ";
 					if (i > 1 || len == 1)
 					{
 						if (i % 8 == 0 || i == len)
@@ -161,8 +161,8 @@ public static unsafe void LogBytes(long ptr, int len)
 				var sBuilder = new StringBuilder();
 #pragma warning restore XS0001
 				for (var i = 0; i < hash.Length; i++)
-					sBuilder.Append(hash[i].ToString("X2"));
-				Log("HASH: " + sBuilder);
+					_ = sBuilder.Append(hash[i].ToString("X2"));
+				Log($"HASH: {sBuilder}");
 			}
 		}
 	}
diff --git a/Harmony/Tools/SymbolExtensions.cs b/Harmony/Tools/SymbolExtensions.cs
index c45c6945..926ec579 100644
--- a/Harmony/Tools/SymbolExtensions.cs
+++ b/Harmony/Tools/SymbolExtensions.cs
@@ -50,7 +50,7 @@ public static MethodInfo GetMethodInfo(LambdaExpression expression)
 
 			var method = outermostExpression.Method;
 			if (method == null)
-				throw new Exception("Cannot find method for expression " + expression);
+				throw new Exception($"Cannot find method for expression {expression}");
 
 			return method;
 		}
diff --git a/Harmony/Tools/Traverse.cs b/Harmony/Tools/Traverse.cs
index 4904b6c4..70a31d11 100644
--- a/Harmony/Tools/Traverse.cs
+++ b/Harmony/Tools/Traverse.cs
@@ -191,7 +191,7 @@ public Traverse SetValue(object value)
 			if (_info is PropertyInfo)
 				((PropertyInfo)_info).SetValue(_root, value, AccessTools.all, null, _params, CultureInfo.CurrentCulture);
 			if (_method != null)
-				throw new Exception("cannot set value of method " + _method.FullDescription());
+				throw new Exception($"cannot set value of method {_method.FullDescription()}");
 			return this;
 		}
 
diff --git a/HarmonyTests/GlobalSuppressions.cs b/HarmonyTests/GlobalSuppressions.cs
index baa1cf4d..bfc8f9d3 100644
--- a/HarmonyTests/GlobalSuppressions.cs
+++ b/HarmonyTests/GlobalSuppressions.cs
@@ -6,3 +6,4 @@
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0060:Remove unused parameter")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1802:Use literals where appropriate")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:Do not catch general exception types")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Code Quality", "IDE0051:Remove unused private members")]
\ No newline at end of file
diff --git a/HarmonyTests/Patching/Assets/CombinedPatchClass.cs b/HarmonyTests/Patching/Assets/CombinedPatchClass.cs
new file mode 100644
index 00000000..fa9c3fd8
--- /dev/null
+++ b/HarmonyTests/Patching/Assets/CombinedPatchClass.cs
@@ -0,0 +1,64 @@
+using HarmonyLib;
+using System;
+using System.Runtime.CompilerServices;
+
+namespace HarmonyLibTests.Assets
+{
+	public class CombinedPatchClass
+	{
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		public void Method1()
+		{
+			throw new Exception();
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		public string Method2(string str)
+		{
+			return str;
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		public void Method3(int n)
+		{
+			throw new Exception("" + n);
+		}
+	}
+
+	[HarmonyPatch]
+	public class CombinedPatchClass_Patch_1
+	{
+		public static int counter = 0;
+
+		[HarmonyFinalizer]
+		[HarmonyPatch(typeof(CombinedPatchClass), "Method1")]
+		static bool Prefix1()
+		{
+			counter++;
+			return false;
+		}
+
+		[HarmonyFinalizer]
+		[HarmonyPatch(typeof(CombinedPatchClass), "Method2")]
+		static void Postfix(ref string __result)
+		{
+			counter++;
+			__result = "tested";
+		}
+
+		[HarmonyFinalizer]
+		[HarmonyPatch(typeof(CombinedPatchClass), "Method3")]
+		static void Finalizer3()
+		{
+			counter++;
+		}
+
+		[HarmonyFinalizer]
+		[HarmonyPatch(typeof(CombinedPatchClass), "Method3")]
+		static Exception Finalizer4()
+		{
+			counter++;
+			return null;
+		}
+	}
+}
\ No newline at end of file
diff --git a/HarmonyTests/Patching/CombinedPatches.cs b/HarmonyTests/Patching/CombinedPatches.cs
new file mode 100644
index 00000000..3a4d5bb9
--- /dev/null
+++ b/HarmonyTests/Patching/CombinedPatches.cs
@@ -0,0 +1,33 @@
+using HarmonyLib;
+using HarmonyLibTests.Assets;
+using NUnit.Framework;
+
+namespace HarmonyLibTests
+{
+	[TestFixture]
+	public class CombinedPatches
+	{
+		[Test]
+		public void ManyPostfixes()
+		{
+			var originalClass = typeof(Assets.CombinedPatchClass);
+			Assert.IsNotNull(originalClass);
+			var patchClass = typeof(Assets.CombinedPatchClass_Patch_1);
+			Assert.IsNotNull(patchClass);
+
+			var harmonyInstance = new Harmony("test");
+			Assert.IsNotNull(harmonyInstance);
+
+			var processor = harmonyInstance.ProcessorForAnnotatedClass(patchClass);
+			Assert.IsNotNull(processor);
+			Assert.IsNotNull(processor.Patch());
+
+			CombinedPatchClass_Patch_1.counter = 0;
+			var instance = new CombinedPatchClass();
+			instance.Method1();
+			Assert.AreEqual("tested", instance.Method2("test"));
+			instance.Method3(123);
+			Assert.AreEqual(4, CombinedPatchClass_Patch_1.counter);
+		}
+	}
+}
\ No newline at end of file
diff --git a/HarmonyTests/Patching/GenericsPatches.cs b/HarmonyTests/Patching/GenericsPatches.cs
index f8bb5257..a823cda7 100644
--- a/HarmonyTests/Patching/GenericsPatches.cs
+++ b/HarmonyTests/Patching/GenericsPatches.cs
@@ -10,7 +10,7 @@ public class MyList<T> : IEnumerable<T>, IEnumerable
 	{
 		public struct MyEnumerator : IEnumerator<T>, IEnumerator
 		{
-			private readonly List<T> list;
+			public List<T> list;
 			private int index;
 			public T Current { get; private set; }
 
@@ -24,6 +24,11 @@ object IEnumerator.Current
 				}
 			}
 
+			internal void SetList(List<T> list)
+			{
+				this.list = list;
+			}
+
 			internal MyEnumerator(List<T> list)
 			{
 				this.list = list;
@@ -37,7 +42,6 @@ public void Dispose()
 
 			public bool MoveNext()
 			{
-				var list = this.list;
 				if ((uint)index < (uint)list.Count)
 				{
 					Current = list[index];
@@ -81,21 +85,10 @@ IEnumerator IEnumerable.GetEnumerator()
 
 	public class TestGenericStructReturnTypes_Patch
 	{
-		public static MyList<int>.MyEnumerator CachedResult
-		{
-			get
-			{
-				var myList = new MyList<int>
-				{
-					list = new List<int>() { 100, 200, 300 }
-				};
-				return myList.GetEnumerator();
-			}
-		}
-
 		public static MyList<int>.MyEnumerator Postfix(MyList<int>.MyEnumerator input)
 		{
-			return CachedResult;
+			input.SetList(new List<int>() { 100, 200, 300 });
+			return input;
 		}
 	}
 
diff --git a/HarmonyTests/Patching/StaticPatches.cs b/HarmonyTests/Patching/StaticPatches.cs
index a3597541..27e68634 100644
--- a/HarmonyTests/Patching/StaticPatches.cs
+++ b/HarmonyTests/Patching/StaticPatches.cs
@@ -218,7 +218,7 @@ public void TestAttributes()
 
 			var patcher = instance.ProcessorForAnnotatedClass(patchClass);
 			Assert.IsNotNull(patcher);
-			_ = patcher.Patch();
+			Assert.IsNotNull(patcher.Patch());
 
 			(new AttributesClass()).Method("foo");
 			Assert.IsTrue(AttributesPatch.targeted, "TargetMethod was not executed");
diff --git a/HarmonyTests/ReversePatching/AttributeReversePatches.cs b/HarmonyTests/ReversePatching/AttributeReversePatches.cs
index 873515bd..3f7c9088 100644
--- a/HarmonyTests/ReversePatching/AttributeReversePatches.cs
+++ b/HarmonyTests/ReversePatching/AttributeReversePatches.cs
@@ -21,7 +21,7 @@ public void TestReversePatchingWithAttributes()
 
 			var processor = instance.ProcessorForAnnotatedClass(typeof(Class1ReversePatch));
 			Assert.IsNotNull(processor);
-			Assert.AreEqual(1, processor.Patch().Count);
+			Assert.IsNotNull(processor.Patch());
 
 			var result2 = test.Method("Bar", 456);
 			Assert.AreEqual("PrefixedExtra456Bar", result2);
diff --git a/HarmonyTests/Tools/TestAttributes.cs b/HarmonyTests/Tools/TestAttributes.cs
index 23d32eaf..8b8ba95e 100644
--- a/HarmonyTests/Tools/TestAttributes.cs
+++ b/HarmonyTests/Tools/TestAttributes.cs
@@ -31,8 +31,7 @@ public void TestSubClassPatching()
 			Assert.IsNotNull(type1);
 			var processor1 = instance1.ProcessorForAnnotatedClass(type1);
 			Assert.IsNotNull(processor1);
-			var dynamicMethods1 = processor1.Patch();
-			Assert.AreEqual(1, dynamicMethods1.Count);
+			Assert.IsNotNull(processor1.Patch());
 
 			var instance2 = new Harmony("test2");
 			Assert.IsNotNull(instance2);