diff --git a/.editorconfig b/.editorconfig
index 6967d7e7..480efd97 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -37,9 +37,9 @@ dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggesti
 csharp_style_var_for_built_in_types = true:suggestion
 csharp_style_var_when_type_is_apparent = true:suggestion
 csharp_style_var_elsewhere = true:suggestion
-csharp_style_expression_bodied_methods = false:suggestion
-csharp_style_expression_bodied_constructors = false:suggestion
-csharp_style_expression_bodied_operators = false:suggestion
+csharp_style_expression_bodied_methods = when_on_single_line:suggestion
+csharp_style_expression_bodied_constructors = when_on_single_line:suggestion
+csharp_style_expression_bodied_operators = when_on_single_line:suggestion
 csharp_style_expression_bodied_properties = true:suggestion
 csharp_style_expression_bodied_indexers = true:suggestion
 csharp_style_expression_bodied_accessors = true:suggestion
@@ -78,6 +78,7 @@ csharp_style_prefer_method_group_conversion = true:silent
 csharp_style_prefer_top_level_statements = true:silent
 csharp_style_expression_bodied_lambdas = when_on_single_line:silent
 csharp_style_expression_bodied_local_functions = when_on_single_line:silent
+csharp_style_prefer_primary_constructors = true:suggestion
 
 [*.{cs,vb}]
 #### Naming styles ####
@@ -141,3 +142,4 @@ dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
 dotnet_style_operator_placement_when_wrapping = beginning_of_line
 tab_width = 3
 indent_size = 3
+dotnet_style_allow_statement_immediately_after_block_experimental = true:silent
diff --git a/Harmony/Documentation/GlobalSuppressions.cs b/Harmony/Documentation/GlobalSuppressions.cs
index d023e715..35b3f4e0 100644
--- a/Harmony/Documentation/GlobalSuppressions.cs
+++ b/Harmony/Documentation/GlobalSuppressions.cs
@@ -17,6 +17,7 @@
 
 [assembly: SuppressMessage("Performance", "CA1822")]
 [assembly: SuppressMessage("Performance", "CA1806")]
+[assembly: SuppressMessage("Performance", "CA1859")]
 
 [assembly: SuppressMessage("", "CS0649")]
 [assembly: SuppressMessage("", "IDE0251")]
diff --git a/Harmony/Documentation/examples/execution_with.cs b/Harmony/Documentation/examples/execution_with.cs
index ba1e6f9c..ab89a36f 100644
--- a/Harmony/Documentation/examples/execution_with.cs
+++ b/Harmony/Documentation/examples/execution_with.cs
@@ -2,6 +2,7 @@ namespace Execution_With
 {
 	using System;
 
+#pragma warning disable CS9113
 	public class Code
 	{
 		// <example>
@@ -69,13 +70,14 @@ static R ReplacementMethod(T optionalThisArgument /*, ... arguments ... */ )
 		}
 
 		// given the following signatures:
-		public static R Original() { return new R("original"); }
+		public static R Original() => new("original");
 		public static void SimpleFinalizer(ref R result) { }
-		public static Exception EditFinalizer(Exception ex, ref R result) { return ex; }
+		public static Exception EditFinalizer(Exception ex, ref R result) => ex;
 		// </example>
 
-		public class R { public R(string s) { } }
+		public class R(string s) { }
 		public class T { }
 		public static bool allVoid;
 	}
+#pragma warning restore CS9113
 }
diff --git a/Harmony/Documentation/examples/execution_without.cs b/Harmony/Documentation/examples/execution_without.cs
index 51cb3108..6b00efc5 100644
--- a/Harmony/Documentation/examples/execution_without.cs
+++ b/Harmony/Documentation/examples/execution_without.cs
@@ -47,13 +47,13 @@ class R { }
 		static int someArgument;
 
 		static void SimplePrefix1(params object[] arguments) { }
-		static bool Prefix2() { return true; }
+		static bool Prefix2() => true;
 		static void SimplePrefix3(params object[] arguments) { }
 		static void SimplePrefix4(params object[] arguments) { }
-		static bool Prefix5(ref int i, ref R r) { return true; }
-		static R ModifiedOriginal(params object[] arguments) { return null; }
+		static bool Prefix5(ref int i, ref R r) => true;
+		static R ModifiedOriginal(params object[] arguments) => null;
 		static void Postfix1(ref R r) { }
-		static R Postfix2(R r, params object[] arguments) { return r; }
+		static R Postfix2(R r, params object[] arguments) => r;
 		static void Postfix3() { }
 	}
 }
diff --git a/Harmony/Documentation/examples/intro_annotations.cs b/Harmony/Documentation/examples/intro_annotations.cs
index c1ca43ad..4fdbe9a6 100644
--- a/Harmony/Documentation/examples/intro_annotations.cs
+++ b/Harmony/Documentation/examples/intro_annotations.cs
@@ -36,10 +36,7 @@ static bool Prefix(SomeGameClass __instance, ref int ___counter)
 			return true;
 		}
 
-		static void Postfix(ref int __result)
-		{
-			__result *= 2;
-		}
+		static void Postfix(ref int __result) => __result *= 2;
 	}
 	// </example>
 }
diff --git a/Harmony/Documentation/examples/patching-edgecases.cs b/Harmony/Documentation/examples/patching-edgecases.cs
index 5f7b02ac..97ac5206 100644
--- a/Harmony/Documentation/examples/patching-edgecases.cs
+++ b/Harmony/Documentation/examples/patching-edgecases.cs
@@ -11,7 +11,7 @@ class Patch
 		[HarmonyReversePatch]
 		[HarmonyPatch(typeof(BaseClass), nameof(BaseClass.Method))]
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		static string BaseMethodDummy(SubClass instance) { return null; }
+		static string BaseMethodDummy(SubClass instance) => null;
 
 		[HarmonyPatch(typeof(SubClass), nameof(SubClass.Method))]
 		static void Prefix(SubClass __instance)
@@ -23,18 +23,12 @@ static void Prefix(SubClass __instance)
 
 	public class BaseClass
 	{
-		public virtual string Method()
-		{
-			return "base";
-		}
+		public virtual string Method() => "base";
 	}
 
 	public class SubClass : BaseClass
 	{
-		public override string Method()
-		{
-			return "subclass";
-		}
+		public override string Method() => "subclass";
 	}
 	// </example>
 
@@ -67,15 +61,9 @@ class SomeGameObject
 	{
 		GameObject gameObject;
 
-		void SomeMethod()
-		{
-			UnityEngine.Object.DontDestroyOnLoad(gameObject);
-		}
+		void SomeMethod() => UnityEngine.Object.DontDestroyOnLoad(gameObject);
 
-		void SomeOtherMethod()
-		{
-			SomeMethod();
-		}
+		void SomeOtherMethod() => SomeMethod();
 	}
 	// </early1>
 #pragma warning restore CS0649
@@ -85,11 +73,9 @@ public static class Patcher
 	{
 		private static bool patched = false;
 
-		public static void Main()
-		{
+		public static void Main() =>
 			//DoPatch(); <-- Do not execute patching on assembly entry point
 			SceneManager.sceneLoaded += SceneLoaded;
-		}
 
 		private static void DoPatch()
 		{
diff --git a/Harmony/Documentation/examples/patching-finalizer.cs b/Harmony/Documentation/examples/patching-finalizer.cs
index 1babf68e..11f90d53 100644
--- a/Harmony/Documentation/examples/patching-finalizer.cs
+++ b/Harmony/Documentation/examples/patching-finalizer.cs
@@ -15,16 +15,10 @@ public class MyException : Exception
 			public MyException() { }
 			public MyException(string message) : base(message) { }
 			public MyException(string message, Exception innerException) : base(message, innerException) { }
-			protected MyException(SerializationInfo serializationInfo, StreamingContext streamingContext)
-			{
-				throw new NotImplementedException();
-			}
+			protected MyException(SerializationInfo serializationInfo, StreamingContext streamingContext) => throw new NotImplementedException();
 		}
 
-		static Exception Finalizer(Exception __exception)
-		{
-			return new MyException("Oops", __exception);
-		}
+		static Exception Finalizer(Exception __exception) => new MyException("Oops", __exception);
 		// </rethrow>
 	}
 }
diff --git a/Harmony/Documentation/examples/patching-postfix.cs b/Harmony/Documentation/examples/patching-postfix.cs
index d2faafdc..6f965ef4 100644
--- a/Harmony/Documentation/examples/patching-postfix.cs
+++ b/Harmony/Documentation/examples/patching-postfix.cs
@@ -8,10 +8,7 @@ public class ResultExample
 		// <result>
 		public class OriginalCode
 		{
-			public string GetName()
-			{
-				return name; // ...
-			}
+			public string GetName() => name; // ...
 		}
 
 		[HarmonyPatch(typeof(OriginalCode), nameof(OriginalCode.GetName))]
@@ -33,10 +30,7 @@ public class PassThroughExample
 		// <passthrough>
 		public class OriginalCode
 		{
-			public string GetName()
-			{
-				return "David";
-			}
+			public string GetName() => "David";
 
 			public IEnumerable<int> GetNumbers()
 			{
@@ -49,10 +43,7 @@ public IEnumerable<int> GetNumbers()
 		[HarmonyPatch(typeof(OriginalCode), nameof(OriginalCode.GetName))]
 		class Patch1
 		{
-			static string Postfix(string name)
-			{
-				return "Hello " + name;
-			}
+			static string Postfix(string name) => "Hello " + name;
 		}
 
 		[HarmonyPatch(typeof(OriginalCode), nameof(OriginalCode.GetNumbers))]
@@ -86,10 +77,7 @@ public void Test(int counter)
 		[HarmonyPatch(typeof(OriginalCode), nameof(OriginalCode.Test))]
 		class Patch
 		{
-			static void Prefix(int counter)
-			{
-				FileLog.Log("counter = " + counter);
-			}
+			static void Prefix(int counter) => FileLog.Log("counter = " + counter);
 		}
 		// </args>
 	}
diff --git a/Harmony/Documentation/examples/patching-prefix.cs b/Harmony/Documentation/examples/patching-prefix.cs
index 2c284c48..8ef41af6 100644
--- a/Harmony/Documentation/examples/patching-prefix.cs
+++ b/Harmony/Documentation/examples/patching-prefix.cs
@@ -31,10 +31,7 @@ public class SkipExample
 		// <skip>
 		public class OriginalCode
 		{
-			public string GetName()
-			{
-				return name; // ...
-			}
+			public string GetName() => name; // ...
 		}
 
 		[HarmonyPatch(typeof(OriginalCode), nameof(OriginalCode.GetName))]
@@ -56,10 +53,7 @@ public class SkipMaybeExample
 		// <skip_maybe>
 		public class OriginalCode
 		{
-			public bool IsFullAfterTakingIn(int i)
-			{
-				return DoSomeExpensiveCalculation() > i;
-			}
+			public bool IsFullAfterTakingIn(int i) => DoSomeExpensiveCalculation() > i;
 		}
 
 		[HarmonyPatch(typeof(OriginalCode), nameof(OriginalCode.IsFullAfterTakingIn))]
@@ -77,7 +71,7 @@ static bool Prefix(ref bool __result, int i)
 		}
 		// </skip_maybe>
 
-		static int DoSomeExpensiveCalculation() { return 0; }
+		static int DoSomeExpensiveCalculation() => 0;
 	}
 
 	public class StateExample
diff --git a/Harmony/Documentation/examples/patching-transpiler.cs b/Harmony/Documentation/examples/patching-transpiler.cs
index fd9d8933..a4a337a3 100644
--- a/Harmony/Documentation/examples/patching-transpiler.cs
+++ b/Harmony/Documentation/examples/patching-transpiler.cs
@@ -36,7 +36,7 @@ class SomeType { public string someField; }
 
 		class Tools
 		{
-			public static MethodInfo MyExtraMethod() { return null; }
+			public static MethodInfo MyExtraMethod() => null;
 		}
 
 		static void ReportError(string s) { }
diff --git a/Harmony/Documentation/examples/priorities.cs b/Harmony/Documentation/examples/priorities.cs
index 04ba6bf8..a4595152 100644
--- a/Harmony/Documentation/examples/priorities.cs
+++ b/Harmony/Documentation/examples/priorities.cs
@@ -6,10 +6,7 @@ namespace Priorities
 	// <foo>
 	class Foo
 	{
-		static string Bar()
-		{
-			return "secret";
-		}
+		static string Bar() => "secret";
 	}
 	// </foo>
 
@@ -26,10 +23,7 @@ void Main_Plugin1()
 		[HarmonyPatch("Bar")]
 		class MyPatch
 		{
-			static void Postfix(ref string result)
-			{
-				result = "new secret 1";
-			}
+			static void Postfix(ref string result) => result = "new secret 1";
 		}
 		// </plugin1>
 	}
@@ -48,10 +42,7 @@ void Main_Plugin1b()
 		class MyPatch
 		{
 			[HarmonyAfter(["net.example.plugin2"])]
-			static void Postfix(ref string result)
-			{
-				result = "new secret 1";
-			}
+			static void Postfix(ref string result) => result = "new secret 1";
 		}
 		// </plugin1b>
 	}
@@ -69,10 +60,7 @@ void Main_Plugin2()
 		[HarmonyPatch("Bar")]
 		class MyPatch
 		{
-			static void Postfix(ref string result)
-			{
-				result = "new secret 2";
-			}
+			static void Postfix(ref string result) => result = "new secret 2";
 		}
 		// </plugin2>
 	}
diff --git a/Harmony/Documentation/examples/reverse-patching.cs b/Harmony/Documentation/examples/reverse-patching.cs
index 9464eec6..bff2073d 100644
--- a/Harmony/Documentation/examples/reverse-patching.cs
+++ b/Harmony/Documentation/examples/reverse-patching.cs
@@ -23,20 +23,16 @@ public class Patch
 		{
 			[HarmonyReversePatch]
 			[HarmonyPatch(typeof(OriginalCode), "Test")]
-			public static void MyTest(object instance, int counter, string name)
-			{
+			public static void MyTest(object instance, int counter, string name) =>
 				// its a stub so it has no initial content
 				throw new NotImplementedException("It's a stub");
-			}
 		}
 
 		class Main
 		{
-			void Test()
-			{
+			void Test() =>
 				// here we call OriginalCode.Test()
 				Patch.MyTest(originalInstance, 100, "hello");
-			}
 		}
 		// </example>
 
diff --git a/Harmony/Documentation/examples/utilities.cs b/Harmony/Documentation/examples/utilities.cs
index 2bfb5653..129059b4 100644
--- a/Harmony/Documentation/examples/utilities.cs
+++ b/Harmony/Documentation/examples/utilities.cs
@@ -12,10 +12,7 @@ struct Bar
 			{
 				static string secret = "hello";
 
-				public string ModifiedSecret()
-				{
-					return secret.ToUpper();
-				}
+				public string ModifiedSecret() => secret.ToUpper();
 			}
 
 			Bar MyBar
@@ -26,19 +23,13 @@ Bar MyBar
 				}
 			}
 
-			public string GetSecret()
-			{
-				return MyBar.ModifiedSecret();
-			}
+			public string GetSecret() => MyBar.ModifiedSecret();
 
 			Foo()
 			{
 			}
 
-			static Foo MakeFoo()
-			{
-				return new Foo();
-			}
+			static Foo MakeFoo() => new();
 		}
 
 		void Test()
diff --git a/Harmony/Extras/FastAccess.cs b/Harmony/Extras/FastAccess.cs
index 4af91d53..e58d4bb3 100644
--- a/Harmony/Extras/FastAccess.cs
+++ b/Harmony/Extras/FastAccess.cs
@@ -43,7 +43,7 @@ public static InstantiationHandler<T> CreateInstantiationHandler<T>()
 		{
 			var constructorInfo =
 				typeof(T).GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null,
-					new Type[0], null);
+					[], null);
 			if (constructorInfo is null)
 			{
 				throw new ApplicationException(string.Format(
@@ -162,14 +162,8 @@ public static SetterHandler<T, S> CreateSetterHandler<T, S>(FieldInfo fieldInfo)
 			return (SetterHandler<T, S>)dynamicSet.Generate().CreateDelegate(typeof(SetterHandler<T, S>));
 		}
 
-		static DynamicMethodDefinition CreateGetDynamicMethod<T, S>(Type type)
-		{
-			return new DynamicMethodDefinition($"DynamicGet_{type.Name}", typeof(S), [typeof(T)]);
-		}
+		static DynamicMethodDefinition CreateGetDynamicMethod<T, S>(Type type) => new($"DynamicGet_{type.Name}", typeof(S), [typeof(T)]);
 
-		static DynamicMethodDefinition CreateSetDynamicMethod<T, S>(Type type)
-		{
-			return new DynamicMethodDefinition($"DynamicSet_{type.Name}", typeof(void), [typeof(T), typeof(S)]);
-		}
+		static DynamicMethodDefinition CreateSetDynamicMethod<T, S>(Type type) => new($"DynamicSet_{type.Name}", typeof(void), [typeof(T), typeof(S)]);
 	}
 }
diff --git a/Harmony/Extras/MethodInvoker.cs b/Harmony/Extras/MethodInvoker.cs
index 930a28f5..e1fbc2c4 100644
--- a/Harmony/Extras/MethodInvoker.cs
+++ b/Harmony/Extras/MethodInvoker.cs
@@ -144,20 +144,11 @@ public static FastInvokeHandler GetHandler(MethodInfo methodInfo, bool directBox
 			return invoder;
 		}
 
-		internal static void Emit(ILGenerator il, OpCode opcode)
-		{
-			il.Emit(opcode);
-		}
+		internal static void Emit(ILGenerator il, OpCode opcode) => il.Emit(opcode);
 
-		internal static void Emit(ILGenerator il, OpCode opcode, Type type)
-		{
-			il.Emit(opcode, type);
-		}
+		internal static void Emit(ILGenerator il, OpCode opcode, Type type) => il.Emit(opcode, type);
 
-		internal static void EmitCall(ILGenerator il, OpCode opcode, MethodInfo methodInfo)
-		{
-			il.EmitCall(opcode, methodInfo, null);
-		}
+		internal static void EmitCall(ILGenerator il, OpCode opcode, MethodInfo methodInfo) => il.EmitCall(opcode, methodInfo, null);
 
 		static void EmitUnboxIfNeeded(ILGenerator il, Type type)
 		{
diff --git a/Harmony/GlobalSuppressions.cs b/Harmony/GlobalSuppressions.cs
index 847e4bec..bc560d54 100644
--- a/Harmony/GlobalSuppressions.cs
+++ b/Harmony/GlobalSuppressions.cs
@@ -19,3 +19,7 @@
 
 [assembly: SuppressMessage("Reliability", "CA2020:Prevent from behavioral change", Justification = "<Pending>", Scope = "member", Target = "~M:HarmonyLib.FileLog.LogBytes(System.Int64,System.Int32)")]
 [assembly: SuppressMessage("Performance", "CA1850:Prefer static 'HashData' method over 'ComputeHash'", Justification = "<Pending>", Scope = "member", Target = "~M:HarmonyLib.FileLog.LogBytes(System.Int64,System.Int32)")]
+
+#if NET8_0_OR_GREATER
+[assembly: SuppressMessage("Maintainability", "CA1510")]
+#endif
diff --git a/Harmony/Internal/ByteBuffer.cs b/Harmony/Internal/ByteBuffer.cs
index 99e81ce9..26176089 100644
--- a/Harmony/Internal/ByteBuffer.cs
+++ b/Harmony/Internal/ByteBuffer.cs
@@ -8,10 +8,7 @@ internal class ByteBuffer
 
 		internal int position;
 
-		internal ByteBuffer(byte[] buffer)
-		{
-			this.buffer = buffer;
-		}
+		internal ByteBuffer(byte[] buffer) => this.buffer = buffer;
 
 		internal byte ReadByte()
 		{
diff --git a/Harmony/Internal/CodeTranspiler.cs b/Harmony/Internal/CodeTranspiler.cs
index 3bfc240b..778e8796 100644
--- a/Harmony/Internal/CodeTranspiler.cs
+++ b/Harmony/Internal/CodeTranspiler.cs
@@ -19,10 +19,7 @@ internal CodeTranspiler(List<ILInstruction> ilInstructions)
 				.ToList().AsEnumerable();
 		}
 
-		internal void Add(MethodInfo transpiler)
-		{
-			transpilers.Add(transpiler);
-		}
+		internal void Add(MethodInfo transpiler) => transpilers.Add(transpiler);
 
 		internal static object ConvertInstruction(Type type, object instruction, out Dictionary<string, object> unassigned)
 		{
@@ -191,10 +188,7 @@ internal static IEnumerable ConvertToOurInstructions(IEnumerable instructions, T
 			}
 		}
 
-		static bool IsCodeInstructionsParameter(Type type)
-		{
-			return type.IsGenericType && type.GetGenericTypeDefinition().Name.StartsWith("IEnumerable", StringComparison.Ordinal);
-		}
+		static bool IsCodeInstructionsParameter(Type type) => type.IsGenericType && type.GetGenericTypeDefinition().Name.StartsWith("IEnumerable", StringComparison.Ordinal);
 
 		internal static IEnumerable ConvertToGeneralInstructions(MethodInfo transpiler, IEnumerable enumerable, out Dictionary<object, Dictionary<string, object>> unassignedValues)
 		{
diff --git a/Harmony/Internal/Emitter.cs b/Harmony/Internal/Emitter.cs
index a1794d2a..4d4c050d 100644
--- a/Harmony/Internal/Emitter.cs
+++ b/Harmony/Internal/Emitter.cs
@@ -10,10 +10,7 @@ namespace HarmonyLib
 {
 	internal class LeaveTry
 	{
-		public override string ToString()
-		{
-			return "(autogenerated)";
-		}
+		public override string ToString() => "(autogenerated)";
 	}
 
 	internal class Emitter
@@ -28,30 +25,15 @@ internal Emitter(ILGenerator il, bool debug)
 			this.debug = debug;
 		}
 
-		internal Dictionary<int, CodeInstruction> GetInstructions()
-		{
-			return instructions;
-		}
+		internal Dictionary<int, CodeInstruction> GetInstructions() => instructions;
 
-		internal void AddInstruction(OpCode opcode, object operand)
-		{
-			instructions.Add(CurrentPos(), new CodeInstruction(opcode, operand));
-		}
+		internal void AddInstruction(OpCode opcode, object operand) => instructions.Add(CurrentPos(), new CodeInstruction(opcode, operand));
 
-		internal int CurrentPos()
-		{
-			return il.ILOffset;
-		}
+		internal int CurrentPos() => il.ILOffset;
 
-		internal static string CodePos(int offset)
-		{
-			return string.Format("IL_{0:X4}: ", offset);
-		}
+		internal static string CodePos(int offset) => string.Format("IL_{0:X4}: ", offset);
 
-		internal string CodePos()
-		{
-			return CodePos(CurrentPos());
-		}
+		internal string CodePos() => CodePos(CurrentPos());
 
 		internal void LogComment(string comment)
 		{
diff --git a/Harmony/Internal/HarmonySharedState.cs b/Harmony/Internal/HarmonySharedState.cs
index 4b145cd5..839dfa21 100644
--- a/Harmony/Internal/HarmonySharedState.cs
+++ b/Harmony/Internal/HarmonySharedState.cs
@@ -3,7 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using System.Reflection;
 
 namespace HarmonyLib
@@ -112,7 +111,7 @@ internal static PatchInfo GetPatchInfo(MethodBase method)
 
 		internal static IEnumerable<MethodBase> GetPatchedMethods()
 		{
-			lock (state) return state.Keys.ToArray();
+			lock (state) return [.. state.Keys];
 		}
 
 		internal static void UpdatePatchInfo(MethodBase original, MethodInfo replacement, PatchInfo patchInfo)
diff --git a/Harmony/Internal/MethodCopier.cs b/Harmony/Internal/MethodCopier.cs
index 0f93b1c4..70f6b817 100644
--- a/Harmony/Internal/MethodCopier.cs
+++ b/Harmony/Internal/MethodCopier.cs
@@ -24,20 +24,11 @@ internal MethodCopier(MethodBase fromMethod, ILGenerator toILGenerator, LocalBui
 			reader.GenerateInstructions();
 		}
 
-		internal void SetDebugging(bool debug)
-		{
-			reader.SetDebugging(debug);
-		}
+		internal void SetDebugging(bool debug) => reader.SetDebugging(debug);
 
-		internal void AddTranspiler(MethodInfo transpiler)
-		{
-			transpilers.Add(transpiler);
-		}
+		internal void AddTranspiler(MethodInfo transpiler) => transpilers.Add(transpiler);
 
-		internal List<CodeInstruction> Finalize(Emitter emitter, List<Label> endLabels, out bool hasReturnCode, out bool methodEndsInDeadCode)
-		{
-			return reader.FinalizeILCodes(emitter, transpilers, endLabels, out hasReturnCode, out methodEndsInDeadCode);
-		}
+		internal List<CodeInstruction> Finalize(Emitter emitter, List<Label> endLabels, out bool hasReturnCode, out bool methodEndsInDeadCode) => reader.FinalizeILCodes(emitter, transpilers, endLabels, out hasReturnCode, out methodEndsInDeadCode);
 
 		internal static List<CodeInstruction> GetInstructions(ILGenerator generator, MethodBase method, int maxTranspilers)
 		{
@@ -97,7 +88,7 @@ internal MethodBodyReader(MethodBase method, ILGenerator generator)
 			var body = method.GetMethodBody();
 			if ((body?.GetILAsByteArray()?.Length ?? 0) == 0)
 			{
-				ilBytes = new ByteBuffer(new byte[0]);
+				ilBytes = new ByteBuffer([]);
 				ilInstructions = [];
 			}
 			else
@@ -131,10 +122,7 @@ internal MethodBodyReader(MethodBase method, ILGenerator generator)
 			exceptions = body?.ExceptionHandlingClauses ?? [];
 		}
 
-		internal void SetDebugging(bool debug)
-		{
-			this.debug = debug;
-		}
+		internal void SetDebugging(bool debug) => this.debug = debug;
 
 		internal void GenerateInstructions()
 		{
@@ -739,15 +727,9 @@ ILInstruction GetInstruction(int offset, bool isEndOfInstruction)
 			throw new Exception($"Cannot find instruction for {offset:X4}");
 		}
 
-		static bool TargetsLocalVariable(OpCode opcode)
-		{
-			return opcode.Name.Contains("loc");
-		}
+		static bool TargetsLocalVariable(OpCode opcode) => opcode.Name.Contains("loc");
 
-		LocalVariableInfo GetLocalVariable(int index)
-		{
-			return localVariables?[index];
-		}
+		LocalVariableInfo GetLocalVariable(int index) => localVariables?[index];
 
 		ParameterInfo GetParameter(int index)
 		{
diff --git a/Harmony/Internal/MethodPatcher.cs b/Harmony/Internal/MethodPatcher.cs
index 877a9756..448eabce 100644
--- a/Harmony/Internal/MethodPatcher.cs
+++ b/Harmony/Internal/MethodPatcher.cs
@@ -276,7 +276,7 @@ internal static LocalBuilder[] DeclareOriginalLocalVariables(ILGenerator il, Met
 		{
 			var vars = member.GetMethodBody()?.LocalVariables;
 			if (vars is null)
-				return new LocalBuilder[0];
+				return [];
 			return vars.Select(lvi => il.DeclareLocal(lvi.LocalType, lvi.IsPinned)).ToArray();
 		}
 
diff --git a/Harmony/Internal/PatchFunctions.cs b/Harmony/Internal/PatchFunctions.cs
index e8e5c533..808c6fe8 100644
--- a/Harmony/Internal/PatchFunctions.cs
+++ b/Harmony/Internal/PatchFunctions.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
 
 namespace HarmonyLib
@@ -14,10 +13,7 @@ internal static class PatchFunctions
 		/// <param name="debug">Use debug mode</param>
 		/// <returns>The sorted patch methods</returns>
 		///
-		internal static List<MethodInfo> GetSortedPatchMethods(MethodBase original, Patch[] patches, bool debug)
-		{
-			return new PatchSorter(patches, debug).Sort(original);
-		}
+		internal static List<MethodInfo> GetSortedPatchMethods(MethodBase original, Patch[] patches, bool debug) => new PatchSorter(patches, debug).Sort(original);
 
 		/// <summary>Creates new replacement method with the latest patches and detours the original method</summary>
 		/// <param name="original">The original method</param>
diff --git a/Harmony/Internal/PatchModels.cs b/Harmony/Internal/PatchModels.cs
index e328e257..ca97c70c 100644
--- a/Harmony/Internal/PatchModels.cs
+++ b/Harmony/Internal/PatchModels.cs
@@ -62,10 +62,7 @@ internal List<Job> GetJobs()
 			).ToList();
 		}
 
-		internal List<T> GetReplacements()
-		{
-			return state.Values.Select(job => job.replacement).ToList();
-		}
+		internal List<T> GetReplacements() => state.Values.Select(job => job.replacement).ToList();
 	}
 
 	// AttributePatch contains all information for a patch defined by attributes
diff --git a/Harmony/Internal/PatchSorter.cs b/Harmony/Internal/PatchSorter.cs
index 6fd226d0..d1f89f01 100644
--- a/Harmony/Internal/PatchSorter.cs
+++ b/Harmony/Internal/PatchSorter.cs
@@ -181,17 +181,11 @@ public int CompareTo(object obj)
 			/// <summary>Determines whether patches are equal</summary>
 			/// <param name="obj">The other patch</param>
 			/// <returns>true if equal</returns>
-			public override bool Equals(object obj)
-			{
-				return obj is PatchSortingWrapper wrapper && innerPatch.PatchMethod == wrapper.innerPatch.PatchMethod;
-			}
+			public override bool Equals(object obj) => obj is PatchSortingWrapper wrapper && innerPatch.PatchMethod == wrapper.innerPatch.PatchMethod;
 
 			/// <summary>Hash function</summary>
 			/// <returns>A hash code</returns>
-			public override int GetHashCode()
-			{
-				return innerPatch.PatchMethod.GetHashCode();
-			}
+			public override int GetHashCode() => innerPatch.PatchMethod.GetHashCode();
 
 			/// <summary>Bidirectionally registers Patches as after dependencies</summary>
 			/// <param name="dependencies">List of dependencies to register</param>
@@ -242,10 +236,7 @@ public bool Equals(Patch x, Patch y)
 					&& x.before.All(y.before.Contains) && x.after.All(y.after.Contains);
 			}
 
-			public int GetHashCode(Patch obj)
-			{
-				return obj.GetHashCode();
-			}
+			public int GetHashCode(Patch obj) => obj.GetHashCode();
 		}
 	}
 }
diff --git a/Harmony/Internal/PatchTools.cs b/Harmony/Internal/PatchTools.cs
index b96a6537..2f5d92d7 100644
--- a/Harmony/Internal/PatchTools.cs
+++ b/Harmony/Internal/PatchTools.cs
@@ -36,10 +36,7 @@ static Assembly GetExecutingAssemblyReplacement()
 				return original.Module.Assembly;
 			return Assembly.GetExecutingAssembly();
 		}
-		internal static IEnumerable<CodeInstruction> GetExecutingAssemblyTranspiler(IEnumerable<CodeInstruction> instructions)
-		{
-			return instructions.MethodReplacer(m_GetExecutingAssembly, m_GetExecutingAssemblyReplacement);
-		}
+		internal static IEnumerable<CodeInstruction> GetExecutingAssemblyTranspiler(IEnumerable<CodeInstruction> instructions) => instructions.MethodReplacer(m_GetExecutingAssembly, m_GetExecutingAssemblyReplacement);
 
 		public static MethodInfo CreateMethod(string name, Type returnType, List<KeyValuePair<string, Type>> parameters, Action<ILGenerator> generator)
 		{
diff --git a/Harmony/Public/Attributes.cs b/Harmony/Public/Attributes.cs
index 06b03666..1ce22430 100644
--- a/Harmony/Public/Attributes.cs
+++ b/Harmony/Public/Attributes.cs
@@ -118,10 +118,7 @@ public class HarmonyPatchCategory : HarmonyAttribute
 		/// <summary>Annotation specifying the category</summary>
 		/// <param name="category">Name of patch category</param>
 		///
-		public HarmonyPatchCategory(string category)
-		{
-			info.category = category;
-		}
+		public HarmonyPatchCategory(string category) => info.category = category;
 	}
 
 	/// <summary>Annotation to define your Harmony patch methods</summary>
@@ -138,10 +135,7 @@ public HarmonyPatch()
 		/// <summary>An annotation that specifies a class to patch</summary>
 		/// <param name="declaringType">The declaring class/type</param>
 		///
-		public HarmonyPatch(Type declaringType)
-		{
-			info.declaringType = declaringType;
-		}
+		public HarmonyPatch(Type declaringType) => info.declaringType = declaringType;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="declaringType">The declaring class/type</param>
@@ -238,10 +232,7 @@ public HarmonyPatch(Type declaringType, string methodName, MethodType methodType
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="methodName">The name of the method, property or constructor to patch</param>
 		///
-		public HarmonyPatch(string methodName)
-		{
-			info.methodName = methodName;
-		}
+		public HarmonyPatch(string methodName) => info.methodName = methodName;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="methodName">The name of the method, property or constructor to patch</param>
@@ -277,10 +268,7 @@ public HarmonyPatch(string methodName, MethodType methodType)
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="methodType">The <see cref="MethodType"/></param>
 		///
-		public HarmonyPatch(MethodType methodType)
-		{
-			info.methodType = methodType;
-		}
+		public HarmonyPatch(MethodType methodType) => info.methodType = methodType;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="methodType">The <see cref="MethodType"/></param>
@@ -306,19 +294,13 @@ public HarmonyPatch(MethodType methodType, Type[] argumentTypes, ArgumentType[]
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="argumentTypes">An array of argument types to target overloads</param>
 		///
-		public HarmonyPatch(Type[] argumentTypes)
-		{
-			info.argumentTypes = argumentTypes;
-		}
+		public HarmonyPatch(Type[] argumentTypes) => info.argumentTypes = argumentTypes;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="argumentTypes">An array of argument types to target overloads</param>
 		/// <param name="argumentVariations">An array of <see cref="ArgumentType"/></param>
 		///
-		public HarmonyPatch(Type[] argumentTypes, ArgumentType[] argumentVariations)
-		{
-			ParseSpecialArguments(argumentTypes, argumentVariations);
-		}
+		public HarmonyPatch(Type[] argumentTypes, ArgumentType[] argumentVariations) => ParseSpecialArguments(argumentTypes, argumentVariations);
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="typeName">The full name of the declaring class/type</param>
@@ -412,10 +394,7 @@ public HarmonyDelegate(Type declaringType, string methodName, Type[] argumentTyp
 		/// <param name="methodDispatchType">The <see cref="MethodDispatchType"/></param>
 		///
 		public HarmonyDelegate(Type declaringType, MethodDispatchType methodDispatchType)
-			: base(declaringType, MethodType.Normal)
-		{
-			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
-		}
+			: base(declaringType, MethodType.Normal) => info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="declaringType">The declaring class/type</param>
@@ -423,10 +402,7 @@ public HarmonyDelegate(Type declaringType, MethodDispatchType methodDispatchType
 		/// <param name="argumentTypes">An array of argument types to target overloads</param>
 		///
 		public HarmonyDelegate(Type declaringType, MethodDispatchType methodDispatchType, params Type[] argumentTypes)
-			: base(declaringType, MethodType.Normal, argumentTypes)
-		{
-			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
-		}
+			: base(declaringType, MethodType.Normal, argumentTypes) => info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="declaringType">The declaring class/type</param>
@@ -435,10 +411,7 @@ public HarmonyDelegate(Type declaringType, MethodDispatchType methodDispatchType
 		/// <param name="argumentVariations">Array of <see cref="ArgumentType"/></param>
 		///
 		public HarmonyDelegate(Type declaringType, MethodDispatchType methodDispatchType, Type[] argumentTypes, ArgumentType[] argumentVariations)
-			: base(declaringType, MethodType.Normal, argumentTypes, argumentVariations)
-		{
-			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
-		}
+			: base(declaringType, MethodType.Normal, argumentTypes, argumentVariations) => info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="declaringType">The declaring class/type</param>
@@ -446,10 +419,7 @@ public HarmonyDelegate(Type declaringType, MethodDispatchType methodDispatchType
 		/// <param name="methodDispatchType">The <see cref="MethodDispatchType"/></param>
 		///
 		public HarmonyDelegate(Type declaringType, string methodName, MethodDispatchType methodDispatchType)
-			: base(declaringType, methodName, MethodType.Normal)
-		{
-			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
-		}
+			: base(declaringType, methodName, MethodType.Normal) => info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="methodName">The name of the method, property or constructor to patch</param>
@@ -477,28 +447,19 @@ public HarmonyDelegate(string methodName, Type[] argumentTypes, ArgumentType[] a
 		/// <param name="methodDispatchType">The <see cref="MethodDispatchType"/></param>
 		///
 		public HarmonyDelegate(string methodName, MethodDispatchType methodDispatchType)
-			: base(methodName, MethodType.Normal)
-		{
-			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
-		}
+			: base(methodName, MethodType.Normal) => info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
 
 		/// <summary>An annotation that specifies call dispatching mechanics for the delegate</summary>
 		/// <param name="methodDispatchType">The <see cref="MethodDispatchType"/></param>
 		///
-		public HarmonyDelegate(MethodDispatchType methodDispatchType)
-		{
-			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
-		}
+		public HarmonyDelegate(MethodDispatchType methodDispatchType) => info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="methodDispatchType">The <see cref="MethodDispatchType"/></param>
 		/// <param name="argumentTypes">An array of argument types to target overloads</param>
 		///
 		public HarmonyDelegate(MethodDispatchType methodDispatchType, params Type[] argumentTypes)
-			: base(MethodType.Normal, argumentTypes)
-		{
-			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
-		}
+			: base(MethodType.Normal, argumentTypes) => info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="methodDispatchType">The <see cref="MethodDispatchType"/></param>
@@ -506,10 +467,7 @@ public HarmonyDelegate(MethodDispatchType methodDispatchType, params Type[] argu
 		/// <param name="argumentVariations">An array of <see cref="ArgumentType"/></param>
 		///
 		public HarmonyDelegate(MethodDispatchType methodDispatchType, Type[] argumentTypes, ArgumentType[] argumentVariations)
-			: base(MethodType.Normal, argumentTypes, argumentVariations)
-		{
-			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
-		}
+			: base(MethodType.Normal, argumentTypes, argumentVariations) => info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
 
 		/// <summary>An annotation that specifies a method, property or constructor to patch</summary>
 		/// <param name="argumentTypes">An array of argument types to target overloads</param>
@@ -533,10 +491,7 @@ public class HarmonyReversePatch : HarmonyAttribute
 		/// <summary>An annotation that specifies the type of reverse patching</summary>
 		/// <param name="type">The <see cref="HarmonyReversePatchType"/> of the reverse patch</param>
 		///
-		public HarmonyReversePatch(HarmonyReversePatchType type = HarmonyReversePatchType.Original)
-		{
-			info.reversePatchType = type;
-		}
+		public HarmonyReversePatch(HarmonyReversePatchType type = HarmonyReversePatchType.Original) => info.reversePatchType = type;
 	}
 
 	/// <summary>A Harmony annotation to define that all methods in a class are to be patched</summary>
@@ -554,10 +509,7 @@ public class HarmonyPriority : HarmonyAttribute
 		/// <summary>A Harmony annotation to define patch priority</summary>
 		/// <param name="priority">The priority</param>
 		///
-		public HarmonyPriority(int priority)
-		{
-			info.priority = priority;
-		}
+		public HarmonyPriority(int priority) => info.priority = priority;
 	}
 
 	/// <summary>A Harmony annotation</summary>
@@ -568,10 +520,7 @@ public class HarmonyBefore : HarmonyAttribute
 		/// <summary>A Harmony annotation to define that a patch comes before another patch</summary>
 		/// <param name="before">The array of harmony IDs of the other patches</param>
 		///
-		public HarmonyBefore(params string[] before)
-		{
-			info.before = before;
-		}
+		public HarmonyBefore(params string[] before) => info.before = before;
 	}
 
 	/// <summary>A Harmony annotation</summary>
@@ -581,10 +530,7 @@ public class HarmonyAfter : HarmonyAttribute
 		/// <summary>A Harmony annotation to define that a patch comes after another patch</summary>
 		/// <param name="after">The array of harmony IDs of the other patches</param>
 		///
-		public HarmonyAfter(params string[] after)
-		{
-			info.after = after;
-		}
+		public HarmonyAfter(params string[] after) => info.after = after;
 	}
 
 	/// <summary>A Harmony annotation</summary>
@@ -593,10 +539,7 @@ public class HarmonyDebug : HarmonyAttribute
 	{
 		/// <summary>A Harmony annotation to debug a patch (output uses <see cref="FileLog"/> to log to your Desktop)</summary>
 		///
-		public HarmonyDebug()
-		{
-			info.debug = true;
-		}
+		public HarmonyDebug() => info.debug = true;
 	}
 
 	/// <summary>Specifies the Prepare function in a patch class</summary>
diff --git a/Harmony/Public/CodeInstruction.cs b/Harmony/Public/CodeInstruction.cs
index 257210d6..616f3fcd 100644
--- a/Harmony/Public/CodeInstruction.cs
+++ b/Harmony/Public/CodeInstruction.cs
@@ -127,37 +127,25 @@ public static CodeInstruction Call(string typeColonMethodname, Type[] parameters
 		/// <param name="expression">The lambda expression using the method</param>
 		/// <returns></returns>
 		///
-		public static CodeInstruction Call(Expression<Action> expression)
-		{
-			return new CodeInstruction(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
-		}
+		public static CodeInstruction Call(Expression<Action> expression) => new(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
 
 		/// <summary>Creates a CodeInstruction calling a method (CALL)</summary>
 		/// <param name="expression">The lambda expression using the method</param>
 		/// <returns></returns>
 		///
-		public static CodeInstruction Call<T>(Expression<Action<T>> expression)
-		{
-			return new CodeInstruction(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
-		}
+		public static CodeInstruction Call<T>(Expression<Action<T>> expression) => new(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
 
 		/// <summary>Creates a CodeInstruction calling a method (CALL)</summary>
 		/// <param name="expression">The lambda expression using the method</param>
 		/// <returns></returns>
 		///
-		public static CodeInstruction Call<T, TResult>(Expression<Func<T, TResult>> expression)
-		{
-			return new CodeInstruction(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
-		}
+		public static CodeInstruction Call<T, TResult>(Expression<Func<T, TResult>> expression) => new(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
 
 		/// <summary>Creates a CodeInstruction calling a method (CALL)</summary>
 		/// <param name="expression">The lambda expression using the method</param>
 		/// <returns></returns>
 		///
-		public static CodeInstruction Call(LambdaExpression expression)
-		{
-			return new CodeInstruction(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
-		}
+		public static CodeInstruction Call(LambdaExpression expression) => new(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
 
 		/// <summary>Returns an instruction to call the specified closure</summary>
 		/// <typeparam name="T">The delegate type to emit</typeparam>
diff --git a/Harmony/Public/Harmony.cs b/Harmony/Public/Harmony.cs
index a5f2655a..65b8e9ed 100644
--- a/Harmony/Public/Harmony.cs
+++ b/Harmony/Public/Harmony.cs
@@ -1,4 +1,3 @@
-using MonoMod;
 using MonoMod.Core.Platforms;
 using System;
 using System.Collections.Generic;
@@ -86,37 +85,25 @@ public void PatchAll()
 		/// <param name="original">The original method/constructor</param>
 		/// <returns>A new <see cref="PatchProcessor"/> instance</returns>
 		///
-		public PatchProcessor CreateProcessor(MethodBase original)
-		{
-			return new PatchProcessor(this, original);
-		}
+		public PatchProcessor CreateProcessor(MethodBase original) => new(this, original);
 
 		/// <summary>Creates a patch class processor from an annotated class</summary>
 		/// <param name="type">The class/type</param>
 		/// <returns>A new <see cref="PatchClassProcessor"/> instance</returns>
 		/// 
-		public PatchClassProcessor CreateClassProcessor(Type type)
-		{
-			return new PatchClassProcessor(this, type);
-		}
+		public PatchClassProcessor CreateClassProcessor(Type type) => new(this, type);
 
 		/// <summary>Creates a reverse patcher for one of your stub methods</summary>
 		/// <param name="original">The original method/constructor</param>
 		/// <param name="standin">The stand-in stub method as <see cref="HarmonyMethod"/></param>
 		/// <returns>A new <see cref="ReversePatcher"/> instance</returns>
 		///
-		public ReversePatcher CreateReversePatcher(MethodBase original, HarmonyMethod standin)
-		{
-			return new ReversePatcher(this, original, standin);
-		}
+		public ReversePatcher CreateReversePatcher(MethodBase original, HarmonyMethod standin) => new(this, original, standin);
 
 		/// <summary>Searches an assembly for Harmony annotations and uses them to create patches</summary>
 		/// <param name="assembly">The assembly</param>
 		/// 
-		public void PatchAll(Assembly assembly)
-		{
-			AccessTools.GetTypesFromAssembly(assembly).Do(type => CreateClassProcessor(type).Patch());
-		}
+		public void PatchAll(Assembly assembly) => AccessTools.GetTypesFromAssembly(assembly).Do(type => CreateClassProcessor(type).Patch());
 
 		/// <summary>Searches an assembly for Harmony-annotated classes without category annotations and uses them to create patches</summary>
 		/// 
@@ -186,10 +173,7 @@ public MethodInfo Patch(MethodBase original, HarmonyMethod prefix = null, Harmon
 		/// <param name="transpiler">An optional transpiler as method that will be applied during the process</param>
 		/// <returns>The replacement method that was created to patch the stub method</returns>
 		/// 
-		public static MethodInfo ReversePatch(MethodBase original, HarmonyMethod standin, MethodInfo transpiler = null)
-		{
-			return PatchFunctions.ReversePatch(standin, original, transpiler);
-		}
+		public static MethodInfo ReversePatch(MethodBase original, HarmonyMethod standin, MethodInfo transpiler = null) => PatchFunctions.ReversePatch(standin, original, transpiler);
 
 		/// <summary>Unpatches methods by patching them with zero patches. Fully unpatching is not supported. Be careful, unpatching is global</summary>
 		/// <param name="harmonyID">The optional Harmony ID to restrict unpatching to a specific Harmony instance</param>
@@ -251,10 +235,7 @@ public static bool HasAnyPatches(string harmonyID)
 		/// <param name="method">The original method/constructor</param>
 		/// <returns>The patch information as <see cref="Patches"/></returns>
 		///
-		public static Patches GetPatchInfo(MethodBase method)
-		{
-			return PatchProcessor.GetPatchInfo(method);
-		}
+		public static Patches GetPatchInfo(MethodBase method) => PatchProcessor.GetPatchInfo(method);
 
 		/// <summary>Gets the methods this instance has patched</summary>
 		/// <returns>An enumeration of original methods/constructors</returns>
@@ -268,10 +249,7 @@ public IEnumerable<MethodBase> GetPatchedMethods()
 		/// <summary>Gets all patched original methods in the appdomain</summary>
 		/// <returns>An enumeration of patched original methods/constructors</returns>
 		///
-		public static IEnumerable<MethodBase> GetAllPatchedMethods()
-		{
-			return PatchProcessor.GetAllPatchedMethods();
-		}
+		public static IEnumerable<MethodBase> GetAllPatchedMethods() => PatchProcessor.GetAllPatchedMethods();
 
 		/// <summary>Gets the original method from a given replacement method</summary>
 		/// <param name="replacement">A replacement method, for example from a stacktrace</param>
@@ -310,9 +288,6 @@ public static MethodBase GetOriginalMethodFromStackframe(StackFrame frame)
 		/// <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)
-		{
-			return PatchProcessor.VersionInfo(out currentVersion);
-		}
+		public static Dictionary<string, Version> VersionInfo(out Version currentVersion) => PatchProcessor.VersionInfo(out currentVersion);
 	}
 }
diff --git a/Harmony/Public/HarmonyException.cs b/Harmony/Public/HarmonyException.cs
index 26ba2502..98fa4d35 100644
--- a/Harmony/Public/HarmonyException.cs
+++ b/Harmony/Public/HarmonyException.cs
@@ -21,10 +21,7 @@ internal HarmonyException(string message, Exception innerException) : base(messa
 		/// <param name="serializationInfo">The info</param>
 		/// <param name="streamingContext">The context</param>
 		/// 
-		protected HarmonyException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext)
-		{
-			throw new NotImplementedException();
-		}
+		protected HarmonyException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) => throw new NotImplementedException();
 
 		internal HarmonyException(Exception innerException, Dictionary<int, CodeInstruction> instructions, int errorOffset) : base("IL Compile Error", innerException)
 		{
@@ -51,26 +48,17 @@ internal static Exception Create(Exception ex, Dictionary<int, CodeInstruction>
 		/// <summary>Get a list of IL instructions in pairs of offset+code</summary>
 		/// <returns>A list of key/value pairs which represent an offset and the code at that offset</returns>
 		/// 
-		public List<KeyValuePair<int, CodeInstruction>> GetInstructionsWithOffsets()
-		{
-			return [.. instructions.OrderBy(ins => ins.Key)];
-		}
+		public List<KeyValuePair<int, CodeInstruction>> GetInstructionsWithOffsets() => [.. instructions.OrderBy(ins => ins.Key)];
 
 		/// <summary>Get a list of IL instructions without offsets</summary>
 		/// <returns>A list of <see cref="CodeInstruction"/></returns>
 		/// 
-		public List<CodeInstruction> GetInstructions()
-		{
-			return instructions.OrderBy(ins => ins.Key).Select(ins => ins.Value).ToList();
-		}
+		public List<CodeInstruction> GetInstructions() => instructions.OrderBy(ins => ins.Key).Select(ins => ins.Value).ToList();
 
 		/// <summary>Get the error offset of the errornous IL instruction</summary>
 		/// <returns>The offset</returns>
 		/// 
-		public int GetErrorOffset()
-		{
-			return errorOffset;
-		}
+		public int GetErrorOffset() => errorOffset;
 
 		/// <summary>Get the index of the errornous IL instruction</summary>
 		/// <returns>The index into the list of instructions or -1 if not found</returns>
diff --git a/Harmony/Public/HarmonyMethod.cs b/Harmony/Public/HarmonyMethod.cs
index 9a0ac2e7..e19d8cc0 100644
--- a/Harmony/Public/HarmonyMethod.cs
+++ b/Harmony/Public/HarmonyMethod.cs
@@ -199,18 +199,12 @@ internal string Description()
 		/// <summary>Creates a patch from a given method</summary>
 		/// <param name="method">The original method</param>
 		///
-		public static implicit operator HarmonyMethod(MethodInfo method)
-		{
-			return new HarmonyMethod(method);
-		}
+		public static implicit operator HarmonyMethod(MethodInfo method) => new(method);
 
 		/// <summary>Creates a patch from a given method</summary>
 		/// <param name="delegate">The original method</param>
 		///
-		public static implicit operator HarmonyMethod(Delegate @delegate)
-		{
-			return new HarmonyMethod(@delegate);
-		}
+		public static implicit operator HarmonyMethod(Delegate @delegate) => new(@delegate);
 	}
 
 	/// <summary>Annotation extensions</summary>
@@ -307,10 +301,7 @@ public static List<HarmonyMethod> GetFromType(Type type)
 		/// <param name="type">The class/type</param>
 		/// <returns>The merged <see cref="HarmonyMethod"/></returns>
 		///
-		public static HarmonyMethod GetMergedFromType(Type type)
-		{
-			return HarmonyMethod.Merge(GetFromType(type));
-		}
+		public static HarmonyMethod GetMergedFromType(Type type) => HarmonyMethod.Merge(GetFromType(type));
 
 		/// <summary>Gets all annotations on a method</summary>
 		/// <param name="method">The method/constructor</param>
@@ -328,9 +319,6 @@ public static List<HarmonyMethod> GetFromMethod(MethodBase method)
 		/// <param name="method">The method/constructor</param>
 		/// <returns>The merged <see cref="HarmonyMethod"/></returns>
 		///
-		public static HarmonyMethod GetMergedFromMethod(MethodBase method)
-		{
-			return HarmonyMethod.Merge(GetFromMethod(method));
-		}
+		public static HarmonyMethod GetMergedFromMethod(MethodBase method) => HarmonyMethod.Merge(GetFromMethod(method));
 	}
 }
diff --git a/Harmony/Public/InlineSignature.cs b/Harmony/Public/InlineSignature.cs
index f6f5a4ee..c6fdb705 100644
--- a/Harmony/Public/InlineSignature.cs
+++ b/Harmony/Public/InlineSignature.cs
@@ -36,10 +36,7 @@ internal class InlineSignature : ICallSiteGenerator
 		/// <summary>Returns a string representation of the inline signature</summary>
 		/// <returns>A string representation of the inline signature</returns>
 		///
-		public override string ToString()
-		{
-			return $"{(ReturnType is Type rt ? rt.FullDescription() : ReturnType?.ToString())} ({Parameters.Join(p => p is Type pt ? pt.FullDescription() : p?.ToString())})";
-		}
+		public override string ToString() => $"{(ReturnType is Type rt ? rt.FullDescription() : ReturnType?.ToString())} ({Parameters.Join(p => p is Type pt ? pt.FullDescription() : p?.ToString())})";
 
 		internal static TypeReference GetTypeReference(ModuleDefinition module, object param)
 		{
@@ -105,10 +102,7 @@ public class ModifierType
 			/// <summary>Returns a string representation of the modifier type</summary>
 			/// <returns>A string representation of the modifier type</returns>
 			///
-			public override string ToString()
-			{
-				return $"{(Type is Type rt ? rt.FullDescription() : Type?.ToString())} mod{(IsOptional ? "opt" : "req")}({Modifier?.FullDescription()})";
-			}
+			public override string ToString() => $"{(Type is Type rt ? rt.FullDescription() : Type?.ToString())} mod{(IsOptional ? "opt" : "req")}({Modifier?.FullDescription()})";
 
 			internal TypeReference ToTypeReference(ModuleDefinition module)
 			{
diff --git a/Harmony/Public/Patch.cs b/Harmony/Public/Patch.cs
index ce37e36c..cb13b923 100644
--- a/Harmony/Public/Patch.cs
+++ b/Harmony/Public/Patch.cs
@@ -133,28 +133,28 @@ public class PatchInfo
 #if NET5_0_OR_GREATER
 		[JsonInclude]
 #endif
-		public Patch[] prefixes = new Patch[0];
+		public Patch[] prefixes = [];
 
 		/// <summary>Postfixes as an array of <see cref="Patch"/></summary>
 		///
 #if NET5_0_OR_GREATER
 		[JsonInclude]
 #endif
-		public Patch[] postfixes = new Patch[0];
+		public Patch[] postfixes = [];
 
 		/// <summary>Transpilers as an array of <see cref="Patch"/></summary>
 		///
 #if NET5_0_OR_GREATER
 		[JsonInclude]
 #endif
-		public Patch[] transpilers = new Patch[0];
+		public Patch[] transpilers = [];
 
 		/// <summary>Finalizers as an array of <see cref="Patch"/></summary>
 		///
 #if NET5_0_OR_GREATER
 		[JsonInclude]
 #endif
-		public Patch[] finalizers = new Patch[0];
+		public Patch[] finalizers = [];
 
 		/// <summary>Returns if any of the patches wants debugging turned on</summary>
 		///
@@ -167,97 +167,61 @@ public class PatchInfo
 		/// <param name="owner">An owner (Harmony ID)</param>
 		/// <param name="methods">The patch methods</param>
 		///
-		internal void AddPrefixes(string owner, params HarmonyMethod[] methods)
-		{
-			prefixes = Add(owner, methods, prefixes);
-		}
+		internal void AddPrefixes(string owner, params HarmonyMethod[] methods) => prefixes = Add(owner, methods, prefixes);
 
 		/// <summary>Adds a prefix</summary>
 		[Obsolete("This method only exists for backwards compatibility since the class is public.")]
-		public void AddPrefix(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug)
-		{
-			AddPrefixes(owner, new HarmonyMethod(patch, priority, before, after, debug));
-		}
+		public void AddPrefix(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug) => AddPrefixes(owner, new HarmonyMethod(patch, priority, before, after, debug));
 
 		/// <summary>Removes prefixes</summary>
 		/// <param name="owner">The owner of the prefixes, or <c>*</c> for all</param>
 		///
-		public void RemovePrefix(string owner)
-		{
-			prefixes = Remove(owner, prefixes);
-		}
+		public void RemovePrefix(string owner) => prefixes = Remove(owner, prefixes);
 
 		/// <summary>Adds postfixes</summary>
 		/// <param name="owner">An owner (Harmony ID)</param>
 		/// <param name="methods">The patch methods</param>
 		///
-		internal void AddPostfixes(string owner, params HarmonyMethod[] methods)
-		{
-			postfixes = Add(owner, methods, postfixes);
-		}
+		internal void AddPostfixes(string owner, params HarmonyMethod[] methods) => postfixes = Add(owner, methods, postfixes);
 
 		/// <summary>Adds a postfix</summary>
 		[Obsolete("This method only exists for backwards compatibility since the class is public.")]
-		public void AddPostfix(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug)
-		{
-			AddPostfixes(owner, new HarmonyMethod(patch, priority, before, after, debug));
-		}
+		public void AddPostfix(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug) => AddPostfixes(owner, new HarmonyMethod(patch, priority, before, after, debug));
 
 		/// <summary>Removes postfixes</summary>
 		/// <param name="owner">The owner of the postfixes, or <c>*</c> for all</param>
 		///
-		public void RemovePostfix(string owner)
-		{
-			postfixes = Remove(owner, postfixes);
-		}
+		public void RemovePostfix(string owner) => postfixes = Remove(owner, postfixes);
 
 		/// <summary>Adds transpilers</summary>
 		/// <param name="owner">An owner (Harmony ID)</param>
 		/// <param name="methods">The patch methods</param>
 		///
-		internal void AddTranspilers(string owner, params HarmonyMethod[] methods)
-		{
-			transpilers = Add(owner, methods, transpilers);
-		}
+		internal void AddTranspilers(string owner, params HarmonyMethod[] methods) => transpilers = Add(owner, methods, transpilers);
 
 		/// <summary>Adds a transpiler</summary>
 		[Obsolete("This method only exists for backwards compatibility since the class is public.")]
-		public void AddTranspiler(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug)
-		{
-			AddTranspilers(owner, new HarmonyMethod(patch, priority, before, after, debug));
-		}
+		public void AddTranspiler(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug) => AddTranspilers(owner, new HarmonyMethod(patch, priority, before, after, debug));
 
 		/// <summary>Removes transpilers</summary>
 		/// <param name="owner">The owner of the transpilers, or <c>*</c> for all</param>
 		///
-		public void RemoveTranspiler(string owner)
-		{
-			transpilers = Remove(owner, transpilers);
-		}
+		public void RemoveTranspiler(string owner) => transpilers = Remove(owner, transpilers);
 
 		/// <summary>Adds finalizers</summary>
 		/// <param name="owner">An owner (Harmony ID)</param>
 		/// <param name="methods">The patch methods</param>
 		///
-		internal void AddFinalizers(string owner, params HarmonyMethod[] methods)
-		{
-			finalizers = Add(owner, methods, finalizers);
-		}
+		internal void AddFinalizers(string owner, params HarmonyMethod[] methods) => finalizers = Add(owner, methods, finalizers);
 
 		/// <summary>Adds a finalizer</summary>
 		[Obsolete("This method only exists for backwards compatibility since the class is public.")]
-		public void AddFinalizer(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug)
-		{
-			AddFinalizers(owner, new HarmonyMethod(patch, priority, before, after, debug));
-		}
+		public void AddFinalizer(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug) => AddFinalizers(owner, new HarmonyMethod(patch, priority, before, after, debug));
 
 		/// <summary>Removes finalizers</summary>
 		/// <param name="owner">The owner of the finalizers, or <c>*</c> for all</param>
 		///
-		public void RemoveFinalizer(string owner)
-		{
-			finalizers = Remove(owner, finalizers);
-		}
+		public void RemoveFinalizer(string owner) => finalizers = Remove(owner, finalizers);
 
 		/// <summary>Removes a patch using its method</summary>
 		/// <param name="patch">The method of the patch to remove</param>
@@ -301,7 +265,7 @@ .. add
 		private static Patch[] Remove(string owner, Patch[] current)
 		{
 			return owner == "*"
-				? new Patch[0]
+				? []
 				: current.Where(patch => patch.owner != owner).ToArray();
 		}
 	}
@@ -386,8 +350,8 @@ public Patch(MethodInfo patch, int index, string owner, int priority, string[] b
 			this.index = index;
 			this.owner = owner;
 			this.priority = priority == -1 ? Priority.Normal : priority;
-			this.before = before ?? new string[0];
-			this.after = after ?? new string[0];
+			this.before = before ?? [];
+			this.after = after ?? [];
 			this.debug = debug;
 			PatchMethod = patch;
 		}
@@ -404,8 +368,8 @@ internal Patch(int index, string owner, int priority, string[] before, string[]
 			this.index = index;
 			this.owner = owner;
 			this.priority = priority == -1 ? Priority.Normal : priority;
-			this.before = before ?? new string[0];
-			this.after = after ?? new string[0];
+			this.before = before ?? [];
+			this.after = after ?? [];
 			this.debug = debug;
 			this.methodToken = methodToken;
 			this.moduleGUID = moduleGUID;
@@ -432,26 +396,17 @@ public MethodInfo GetMethod(MethodBase original)
 		/// <param name="obj">The other patch</param>
 		/// <returns>true if equal</returns>
 		///
-		public override bool Equals(object obj)
-		{
-			return ((obj is not null) && (obj is Patch) && (PatchMethod == ((Patch)obj).PatchMethod));
-		}
+		public override bool Equals(object obj) => ((obj is not null) && (obj is Patch) && (PatchMethod == ((Patch)obj).PatchMethod));
 
 		/// <summary>Determines how patches sort</summary>
 		/// <param name="obj">The other patch</param>
 		/// <returns>integer to define sort order (-1, 0, 1)</returns>
 		///
-		public int CompareTo(object obj)
-		{
-			return PatchInfoSerialization.PriorityComparer(obj, index, priority);
-		}
+		public int CompareTo(object obj) => PatchInfoSerialization.PriorityComparer(obj, index, priority);
 
 		/// <summary>Hash function</summary>
 		/// <returns>A hash code</returns>
 		///
-		public override int GetHashCode()
-		{
-			return PatchMethod.GetHashCode();
-		}
+		public override int GetHashCode() => PatchMethod.GetHashCode();
 	}
 }
diff --git a/Harmony/Public/PatchClassProcessor.cs b/Harmony/Public/PatchClassProcessor.cs
index 7f25825f..20a0e3e5 100644
--- a/Harmony/Public/PatchClassProcessor.cs
+++ b/Harmony/Public/PatchClassProcessor.cs
@@ -278,7 +278,7 @@ T RunMethod<S, T>(T defaultIfNotExisting, T defaultIfFailing, Func<T, string> fa
 		{
 			if (auxilaryMethods.TryGetValue(typeof(S), out var method))
 			{
-				var input = (parameters ?? new object[0]).Union(new object[] { instance }).ToArray();
+				var input = (parameters ?? []).Union([instance]).ToArray();
 				var actualParameters = AccessTools.ActualParameters(method, input);
 
 				if (method.ReturnType != typeof(void) && typeof(T).IsAssignableFrom(method.ReturnType) is false)
@@ -316,7 +316,7 @@ void RunMethod<S>(ref Exception exception, params object[] parameters)
 		{
 			if (auxilaryMethods.TryGetValue(typeof(S), out var method))
 			{
-				var input = (parameters ?? new object[0]).Union(new object[] { instance }).ToArray();
+				var input = (parameters ?? []).Union([instance]).ToArray();
 				var actualParameters = AccessTools.ActualParameters(method, input);
 				try
 				{
diff --git a/Harmony/Public/PatchProcessor.cs b/Harmony/Public/PatchProcessor.cs
index f86ce86f..2a0b2f78 100644
--- a/Harmony/Public/PatchProcessor.cs
+++ b/Harmony/Public/PatchProcessor.cs
@@ -209,10 +209,7 @@ public static Patches GetPatchInfo(MethodBase method)
 		/// <param name="patches">Patches to sort</param>
 		/// <returns>The sorted patch methods</returns>
 		///
-		public static List<MethodInfo> GetSortedPatchMethods(MethodBase original, Patch[] patches)
-		{
-			return PatchFunctions.GetSortedPatchMethods(original, patches, false);
-		}
+		public static List<MethodInfo> GetSortedPatchMethods(MethodBase original, Patch[] patches) => PatchFunctions.GetSortedPatchMethods(original, patches, false);
 
 		/// <summary>Gets Harmony version for all active Harmony instances</summary>
 		/// <param name="currentVersion">[out] The current Harmony version</param>
@@ -247,7 +244,7 @@ public static Dictionary<string, Version> VersionInfo(out Version currentVersion
 		/// 
 		public static ILGenerator CreateILGenerator()
 		{
-			var method = new DynamicMethodDefinition($"ILGenerator_{Guid.NewGuid()}", typeof(void), new Type[0]);
+			var method = new DynamicMethodDefinition($"ILGenerator_{Guid.NewGuid()}", typeof(void), []);
 			return method.GetILGenerator();
 		}
 
@@ -269,10 +266,7 @@ public static ILGenerator CreateILGenerator(MethodBase original)
 		/// <param name="generator">Optionally an existing generator that will be used to create all local variables and labels contained in the result (if not specified, an internal generator is used)</param>
 		/// <returns>A list containing all the original <see cref="CodeInstruction"/></returns>
 		/// 
-		public static List<CodeInstruction> GetOriginalInstructions(MethodBase original, ILGenerator generator = null)
-		{
-			return MethodCopier.GetInstructions(generator ?? CreateILGenerator(original), original, 0);
-		}
+		public static List<CodeInstruction> GetOriginalInstructions(MethodBase original, ILGenerator generator = null) => MethodCopier.GetInstructions(generator ?? CreateILGenerator(original), original, 0);
 
 		/// <summary>Returns the methods unmodified list of code instructions</summary>
 		/// <param name="original">The original method/constructor</param>
@@ -291,10 +285,7 @@ public static List<CodeInstruction> GetOriginalInstructions(MethodBase original,
 		/// <param name="generator">Optionally an existing generator that will be used to create all local variables and labels contained in the result (if not specified, an internal generator is used)</param>
 		/// <returns>A list of <see cref="CodeInstruction"/></returns>
 		/// 
-		public static List<CodeInstruction> GetCurrentInstructions(MethodBase original, int maxTranspilers = int.MaxValue, ILGenerator generator = null)
-		{
-			return MethodCopier.GetInstructions(generator ?? CreateILGenerator(original), original, maxTranspilers);
-		}
+		public static List<CodeInstruction> GetCurrentInstructions(MethodBase original, int maxTranspilers = int.MaxValue, ILGenerator generator = null) => MethodCopier.GetInstructions(generator ?? CreateILGenerator(original), original, maxTranspilers);
 
 		/// <summary>Returns the methods current list of code instructions after all existing transpilers have been applied</summary>
 		/// <param name="original">The original method/constructor</param>
diff --git a/Harmony/Public/Patches.cs b/Harmony/Public/Patches.cs
index 9164dfc8..8d451ad9 100644
--- a/Harmony/Public/Patches.cs
+++ b/Harmony/Public/Patches.cs
@@ -48,10 +48,10 @@ public ReadOnlyCollection<string> Owners
 		///
 		public Patches(Patch[] prefixes, Patch[] postfixes, Patch[] transpilers, Patch[] finalizers)
 		{
-			prefixes ??= new Patch[0];
-			postfixes ??= new Patch[0];
-			transpilers ??= new Patch[0];
-			finalizers ??= new Patch[0];
+			prefixes ??= [];
+			postfixes ??= [];
+			transpilers ??= [];
+			finalizers ??= [];
 
 			Prefixes = prefixes.ToList().AsReadOnly();
 			Postfixes = postfixes.ToList().AsReadOnly();
diff --git a/Harmony/Tools/AccessTools.cs b/Harmony/Tools/AccessTools.cs
index d09be2bb..fe73ec53 100644
--- a/Harmony/Tools/AccessTools.cs
+++ b/Harmony/Tools/AccessTools.cs
@@ -8,7 +8,6 @@
 using System.Reflection;
 using System.Reflection.Emit;
 using System.Threading;
-using System.Runtime.Serialization;
 
 
 #if NET45_OR_GREATER || NETSTANDARD || NETCOREAPP
@@ -45,10 +44,7 @@ public static class AccessTools
 		/// <summary>Enumerates all assemblies in the current app domain, excluding visual studio assemblies</summary>
 		/// <returns>An enumeration of <see cref="Assembly"/></returns>
 		///
-		public static IEnumerable<Assembly> AllAssemblies()
-		{
-			return AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.StartsWith("Microsoft.VisualStudio") is false);
-		}
+		public static IEnumerable<Assembly> AllAssemblies() => AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.StartsWith("Microsoft.VisualStudio") is false);
 
 		/// <summary>Gets a type by name. Prefers a full name with namespace but falls back to the first type matching the name otherwise</summary>
 		/// <param name="name">The name</param>
@@ -88,19 +84,13 @@ public static Type[] GetTypesFromAssembly(Assembly assembly)
 		/// <summary>Enumerates all successfully loaded types in the current app domain, excluding visual studio assemblies</summary>
 		/// <returns>An enumeration of all <see cref="Type"/> in all assemblies, excluding visual studio assemblies</returns>
 		///
-		public static IEnumerable<Type> AllTypes()
-		{
-			return AllAssemblies().SelectMany(a => GetTypesFromAssembly(a));
-		}
+		public static IEnumerable<Type> AllTypes() => AllAssemblies().SelectMany(a => GetTypesFromAssembly(a));
 
 		/// <summary>Enumerates all inner types (non-recursive) of a given type</summary>
 		/// <param name="type">The class/type to start with</param>
 		/// <returns>An enumeration of all inner <see cref="Type"/></returns>
 		///
-		public static IEnumerable<Type> InnerTypes(Type type)
-		{
-			return type.GetNestedTypes(all);
-		}
+		public static IEnumerable<Type> InnerTypes(Type type) => type.GetNestedTypes(all);
 
 		/// <summary>Applies a function going up the type hierarchy and stops at the first non-<c>null</c> result</summary>
 		/// <typeparam name="T">Result type of func()</typeparam>
@@ -297,58 +287,40 @@ public static PropertyInfo DeclaredIndexer(Type type, Type[] parameters = null)
 		/// <param name="name">The name of the property (case sensitive)</param>
 		/// <returns>A method or null when type/name is null or when the property cannot be found</returns>
 		///
-		public static MethodInfo DeclaredPropertyGetter(Type type, string name)
-		{
-			return DeclaredProperty(type, name)?.GetGetMethod(true);
-		}
+		public static MethodInfo DeclaredPropertyGetter(Type type, string name) => DeclaredProperty(type, name)?.GetGetMethod(true);
 
 		/// <summary>Gets the reflection information for the getter method of a directly declared property</summary>
 		/// <param name="typeColonName">The member in the form <c>TypeFullName:MemberName</c>, where TypeFullName matches the form recognized by <a href="https://docs.microsoft.com/en-us/dotnet/api/system.type.gettype">Type.GetType</a> like <c>Some.Namespace.Type</c>.</param>
 		/// <returns>A method or null when the property cannot be found</returns>
 		///
-		public static MethodInfo DeclaredPropertyGetter(string typeColonName)
-		{
-			return DeclaredProperty(typeColonName)?.GetGetMethod(true);
-		}
+		public static MethodInfo DeclaredPropertyGetter(string typeColonName) => DeclaredProperty(typeColonName)?.GetGetMethod(true);
 
 		/// <summary>Gets the reflection information for the getter method of a directly declared indexer property</summary>
 		/// <param name="type">The class/type where the indexer property is declared</param>
 		/// <param name="parameters">Optional parameters to target a specific overload of multiple indexers</param>
 		/// <returns>A method or null when type is null or when indexer property cannot be found</returns>
 		///
-		public static MethodInfo DeclaredIndexerGetter(Type type, Type[] parameters = null)
-		{
-			return DeclaredIndexer(type, parameters)?.GetGetMethod(true);
-		}
+		public static MethodInfo DeclaredIndexerGetter(Type type, Type[] parameters = null) => DeclaredIndexer(type, parameters)?.GetGetMethod(true);
 
 		/// <summary>Gets the reflection information for the setter method of a directly declared property</summary>
 		/// <param name="type">The class/type where the property is declared</param>
 		/// <param name="name">The name of the property (case sensitive)</param>
 		/// <returns>A method or null when type/name is null or when the property cannot be found</returns>
 		///
-		public static MethodInfo DeclaredPropertySetter(Type type, string name)
-		{
-			return DeclaredProperty(type, name)?.GetSetMethod(true);
-		}
+		public static MethodInfo DeclaredPropertySetter(Type type, string name) => DeclaredProperty(type, name)?.GetSetMethod(true);
 
 		/// <summary>Gets the reflection information for the Setter method of a directly declared property</summary>
 		/// <param name="typeColonName">The member in the form <c>TypeFullName:MemberName</c>, where TypeFullName matches the form recognized by <a href="https://docs.microsoft.com/en-us/dotnet/api/system.type.gettype">Type.GetType</a> like <c>Some.Namespace.Type</c>.</param>
 		/// <returns>A method or null when the property cannot be found</returns>
 		///
-		public static MethodInfo DeclaredPropertySetter(string typeColonName)
-		{
-			return DeclaredProperty(typeColonName)?.GetSetMethod(true);
-		}
+		public static MethodInfo DeclaredPropertySetter(string typeColonName) => DeclaredProperty(typeColonName)?.GetSetMethod(true);
 
 		/// <summary>Gets the reflection information for the setter method of a directly declared indexer property</summary>
 		/// <param name="type">The class/type where the indexer property is declared</param>
 		/// <param name="parameters">Optional parameters to target a specific overload of multiple indexers</param>
 		/// <returns>A method or null when type is null or when indexer property cannot be found</returns>
 		///
-		public static MethodInfo DeclaredIndexerSetter(Type type, Type[] parameters)
-		{
-			return DeclaredIndexer(type, parameters)?.GetSetMethod(true);
-		}
+		public static MethodInfo DeclaredIndexerSetter(Type type, Type[] parameters) => DeclaredIndexer(type, parameters)?.GetSetMethod(true);
 
 		/// <summary>Gets the reflection information for a property by searching the type and all its super types</summary>
 		/// <param name="type">The class/type</param>
@@ -421,58 +393,40 @@ public static PropertyInfo Indexer(Type type, Type[] parameters = null)
 		/// <param name="name">The name</param>
 		/// <returns>A method or null when type/name is null or when the property cannot be found</returns>
 		///
-		public static MethodInfo PropertyGetter(Type type, string name)
-		{
-			return Property(type, name)?.GetGetMethod(true);
-		}
+		public static MethodInfo PropertyGetter(Type type, string name) => Property(type, name)?.GetGetMethod(true);
 
 		/// <summary>Gets the reflection information for the getter method of a property by searching the type and all its super types</summary>
 		/// <param name="typeColonName">The member in the form <c>TypeFullName:MemberName</c>, where TypeFullName matches the form recognized by <a href="https://docs.microsoft.com/en-us/dotnet/api/system.type.gettype">Type.GetType</a> like <c>Some.Namespace.Type</c>.</param>
 		/// <returns>A method or null when type/name is null or when the property cannot be found</returns>
 		///
-		public static MethodInfo PropertyGetter(string typeColonName)
-		{
-			return Property(typeColonName)?.GetGetMethod(true);
-		}
+		public static MethodInfo PropertyGetter(string typeColonName) => Property(typeColonName)?.GetGetMethod(true);
 
 		/// <summary>Gets the reflection information for the getter method of an indexer property by searching the type and all its super types</summary>
 		/// <param name="type">The class/type</param>
 		/// <param name="parameters">Optional parameters to target a specific overload of multiple indexers</param>
 		/// <returns>A method or null when type is null or when the indexer property cannot be found</returns>
 		///
-		public static MethodInfo IndexerGetter(Type type, Type[] parameters = null)
-		{
-			return Indexer(type, parameters)?.GetGetMethod(true);
-		}
+		public static MethodInfo IndexerGetter(Type type, Type[] parameters = null) => Indexer(type, parameters)?.GetGetMethod(true);
 
 		/// <summary>Gets the reflection information for the setter method of a property by searching the type and all its super types</summary>
 		/// <param name="type">The class/type</param>
 		/// <param name="name">The name</param>
 		/// <returns>A method or null when type/name is null or when the property cannot be found</returns>
 		///
-		public static MethodInfo PropertySetter(Type type, string name)
-		{
-			return Property(type, name)?.GetSetMethod(true);
-		}
+		public static MethodInfo PropertySetter(Type type, string name) => Property(type, name)?.GetSetMethod(true);
 
 		/// <summary>Gets the reflection information for the setter method of a property by searching the type and all its super types</summary>
 		/// <param name="typeColonName">The member in the form <c>TypeFullName:MemberName</c>, where TypeFullName matches the form recognized by <a href="https://docs.microsoft.com/en-us/dotnet/api/system.type.gettype">Type.GetType</a> like <c>Some.Namespace.Type</c>.</param>
 		/// <returns>A method or null when type/name is null or when the property cannot be found</returns>
 		///
-		public static MethodInfo PropertySetter(string typeColonName)
-		{
-			return Property(typeColonName)?.GetSetMethod(true);
-		}
+		public static MethodInfo PropertySetter(string typeColonName) => Property(typeColonName)?.GetSetMethod(true);
 
 		/// <summary>Gets the reflection information for the setter method of an indexer property by searching the type and all its super types</summary>
 		/// <param name="type">The class/type</param>
 		/// <param name="parameters">Optional parameters to target a specific overload of multiple indexers</param>
 		/// <returns>A method or null when type is null or when the indexer property cannot be found</returns>
 		///
-		public static MethodInfo IndexerSetter(Type type, Type[] parameters = null)
-		{
-			return Indexer(type, parameters)?.GetSetMethod(true);
-		}
+		public static MethodInfo IndexerSetter(Type type, Type[] parameters = null) => Indexer(type, parameters)?.GetSetMethod(true);
 
 		/// <summary>Gets the reflection information for a directly declared method</summary>
 		/// <param name="type">The class/type where the method is declared</param>
@@ -552,7 +506,7 @@ public static MethodInfo Method(Type type, string name, Type[] parameters = null
 				}
 				catch (AmbiguousMatchException ex)
 				{
-					result = FindIncludingBaseTypes(type, t => t.GetMethod(name, all, null, new Type[0], modifiers));
+					result = FindIncludingBaseTypes(type, t => t.GetMethod(name, all, null, [], modifiers));
 					if (result is null)
 					{
 						throw new AmbiguousMatchException($"Ambiguous match in Harmony patch for {type}:{name}", ex);
@@ -755,10 +709,7 @@ public static Type GetUnderlyingType(this MemberInfo member)
 		/// <param name="member">A member</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;
-		}
+		public static bool IsDeclaredMember<T>(this T member) where T : MemberInfo => member.DeclaringType == member.ReflectedType;
 
 		/// <summary>Gets the real implementation of a class member</summary>
 		/// <param name="member">A member</param>
@@ -770,7 +721,7 @@ public static T GetDeclaredMember<T>(this T member) where T : MemberInfo
 				return member;
 
 			var metaToken = member.MetadataToken;
-			var members = member.DeclaringType?.GetMembers(all) ?? new MemberInfo[0];
+			var members = member.DeclaringType?.GetMembers(all) ?? [];
 			foreach (var other in members)
 				if (other.MetadataToken == metaToken)
 					return (T)other;
@@ -791,7 +742,7 @@ public static ConstructorInfo DeclaredConstructor(Type type, Type[] parameters =
 				FileLog.Debug("AccessTools.DeclaredConstructor: type is null");
 				return null;
 			}
-			parameters ??= new Type[0];
+			parameters ??= [];
 			var flags = searchForStatic ? allDeclared & ~BindingFlags.Instance : allDeclared & ~BindingFlags.Static;
 			return type.GetConstructor(flags, null, parameters, []);
 		}
@@ -809,7 +760,7 @@ public static ConstructorInfo Constructor(Type type, Type[] parameters = null, b
 				FileLog.Debug("AccessTools.ConstructorInfo: type is null");
 				return null;
 			}
-			parameters ??= new Type[0];
+			parameters ??= [];
 			var flags = searchForStatic ? all & ~BindingFlags.Instance : all & ~BindingFlags.Static;
 			return FindIncludingBaseTypes(type, t => t.GetConstructor(flags, null, parameters, []));
 		}
@@ -996,7 +947,7 @@ public static PropertyInfo FirstProperty(Type type, Func<PropertyInfo, bool> pre
 		///
 		public static Type[] GetTypes(object[] parameters)
 		{
-			if (parameters is null) return new Type[0];
+			if (parameters is null) return [];
 			return parameters.Select(p => p is null ? typeof(object) : p.GetType()).ToArray();
 		}
 
@@ -1466,10 +1417,7 @@ public static ref F StructFieldRefAccess<T, F>(ref T instance, FieldInfo fieldIn
 		/// <param name="fieldName">The name of the field</param>
 		/// <returns>A readable/assignable reference to the field</returns>
 		///
-		public static ref F StaticFieldRefAccess<T, F>(string fieldName)
-		{
-			return ref StaticFieldRefAccess<F>(typeof(T), fieldName);
-		}
+		public static ref F StaticFieldRefAccess<T, F>(string fieldName) => ref StaticFieldRefAccess<F>(typeof(T), fieldName);
 
 		/// <summary>Creates a static field reference</summary>
 		/// <typeparam name="F">
@@ -1703,7 +1651,7 @@ public static DelegateType MethodDelegate<DelegateType>(MethodInfo method, objec
 				var dmd = new DynamicMethodDefinition(
 					"LdftnDelegate_" + method.Name,
 					delegateType,
-					new[] { typeof(object) })
+					[typeof(object)])
 				{
 					// OwnerType = delegateType
 				};
@@ -1863,7 +1811,7 @@ public static object CreateInstance(Type type)
 			if (type is null)
 				throw new ArgumentNullException(nameof(type));
 			var ctor = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, binder: null,
-				CallingConventions.Any, new Type[0], modifiers: null);
+				CallingConventions.Any, [], modifiers: null);
 			if (ctor is not null)
 				return ctor.Invoke(null);
 #if NET5_0_OR_GREATER
@@ -1903,10 +1851,7 @@ public static T CreateInstance<T>()
 		/// <param name="source">The original object</param>
 		/// <returns>A copy of the original object but of type T</returns>
 		///
-		public static T MakeDeepCopy<T>(object source) where T : class
-		{
-			return MakeDeepCopy(source, typeof(T)) as T;
-		}
+		public static T MakeDeepCopy<T>(object source) where T : class => MakeDeepCopy(source, typeof(T)) as T;
 
 		/// <summary>Makes a deep copy of any object</summary>
 		/// <typeparam name="T">The type of the instance that should be created</typeparam>
@@ -1915,10 +1860,7 @@ public static T MakeDeepCopy<T>(object source) where T : class
 		/// <param name="processor">Optional value transformation function (taking a field name and src/dst <see cref="Traverse"/> instances)</param>
 		/// <param name="pathRoot">The optional path root to start with</param>
 		///
-		public static void MakeDeepCopy<T>(object source, out T result, Func<string, Traverse, Traverse, object> processor = null, string pathRoot = "")
-		{
-			result = (T)MakeDeepCopy(source, typeof(T), processor, pathRoot);
-		}
+		public static void MakeDeepCopy<T>(object source, out T result, Func<string, Traverse, Traverse, object> processor = null, string pathRoot = "") => result = (T)MakeDeepCopy(source, typeof(T), processor, pathRoot);
 
 		/// <summary>Makes a deep copy of any object</summary>
 		/// <param name="source">The original object</param>
@@ -2097,19 +2039,13 @@ public static bool IsFloatingPoint(Type type)
 		/// <param name="type">The type</param>
 		/// <returns>True if the type represents some number</returns>
 		///
-		public static bool IsNumber(Type type)
-		{
-			return IsInteger(type) || IsFloatingPoint(type);
-		}
+		public static bool IsNumber(Type type) => IsInteger(type) || IsFloatingPoint(type);
 
 		/// <summary>Tests if a type is void</summary>
 		/// <param name="type">The type</param>
 		/// <returns>True if the type is void</returns>
 		///
-		public static bool IsVoid(Type type)
-		{
-			return type == typeof(void);
-		}
+		public static bool IsVoid(Type type) => type == typeof(void);
 
 		/// <summary>Test whether an instance is of a nullable type</summary>
 		/// <typeparam name="T">Type of instance</typeparam>
@@ -2117,11 +2053,7 @@ public static bool IsVoid(Type type)
 		/// <returns>True if instance is of nullable type, false if not</returns>
 		///
 #pragma warning disable IDE0060
-		public static bool IsOfNullableType<T>(T instance)
-#pragma warning restore IDE0060
-		{
-			return Nullable.GetUnderlyingType(typeof(T)) is not null;
-		}
+		public static bool IsOfNullableType<T>(T instance) => Nullable.GetUnderlyingType(typeof(T)) is not null;
 
 		/// <summary>Tests whether a type or member is static, as defined in C#</summary>
 		/// <param name="member">The type or member</param>
diff --git a/Harmony/Tools/Code.cs b/Harmony/Tools/Code.cs
index 7dd661d3..ebecfde3 100644
--- a/Harmony/Tools/Code.cs
+++ b/Harmony/Tools/Code.cs
@@ -3,6 +3,12 @@
 
 namespace HarmonyLib
 {
+	/// <summary>By adding the following using statement to your source code:</summary>
+	/// <code>using static HarmonyLib.Code;</code>
+	/// you can i.e. start using <c>Ldarg_1</c> instead of <c>new CodeMatch(OpCodes.Ldarg_1)</c>
+	/// and then you can use array notation to add an operand and/or a name:
+	/// <c>Call[myMethodInfo]</c> instead of <c>new CodeMatch(OpCodes.Call, myMethodInfo)</c>
+	///
 	public static class Code
 	{
 		public static Operand_ Operand => new();
diff --git a/Harmony/Tools/CodeMatch.cs b/Harmony/Tools/CodeMatch.cs
index 0aab6db7..cda50bdf 100644
--- a/Harmony/Tools/CodeMatch.cs
+++ b/Harmony/Tools/CodeMatch.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Reflection;
 using System.Reflection.Emit;
 
 namespace HarmonyLib
@@ -21,7 +22,7 @@ public class CodeMatch : CodeInstruction
 #pragma warning disable IDE1006
 		public List<OpCode> opcodes
 		{
-			get => opcodeSet.ToList();
+			get => [.. opcodeSet];
 			set => opcodeSet = new HashSet<OpCode>(value);
 		}
 #pragma warning restore IDE1006
@@ -79,10 +80,7 @@ public CodeMatch(OpCode? opcode = null, object operand = null, string name = nul
 		/// <param name="operand">The optional operand</param>
 		/// <param name="name">The optional name</param>
 		///
-		public static CodeMatch WithOpcodes(HashSet<OpCode> opcodes, object operand = null, string name = null)
-		{
-			return new CodeMatch(null, operand, name) { opcodeSet = opcodes };
-		}
+		public static CodeMatch WithOpcodes(HashSet<OpCode> opcodes, object operand = null, string name = null) => new(null, operand, name) { opcodeSet = opcodes };
 
 		/// <summary>Creates a code match that calls a method</summary>
 		/// <param name="expression">The lambda expression using the method</param>
@@ -152,47 +150,121 @@ internal bool Matches(List<CodeInstruction> codes, CodeInstruction instruction)
 			return true;
 		}
 
+		/// <summary>Tests for any form of Ldarg*</summary>
+		/// <param name="n">The (optional) index</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch IsLdarg(int? n = null) => new(instruction => instruction.IsLdarg(n));
+
+		/// <summary>Tests for Ldarga/Ldarga_S</summary>
+		/// <param name="n">The (optional) index</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch IsLdarga(int? n = null) => new(instruction => instruction.IsLdarga(n));
+
+		/// <summary>Tests for Starg/Starg_S</summary>
+		/// <param name="n">The (optional) index</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch IsStarg(int? n = null) => new(instruction => instruction.IsStarg(n));
+
+		/// <summary>Tests for any form of Ldloc*</summary>
+		/// <param name="variable">The optional local variable</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch IsLdloc(LocalBuilder variable = null) => new(instruction => instruction.IsLdloc(variable));
+
+		/// <summary>Tests for any form of Stloc*</summary>
+		/// <param name="variable">The optional local variable</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch IsStloc(LocalBuilder variable = null) => new(instruction => instruction.IsStloc(variable));
+
+		/// <summary>Tests if the code instruction calls the method/constructor</summary>
+		/// <param name="method">The method</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch Calls(MethodInfo method) => WithOpcodes(CodeInstructionExtensions.opcodesCalling, method);
+
+		/// <summary>Tests if the code instruction loads a constant</summary>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch LoadsConstant() => new(instruction => instruction.LoadsConstant());
+
+		/// <summary>Tests if the code instruction loads an integer constant</summary>
+		/// <param name="number">The integer constant</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch LoadsConstant(long number) => new(instruction => instruction.LoadsConstant(number));
+
+		/// <summary>Tests if the code instruction loads a floating point constant</summary>
+		/// <param name="number">The floating point constant</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch LoadsConstant(double number) => new(instruction => instruction.LoadsConstant(number));
+
+		/// <summary>Tests if the code instruction loads an enum constant</summary>
+		/// <param name="e">The enum</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch LoadsConstant(Enum e) => new(instruction => instruction.LoadsConstant(e));
+
+		/// <summary>Tests if the code instruction loads a string constant</summary>
+		/// <param name="str">The string</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch LoadsConstant(string str) => new(instruction => instruction.LoadsConstant(str));
+
+		/// <summary>Tests if the code instruction loads a field</summary>
+		/// <param name="field">The field</param>
+		/// <param name="byAddress">Set to true if the address of the field is loaded</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch LoadsField(FieldInfo field, bool byAddress = false) => new(instruction => instruction.LoadsField(field, byAddress));
+
+		/// <summary>Tests if the code instruction stores a field</summary>
+		/// <param name="field">The field</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch StoresField(FieldInfo field) => new(instruction => instruction.StoresField(field));
+
+		/// <summary>Creates a code match that calls a method</summary>
+		/// <param name="expression">The lambda expression using the method</param>
+		/// <returns>A new code match</returns>
+		public static CodeMatch Calls(Expression<Action> expression) => new(expression);
+
+		/// <summary>Creates a code match that calls a method</summary>
+		/// <param name="expression">The lambda expression using the method</param>
+		/// <returns>A new code match</returns>
+		///
+		public static CodeMatch Calls(LambdaExpression expression) => new(expression);
+
 		/// <summary>Creates a code match for local loads</summary>
 		/// <param name="useAddress">Whether to match for address loads</param>
 		/// <param name="name">An optional name</param>
-		/// <returns></returns>
-		public static CodeMatch LoadsLocal(bool useAddress = false, string name = null)
-		{
-			return WithOpcodes(useAddress ? CodeInstructionExtensions.opcodesLoadingLocalByAddress : CodeInstructionExtensions.opcodesLoadingLocalNormal, null, name);
-		}
+		/// <returns>A new code match</returns>
+		public static CodeMatch LoadsLocal(bool useAddress = false, string name = null) => WithOpcodes(useAddress ? CodeInstructionExtensions.opcodesLoadingLocalByAddress : CodeInstructionExtensions.opcodesLoadingLocalNormal, null, name);
 
 		/// <summary>Creates a code match for local stores</summary>
 		/// <param name="name">An optional name</param>
-		/// <returns></returns>
-		public static CodeMatch StoresLocal(string name = null)
-		{
-			return WithOpcodes(CodeInstructionExtensions.opcodesStoringLocal, null, name);
-		}
+		/// <returns>A new code match</returns>
+		public static CodeMatch StoresLocal(string name = null) => WithOpcodes(CodeInstructionExtensions.opcodesStoringLocal, null, name);
 
 		/// <summary>Creates a code match for argument loads</summary>
 		/// <param name="useAddress">Whether to match for address loads</param>
 		/// <param name="name">An optional name</param>
-		/// <returns></returns>
-		public static CodeMatch LoadsArgument(bool useAddress = false, string name = null)
-		{
-			return WithOpcodes(useAddress ? CodeInstructionExtensions.opcodesLoadingArgumentByAddress : CodeInstructionExtensions.opcodesLoadingArgumentNormal, null, name);
-		}
+		/// <returns>A new code match</returns>
+		public static CodeMatch LoadsArgument(bool useAddress = false, string name = null) => WithOpcodes(useAddress ? CodeInstructionExtensions.opcodesLoadingArgumentByAddress : CodeInstructionExtensions.opcodesLoadingArgumentNormal, null, name);
 
 		/// <summary>Creates a code match for argument stores</summary>
 		/// <param name="name">An optional name</param>
-		/// <returns></returns>
-		public static CodeMatch StoresArgument(string name = null)
-		{
-			return WithOpcodes(CodeInstructionExtensions.opcodesStoringArgument, null, name);
-		}
+		/// <returns>A new code match</returns>
+		public static CodeMatch StoresArgument(string name = null) => WithOpcodes(CodeInstructionExtensions.opcodesStoringArgument, null, name);
 
 		/// <summary>Creates a code match for branching</summary>
 		/// <param name="name">An optional name</param>
-		/// <returns></returns>
-		public static CodeMatch Branches(string name = null)
-		{
-			return WithOpcodes(CodeInstructionExtensions.opcodesBranching, null, name);
-		}
+		/// <returns>A new code match</returns>
+		public static CodeMatch Branches(string name = null) => WithOpcodes(CodeInstructionExtensions.opcodesBranching, null, name);
 
 		/// <summary>Returns a string that represents the match</summary>
 		/// <returns>A string representation</returns>
diff --git a/Harmony/Tools/CodeMatcher.cs b/Harmony/Tools/CodeMatcher.cs
index 5bbbae5f..8d49ca6b 100644
--- a/Harmony/Tools/CodeMatcher.cs
+++ b/Harmony/Tools/CodeMatcher.cs
@@ -22,15 +22,9 @@ public class CodeMatcher
 		private delegate CodeMatcher MatchDelegate();
 		private MatchDelegate lastMatchCall;
 
-		private void FixStart()
-		{
-			Pos = Math.Max(0, Pos);
-		}
+		private void FixStart() => Pos = Math.Max(0, Pos);
 
-		private void SetOutOfBounds(int direction)
-		{
-			Pos = direction > 0 ? Length : -1;
-		}
+		private void SetOutOfBounds(int direction) => Pos = direction > 0 ? Length : -1;
 
 		/// <summary>Gets the number of code instructions in this matcher</summary>
 		/// <value>The count</value>
@@ -110,35 +104,23 @@ public CodeMatcher Clone()
 		/// <param name="offset">The offset</param>
 		/// <returns>The instruction</returns>
 		///
-		public CodeInstruction InstructionAt(int offset)
-		{
-			return codes[Pos + offset];
-		}
+		public CodeInstruction InstructionAt(int offset) => codes[Pos + offset];
 
 		/// <summary>Gets all instructions</summary>
 		/// <returns>A list of instructions</returns>
 		///
-		public List<CodeInstruction> Instructions()
-		{
-			return codes;
-		}
+		public List<CodeInstruction> Instructions() => codes;
 
 		/// <summary>Gets all instructions as an enumeration</summary>
 		/// <returns>A list of instructions</returns>
 		///
-		public IEnumerable<CodeInstruction> InstructionEnumeration()
-		{
-			return codes.AsEnumerable();
-		}
+		public IEnumerable<CodeInstruction> InstructionEnumeration() => codes.AsEnumerable();
 
 		/// <summary>Gets some instructions counting from current position</summary>
 		/// <param name="count">Number of instructions</param>
 		/// <returns>A list of instructions</returns>
 		///
-		public List<CodeInstruction> Instructions(int count)
-		{
-			return codes.GetRange(Pos, count).Select(c => new CodeInstruction(c)).ToList();
-		}
+		public List<CodeInstruction> Instructions(int count) => codes.GetRange(Pos, count).Select(c => new CodeInstruction(c)).ToList();
 
 		/// <summary>Gets all instructions within a range</summary>
 		/// <param name="start">The start index</param>
@@ -160,19 +142,13 @@ public List<CodeInstruction> InstructionsInRange(int start, int end)
 		/// <param name="endOffset">The end offset</param>
 		/// <returns>A list of instructions</returns>
 		///
-		public List<CodeInstruction> InstructionsWithOffsets(int startOffset, int endOffset)
-		{
-			return InstructionsInRange(Pos + startOffset, Pos + endOffset);
-		}
+		public List<CodeInstruction> InstructionsWithOffsets(int startOffset, int endOffset) => InstructionsInRange(Pos + startOffset, Pos + endOffset);
 
 		/// <summary>Gets a list of all distinct labels</summary>
 		/// <param name="instructions">The instructions (transpiler argument)</param>
 		/// <returns>A list of Labels</returns>
 		///
-		public List<Label> DistinctLabels(IEnumerable<CodeInstruction> instructions)
-		{
-			return instructions.SelectMany(instruction => instruction.labels).Distinct().ToList();
-		}
+		public List<Label> DistinctLabels(IEnumerable<CodeInstruction> instructions) => instructions.SelectMany(instruction => instruction.labels).Distinct().ToList();
 
 		/// <summary>Reports a failure</summary>
 		/// <param name="method">The method involved</param>
@@ -331,6 +307,27 @@ public CodeMatcher SetOperandAndAdvance(object operand)
 			return this;
 		}
 
+		/// <summary>Declares a local variable but does not add it</summary>
+		/// <param name="variableType">The variable type</param>
+		/// <param name="localVariable">[out] The new local variable</param>
+		/// <returns>The same code matcher</returns>
+		///
+		public CodeMatcher DeclareLocal(Type variableType, out LocalBuilder localVariable)
+		{
+			localVariable = generator.DeclareLocal(variableType);
+			return this;
+		}
+
+		/// <summary>Declares a new label but does not add it</summary>
+		/// <param name="label">[out] The new label</param>
+		/// <returns>The same code matcher</returns>
+		///
+		public CodeMatcher DefineLabel(out Label label)
+		{
+			label = generator.DefineLabel();
+			return this;
+		}
+
 		/// <summary>Creates a label at current position</summary>
 		/// <param name="label">[out] The label</param>
 		/// <returns>The same code matcher</returns>
@@ -350,7 +347,7 @@ public CodeMatcher CreateLabel(out Label label)
 		public CodeMatcher CreateLabelAt(int position, out Label label)
 		{
 			label = generator.DefineLabel();
-			_ = AddLabelsAt(position, new[] { label });
+			_ = AddLabelsAt(position, [label]);
 			return this;
 		}
 
@@ -362,7 +359,7 @@ public CodeMatcher CreateLabelAt(int position, out Label label)
 		public CodeMatcher CreateLabelWithOffsets(int offset, out Label label)
 		{
 			label = generator.DefineLabel();
-			return AddLabelsAt(Pos + offset, new[] { label });
+			return AddLabelsAt(Pos + offset, [label]);
 		}
 
 		/// <summary>Adds an enumeration of labels to current position</summary>
@@ -506,10 +503,7 @@ public CodeMatcher RemoveInstructionsInRange(int start, int end)
 		/// <param name="endOffset">The end offset</param>
 		/// <returns>The same code matcher</returns>
 		///
-		public CodeMatcher RemoveInstructionsWithOffsets(int startOffset, int endOffset)
-		{
-			return RemoveInstructionsInRange(Pos + startOffset, Pos + endOffset);
-		}
+		public CodeMatcher RemoveInstructionsWithOffsets(int startOffset, int endOffset) => RemoveInstructionsInRange(Pos + startOffset, Pos + endOffset);
 
 		/// <summary>Advances the current position</summary>
 		/// <param name="offset">The offset</param>
@@ -544,19 +538,13 @@ public CodeMatcher End()
 		/// <param name="predicate">The predicate</param>
 		/// <returns>The same code matcher</returns>
 		///
-		public CodeMatcher SearchForward(Func<CodeInstruction, bool> predicate)
-		{
-			return Search(predicate, 1);
-		}
+		public CodeMatcher SearchForward(Func<CodeInstruction, bool> predicate) => Search(predicate, 1);
 
 		/// <summary>Searches backwards with a predicate and reverses position</summary>
 		/// <param name="predicate">The predicate</param>
 		/// <returns>The same code matcher</returns>
 		///
-		public CodeMatcher SearchBackwards(Func<CodeInstruction, bool> predicate)
-		{
-			return Search(predicate, -1);
-		}
+		public CodeMatcher SearchBackwards(Func<CodeInstruction, bool> predicate) => Search(predicate, -1);
 
 		private CodeMatcher Search(Func<CodeInstruction, bool> predicate, int direction)
 		{
@@ -571,37 +559,25 @@ private CodeMatcher Search(Func<CodeInstruction, bool> predicate, int direction)
 		/// <param name="matches">Some code matches</param>
 		/// <returns>The same code matcher</returns>
 		///
-		public CodeMatcher MatchStartForward(params CodeMatch[] matches)
-		{
-			return Match(matches, 1, false);
-		}
+		public CodeMatcher MatchStartForward(params CodeMatch[] matches) => Match(matches, 1, false);
 
 		/// <summary>Matches forward and advances position to ending of matching sequence</summary>
 		/// <param name="matches">Some code matches</param>
 		/// <returns>The same code matcher</returns>
 		///
-		public CodeMatcher MatchEndForward(params CodeMatch[] matches)
-		{
-			return Match(matches, 1, true);
-		}
+		public CodeMatcher MatchEndForward(params CodeMatch[] matches) => Match(matches, 1, true);
 
 		/// <summary>Matches backwards and reverses position to beginning of matching sequence</summary>
 		/// <param name="matches">Some code matches</param>
 		/// <returns>The same code matcher</returns>
 		///
-		public CodeMatcher MatchStartBackwards(params CodeMatch[] matches)
-		{
-			return Match(matches, -1, false);
-		}
+		public CodeMatcher MatchStartBackwards(params CodeMatch[] matches) => Match(matches, -1, false);
 
 		/// <summary>Matches backwards and reverses position to ending of matching sequence</summary>
 		/// <param name="matches">Some code matches</param>
 		/// <returns>The same code matcher</returns>
 		///
-		public CodeMatcher MatchEndBackwards(params CodeMatch[] matches)
-		{
-			return Match(matches, -1, true);
-		}
+		public CodeMatcher MatchEndBackwards(params CodeMatch[] matches) => Match(matches, -1, true);
 
 		private CodeMatcher Match(CodeMatch[] matches, int direction, bool useEnd)
 		{
@@ -655,10 +631,7 @@ public CodeMatcher Repeat(Action<CodeMatcher> matchAction, Action<string> notFou
 		/// <param name="name">The match name</param>
 		/// <returns>An instruction</returns>
 		///
-		public CodeInstruction NamedMatch(string name)
-		{
-			return lastMatches[name];
-		}
+		public CodeInstruction NamedMatch(string name) => lastMatches[name];
 
 		private bool MatchSequence(int start, CodeMatch[] matches)
 		{
diff --git a/Harmony/Tools/Extensions.cs b/Harmony/Tools/Extensions.cs
index c8ff9ab2..efe75f42 100644
--- a/Harmony/Tools/Extensions.cs
+++ b/Harmony/Tools/Extensions.cs
@@ -54,7 +54,13 @@ public static string FullDescription(this Type type)
 				var subTypes = type.GetGenericArguments();
 				for (var i = 0; i < subTypes.Length; i++)
 				{
-					if (result.EndsWith("<", StringComparison.Ordinal) is false)
+					if (result
+#if NET8_0_OR_GREATER
+					.EndsWith('<')
+#else
+					.EndsWith("<", StringComparison.Ordinal)
+#endif
+					is false)
 						result += ", ";
 					result += subTypes[i].FullDescription();
 				}
@@ -88,10 +94,7 @@ public static string FullDescription(this MethodBase member)
 		/// <param name="pinfo">The array of parameter infos</param>
 		/// <returns>An array of types</returns>
 		///
-		public static Type[] Types(this ParameterInfo[] pinfo)
-		{
-			return pinfo.Select(pi => pi.ParameterType).ToArray();
-		}
+		public static Type[] Types(this ParameterInfo[] pinfo) => pinfo.Select(pi => pi.ParameterType).ToArray();
 
 		/// <summary>A helper to access a value via key from a dictionary</summary>
 		/// <typeparam name="S">The key type</typeparam>
@@ -271,10 +274,7 @@ public static class CodeInstructionExtensions
 		/// <summary>Returns if an <see cref="OpCode"/> is initialized and valid</summary>
 		/// <param name="code">The <see cref="OpCode"/></param>
 		/// <returns></returns>
-		public static bool IsValid(this OpCode code)
-		{
-			return code.Size > 0;
-		}
+		public static bool IsValid(this OpCode code) => code.Size > 0;
 
 		/// <summary>Shortcut for testing whether the operand is equal to a non-null value</summary>
 		/// <param name="code">The <see cref="CodeInstruction"/></param>
@@ -313,10 +313,7 @@ public static bool OperandIs(this CodeInstruction code, MemberInfo value)
 		/// <param name="operand">The operand value</param>
 		/// <returns>True if the opcode is equal to the given opcode and the operand has the same type and is equal to the given operand</returns>
 		///
-		public static bool Is(this CodeInstruction code, OpCode opcode, object operand)
-		{
-			return code.opcode == opcode && code.OperandIs(operand);
-		}
+		public static bool Is(this CodeInstruction code, OpCode opcode, object operand) => code.opcode == opcode && code.OperandIs(operand);
 
 		/// <summary>Shortcut for <code>code.opcode == opcode &amp;&amp; code.OperandIs(operand)</code></summary>
 		/// <param name="code">The <see cref="CodeInstruction"/></param>
@@ -326,10 +323,7 @@ public static bool Is(this CodeInstruction code, OpCode opcode, object operand)
 		/// <remarks>This is an optimized version of <see cref="Is(CodeInstruction, OpCode, object)"/> for <see cref="MemberInfo"/></remarks>
 		///
 		[EditorBrowsable(EditorBrowsableState.Never)]
-		public static bool Is(this CodeInstruction code, OpCode opcode, MemberInfo operand)
-		{
-			return code.opcode == opcode && code.OperandIs(operand);
-		}
+		public static bool Is(this CodeInstruction code, OpCode opcode, MemberInfo operand) => code.opcode == opcode && code.OperandIs(operand);
 
 		/// <summary>Tests for any form of Ldarg*</summary>
 		/// <param name="code">The <see cref="CodeInstruction"/></param>
@@ -425,10 +419,7 @@ public static bool Calls(this CodeInstruction code, MethodInfo method)
 		/// <param name="code">The <see cref="CodeInstruction"/></param>
 		/// <returns>True if the instruction loads a constant</returns>
 		///
-		public static bool LoadsConstant(this CodeInstruction code)
-		{
-			return constantLoadingCodes.Contains(code.opcode);
-		}
+		public static bool LoadsConstant(this CodeInstruction code) => constantLoadingCodes.Contains(code.opcode);
 
 		/// <summary>Tests if the code instruction loads an integer constant</summary>
 		/// <param name="code">The <see cref="CodeInstruction"/></param>
@@ -469,10 +460,7 @@ public static bool LoadsConstant(this CodeInstruction code, double number)
 		/// <param name="e">The enum</param>
 		/// <returns>True if the instruction loads the constant</returns>
 		///
-		public static bool LoadsConstant(this CodeInstruction code, Enum e)
-		{
-			return code.LoadsConstant(Convert.ToInt64(e));
-		}
+		public static bool LoadsConstant(this CodeInstruction code, Enum e) => code.LoadsConstant(Convert.ToInt64(e));
 
 		/// <summary>Tests if the code instruction loads a string constant</summary>
 		/// <param name="code">The <see cref="CodeInstruction"/></param>
@@ -592,10 +580,7 @@ public static CodeInstruction MoveLabelsTo(this CodeInstruction code, CodeInstru
 		/// <param name="code">The <see cref="CodeInstruction"/> to move the labels to</param>
 		/// <param name="other">The other <see cref="CodeInstruction"/> to move the labels from</param>
 		/// <returns>The code instruction that received the labels</returns>
-		public static CodeInstruction MoveLabelsFrom(this CodeInstruction code, CodeInstruction other)
-		{
-			return code.WithLabels(other.ExtractLabels());
-		}
+		public static CodeInstruction MoveLabelsFrom(this CodeInstruction code, CodeInstruction other) => code.WithLabels(other.ExtractLabels());
 
 		/// <summary>Adds ExceptionBlocks to the code instruction and return it</summary>
 		/// <param name="code">The <see cref="CodeInstruction"/></param>
@@ -641,10 +626,7 @@ public static CodeInstruction MoveBlocksTo(this CodeInstruction code, CodeInstru
 		/// <param name="code">The <see cref="CodeInstruction"/> to move the ExceptionBlocks to</param>
 		/// <param name="other">The other <see cref="CodeInstruction"/> to move the ExceptionBlocks from</param>
 		/// <returns>The code instruction that received the blocks</returns>
-		public static CodeInstruction MoveBlocksFrom(this CodeInstruction code, CodeInstruction other)
-		{
-			return code.WithBlocks(other.ExtractBlocks());
-		}
+		public static CodeInstruction MoveBlocksFrom(this CodeInstruction code, CodeInstruction other) => code.WithBlocks(other.ExtractBlocks());
 	}
 
 	/// <summary>Extensions for a sequence of <see cref="CodeInstruction"/></summary>
@@ -655,10 +637,7 @@ public static class CodeInstructionsExtensions
 		/// <param name="instructions">The CodeInstructions (like a body of a method) to search in</param>
 		/// <param name="matches">An array of <see cref="CodeMatch"/> representing the sequence of codes you want to search for</param>
 		/// <returns></returns>
-		public static bool Matches(this IEnumerable<CodeInstruction> instructions, CodeMatch[] matches)
-		{
-			return new CodeMatcher(instructions).MatchStartForward(matches).IsValid;
-		}
+		public static bool Matches(this IEnumerable<CodeInstruction> instructions, CodeMatch[] matches) => new CodeMatcher(instructions).MatchStartForward(matches).IsValid;
 	}
 
 	/// <summary>General extensions for collections</summary>
@@ -683,10 +662,7 @@ public static void Do<T>(this IEnumerable<T> sequence, Action<T> action)
 		/// <param name="condition">The predicate</param>
 		/// <param name="action">The action to execute</param>
 		///
-		public static void DoIf<T>(this IEnumerable<T> sequence, Func<T, bool> condition, Action<T> action)
-		{
-			sequence.Where(condition).Do(action);
-		}
+		public static void DoIf<T>(this IEnumerable<T> sequence, Func<T, bool> condition, Action<T> action) => sequence.Where(condition).Do(action);
 
 		/// <summary>A helper to add an item to a collection</summary>
 		/// <typeparam name="T">The inner type of the collection</typeparam>
@@ -694,10 +670,7 @@ public static void DoIf<T>(this IEnumerable<T> sequence, Func<T, bool> condition
 		/// <param name="item">The item to add</param>
 		/// <returns>The collection containing the item</returns>
 		///
-		public static IEnumerable<T> AddItem<T>(this IEnumerable<T> sequence, T item)
-		{
-			return (sequence ?? Enumerable.Empty<T>()).Concat(new[] { item });
-		}
+		public static IEnumerable<T> AddItem<T>(this IEnumerable<T> sequence, T item) => (sequence ?? []).Concat([item]);
 
 		/// <summary>A helper to add an item to an array</summary>
 		/// <typeparam name="T">The inner type of the collection</typeparam>
@@ -705,10 +678,7 @@ public static IEnumerable<T> AddItem<T>(this IEnumerable<T> sequence, T item)
 		/// <param name="item">The item to add</param>
 		/// <returns>The array containing the item</returns>
 		///
-		public static T[] AddToArray<T>(this T[] sequence, T item)
-		{
-			return AddItem(sequence, item).ToArray();
-		}
+		public static T[] AddToArray<T>(this T[] sequence, T item) => AddItem(sequence, item).ToArray();
 
 		/// <summary>A helper to add items to an array</summary>
 		/// <typeparam name="T">The inner type of the collection</typeparam>
@@ -716,10 +686,7 @@ public static T[] AddToArray<T>(this T[] sequence, T item)
 		/// <param name="items">The items to add</param>
 		/// <returns>The array containing the items</returns>
 		///
-		public static T[] AddRangeToArray<T>(this T[] sequence, T[] items)
-		{
-			return (sequence ?? Enumerable.Empty<T>()).Concat(items).ToArray();
-		}
+		public static T[] AddRangeToArray<T>(this T[] sequence, T[] items) => (sequence ?? Enumerable.Empty<T>()).Concat(items).ToArray();
 
 		// TODO: Should these be made public?
 		// These extension methods may collide with extension methods from other libraries users may be using,
@@ -760,9 +727,6 @@ public static class MethodBaseExtensions
 		/// <summary>Tests a class member if it has an IL method body (external methods for example don't have a body)</summary>
 		/// <param name="member">The member to test</param>
 		/// <returns>Returns true if the member has an IL body or false if not</returns>
-		public static bool HasMethodBody(this MethodBase member)
-		{
-			return (member.GetMethodBody()?.GetILAsByteArray()?.Length ?? 0) > 0;
-		}
+		public static bool HasMethodBody(this MethodBase member) => (member.GetMethodBody()?.GetILAsByteArray()?.Length ?? 0) > 0;
 	}
 }
diff --git a/Harmony/Tools/FileLog.cs b/Harmony/Tools/FileLog.cs
index 4f8ec8ba..b2d1e7d9 100644
--- a/Harmony/Tools/FileLog.cs
+++ b/Harmony/Tools/FileLog.cs
@@ -62,10 +62,7 @@ public static string LogPath
 
 		static List<string> buffer = [];
 
-		static string IndentString()
-		{
-			return new string(indentChar, indentLevel);
-		}
+		static string IndentString() => new(indentChar, indentLevel);
 
 		/// <summary>Changes the indentation level</summary>
 		/// <param name="delta">The value to add to the indentation level</param>
diff --git a/Harmony/Tools/SymbolExtensions.cs b/Harmony/Tools/SymbolExtensions.cs
index b2b4e44c..1eb0f53c 100644
--- a/Harmony/Tools/SymbolExtensions.cs
+++ b/Harmony/Tools/SymbolExtensions.cs
@@ -12,20 +12,14 @@ public static class SymbolExtensions
 		/// <param name="expression">The lambda expression using the method</param>
 		/// <returns>The method in the lambda expression</returns>
 		///
-		public static MethodInfo GetMethodInfo(Expression<Action> expression)
-		{
-			return GetMethodInfo((LambdaExpression)expression);
-		}
+		public static MethodInfo GetMethodInfo(Expression<Action> expression) => GetMethodInfo((LambdaExpression)expression);
 
 		/// <summary>Given a lambda expression that calls a method, returns the method info</summary>
 		/// <typeparam name="T">The generic type</typeparam>
 		/// <param name="expression">The lambda expression using the method</param>
 		/// <returns>The method in the lambda expression</returns>
 		///
-		public static MethodInfo GetMethodInfo<T>(Expression<Action<T>> expression)
-		{
-			return GetMethodInfo((LambdaExpression)expression);
-		}
+		public static MethodInfo GetMethodInfo<T>(Expression<Action<T>> expression) => GetMethodInfo((LambdaExpression)expression);
 
 		/// <summary>Given a lambda expression that calls a method, returns the method info</summary>
 		/// <typeparam name="T">The generic type</typeparam>
@@ -33,10 +27,7 @@ public static MethodInfo GetMethodInfo<T>(Expression<Action<T>> expression)
 		/// <param name="expression">The lambda expression using the method</param>
 		/// <returns>The method in the lambda expression</returns>
 		///
-		public static MethodInfo GetMethodInfo<T, TResult>(Expression<Func<T, TResult>> expression)
-		{
-			return GetMethodInfo((LambdaExpression)expression);
-		}
+		public static MethodInfo GetMethodInfo<T, TResult>(Expression<Func<T, TResult>> expression) => GetMethodInfo((LambdaExpression)expression);
 
 		/// <summary>Given a lambda expression that calls a method, returns the method info</summary>
 		/// <param name="expression">The lambda expression using the method</param>
diff --git a/Harmony/Tools/Tools.cs b/Harmony/Tools/Tools.cs
index 0e490a12..c20a83cf 100644
--- a/Harmony/Tools/Tools.cs
+++ b/Harmony/Tools/Tools.cs
@@ -58,7 +58,7 @@ internal static FieldRef<T, F> FieldRefAccess<T, F>(FieldInfo fieldInfo, bool ne
 			var declaringType = fieldInfo.DeclaringType;
 
 			var dm = new DynamicMethodDefinition($"__refget_{delegateInstanceType.Name}_fi_{fieldInfo.Name}",
-				typeof(F).MakeByRefType(), new[] { delegateInstanceType });
+				typeof(F).MakeByRefType(), [delegateInstanceType]);
 
 			var il = dm.GetILGenerator();
 			// Backwards compatibility: This supports static fields, even those defined in structs.
@@ -88,7 +88,7 @@ internal static StructFieldRef<T, F> StructFieldRefAccess<T, F>(FieldInfo fieldI
 			ValidateFieldType<F>(fieldInfo);
 
 			var dm = new DynamicMethodDefinition($"__refget_{typeof(T).Name}_struct_fi_{fieldInfo.Name}",
-				typeof(F).MakeByRefType(), new[] { typeof(T).MakeByRefType() });
+				typeof(F).MakeByRefType(), [typeof(T).MakeByRefType()]);
 
 			var il = dm.GetILGenerator();
 			il.Emit(OpCodes.Ldarg_0);
@@ -105,7 +105,7 @@ internal static FieldRef<F> StaticFieldRefAccess<F>(FieldInfo fieldInfo)
 			ValidateFieldType<F>(fieldInfo);
 
 			var dm = new DynamicMethodDefinition($"__refget_{fieldInfo.DeclaringType?.Name ?? "null"}_static_fi_{fieldInfo.Name}",
-				typeof(F).MakeByRefType(), new Type[0]);
+				typeof(F).MakeByRefType(), []);
 
 			var il = dm.GetILGenerator();
 			il.Emit(OpCodes.Ldsflda, fieldInfo);
diff --git a/Harmony/Tools/Traverse.cs b/Harmony/Tools/Traverse.cs
index 4fde1063..2dbb0b4c 100644
--- a/Harmony/Tools/Traverse.cs
+++ b/Harmony/Tools/Traverse.cs
@@ -20,10 +20,7 @@ public class Traverse<T>
 		/// <summary>Creates a traverse instance from an existing instance</summary>
 		/// <param name="traverse">The existing <see cref="Traverse"/> instance</param>
 		///
-		public Traverse(Traverse traverse)
-		{
-			this.traverse = traverse;
-		}
+		public Traverse(Traverse traverse) => this.traverse = traverse;
 
 		/// <summary>Gets/Sets the current value</summary>
 		/// <value>The value to read or write</value>
@@ -48,46 +45,31 @@ public class Traverse
 		readonly object[] _params;
 
 		[MethodImpl(MethodImplOptions.Synchronized)]
-		static Traverse()
-		{
-			Cache ??= new AccessCache();
-		}
+		static Traverse() => Cache ??= new AccessCache();
 
 		/// <summary>Creates a new traverse instance from a class/type</summary>
 		/// <param name="type">The class/type</param>
 		/// <returns>A <see cref="Traverse"/> instance</returns>
 		///
-		public static Traverse Create(Type type)
-		{
-			return new Traverse(type);
-		}
+		public static Traverse Create(Type type) => new(type);
 
 		/// <summary>Creates a new traverse instance from a class T</summary>
 		/// <typeparam name="T">The class</typeparam>
 		/// <returns>A <see cref="Traverse"/> instance</returns>
 		///
-		public static Traverse Create<T>()
-		{
-			return Create(typeof(T));
-		}
+		public static Traverse Create<T>() => Create(typeof(T));
 
 		/// <summary>Creates a new traverse instance from an instance</summary>
 		/// <param name="root">The object</param>
 		/// <returns>A <see cref="Traverse"/> instance</returns>
 		///
-		public static Traverse Create(object root)
-		{
-			return new Traverse(root);
-		}
+		public static Traverse Create(object root) => new(root);
 
 		/// <summary>Creates a new traverse instance from a named type</summary>
 		/// <param name="name">The type name, for format see <see cref="AccessTools.TypeByName"/></param>
 		/// <returns>A <see cref="Traverse"/> instance</returns>
 		///
-		public static Traverse CreateWithType(string name)
-		{
-			return new Traverse(AccessTools.TypeByName(name));
-		}
+		public static Traverse CreateWithType(string name) => new(AccessTools.TypeByName(name));
 
 		/// <summary>Creates a new and empty traverse instance</summary>
 		///
@@ -98,10 +80,7 @@ public static Traverse CreateWithType(string name)
 		/// <summary>Creates a new traverse instance from a class/type</summary>
 		/// <param name="type">The class/type</param>
 		///
-		public Traverse(Type type)
-		{
-			_type = type;
-		}
+		public Traverse(Type type) => _type = type;
 
 		/// <summary>Creates a new traverse instance from an instance</summary>
 		/// <param name="root">The object</param>
@@ -254,10 +233,7 @@ public Traverse Field(string name)
 		/// <param name="name">The type name</param>
 		/// <returns>A traverse instance</returns>
 		///
-		public Traverse<T> Field<T>(string name)
-		{
-			return new Traverse<T>(Field(name));
-		}
+		public Traverse<T> Field<T>(string name) => new(Field(name));
 
 		/// <summary>Gets all fields of the current type</summary>
 		/// <returns>A list of field names</returns>
@@ -289,10 +265,7 @@ public Traverse Property(string name, object[] index = null)
 		/// <param name="index">Optional property index</param>
 		/// <returns>A traverse instance</returns>
 		///
-		public Traverse<T> Property<T>(string name, object[] index = null)
-		{
-			return new Traverse<T>(Property(name, index));
-		}
+		public Traverse<T> Property<T>(string name, object[] index = null) => new(Property(name, index));
 
 		/// <summary>Gets all properties of the current type</summary>
 		/// <returns>A list of property names</returns>
@@ -347,34 +320,22 @@ public List<string> Methods()
 		/// <summary>Checks if the current traverse instance is for a field</summary>
 		/// <returns>True if its a field</returns>
 		///
-		public bool FieldExists()
-		{
-			return _info is not null && _info is FieldInfo;
-		}
+		public bool FieldExists() => _info is not null && _info is FieldInfo;
 
 		/// <summary>Checks if the current traverse instance is for a property</summary>
 		/// <returns>True if its a property</returns>
 		///
-		public bool PropertyExists()
-		{
-			return _info is not null && _info is PropertyInfo;
-		}
+		public bool PropertyExists() => _info is not null && _info is PropertyInfo;
 
 		/// <summary>Checks if the current traverse instance is for a method</summary>
 		/// <returns>True if its a method</returns>
 		///
-		public bool MethodExists()
-		{
-			return _method is not null;
-		}
+		public bool MethodExists() => _method is not null;
 
 		/// <summary>Checks if the current traverse instance is for a type</summary>
 		/// <returns>True if its a type</returns>
 		///
-		public bool TypeExists()
-		{
-			return _type is not null;
-		}
+		public bool TypeExists() => _type is not null;
 
 		/// <summary>Iterates over all fields of the current type and executes a traverse action</summary>
 		/// <param name="source">Original object</param>
diff --git a/HarmonyTests/Extras/Assets/MethodInvokerClasses.cs b/HarmonyTests/Extras/Assets/MethodInvokerClasses.cs
index 7a5ca8eb..bf35ae1d 100644
--- a/HarmonyTests/Extras/Assets/MethodInvokerClasses.cs
+++ b/HarmonyTests/Extras/Assets/MethodInvokerClasses.cs
@@ -3,10 +3,7 @@ namespace HarmonyLibTests.Assets
 	public class TestMethodInvokerObject
 	{
 		public int Value;
-		public void Method1(int a)
-		{
-			Value += a;
-		}
+		public void Method1(int a) => Value += a;
 	}
 
 	public struct TestMethodInvokerStruct
diff --git a/HarmonyTests/Extras/PatchSerialization.cs b/HarmonyTests/Extras/PatchSerialization.cs
index 736a291a..87a8ae6a 100644
--- a/HarmonyTests/Extras/PatchSerialization.cs
+++ b/HarmonyTests/Extras/PatchSerialization.cs
@@ -32,7 +32,7 @@ static string ExpectedJSON()
 		public void Serialize()
 		{
 			var method = SymbolExtensions.GetMethodInfo(() => ExpectedJSON());
-			var hMethod = new HarmonyMethod(method, Priority.High, ["p1", null, "p2"], new string[0], true);
+			var hMethod = new HarmonyMethod(method, Priority.High, ["p1", null, "p2"], [], true);
 
 			var patchInfo = new PatchInfo();
 			patchInfo.AddPrefixes("prefixes", [hMethod]);
@@ -76,7 +76,7 @@ public void Deserialize()
 		public void SerializeAndDeserialize()
 		{
 			var method = SymbolExtensions.GetMethodInfo(() => ExpectedJSON());
-			var hMethod = new HarmonyMethod(method, Priority.High, ["p1", null, "p2"], new string[0], true);
+			var hMethod = new HarmonyMethod(method, Priority.High, ["p1", null, "p2"], [], true);
 
 			var originalPatchInfo = new PatchInfo();
 			originalPatchInfo.AddPrefixes("prefixes", [hMethod]);
diff --git a/HarmonyTests/GlobalSuppressions.cs b/HarmonyTests/GlobalSuppressions.cs
index 209b033d..549481c4 100644
--- a/HarmonyTests/GlobalSuppressions.cs
+++ b/HarmonyTests/GlobalSuppressions.cs
@@ -3,20 +3,26 @@
 [assembly: SuppressMessage("Performance", "CA1802")]
 [assembly: SuppressMessage("Performance", "CA1815")]
 [assembly: SuppressMessage("Performance", "CA1822")]
+[assembly: SuppressMessage("Performance", "CA1859")]
+[assembly: SuppressMessage("Performance", "CA1861")]
+[assembly: SuppressMessage("Performance", "CA1825")]
 
 [assembly: SuppressMessage("Design", "CA1031")]
 [assembly: SuppressMessage("Design", "CA1034")]
 [assembly: SuppressMessage("Design", "CA1052")]
 
-[assembly: SuppressMessage("Code Quality", "IDE0051")]
-
 [assembly: SuppressMessage("", "CS0169")]
 [assembly: SuppressMessage("", "CA1401")]
-[assembly: SuppressMessage("Style", "IDE0066")]
-[assembly: SuppressMessage("Style", "IDE0060")]
+
+[assembly: SuppressMessage("Style", "IDE0044")]
 [assembly: SuppressMessage("Style", "IDE0057")]
+[assembly: SuppressMessage("Style", "IDE0060")]
+[assembly: SuppressMessage("Style", "IDE0066")]
 [assembly: SuppressMessage("Style", "IDE0251")]
+
+[assembly: SuppressMessage("Usage", "CA2208")]
 [assembly: SuppressMessage("Usage", "CA2211")]
-[assembly: SuppressMessage("Performance", "CA1825")]
+
+[assembly: SuppressMessage("Code Quality", "IDE0051")]
 [assembly: SuppressMessage("Interoperability", "SYSLIB1054")]
 [assembly: SuppressMessage("Obsoletions", "SYSLIB0014")]
diff --git a/HarmonyTests/IL/DynamicArgumentPatches.cs b/HarmonyTests/IL/DynamicArgumentPatches.cs
index b301b5b6..2afd1898 100644
--- a/HarmonyTests/IL/DynamicArgumentPatches.cs
+++ b/HarmonyTests/IL/DynamicArgumentPatches.cs
@@ -9,25 +9,15 @@
 
 namespace HarmonyLibTests.IL
 {
-	public struct Vec3
+	public struct Vec3(int v1, int v2, int v3)
 	{
-		public int v1;
-		public int v2;
-		public int v3;
-
-		public Vec3(int v1, int v2, int v3)
-		{
-			this.v1 = v1;
-			this.v2 = v2;
-			this.v3 = v3;
-		}
+		public int v1 = v1;
+		public int v2 = v2;
+		public int v3 = v3;
 
 		public static Vec3 Zero => new(0, 0, 0);
 
-		public override string ToString()
-		{
-			return v1 + "," + v2 + "," + v3;
-		}
+		public override string ToString() => v1 + "," + v2 + "," + v3;
 	}
 
 	public static class TestMethods1
diff --git a/HarmonyTests/IL/TestMethodBodyReader.cs b/HarmonyTests/IL/TestMethodBodyReader.cs
index 518734f7..99e7668b 100644
--- a/HarmonyTests/IL/TestMethodBodyReader.cs
+++ b/HarmonyTests/IL/TestMethodBodyReader.cs
@@ -92,10 +92,7 @@ static void AssertAreEqual(LocalVariableInfo x, LocalVariableInfo y, string labe
 
 		struct ILInstructionOffsetComparer : IComparer
 		{
-			public int Compare(object x, object y)
-			{
-				return ((ILInstruction)x).offset.CompareTo(((ILInstruction)y).offset);
-			}
+			public int Compare(object x, object y) => ((ILInstruction)x).offset.CompareTo(((ILInstruction)y).offset);
 		}
 	}
 }
diff --git a/HarmonyTests/Patching/Arguments.cs b/HarmonyTests/Patching/Arguments.cs
index bc3d864f..c5bff556 100644
--- a/HarmonyTests/Patching/Arguments.cs
+++ b/HarmonyTests/Patching/Arguments.cs
@@ -286,7 +286,7 @@ public void Test_SimpleArgumentArrayUsage()
 			SimpleArgumentArrayUsage.n = 0;
 			SimpleArgumentArrayUsage.s = "";
 			SimpleArgumentArrayUsage.st = new SimpleArgumentArrayUsage.SomeStruct() { n = 0 };
-			SimpleArgumentArrayUsage.f = new float[0];
+			SimpleArgumentArrayUsage.f = [];
 
 			var instance = new SimpleArgumentArrayUsage();
 			instance.Method(
diff --git a/HarmonyTests/Patching/Assets/ArgumentCases.cs b/HarmonyTests/Patching/Assets/ArgumentCases.cs
index 0d31dbbf..fe4f199f 100644
--- a/HarmonyTests/Patching/Assets/ArgumentCases.cs
+++ b/HarmonyTests/Patching/Assets/ArgumentCases.cs
@@ -13,106 +13,55 @@ public struct Value { public int n; }
 	public class ArgumentOriginalMethods
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Object_2_Object(ArgumentTypes.Object p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void Object_2_Object(ArgumentTypes.Object p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Object_2_ObjectRef(ArgumentTypes.Object p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void Object_2_ObjectRef(ArgumentTypes.Object p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void ObjectRef_2_Object(ref ArgumentTypes.Object p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void ObjectRef_2_Object(ref ArgumentTypes.Object p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void ObjectRef_2_ObjectRef(ref ArgumentTypes.Object p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void ObjectRef_2_ObjectRef(ref ArgumentTypes.Object p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Value_2_Value(ArgumentTypes.Value p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void Value_2_Value(ArgumentTypes.Value p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Value_2_Boxing(ArgumentTypes.Value p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void Value_2_Boxing(ArgumentTypes.Value p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Value_2_ValueRef(ArgumentTypes.Value p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void Value_2_ValueRef(ArgumentTypes.Value p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Value_2_BoxingRef(ArgumentTypes.Value p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void Value_2_BoxingRef(ArgumentTypes.Value p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void ValueRef_2_Value(ref ArgumentTypes.Value p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void ValueRef_2_Value(ref ArgumentTypes.Value p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void ValueRef_2_Boxing(ref ArgumentTypes.Value p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void ValueRef_2_Boxing(ref ArgumentTypes.Value p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void ValueRef_2_ValueRef(ref ArgumentTypes.Value p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void ValueRef_2_ValueRef(ref ArgumentTypes.Value p) => Console.WriteLine("ok");
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void ValueRef_2_BoxingRef(ref ArgumentTypes.Value p)
-		{
-			Console.WriteLine("ok");
-		}
+		public void ValueRef_2_BoxingRef(ref ArgumentTypes.Value p) => Console.WriteLine("ok");
 	}
 
 	public static class ArgumentPatchMethods
 	{
 		public static string result;
 
-		public static void Reset()
-		{
-			result = "";
-		}
+		public static void Reset() => result = "";
 
-		public static void To_Object(ArgumentTypes.Object p)
-		{
-			result += p.GetType().Name[0];
-		}
+		public static void To_Object(ArgumentTypes.Object p) => result += p.GetType().Name[0];
 
-		public static void To_Value(ArgumentTypes.Value p)
-		{
-			result += p.GetType().Name[0];
-		}
+		public static void To_Value(ArgumentTypes.Value p) => result += p.GetType().Name[0];
 
-		public static void To_Boxing(object p)
-		{
-			result += p.GetType().Name[0];
-		}
+		public static void To_Boxing(object p) => result += p.GetType().Name[0];
 
-		public static void To_ObjectRef(ref ArgumentTypes.Object p)
-		{
-			result += p.GetType().Name[0];
-		}
+		public static void To_ObjectRef(ref ArgumentTypes.Object p) => result += p.GetType().Name[0];
 
 		public static void To_ValueRef(ref ArgumentTypes.Value p)
 		{
diff --git a/HarmonyTests/Patching/Assets/CombinedPatchClass.cs b/HarmonyTests/Patching/Assets/CombinedPatchClass.cs
index 1046fa63..588a9915 100644
--- a/HarmonyTests/Patching/Assets/CombinedPatchClass.cs
+++ b/HarmonyTests/Patching/Assets/CombinedPatchClass.cs
@@ -19,10 +19,7 @@ public void Method1()
 		}
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public string Method2(string str)
-		{
-			return str;
-		}
+		public string Method2(string str) => str;
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
 		public void Method3(int n)
@@ -60,10 +57,7 @@ static void Postfix2(ref string __result)
 
 		[HarmonyFinalizer]
 		[HarmonyPatch(typeof(CombinedPatchClass), "Method3")]
-		static void Finalizer3()
-		{
-			counter += 100;
-		}
+		static void Finalizer3() => counter += 100;
 
 		[HarmonyFinalizer]
 		[HarmonyPatch(typeof(CombinedPatchClass), "Method3")]
diff --git a/HarmonyTests/Patching/Assets/FinalizerPatchClasses.cs b/HarmonyTests/Patching/Assets/FinalizerPatchClasses.cs
index d6c53804..18fa8b2d 100644
--- a/HarmonyTests/Patching/Assets/FinalizerPatchClasses.cs
+++ b/HarmonyTests/Patching/Assets/FinalizerPatchClasses.cs
@@ -9,10 +9,7 @@ public class OriginalException : Exception
 		public OriginalException() { }
 		public OriginalException(string message) : base(message) { }
 		public OriginalException(string message, Exception innerException) : base(message, innerException) { }
-		protected OriginalException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext)
-		{
-			throw new NotImplementedException();
-		}
+		protected OriginalException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) => throw new NotImplementedException();
 	}
 
 	[Serializable]
@@ -21,10 +18,7 @@ public class ReplacedException : Exception
 		public ReplacedException() { }
 		public ReplacedException(string message) : base(message) { }
 		public ReplacedException(string message, Exception innerException) : base(message, innerException) { }
-		protected ReplacedException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext)
-		{
-			throw new NotImplementedException();
-		}
+		protected ReplacedException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) => throw new NotImplementedException();
 	}
 
 	public class NoThrowingVoidMethod
@@ -45,10 +39,7 @@ public void Method()
 	public class ThrowingVoidMethod
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Method()
-		{
-			throw new OriginalException();
-		}
+		public void Method() => throw new OriginalException();
 	}
 
 	public class NoThrowingStringReturningMethod
@@ -69,10 +60,7 @@ public class ThrowingStringReturningMethod
 		// So for now this is excluded on mono (except for NET Core 3.x where it works)
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public string Method()
-		{
-			throw new OriginalException();
-		}
+		public string Method() => throw new OriginalException();
 	}
 
 	//
@@ -81,10 +69,7 @@ public class EmptyFinalizer
 	{
 		public static bool finalized = false;
 
-		public static void Finalizer()
-		{
-			finalized = true;
-		}
+		public static void Finalizer() => finalized = true;
 	}
 
 	public class EmptyFinalizerWithExceptionArg
diff --git a/HarmonyTests/Patching/Assets/PatchClasses.cs b/HarmonyTests/Patching/Assets/PatchClasses.cs
index 3c4ee52f..73db2e95 100644
--- a/HarmonyTests/Patching/Assets/PatchClasses.cs
+++ b/HarmonyTests/Patching/Assets/PatchClasses.cs
@@ -12,18 +12,12 @@ namespace HarmonyLibTests.Assets
 	public class Class0
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public string Method0()
-		{
-			return "original";
-		}
+		public string Method0() => "original";
 	}
 
 	public class Class0Patch
 	{
-		public static void Postfix(ref string __result)
-		{
-			__result = "patched";
-		}
+		public static void Postfix(ref string __result) => __result = "patched";
 	}
 
 	public class Class1
@@ -53,10 +47,7 @@ public static bool Prefix()
 			return true;
 		}
 
-		public static void Postfix()
-		{
-			postfixed = true;
-		}
+		public static void Postfix() => postfixed = true;
 
 		public static IEnumerable<CodeInstruction> Transpiler(ILGenerator il, IEnumerable<CodeInstruction> instructions)
 		{
@@ -103,16 +94,11 @@ public static bool Prefix()
 			return true;
 		}
 
-		public static void Postfix()
-		{
-			postfixed = true;
-		}
+		public static void Postfix() => postfixed = true;
 
-		public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
-		{
+		public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) =>
 			// no-op / passthrough
-			return instructions;
-		}
+			instructions;
 
 		public static void ResetTest()
 		{
@@ -190,10 +176,7 @@ public static void ResetTest()
 	public class Class5
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Method5(object xxxyyy)
-		{
-			_ = DateTime.Now;
-		}
+		public void Method5(object xxxyyy) => _ = DateTime.Now;
 	}
 
 	public class Class5Patch
@@ -202,17 +185,11 @@ public class Class5Patch
 		public static bool postfixed = false;
 
 		[HarmonyArgument("xxxyyy", "bar")]
-		public static void Prefix(object bar)
-		{
-			prefixed = true;
-		}
+		public static void Prefix(object bar) => prefixed = true;
 
 		public static void Postfix(
 			[HarmonyArgument("xxxyyy")] object bar
-		)
-		{
-			postfixed = true;
-		}
+		) => postfixed = true;
 
 		public static void ResetTest()
 		{
@@ -277,10 +254,7 @@ public TestStruct Method7(string test)
 
 	public static class Class7Patch
 	{
-		public static void Postfix(ref TestStruct __result)
-		{
-			__result = new TestStruct() { a = 10, b = 20 };
-		}
+		public static void Postfix(ref TestStruct __result) => __result = new TestStruct() { a = 10, b = 20 };
 
 		/*
 		public static IEnumerable<CodeInstruction> Transpiler(ILGenerator il, IEnumerable<CodeInstruction> instructions)
@@ -346,26 +320,17 @@ public static TestStruct Method8(string test)
 
 	public class Class8Patch
 	{
-		public static void Postfix(ref TestStruct __result)
-		{
-			__result = new TestStruct() { a = 10, b = 20 };
-		}
+		public static void Postfix(ref TestStruct __result) => __result = new TestStruct() { a = 10, b = 20 };
 	}
 
 	public class Class9
 	{
-		public override string ToString()
-		{
-			return string.Format("foobar");
-		}
+		public override string ToString() => string.Format("foobar");
 	}
 
 	public class Class9Patch
 	{
-		public static void Prefix(out object __state)
-		{
-			__state = null;
-		}
+		public static void Prefix(out object __state) => __state = null;
 
 		public static void Postfix(object __state)
 		{
@@ -402,15 +367,9 @@ public static void Reset()
 
 	public class Struct1Patch
 	{
-		public static void Prefix()
-		{
-			Struct1.prefixed = true;
-		}
+		public static void Prefix() => Struct1.prefixed = true;
 
-		public static void Postfix()
-		{
-			Struct1.postfixed = true;
-		}
+		public static void Postfix() => Struct1.postfixed = true;
 	}
 
 	public struct Struct2NoRef
@@ -418,20 +377,14 @@ public struct Struct2NoRef
 		public string s;
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void TestMethod(string val)
-		{
-			s = val;
-		}
+		public void TestMethod(string val) => s = val;
 	}
 
 	public class Struct2NoRefObjectPatch
 	{
 		public static string s;
 
-		public static void Postfix(Struct2NoRef __instance)
-		{
-			s = __instance.s;
-		}
+		public static void Postfix(Struct2NoRef __instance) => s = __instance.s;
 	}
 
 	public struct Struct2Ref
@@ -439,18 +392,12 @@ public struct Struct2Ref
 		public string s;
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void TestMethod(string val)
-		{
-			s = val;
-		}
+		public void TestMethod(string val) => s = val;
 	}
 
 	public class Struct2RefPatch
 	{
-		public static void Postfix(ref Struct2Ref __instance)
-		{
-			__instance.s = "patched";
-		}
+		public static void Postfix(ref Struct2Ref __instance) => __instance.s = "patched";
 	}
 
 	public struct Struct3NoRefObject
@@ -458,10 +405,7 @@ public struct Struct3NoRefObject
 		public string s;
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void TestMethod(string val)
-		{
-			s = val;
-		}
+		public void TestMethod(string val) => s = val;
 	}
 
 	public class Struct3NoRefObjectPatch
@@ -480,10 +424,7 @@ public struct Struct3RefObject
 		public string s;
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void TestMethod(string val)
-		{
-			s = val;
-		}
+		public void TestMethod(string val) => s = val;
 	}
 
 	public class Struct3RefObjectPatch
@@ -499,10 +440,7 @@ public static void Postfix(ref object __instance)
 	public class AttributesClass
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Method(string foo)
-		{
-			_ = DateTime.Now;
-		}
+		public void Method(string foo) => _ = DateTime.Now;
 	}
 
 	[HarmonyPatch]
@@ -520,16 +458,10 @@ public static MethodBase Patch0()
 		}
 
 		[HarmonyPrefix]
-		public static void Patch1()
-		{
-			prefixed = true;
-		}
+		public static void Patch1() => prefixed = true;
 
 		[HarmonyPostfix]
-		public static void Patch2()
-		{
-			postfixed = true;
-		}
+		public static void Patch2() => postfixed = true;
 
 		public static void ResetTest()
 		{
@@ -606,14 +538,9 @@ public static MethodInfo Prefix(MethodBase method)
 		}
 	}
 
-	public class Class12
+	public class Class12(int count)
 	{
-		readonly int count;
-
-		public Class12(int count)
-		{
-			this.count = count;
-		}
+		readonly int count = count;
 
 		public List<string> FizzBuzz()
 		{
@@ -638,20 +565,11 @@ public class Class13<T> : IEnumerable<T>
 		readonly List<T> store = [];
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public void Add(T item)
-		{
-			store.Add(item);
-		}
+		public void Add(T item) => store.Add(item);
 
-		public IEnumerator<T> GetEnumerator()
-		{
-			return store.GetEnumerator();
-		}
+		public IEnumerator<T> GetEnumerator() => store.GetEnumerator();
 
-		IEnumerator IEnumerable.GetEnumerator()
-		{
-			return store.GetEnumerator();
-		}
+		IEnumerator IEnumerable.GetEnumerator() => store.GetEnumerator();
 	}
 
 	public class Class13Patch
@@ -700,10 +618,7 @@ static bool Prefix0()
 		}
 		[HarmonyPatch(typeof(Class14), "Test", [typeof(string), typeof(KeyValuePair<string, int>)])]
 		[HarmonyPostfix]
-		static void Postfix0()
-		{
-			Class14.state.Add("Postfix0");
-		}
+		static void Postfix0() => Class14.state.Add("Postfix0");
 
 		[HarmonyPatch(typeof(Class14), "Test", [typeof(string), typeof(KeyValuePair<string, int>), typeof(KeyValuePair<string, int>)])]
 		[HarmonyPrefix]
@@ -714,19 +629,13 @@ static bool Prefix1()
 		}
 		[HarmonyPatch(typeof(Class14), "Test", [typeof(string), typeof(KeyValuePair<string, int>), typeof(KeyValuePair<string, int>)])]
 		[HarmonyPostfix]
-		static void Postfix1()
-		{
-			Class14.state.Add("Postfix1");
-		}
+		static void Postfix1() => Class14.state.Add("Postfix1");
 	}
 
 	[HarmonyPatch]
 	public static class Class15Patch
 	{
-		static MethodBase TargetMethod()
-		{
-			return null;
-		}
+		static MethodBase TargetMethod() => null;
 
 		static void Postfix()
 		{
@@ -736,10 +645,7 @@ static void Postfix()
 	[HarmonyPatch]
 	public static class Class16Patch
 	{
-		static string TargetMethod()
-		{
-			return null;
-		}
+		static string TargetMethod() => null;
 
 		static void Postfix()
 		{
@@ -790,53 +696,35 @@ public class MultiplePatches1Patch
 	{
 		[HarmonyPatch(typeof(MultiplePatches1), "TestMethod")]
 		[HarmonyPrefix]
-		public static void Fix1(ref string val)
-		{
-			val += ",prefix1";
-		}
+		public static void Fix1(ref string val) => val += ",prefix1";
 
 		[HarmonyPatch(typeof(MultiplePatches1), "TestMethod")]
 		[HarmonyPrefix]
 		[HarmonyPriority(Priority.High)]
-		public static void Fix2(ref string val)
-		{
-			val += ",prefix2";
-		}
+		public static void Fix2(ref string val) => val += ",prefix2";
 
 		[HarmonyPatch(typeof(MultiplePatches1), "TestMethod")]
 		[HarmonyPostfix]
-		public static void Fix3(ref string __result)
-		{
-			__result += ",postfix";
-		}
+		public static void Fix3(ref string __result) => __result += ",postfix";
 	}
 
 	[HarmonyPatch(typeof(MultiplePatches2), "TestMethod")]
 	public class MultiplePatchesPatch2_Part1
 	{
 		[HarmonyPriority(Priority.Low)]
-		public static void Prefix(ref string val)
-		{
-			val += ",prefix1";
-		}
+		public static void Prefix(ref string val) => val += ",prefix1";
 	}
 
 	[HarmonyPatch(typeof(MultiplePatches2), "TestMethod")]
 	public class MultiplePatchesPatch2_Part2
 	{
-		public static void Prefix(ref string val)
-		{
-			val += ",prefix2";
-		}
+		public static void Prefix(ref string val) => val += ",prefix2";
 	}
 
 	[HarmonyPatch(typeof(MultiplePatches2), "TestMethod")]
 	public class MultiplePatchesPatch2_Part3
 	{
-		public static void Postfix(ref string __result)
-		{
-			__result = "patched";
-		}
+		public static void Postfix(ref string __result) => __result = "patched";
 	}
 
 	public class InjectFieldBase
@@ -864,10 +752,7 @@ public void Method(string val)
 	[HarmonyPatch(typeof(InjectFieldSubClass), nameof(InjectFieldSubClass.Method))]
 	public class InjectFieldSubClass_Patch
 	{
-		public static void Postfix(ref string ___testField)
-		{
-			___testField = "patched";
-		}
+		public static void Postfix(ref string ___testField) => ___testField = "patched";
 	}
 
 	public class Finalizer_Patch_Order_Class
@@ -887,15 +772,9 @@ public class Finalizer_Patch_Order_Patch
 	{
 		public static List<string> events = [];
 
-		public static List<string> GetEvents()
-		{
-			return events;
-		}
+		public static List<string> GetEvents() => events;
 
-		public static void ResetTest()
-		{
-			events = [];
-		}
+		public static void ResetTest() => events = [];
 
 		[HarmonyPrefix]
 		[HarmonyPriority(200)]
@@ -907,17 +786,11 @@ public static bool Bool_Prefix()
 
 		[HarmonyPrefix]
 		[HarmonyPriority(100)]
-		public static void Void_Prefix()
-		{
-			events.Add(nameof(Void_Prefix));
-		}
+		public static void Void_Prefix() => events.Add(nameof(Void_Prefix));
 
 		[HarmonyPostfix]
 		[HarmonyPriority(200)]
-		public static void Simple_Postfix()
-		{
-			events.Add(nameof(Simple_Postfix));
-		}
+		public static void Simple_Postfix() => events.Add(nameof(Simple_Postfix));
 
 		[HarmonyPostfix]
 		[HarmonyPriority(200)]
@@ -969,19 +842,13 @@ public static Exception ClearException_Finalizer()
 
 		[HarmonyFinalizer]
 		[HarmonyPriority(100)]
-		public static void Void_Finalizer(Exception __exception)
-		{
-			events.Add(nameof(Void_Finalizer));
-		}
+		public static void Void_Finalizer(Exception __exception) => events.Add(nameof(Void_Finalizer));
 	}
 
 	public class Affecting_Original_Prefixes_Class
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public string Method(int n)
-		{
-			return $"{n}";
-		}
+		public string Method(int n) => $"{n}";
 	}
 
 	[HarmonyPatch(typeof(Affecting_Original_Prefixes_Class))]
@@ -990,15 +857,9 @@ public class Affecting_Original_Prefixes_Patch
 	{
 		public static List<string> events = [];
 
-		public static List<string> GetEvents()
-		{
-			return events;
-		}
+		public static List<string> GetEvents() => events;
 
-		public static void ResetTest()
-		{
-			events = [];
-		}
+		public static void ResetTest() => events = [];
 
 		[HarmonyPrefix]
 		[HarmonyPriority(500)]
@@ -1011,10 +872,7 @@ public static bool Prefix1(ref string __result)
 
 		[HarmonyPrefix]
 		[HarmonyPriority(400)]
-		public static void Prefix2()
-		{
-			events.Add(nameof(Prefix2));
-		}
+		public static void Prefix2() => events.Add(nameof(Prefix2));
 
 		[HarmonyPrefix]
 		[HarmonyPriority(300)]
@@ -1026,17 +884,11 @@ public static bool Prefix3()
 
 		[HarmonyPrefix]
 		[HarmonyPriority(200)]
-		public static void Prefix4(ref string __result)
-		{
-			events.Add(nameof(Prefix4));
-		}
+		public static void Prefix4(ref string __result) => events.Add(nameof(Prefix4));
 
 		[HarmonyPrefix]
 		[HarmonyPriority(100)]
-		public static void Prefix5()
-		{
-			events.Add(nameof(Prefix5));
-		}
+		public static void Prefix5() => events.Add(nameof(Prefix5));
 	}
 
 	public static class LazyTranspilerRunsOnce_Class
@@ -1064,10 +916,7 @@ public class APIUser
 	public class Class18
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public static UnityColor GetDefaultNameplateColor(APIUser user)
-		{
-			return new UnityColor() { r = 0, g = 0, b = 0, a = 0 };
-		}
+		public static UnityColor GetDefaultNameplateColor(APIUser user) => new() { r = 0, g = 0, b = 0, a = 0 };
 	}
 
 	[HarmonyPatch(typeof(Class18))]
@@ -1090,20 +939,14 @@ public class Class19
 		static readonly string[] test = ["abc"];
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public static ref string Method19()
-		{
-			return ref test[0];
-		}
+		public static ref string Method19() => ref test[0];
 	}
 
 	[HarmonyPatch(typeof(Class19))]
 	[HarmonyPatch(nameof(Class19.Method19))]
 	public static class Class19Patch
 	{
-		public static void Postfix(ref string __result)
-		{
-			__result = "def";
-		}
+		public static void Postfix(ref string __result) => __result = "def";
 	}
 
 	public class Class20
@@ -1114,10 +957,7 @@ public struct Struct20
 		}
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public static Struct20 Method20()
-		{
-			return new Struct20 { value = 123 };
-		}
+		public static Struct20 Method20() => new() { value = 123 };
 	}
 
 	[HarmonyPatch(typeof(Class20))]
@@ -1126,10 +966,7 @@ public static class Class20Patch
 	{
 		public static object theResult;
 
-		public static void Postfix(object __result)
-		{
-			theResult = __result;
-		}
+		public static void Postfix(object __result) => theResult = __result;
 	}
 
 	public class Class21
@@ -1140,20 +977,14 @@ public struct Struct21
 		}
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public static Struct21 Method21()
-		{
-			return new Struct21 { value = 123 };
-		}
+		public static Struct21 Method21() => new() { value = 123 };
 	}
 
 	[HarmonyPatch(typeof(Class21))]
 	[HarmonyPatch(nameof(Class21.Method21))]
 	public static class Class21Patch
 	{
-		public static void Postfix(ref object __result)
-		{
-			__result = new Class21.Struct21 { value = 456 };
-		}
+		public static void Postfix(ref object __result) => __result = new Class21.Struct21 { value = 456 };
 	}
 
 	[HarmonyPatch(typeof(Class22), nameof(Method22))]
@@ -1191,16 +1022,10 @@ public static bool Prefix2(bool __runOriginal)
 		}
 
 		[HarmonyPrefix]
-		public static void Prefix3(bool __runOriginal)
-		{
-			bool3 = __runOriginal;
-		}
+		public static void Prefix3(bool __runOriginal) => bool3 = __runOriginal;
 
 		[HarmonyPostfix]
-		public static void Postfix(bool __runOriginal)
-		{
-			bool4 = __runOriginal;
-		}
+		public static void Postfix(bool __runOriginal) => bool4 = __runOriginal;
 	}
 
 	[HarmonyPatch(typeof(Class22b), nameof(Method22b))]
@@ -1225,10 +1050,7 @@ public static bool Prefix(bool __runOriginal)
 			return prefixResult;
 		}
 
-		public static void Postfix(bool __runOriginal)
-		{
-			runOriginalPost = __runOriginal;
-		}
+		public static void Postfix(bool __runOriginal) => runOriginalPost = __runOriginal;
 	}
 
 	[HarmonyPatch(typeof(Class23), nameof(Method23))]
@@ -1248,10 +1070,7 @@ public static void Method23()
 			}
 		}
 
-		public static void Postfix(bool __runOriginal)
-		{
-			bool1 = __runOriginal;
-		}
+		public static void Postfix(bool __runOriginal) => bool1 = __runOriginal;
 	}
 
 	[HarmonyPatch(typeof(Class24), nameof(Method24))]
@@ -1272,15 +1091,9 @@ public static void Method24()
 			}
 		}
 
-		public static void Prefix(bool __runOriginal)
-		{
-			bool1 = __runOriginal;
-		}
+		public static void Prefix(bool __runOriginal) => bool1 = __runOriginal;
 
-		public static void Postfix(bool __runOriginal)
-		{
-			bool2 = __runOriginal;
-		}
+		public static void Postfix(bool __runOriginal) => bool2 = __runOriginal;
 	}
 
 	public class InjectDelegateBaseClass
@@ -1288,20 +1101,14 @@ public class InjectDelegateBaseClass
 		public string pre;
 		public string post;
 
-		internal virtual string SomeMethod(ref string s, int n)
-		{
-			return pre + s + ":" + n + post;
-		}
+		internal virtual string SomeMethod(ref string s, int n) => pre + s + ":" + n + post;
 	}
 
 	public class InjectDelegateClass : InjectDelegateBaseClass
 	{
 		public string result = "";
 
-		internal override string SomeMethod(ref string s, int n)
-		{
-			return $"[{base.SomeMethod(ref s, n)}]";
-		}
+		internal override string SomeMethod(ref string s, int n) => $"[{base.SomeMethod(ref s, n)}]";
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
 		public void Method(int n)
@@ -1333,16 +1140,10 @@ public static bool Prefix(TestDelegate baseSomeMethod, TestVirtualDelegate virtu
 
 	public static class InjectDelegateStaticClass
 	{
-		internal static string SomeMethod(int n)
-		{
-			return $"[{n}]";
-		}
+		internal static string SomeMethod(int n) => $"[{n}]";
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public static string Method(int n)
-		{
-			return SomeMethod(n + 1000);
-		}
+		public static string Method(int n) => SomeMethod(n + 1000);
 	}
 
 	[HarmonyPatch(typeof(InjectDelegateStaticClass), "Method")]
@@ -1363,16 +1164,10 @@ public struct InjectDelegateStruct
 		public string pre;
 		public string post;
 
-		internal string SomeMethod(int n)
-		{
-			return pre + n + post;
-		}
+		internal string SomeMethod(int n) => pre + n + post;
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public string Method(int n)
-		{
-			return SomeMethod(n + 1000);
-		}
+		public string Method(int n) => SomeMethod(n + 1000);
 	}
 
 	[HarmonyPatch(typeof(InjectDelegateStruct), "Method")]
@@ -1391,16 +1186,10 @@ public static bool Prefix(TestDelegate someMethod, ref string __result)
 	public class BulkPatchClass
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public string Method1()
-		{
-			return "TEST1";
-		}
+		public string Method1() => "TEST1";
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public string Method2()
-		{
-			return "TEST2";
-		}
+		public string Method2() => "TEST2";
 	}
 
 	[HarmonyPatch(typeof(BulkPatchClass))]
@@ -1409,10 +1198,7 @@ public class BulkPatchClassPatch
 	{
 		public static int transpileCount = 0;
 
-		static string Fix(string result)
-		{
-			return result + "+";
-		}
+		static string Fix(string result) => result + "+";
 
 		static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
 		{
diff --git a/HarmonyTests/Patching/Assets/Specials.cs b/HarmonyTests/Patching/Assets/Specials.cs
index aa67ad78..a78386e7 100644
--- a/HarmonyTests/Patching/Assets/Specials.cs
+++ b/HarmonyTests/Patching/Assets/Specials.cs
@@ -12,15 +12,9 @@ public class HttpWebRequestPatches
 		public static bool prefixCalled = false;
 		public static bool postfixCalled = false;
 
-		public static void Prefix()
-		{
-			prefixCalled = true;
-		}
+		public static void Prefix() => prefixCalled = true;
 
-		public static void Postfix()
-		{
-			postfixCalled = true;
-		}
+		public static void Postfix() => postfixCalled = true;
 
 		public static void ResetTest()
 		{
@@ -34,10 +28,7 @@ public static void ResetTest()
 	public class DeadEndCode
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public string Method()
-		{
-			throw new FormatException();
-		}
+		public string Method() => throw new FormatException();
 	}
 
 	// not using attributes here because we apply prefix first, then postfix
@@ -46,15 +37,9 @@ public class DeadEndCode_Patch1
 		public static bool prefixCalled = false;
 		public static bool postfixCalled = false;
 
-		public static void Prefix()
-		{
-			prefixCalled = true;
-		}
+		public static void Prefix() => prefixCalled = true;
 
-		public static void Postfix()
-		{
-			postfixCalled = true;
-		}
+		public static void Postfix() => postfixCalled = true;
 	}
 
 	[HarmonyPatch(typeof(DeadEndCode), nameof(DeadEndCode.Method))]
@@ -96,10 +81,7 @@ static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> inst
 			yield return new CodeInstruction(OpCodes.Ret);
 		}
 
-		static Exception Cleanup(Exception ex)
-		{
-			return ex is null ? null : new ArgumentException("Test", ex);
-		}
+		static Exception Cleanup(Exception ex) => ex is null ? null : new ArgumentException("Test", ex);
 	}
 
 	[HarmonyPatch(typeof(DeadEndCode), nameof(DeadEndCode.Method))]
@@ -110,10 +92,7 @@ static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> inst
 			yield return new CodeInstruction(OpCodes.Call, null);
 		}
 
-		static Exception Cleanup()
-		{
-			return null;
-		}
+		static Exception Cleanup() => null;
 	}
 
 	// -----------------------------------------------------
@@ -137,15 +116,9 @@ public class LateThrowClass_Patch1
 		public static bool prefixCalled = false;
 		public static bool postfixCalled = false;
 
-		static void Prefix()
-		{
-			prefixCalled = true;
-		}
+		static void Prefix() => prefixCalled = true;
 
-		static void Postfix()
-		{
-			postfixCalled = true;
-		}
+		static void Postfix() => postfixCalled = true;
 	}
 
 	// -----------------------------------------------------
@@ -172,15 +145,9 @@ public class LateThrowClass_Patch2
 		public static bool prefixCalled = false;
 		public static bool postfixCalled = false;
 
-		static void Prefix()
-		{
-			prefixCalled = true;
-		}
+		static void Prefix() => prefixCalled = true;
 
-		static void Postfix()
-		{
-			postfixCalled = true;
-		}
+		static void Postfix() => postfixCalled = true;
 	}
 
 	// -----------------------------------------------------
@@ -192,15 +159,9 @@ public struct SomeStruct
 		public static SomeStruct WasAccepted => new() { accepted = true };
 		public static SomeStruct WasNotAccepted => new() { accepted = false };
 
-		public static implicit operator SomeStruct(bool value)
-		{
-			return value ? WasAccepted : WasNotAccepted;
-		}
+		public static implicit operator SomeStruct(bool value) => value ? WasAccepted : WasNotAccepted;
 
-		public static implicit operator SomeStruct(string value)
-		{
-			return new SomeStruct();
-		}
+		public static implicit operator SomeStruct(string value) => new();
 	}
 
 	public struct AnotherStruct
@@ -212,29 +173,20 @@ public struct AnotherStruct
 
 	public abstract class AbstractClass
 	{
-		public virtual SomeStruct Method(string originalDef, AnotherStruct loc)
-		{
-			return SomeStruct.WasAccepted;
-		}
+		public virtual SomeStruct Method(string originalDef, AnotherStruct loc) => SomeStruct.WasAccepted;
 	}
 
 	public class ConcreteClass : AbstractClass
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public override SomeStruct Method(string def, AnotherStruct loc)
-		{
-			return true;
-		}
+		public override SomeStruct Method(string def, AnotherStruct loc) => true;
 	}
 
 	[HarmonyPatch(typeof(ConcreteClass))]
 	[HarmonyPatch(nameof(ConcreteClass.Method))]
 	public static class ConcreteClass_Patch
 	{
-		static void Prefix(ConcreteClass __instance, string def, AnotherStruct loc)
-		{
-			TestTools.Log("ConcreteClass_Patch.Method.Prefix");
-		}
+		static void Prefix(ConcreteClass __instance, string def, AnotherStruct loc) => TestTools.Log("ConcreteClass_Patch.Method.Prefix");
 	}
 
 	[HarmonyPatch(typeof(AppDomain), nameof(AppDomain.GetData))]
diff --git a/HarmonyTests/Patching/FinalizerPatches.cs b/HarmonyTests/Patching/FinalizerPatches.cs
index 258beb77..41a9bd9c 100644
--- a/HarmonyTests/Patching/FinalizerPatches.cs
+++ b/HarmonyTests/Patching/FinalizerPatches.cs
@@ -235,7 +235,7 @@ public static void Patch()
 				if (m_method.ReturnType == typeof(void))
 					_ = m_method.Invoke(obj, null);
 				else
-					info["result"] = m_method.Invoke(obj, new object[0]);
+					info["result"] = m_method.Invoke(obj, []);
 				info["outerexception"] = null;
 			}
 			catch (TargetInvocationException e)
diff --git a/HarmonyTests/Patching/GenericsPatches.cs b/HarmonyTests/Patching/GenericsPatches.cs
index 532b465b..5b737580 100644
--- a/HarmonyTests/Patching/GenericsPatches.cs
+++ b/HarmonyTests/Patching/GenericsPatches.cs
@@ -26,10 +26,7 @@ object IEnumerator.Current
 				}
 			}
 
-			internal void SetList(List<T> list)
-			{
-				this.list = list;
-			}
+			internal void SetList(List<T> list) => this.list = list;
 
 			internal MyEnumerator(List<T> list)
 			{
@@ -70,22 +67,13 @@ void IEnumerator.Reset()
 		public List<T> list = [];
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public MyEnumerator GetEnumerator()
-		{
-			return new MyEnumerator(list);
-		}
+		public MyEnumerator GetEnumerator() => new(list);
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		IEnumerator<T> IEnumerable<T>.GetEnumerator()
-		{
-			return new MyEnumerator(list);
-		}
+		IEnumerator<T> IEnumerable<T>.GetEnumerator() => new MyEnumerator(list);
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		IEnumerator IEnumerable.GetEnumerator()
-		{
-			return new MyEnumerator(list);
-		}
+		IEnumerator IEnumerable.GetEnumerator() => new MyEnumerator(list);
 	}
 
 	public class TestGenericStructReturnTypes_Patch
diff --git a/HarmonyTests/Patching/InternalPatches.cs b/HarmonyTests/Patching/InternalPatches.cs
index 25a32780..fbd8dda5 100644
--- a/HarmonyTests/Patching/InternalPatches.cs
+++ b/HarmonyTests/Patching/InternalPatches.cs
@@ -17,10 +17,7 @@ private static void Method(ref Assembly assembly)
 			Assert.AreEqual(assembly, thisAssembly);
 		}
 
-		private static void Prefix(ref Assembly assembly)
-		{
-			assembly = Assembly.GetExecutingAssembly();
-		}
+		private static void Prefix(ref Assembly assembly) => assembly = Assembly.GetExecutingAssembly();
 
 		private static void Postfix(ref Assembly assembly)
 		{
diff --git a/HarmonyTests/Patching/PatchSorting.cs b/HarmonyTests/Patching/PatchSorting.cs
index 2139fddd..ad599420 100644
--- a/HarmonyTests/Patching/PatchSorting.cs
+++ b/HarmonyTests/Patching/PatchSorting.cs
@@ -27,9 +27,9 @@ public void Test_PatchOrder_SamePriorities()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[1], 1, "owner B", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[2], 2, "owner C", Priority.Normal, new string[0], new string[0], false)
+				new Patch(patches[0], 0, "owner A", Priority.Normal, [], [], false),
+				new Patch(patches[1], 1, "owner B", Priority.Normal, [], [], false),
+				new Patch(patches[2], 2, "owner C", Priority.Normal, [], [], false)
 			};
 
 			var expectedOrder = new[] { 0, 1, 2 };
@@ -48,15 +48,15 @@ public void Test_PatchOrder_AllPriorities()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Last, new string[0], new string[0], false),
-				new Patch(patches[1], 1, "owner B", Priority.VeryLow, new string[0], new string[0], false),
-				new Patch(patches[2], 2, "owner C", Priority.Low, new string[0], new string[0], false),
-				new Patch(patches[3], 3, "owner D", Priority.LowerThanNormal, new string[0], new string[0], false),
-				new Patch(patches[4], 4, "owner E", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[5], 5, "owner F", Priority.HigherThanNormal, new string[0], new string[0], false),
-				new Patch(patches[6], 6, "owner G", Priority.High, new string[0], new string[0], false),
-				new Patch(patches[7], 7, "owner H", Priority.VeryHigh, new string[0], new string[0], false),
-				new Patch(patches[8], 8, "owner I", Priority.First, new string[0], new string[0], false)
+				new Patch(patches[0], 0, "owner A", Priority.Last, [], [], false),
+				new Patch(patches[1], 1, "owner B", Priority.VeryLow, [], [], false),
+				new Patch(patches[2], 2, "owner C", Priority.Low, [], [], false),
+				new Patch(patches[3], 3, "owner D", Priority.LowerThanNormal, [], [], false),
+				new Patch(patches[4], 4, "owner E", Priority.Normal, [], [], false),
+				new Patch(patches[5], 5, "owner F", Priority.HigherThanNormal, [], [], false),
+				new Patch(patches[6], 6, "owner G", Priority.High, [], [], false),
+				new Patch(patches[7], 7, "owner H", Priority.VeryHigh, [], [], false),
+				new Patch(patches[8], 8, "owner I", Priority.First, [], [], false)
 			};
 
 			var expectedOrder = new[] { 8, 7, 6, 5, 4, 3, 2, 1, 0 };
@@ -75,11 +75,11 @@ public void Test_PatchOrder_BeforeAndPriorities()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[1], 1, "owner A", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[2], 2, "owner B", Priority.Normal, ["owner A"], new string[0], false),
-				new Patch(patches[3], 3, "owner C", Priority.First, new string[0], new string[0], false),
-				new Patch(patches[4], 4, "owner D", Priority.Low, ["owner A"], new string[0], false)
+				new Patch(patches[0], 0, "owner A", Priority.Normal, [], [], false),
+				new Patch(patches[1], 1, "owner A", Priority.Normal, [], [], false),
+				new Patch(patches[2], 2, "owner B", Priority.Normal, ["owner A"], [], false),
+				new Patch(patches[3], 3, "owner C", Priority.First, [], [], false),
+				new Patch(patches[4], 4, "owner D", Priority.Low, ["owner A"], [], false)
 			};
 
 			var expectedOrder = new[] { 3, 2, 4, 0, 1 };
@@ -98,10 +98,10 @@ public void Test_PatchOrder_AfterAndPriorities()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Normal, new string[0], ["owner C"], false),
-				new Patch(patches[1], 1, "owner B", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[2], 2, "owner C", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[3], 3, "owner D", Priority.First, new string[0], ["owner C"], false)
+				new Patch(patches[0], 0, "owner A", Priority.Normal, [], ["owner C"], false),
+				new Patch(patches[1], 1, "owner B", Priority.Normal, [], [], false),
+				new Patch(patches[2], 2, "owner C", Priority.Normal, [], [], false),
+				new Patch(patches[3], 3, "owner D", Priority.First, [], ["owner C"], false)
 			};
 
 			var expectedOrder = new[] { 1, 2, 3, 0 };
@@ -120,11 +120,11 @@ public void Test_PatchOrder_BeforeAndAfterAndPriorities()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.First, new string[0], new string[0], false),
+				new Patch(patches[0], 0, "owner A", Priority.First, [], [], false),
 				new Patch(patches[1], 1, "owner B", Priority.HigherThanNormal, ["owner E"], ["owner C"], false),
-				new Patch(patches[2], 2, "owner C", Priority.First, new string[0], new string[0], false),
+				new Patch(patches[2], 2, "owner C", Priority.First, [], [], false),
 				new Patch(patches[3], 3, "owner D", Priority.VeryHigh, ["owner E"], ["owner C"], false),
-				new Patch(patches[4], 4, "owner E", Priority.First, new string[0], new string[0], false)
+				new Patch(patches[4], 4, "owner E", Priority.First, [], [], false)
 			};
 
 			var expectedOrder = new[] { 0, 2, 3, 1, 4 };
@@ -143,11 +143,11 @@ public void Test_PatchOrder_TransitiveBefore()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Normal, ["owner B"], new string[0], false),
-				new Patch(patches[1], 1, "owner B", Priority.HigherThanNormal, ["owner C"], new string[0], false),
-				new Patch(patches[2], 2, "owner C", Priority.High, ["owner D"], new string[0], false),
-				new Patch(patches[3], 3, "owner D", Priority.VeryHigh, ["owner E"], new string[0], false),
-				new Patch(patches[4], 4, "owner E", Priority.First, new string[0], new string[0], false)
+				new Patch(patches[0], 0, "owner A", Priority.Normal, ["owner B"], [], false),
+				new Patch(patches[1], 1, "owner B", Priority.HigherThanNormal, ["owner C"], [], false),
+				new Patch(patches[2], 2, "owner C", Priority.High, ["owner D"], [], false),
+				new Patch(patches[3], 3, "owner D", Priority.VeryHigh, ["owner E"], [], false),
+				new Patch(patches[4], 4, "owner E", Priority.First, [], [], false)
 			};
 
 			var expectedOrder = new[] { 0, 1, 2, 3, 4 };
@@ -166,11 +166,11 @@ public void Test_PatchOrder_TransitiveAfter()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.First, new string[0], ["owner B"], false),
-				new Patch(patches[1], 1, "owner B", Priority.VeryHigh, new string[0], ["owner C"], false),
-				new Patch(patches[2], 2, "owner C", Priority.High, new string[0], ["owner D"], false),
-				new Patch(patches[3], 3, "owner D", Priority.HigherThanNormal, new string[0], ["owner E"], false),
-				new Patch(patches[4], 4, "owner E", Priority.Normal, new string[0], new string[0], false)
+				new Patch(patches[0], 0, "owner A", Priority.First, [], ["owner B"], false),
+				new Patch(patches[1], 1, "owner B", Priority.VeryHigh, [], ["owner C"], false),
+				new Patch(patches[2], 2, "owner C", Priority.High, [], ["owner D"], false),
+				new Patch(patches[3], 3, "owner D", Priority.HigherThanNormal, [], ["owner E"], false),
+				new Patch(patches[4], 4, "owner E", Priority.Normal, [], [], false)
 			};
 
 			var expectedOrder = new[] { 4, 3, 2, 1, 0 };
@@ -190,9 +190,9 @@ public void Test_PatchCycle0()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Normal, new string[0], ["owner B"], false),
-				new Patch(patches[1], 1, "owner B", Priority.Normal, new string[0], ["owner C"], false),
-				new Patch(patches[2], 2, "owner C", Priority.Normal, new string[0], ["owner A"], false)
+				new Patch(patches[0], 0, "owner A", Priority.Normal, [], ["owner B"], false),
+				new Patch(patches[1], 1, "owner B", Priority.Normal, [], ["owner C"], false),
+				new Patch(patches[2], 2, "owner C", Priority.Normal, [], ["owner A"], false)
 			};
 
 			var expectedOrder = new[] { 2, 1, 0 };
@@ -212,9 +212,9 @@ public void Test_PatchCycle1()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Normal, ["owner C"], new string[0], false),
-				new Patch(patches[1], 1, "owner B", Priority.Normal, ["owner A"], new string[0], false),
-				new Patch(patches[2], 2, "owner C", Priority.Normal, ["owner B"], new string[0], false)
+				new Patch(patches[0], 0, "owner A", Priority.Normal, ["owner C"], [], false),
+				new Patch(patches[1], 1, "owner B", Priority.Normal, ["owner A"], [], false),
+				new Patch(patches[2], 2, "owner C", Priority.Normal, ["owner B"], [], false)
 			};
 
 			var expectedOrder = new[] { 2, 1, 0 };
@@ -234,14 +234,14 @@ public void Test_PatchCycle2()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Normal, ["owner C"], new string[0], false),
-				new Patch(patches[1], 1, "owner B", Priority.Normal, ["owner A"], new string[0], false),
-				new Patch(patches[2], 2, "owner C", Priority.Normal, ["owner B"], new string[0], false),
-				new Patch(patches[3], 3, "owner D", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[4], 4, "owner E", Priority.First, new string[0], new string[0], false),
-				new Patch(patches[5], 5, "owner F", Priority.Low, new string[0], ["owner G"], false),
-				new Patch(patches[6], 6, "owner G", Priority.Normal, new string[0], ["owner H"], false),
-				new Patch(patches[7], 7, "owner H", Priority.Normal, new string[0], ["owner F"], false)
+				new Patch(patches[0], 0, "owner A", Priority.Normal, ["owner C"], [], false),
+				new Patch(patches[1], 1, "owner B", Priority.Normal, ["owner A"], [], false),
+				new Patch(patches[2], 2, "owner C", Priority.Normal, ["owner B"], [], false),
+				new Patch(patches[3], 3, "owner D", Priority.Normal, [], [], false),
+				new Patch(patches[4], 4, "owner E", Priority.First, [], [], false),
+				new Patch(patches[5], 5, "owner F", Priority.Low, [], ["owner G"], false),
+				new Patch(patches[6], 6, "owner G", Priority.Normal, [], ["owner H"], false),
+				new Patch(patches[7], 7, "owner H", Priority.Normal, [], ["owner F"], false)
 			};
 
 			var expectedOrder = new[] { 4, 3, 5, 7, 6, 2, 1, 0 };
@@ -261,14 +261,14 @@ public void Test_PatchCycle3()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Normal, ["owner C"], new string[0], false),
-				new Patch(patches[1], 1, "owner B", Priority.Normal, ["owner A"], new string[0], false),
-				new Patch(patches[2], 2, "owner C", Priority.Normal, ["owner B"], new string[0], false),
-				new Patch(patches[3], 3, "owner D", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[4], 4, "owner E", Priority.First, new string[0], new string[0], false),
+				new Patch(patches[0], 0, "owner A", Priority.Normal, ["owner C"], [], false),
+				new Patch(patches[1], 1, "owner B", Priority.Normal, ["owner A"], [], false),
+				new Patch(patches[2], 2, "owner C", Priority.Normal, ["owner B"], [], false),
+				new Patch(patches[3], 3, "owner D", Priority.Normal, [], [], false),
+				new Patch(patches[4], 4, "owner E", Priority.First, [], [], false),
 				new Patch(patches[5], 5, "owner F", Priority.Low, ["owner C", "owner H"], ["owner G", "owner B"], false),
-				new Patch(patches[6], 6, "owner G", Priority.Normal, new string[0], ["owner H"], false),
-				new Patch(patches[7], 7, "owner H", Priority.Normal, new string[0], ["owner F"], false)
+				new Patch(patches[6], 6, "owner G", Priority.Normal, [], ["owner H"], false),
+				new Patch(patches[7], 7, "owner H", Priority.Normal, [], ["owner F"], false)
 			};
 
 			var expectedOrder = new[] { 4, 3, 5, 7, 6, 2, 1, 0 };
@@ -289,8 +289,8 @@ public void Test_PatchMissing0()
 			var patchInstances = new[]
 			{
 				new Patch(patches[0], 0, "owner A", Priority.Normal, ["ownerB", "missing 1"], ["owner C"], false),
-				new Patch(patches[1], 1, "owner B", Priority.Normal, new string[0], ["missing 2"], false),
-				new Patch(patches[2], 2, "owner C", Priority.Normal, new string[0], new string[0], false)
+				new Patch(patches[1], 1, "owner B", Priority.Normal, [], ["missing 2"], false),
+				new Patch(patches[2], 2, "owner C", Priority.Normal, [], [], false)
 			};
 
 			var expectedOrder = new[] { 1, 2, 0 };
@@ -310,10 +310,10 @@ public void Test_PatchSorterCache0()
 
 			var patchInstances = new[]
 			{
-				new Patch(patches[0], 0, "owner A", Priority.Normal, new string[0], new string[0], false),
+				new Patch(patches[0], 0, "owner A", Priority.Normal, [], [], false),
 				new Patch(patches[1], 1, "owner B", Priority.Normal, ["owner A"], ["owner C"], false),
-				new Patch(patches[2], 2, "owner C", Priority.Normal, new string[0], new string[0], false),
-				new Patch(patches[3], 3, "owner D", Priority.Normal, new string[0], new string[0], false)
+				new Patch(patches[2], 2, "owner C", Priority.Normal, [], [], false),
+				new Patch(patches[3], 3, "owner D", Priority.Normal, [], [], false)
 			};
 
 			var sorter = new PatchSorter(patchInstances, false);
diff --git a/HarmonyTests/ReversePatching/Assets/ReversePatches.cs b/HarmonyTests/ReversePatching/Assets/ReversePatches.cs
index c11ef246..c41a4e08 100644
--- a/HarmonyTests/ReversePatching/Assets/ReversePatches.cs
+++ b/HarmonyTests/ReversePatching/Assets/ReversePatches.cs
@@ -46,24 +46,15 @@ IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instruction
 			return original;
 		}
 
-		public static void Postfix(string original, ref string __result)
-		{
-			__result = "Epilog" + StringOperation(original);
-		}
+		public static void Postfix(string original, ref string __result) => __result = "Epilog" + StringOperation(original);
 	}
 
 	public class Class1Reverse
 	{
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		public string Method(string original, int n)
-		{
-			return original + GetExtra(n);
-		}
+		public string Method(string original, int n) => original + GetExtra(n);
 
-		private static string GetExtra(int n)
-		{
-			return "Extra" + n;
-		}
+		private static string GetExtra(int n) => "Extra" + n;
 	}
 
 	[HarmonyPatch(typeof(Class1Reverse), "Method")]
@@ -95,10 +86,7 @@ public static bool Prefix(string original, int n, ref string __result)
 	[HarmonyPatch]
 	public class Class1ReversePatchWithTargetMethod
 	{
-		public static MethodBase TargetMethod()
-		{
-			return AccessTools.Method(typeof(Class1Reverse), "GetExtra");
-		}
+		public static MethodBase TargetMethod() => AccessTools.Method(typeof(Class1Reverse), "GetExtra");
 
 		[HarmonyReversePatch]
 		[MethodImpl(MethodImplOptions.NoInlining)]
diff --git a/HarmonyTests/TestEnvironment.cs b/HarmonyTests/TestEnvironment.cs
index 6e45ab17..50fa95e5 100644
--- a/HarmonyTests/TestEnvironment.cs
+++ b/HarmonyTests/TestEnvironment.cs
@@ -42,15 +42,9 @@ public void OutputRuntimeInfo()
 				.FirstOrDefault() ?? "null"));
 		}
 
-		static string GetProperty(Type type, string propertyName)
-		{
-			return AccessTools.Property(type, propertyName)?.GetValue(null, new object[0])?.ToString() ?? "null";
-		}
+		static string GetProperty(Type type, string propertyName) => AccessTools.Property(type, propertyName)?.GetValue(null, [])?.ToString() ?? "null";
 
-		static string CallGetter(Type type, string methodName)
-		{
-			return AccessTools.Method(type, methodName)?.Invoke(null, new object[0])?.ToString() ?? "null";
-		}
+		static string CallGetter(Type type, string methodName) => AccessTools.Method(type, methodName)?.Invoke(null, [])?.ToString() ?? "null";
 
 		[Test]
 		public void OutputEnvironmentVariables()
@@ -60,10 +54,7 @@ public void OutputEnvironmentVariables()
 		}
 
 		[Test]
-		public void OutputAssemblies()
-		{
-			TestTools.Log(AppDomain.CurrentDomain.GetAssemblies().Join(delimiter: "\n"), indentLevelAfterNewLine: 1);
-		}
+		public void OutputAssemblies() => TestTools.Log(AppDomain.CurrentDomain.GetAssemblies().Join(delimiter: "\n"), indentLevelAfterNewLine: 1);
 
 		[Test]
 		public void OutputProcessInfo()
diff --git a/HarmonyTests/TestTools.cs b/HarmonyTests/TestTools.cs
index f6cd8a9e..82ab002d 100644
--- a/HarmonyTests/TestTools.cs
+++ b/HarmonyTests/TestTools.cs
@@ -104,9 +104,9 @@ public static ConstraintResult AssertThat(TestDelegate code, IResolveConstraint
 			return capture.capturedResult;
 		}
 
-		class CaptureResultConstraint : IConstraint
+		class CaptureResultConstraint(IResolveConstraint parent) : IConstraint
 		{
-			readonly IResolveConstraint parent;
+			readonly IResolveConstraint parent = parent;
 			IConstraint resolvedParent;
 			public ConstraintResult capturedResult;
 
@@ -118,11 +118,6 @@ class CaptureResultConstraint : IConstraint
 
 			public ConstraintBuilder Builder { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
-			public CaptureResultConstraint(IResolveConstraint parent)
-			{
-				this.parent = parent;
-			}
-
 			ConstraintResult CaptureResult(ConstraintResult result)
 			{
 				capturedResult = result;
@@ -137,20 +132,119 @@ ConstraintResult CaptureResult(ConstraintResult result)
 				return result;
 			}
 
-			public ConstraintResult ApplyTo<TActual>(TActual actual)
+			public ConstraintResult ApplyTo<TActual>(TActual actual) => CaptureResult(resolvedParent.ApplyTo(actual));
+
+
+/* Unmerged change from project 'HarmonyTests (net8.0)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
 			{
-				return CaptureResult(resolvedParent.ApplyTo(actual));
-			}
+				return CaptureResult(resolvedParent.ApplyTo(del));
+After:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del) => CaptureResult(resolvedParent.ApplyTo(del));
+*/
 
+/* Unmerged change from project 'HarmonyTests (netcoreapp3.0)'
+Before:
 			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
 			{
 				return CaptureResult(resolvedParent.ApplyTo(del));
-			}
+After:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del) => CaptureResult(resolvedParent.ApplyTo(del));
+*/
+
+/* Unmerged change from project 'HarmonyTests (net7.0)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
+			{
+				return CaptureResult(resolvedParent.ApplyTo(del));
+After:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del) => CaptureResult(resolvedParent.ApplyTo(del));
+*/
+
+/* Unmerged change from project 'HarmonyTests (net5.0)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
+			{
+				return CaptureResult(resolvedParent.ApplyTo(del));
+After:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del) => CaptureResult(resolvedParent.ApplyTo(del));
+*/
 
+/* Unmerged change from project 'HarmonyTests (net6.0)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
+			{
+				return CaptureResult(resolvedParent.ApplyTo(del));
+After:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del) => CaptureResult(resolvedParent.ApplyTo(del));
+*/
+
+/* Unmerged change from project 'HarmonyTests (netcoreapp3.1)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
+			{
+				return CaptureResult(resolvedParent.ApplyTo(del));
+After:
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del) => CaptureResult(resolvedParent.ApplyTo(del));
+*/
+			public ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del) => CaptureResult(resolvedParent.ApplyTo(del));
+
+
+/* Unmerged change from project 'HarmonyTests (net8.0)'
+Before:
 			public ConstraintResult ApplyTo<TActual>(ref TActual actual)
 			{
 				return CaptureResult(resolvedParent.ApplyTo(ref actual));
-			}
+After:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual) => CaptureResult(resolvedParent.ApplyTo(ref actual));
+*/
+
+/* Unmerged change from project 'HarmonyTests (netcoreapp3.0)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual)
+			{
+				return CaptureResult(resolvedParent.ApplyTo(ref actual));
+After:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual) => CaptureResult(resolvedParent.ApplyTo(ref actual));
+*/
+
+/* Unmerged change from project 'HarmonyTests (net7.0)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual)
+			{
+				return CaptureResult(resolvedParent.ApplyTo(ref actual));
+After:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual) => CaptureResult(resolvedParent.ApplyTo(ref actual));
+*/
+
+/* Unmerged change from project 'HarmonyTests (net5.0)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual)
+			{
+				return CaptureResult(resolvedParent.ApplyTo(ref actual));
+After:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual) => CaptureResult(resolvedParent.ApplyTo(ref actual));
+*/
+
+/* Unmerged change from project 'HarmonyTests (net6.0)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual)
+			{
+				return CaptureResult(resolvedParent.ApplyTo(ref actual));
+After:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual) => CaptureResult(resolvedParent.ApplyTo(ref actual));
+*/
+
+/* Unmerged change from project 'HarmonyTests (netcoreapp3.1)'
+Before:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual)
+			{
+				return CaptureResult(resolvedParent.ApplyTo(ref actual));
+After:
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual) => CaptureResult(resolvedParent.ApplyTo(ref actual));
+*/
+			public ConstraintResult ApplyTo<TActual>(ref TActual actual) => CaptureResult(resolvedParent.ApplyTo(ref actual));
 
 			public IConstraint Resolve()
 			{
@@ -176,14 +270,61 @@ public static Type ThrowsConstraintExceptionType(IConstraint resolvedConstraint)
 		}
 
 		// Run an action in a test isolation context.
+
+/* Unmerged change from project 'HarmonyTests (net8.0)'
+Before:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action)
+		{
+After:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action) =>
+*/
+
+/* Unmerged change from project 'HarmonyTests (netcoreapp3.0)'
+Before:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action)
+		{
+After:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action) =>
+*/
+
+/* Unmerged change from project 'HarmonyTests (net7.0)'
+Before:
 		public static void RunInIsolationContext(Action<ITestIsolationContext> action)
 		{
+After:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action) =>
+*/
+
+/* Unmerged change from project 'HarmonyTests (net5.0)'
+Before:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action)
+		{
+After:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action) =>
+*/
+
+/* Unmerged change from project 'HarmonyTests (net6.0)'
+Before:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action)
+		{
+After:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action) =>
+*/
+
+/* Unmerged change from project 'HarmonyTests (netcoreapp3.1)'
+Before:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action)
+		{
+After:
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action) =>
+*/
+		public static void RunInIsolationContext(Action<ITestIsolationContext> action) =>
 #if NETCOREAPP
 			TestAssemblyLoadContext.RunInIsolationContext(action);
 #else
 			TestDomainProxy.RunInIsolationContext(action);
 #endif
-		}
+
 
 #if NETCOREAPP
 		// .NET Core does not support multiple AppDomains, but it does support unloading assemblies via AssemblyLoadContext.
@@ -216,30 +357,22 @@ static WeakReference RunInAssemblyLoadContext(Action<ITestIsolationContext> acti
 
 			public TestAssemblyLoadContext() : base(isCollectible: true) { }
 
-			protected override Assembly Load(AssemblyName name)
-			{
+			protected override Assembly Load(AssemblyName name) =>
 				// Defer loading of assembly's dependencies to parent (AssemblyLoadContext.Default) assembly load context.
-				return null;
-			}
+				null;
 
-			public void AssemblyLoad(string name)
-			{
-				_ = LoadFromAssemblyPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, name + ".dll"));
-			}
+			public void AssemblyLoad(string name) => _ = LoadFromAssemblyPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, name + ".dll"));
 
 			// There's no separate AppDomain, so this is just an alias for callback(arg).
-			public void ParentCallback<T>(Action<T> callback, T arg)
-			{
-				callback(arg);
-			}
+			public void ParentCallback<T>(Action<T> callback, T arg) => callback(arg);
 		}
 #else
 		// For .NET Framework and its multiple AppDomain support, need a MarshalByRefObject, so that for an instance created
 		// via appDomain.CreateInstanceAndUnwrap, all calls to that instance's methods are executed in that appDomain.
 
-		class TestDomainProxy : MarshalByRefObject, ITestIsolationContext
+		class TestDomainProxy(AppDomain parentDomain) : MarshalByRefObject, ITestIsolationContext
 		{
-			readonly AppDomain parentDomain;
+			readonly AppDomain parentDomain = parentDomain;
 
 			// Run an action in "isolation" (seperate AppDomain that's unloaded afterwards).
 			// This a static method and thus is run in the AppDomain of the caller (the main AppDomain).
@@ -261,61 +394,36 @@ public static void RunInIsolationContext(Action<ITestIsolationContext> action)
 				AppDomain.Unload(testDomain);
 			}
 
-			public TestDomainProxy(AppDomain parentDomain)
-			{
-				this.parentDomain = parentDomain;
-			}
-
 			// Rules for proxy instance methods:
 			// Ensure that all loaded Types of the dummy assemblies are never leaked out of the test domain, so:
 			// 1) never return loaded Types (or instances of those Types); and
 			// 2) always catch exceptions that may contain loaded Types (or instances of those Types) directly.
 			// As long as there is no such leakage, AppDomain.Unload will fully unload the domain and all its assemblies.
 
-			void Run(Action<ITestIsolationContext> action)
-			{
-				action(this);
-			}
+			void Run(Action<ITestIsolationContext> action) => action(this);
 
 			// Note: Console usage won't work within a non-main domain - that has to be delegated to the main domain via a callback.
-			public void ParentCallback<T>(Action<T> action, T arg)
-			{
-				parentDomain.DoCallBack(new ActionTCallback<T>(action, arg).Call);
-			}
+			public void ParentCallback<T>(Action<T> action, T arg) => parentDomain.DoCallBack(new ActionTCallback<T>(action, arg).Call);
 
 			// Delegates used for DoCallback must be serializable.
 			[Serializable]
-			class ActionTCallback<T>
+			class ActionTCallback<T>(Action<T> action, T arg)
 			{
-				readonly Action<T> action;
-				readonly T arg;
-
-				public ActionTCallback(Action<T> action, T arg)
-				{
-					this.action = action;
-					this.arg = arg;
-				}
+				readonly Action<T> action = action;
+				readonly T arg = arg;
 
-				public void Call()
-				{
-					action(arg);
-				}
+				public void Call() => action(arg);
 			}
 
-			public void AssemblyLoad(string assemblyName)
-			{
-				_ = Assembly.Load(assemblyName);
-			}
+			public void AssemblyLoad(string assemblyName) => _ = Assembly.Load(assemblyName);
 		}
 #endif
 	}
 
 	public class TestLogger
 	{
-		class ExplicitException : ResultStateException
+		class ExplicitException(string message) : ResultStateException(message)
 		{
-			public ExplicitException(string message) : base(message) { }
-
 			public override ResultState ResultState => ResultState.Explicit;
 		}
 
diff --git a/HarmonyTests/Tools/Assets/AccessToolsClass.cs b/HarmonyTests/Tools/Assets/AccessToolsClass.cs
index 8a7fdbea..74ed77a9 100644
--- a/HarmonyTests/Tools/Assets/AccessToolsClass.cs
+++ b/HarmonyTests/Tools/Assets/AccessToolsClass.cs
@@ -22,31 +22,19 @@ private class Inner : IInner
 		{
 			public int x;
 
-			public override string ToString()
-			{
-				return x.ToString();
-			}
+			public override string ToString() => x.ToString();
 		}
 
-		public static IInner NewInner(int x)
-		{
-			return new Inner { x = x };
-		}
+		public static IInner NewInner(int x) => new Inner { x = x };
 
 		private struct InnerStruct : IInner
 		{
 			public int x;
 
-			public override string ToString()
-			{
-				return x.ToString();
-			}
+			public override string ToString() => x.ToString();
 		}
 
-		public static IInner NewInnerStruct(int x)
-		{
-			return new InnerStruct { x = x };
-		}
+		public static IInner NewInnerStruct(int x) => new InnerStruct { x = x };
 
 		protected string field1 = "field1orig";
 		public readonly float field2 = 2.71828f;
@@ -87,30 +75,15 @@ public string this[string key]
 			set { }
 		}
 
-		public string Method1()
-		{
-			return field1;
-		}
+		public string Method1() => field1;
 
-		public double Method2()
-		{
-			return field2;
-		}
+		public double Method2() => field2;
 
-		public void SetField(string val)
-		{
-			field1 = val;
-		}
+		public void SetField(string val) => field1 = val;
 
-		public static long Method3()
-		{
-			return field3;
-		}
+		public static long Method3() => field3;
 
-		public static string Method4()
-		{
-			return field4;
-		}
+		public static string Method4() => field4;
 	}
 
 	public class AccessToolsSubClass : AccessToolsClass
@@ -119,7 +92,8 @@ public class AccessToolsSubClass : AccessToolsClass
 		internal static int subclassField2 = -321;
 	}
 
-	public struct AccessToolsStruct : IAccessToolsType
+#pragma warning disable CS9113
+	public struct AccessToolsStruct(object obj) : IAccessToolsType
 	{
 		private enum InnerEnum : byte
 		{
@@ -128,20 +102,17 @@ private enum InnerEnum : byte
 			C = 4,
 		}
 
-		public static Enum NewInnerEnum(byte b)
-		{
-			return (InnerEnum)b;
-		}
+		public static Enum NewInnerEnum(byte b) => (InnerEnum)b;
 
-		public string structField1;
-		private readonly int structField2;
+		public string structField1 = "structField1orig";
+		private readonly int structField2 = -666;
 		private static int structField3 = -123;
 		public static readonly string structField4 = "structField4orig";
-		private InnerEnum structField5;
+		private InnerEnum structField5 = InnerEnum.B;
 
-		public int Property1 { get; set; }
+		public int Property1 { get; set; } = 161803;
 
-		private string Property2 { get; }
+		private string Property2 { get; } = "1.61803";
 
 		public static int Property3 { get; set; } = 299792458;
 
@@ -149,24 +120,9 @@ public static Enum NewInnerEnum(byte b)
 
 		public string this[string key] => key;
 
-		// Structs don't allow default constructor (and even a constructor with all default parameters won't be called with 'new AccessToolsStruct()'),
-		// but we need to assign some values to instance fields that aren't simply the default value for their types
-		// (so that ref value can be checked against orig value).
-		public AccessToolsStruct(object _)
-		{
-			structField1 = "structField1orig";
-			structField2 = -666;
-			structField5 = InnerEnum.B;
-			Property1 = 161803;
-			Property2 = "1.61803";
-		}
-
-		public string Method1()
-		{
-			return structField1;
-		}
+		public string Method1() => structField1;
 	}
-#pragma warning restore CS0169, CS0414, IDE0044, IDE0051, IDE0052
+#pragma warning restore CS0169, CS0414, CS9113, IDE0044, IDE0051, IDE0052
 
 	public static class AccessToolsCreateInstance
 	{
@@ -177,13 +133,9 @@ public class NoConstructor
 		}
 
 		// Does NOT have a default public parameterless constructor (or any parameterless constructor for that matter).
-		public class OnlyNonParameterlessConstructor
+		public class OnlyNonParameterlessConstructor(int n)
 		{
-			public bool constructorCalled = true;
-
-			public OnlyNonParameterlessConstructor(int _)
-			{
-			}
+			public bool constructorCalled = n != 0xbeef; // true
 		}
 
 		public class PublicParameterlessConstructor
@@ -216,46 +168,31 @@ public class Base : IInterface
 		{
 			public int x;
 
-			public virtual string Test(int n, ref float f)
-			{
-				return $"base test {n} {++f} {++x}";
-			}
+			public virtual string Test(int n, ref float f) => $"base test {n} {++f} {++x}";
 		}
 
 		public class Derived : Base
 		{
-			public override string Test(int n, ref float f)
-			{
-				return $"derived test {n} {++f} {++x}";
-			}
+			public override string Test(int n, ref float f) => $"derived test {n} {++f} {++x}";
 		}
 
 		public struct Struct : IInterface
 		{
 			public int x;
 
-			public string Test(int n, ref float f)
-			{
-				return $"struct result {n} {++f} {++x}";
-			}
+			public string Test(int n, ref float f) => $"struct result {n} {++f} {++x}";
 		}
 
 		public static int x;
 
-		public static string Test(int n, ref float f)
-		{
-			return $"static test {n} {++f} {++x}";
-		}
+		public static string Test(int n, ref float f) => $"static test {n} {++f} {++x}";
 	}
 
 	public static class AccessToolsHarmonyDelegate
 	{
 		public class Foo
 		{
-			private string SomeMethod(string s)
-			{
-				return $"[{s}]";
-			}
+			private string SomeMethod(string s) => $"[{s}]";
 		}
 
 		[HarmonyDelegate(typeof(Foo), "SomeMethod")]
diff --git a/HarmonyTests/Tools/TestAccessTools.cs b/HarmonyTests/Tools/TestAccessTools.cs
index 57eecb70..0e7668fb 100644
--- a/HarmonyTests/Tools/TestAccessTools.cs
+++ b/HarmonyTests/Tools/TestAccessTools.cs
@@ -15,10 +15,7 @@ namespace HarmonyLibTests.Tools
 	public class Test_AccessTools : TestLogger
 	{
 		[OneTimeSetUp]
-		public void CreateAndUnloadTestDummyAssemblies()
-		{
-			TestTools.RunInIsolationContext(CreateTestDummyAssemblies);
-		}
+		public void CreateAndUnloadTestDummyAssemblies() => TestTools.RunInIsolationContext(CreateTestDummyAssemblies);
 
 		// Comment out following attribute if you want to keep the dummy assembly files after the test runs.
 		[OneTimeTearDown]
diff --git a/HarmonyTests/Tools/TestFieldRefAccess.cs b/HarmonyTests/Tools/TestFieldRefAccess.cs
index ac31c8d4..7723ad0e 100644
--- a/HarmonyTests/Tools/TestFieldRefAccess.cs
+++ b/HarmonyTests/Tools/TestFieldRefAccess.cs
@@ -33,103 +33,52 @@ interface IATestCase<T, F>
 
 		// AccessTools.FieldRefAccess
 		// Note: This can't have generic class constraint since there are some FieldRefAccess methods that work with struct static fields.
-		static IATestCase<T, F> ATestCase<T, F>(AccessTools.FieldRef<T, F> fieldRef)
-		{
-			return new ClassFieldRefTestCase<T, F>(fieldRef);
-		}
+		static IATestCase<T, F> ATestCase<T, F>(AccessTools.FieldRef<T, F> fieldRef) => new ClassFieldRefTestCase<T, F>(fieldRef);
 
-		class ClassFieldRefTestCase<T, F> : IATestCase<T, F>
+		class ClassFieldRefTestCase<T, F>(AccessTools.FieldRef<T, F> fieldRef) : IATestCase<T, F>
 		{
-			readonly AccessTools.FieldRef<T, F> fieldRef;
-
-			public ClassFieldRefTestCase(AccessTools.FieldRef<T, F> fieldRef)
-			{
-				this.fieldRef = fieldRef;
-			}
+			readonly AccessTools.FieldRef<T, F> fieldRef = fieldRef;
 
-			public F Get(ref T instance)
-			{
-				return fieldRef(instance);
-			}
+			public F Get(ref T instance) => fieldRef(instance);
 
-			public void Set(ref T instance, F value)
-			{
-				fieldRef(instance) = value;
-			}
+			public void Set(ref T instance, F value) => fieldRef(instance) = value;
 		}
 
-		static IATestCase<T, F> ATestCase<T, F>(AccessTools.StructFieldRef<T, F> fieldRef) where T : struct
-		{
-			return new StructFieldRefTestCase<T, F>(fieldRef);
-		}
+		static IATestCase<T, F> ATestCase<T, F>(AccessTools.StructFieldRef<T, F> fieldRef) where T : struct => new StructFieldRefTestCase<T, F>(fieldRef);
 
-		class StructFieldRefTestCase<T, F> : IATestCase<T, F> where T : struct
+		class StructFieldRefTestCase<T, F>(AccessTools.StructFieldRef<T, F> fieldRef) : IATestCase<T, F> where T : struct
 		{
-			readonly AccessTools.StructFieldRef<T, F> fieldRef;
+			readonly AccessTools.StructFieldRef<T, F> fieldRef = fieldRef;
 
-			public StructFieldRefTestCase(AccessTools.StructFieldRef<T, F> fieldRef)
-			{
-				this.fieldRef = fieldRef;
-			}
+			public F Get(ref T instance) => fieldRef(ref instance);
 
-			public F Get(ref T instance)
-			{
-				return fieldRef(ref instance);
-			}
-
-			public void Set(ref T instance, F value)
-			{
-				fieldRef(ref instance) = value;
-			}
+			public void Set(ref T instance, F value) => fieldRef(ref instance) = value;
 		}
 
 		// AccessTools.StaticFieldRefAccess
-		static IATestCase<T, F> ATestCase<T, F>(AccessTools.FieldRef<F> fieldRef)
-		{
-			return new StaticFieldRefTestCase<T, F>(fieldRef);
-		}
+		static IATestCase<T, F> ATestCase<T, F>(AccessTools.FieldRef<F> fieldRef) => new StaticFieldRefTestCase<T, F>(fieldRef);
 
-		class StaticFieldRefTestCase<T, F> : IATestCase<T, F>
+		class StaticFieldRefTestCase<T, F>(AccessTools.FieldRef<F> fieldRef) : IATestCase<T, F>
 		{
-			readonly AccessTools.FieldRef<F> fieldRef;
+			readonly AccessTools.FieldRef<F> fieldRef = fieldRef;
 
-			public StaticFieldRefTestCase(AccessTools.FieldRef<F> fieldRef)
-			{
-				this.fieldRef = fieldRef;
-			}
+			public F Get(ref T instance) => fieldRef();
 
-			public F Get(ref T instance)
-			{
-				return fieldRef();
-			}
-
-			public void Set(ref T instance, F value)
-			{
-				fieldRef() = value;
-			}
+			public void Set(ref T instance, F value) => fieldRef() = value;
 		}
 
 		// Marker constraint that ATestSuite uses to skip tests that can crash.
-		static SkipTestConstraint SkipTest(string reason)
-		{
-			return new SkipTestConstraint(reason);
-		}
+		static SkipTestConstraint SkipTest(string reason) => new(reason);
 
-		class SkipTestConstraint : Constraint
+		class SkipTestConstraint(string reason) : Constraint(reason)
 		{
-			public SkipTestConstraint(string reason) : base(reason) { }
-
-			public override ConstraintResult ApplyTo<TActual>(TActual actual)
-			{
-				throw new InvalidOperationException(ToString());
-			}
+			public override ConstraintResult ApplyTo<TActual>(TActual actual) => throw new InvalidOperationException(ToString());
 		}
 
 		// As a final check during a test case, ATestSuite checks that field.FieldType.IsInstanceOfType(field.GetValue(instance)),
 		// and throws this specific exception if that check fails.
-		class IncompatibleFieldTypeException : Exception
+		class IncompatibleFieldTypeException(string message) : Exception(message)
 		{
-			public IncompatibleFieldTypeException(string message) : base(message) { }
 		}
 
 		static readonly Dictionary<Type, object> instancePrototypes = new()
@@ -146,7 +95,7 @@ static T CloneInstancePrototype<T>(Type instanceType)
 			var instance = instancePrototypes[instanceType];
 			if (instance is ICloneable cloneable)
 				return (T)cloneable.Clone();
-			return (T)AccessTools.Method(instance.GetType(), "MemberwiseClone").Invoke(instance, new object[0]);
+			return (T)AccessTools.Method(instance.GetType(), "MemberwiseClone").Invoke(instance, []);
 		}
 
 		// Like ATestCase naming above, the "A" here is to distinguish from NUnit's own TestSuite.
@@ -187,12 +136,10 @@ public void Run()
 				});
 			}
 
-			static object GetOrigValue(FieldInfo field)
-			{
+			static object GetOrigValue(FieldInfo field) =>
 				// Not using cloned instance of given instance type since it may be (intentionally) incompatible with the field's declaring type.
 				// Also not casting to F to avoid potential invalid cast exceptions (and to see how test cases handle incompatible types).
-				return field.GetValue(instancePrototypes[field.DeclaringType]);
-			}
+				field.GetValue(instancePrototypes[field.DeclaringType]);
 
 			void Run(string testSuiteLabel, string testCaseName, IATestCase<T, F> testCase, ReusableConstraint expectedConstraint)
 			{
@@ -285,10 +232,7 @@ static object TryConvert(object x)
 		}
 
 		// This helps avoid ambiguous reference between 'HarmonyLib.CollectionExtensions' and 'System.Collections.Generic.CollectionExtensions'.
-		static Dictionary<K, V> Merge<K, V>(Dictionary<K, V> firstDict, params Dictionary<K, V>[] otherDicts)
-		{
-			return firstDict.Merge(otherDicts);
-		}
+		static Dictionary<K, V> Merge<K, V>(Dictionary<K, V> firstDict, params Dictionary<K, V>[] otherDicts) => firstDict.Merge(otherDicts);
 
 		static Dictionary<string, IATestCase<T, F>> AvailableTestCases_FieldRefAccess_ByName<T, F>(string fieldName)
 		{
@@ -667,7 +611,7 @@ public void Test_ClassStatic_PrivateReadonlyString()
 				TestSuite_Class<AccessToolsClass, AccessToolsClass, IComparable>(
 					field, "field4test", expectedCaseToConstraint);
 				TestSuite_Class<AccessToolsClass, AccessToolsClass, IEnumerable<string>>(
-					field, new[] { "should always throw" }, IncompatibleFieldType(expectedCaseToConstraint));
+					field, ["should always throw"], IncompatibleFieldType(expectedCaseToConstraint));
 				TestSuite_Class<AccessToolsClass, AccessToolsClass, int>(
 					field, 1337, IncompatibleFieldType(expectedCaseToConstraint));
 			});
diff --git a/HarmonyTests/Tools/TestGettingInstructions.cs b/HarmonyTests/Tools/TestGettingInstructions.cs
index 22a2c885..2291f15f 100644
--- a/HarmonyTests/Tools/TestGettingInstructions.cs
+++ b/HarmonyTests/Tools/TestGettingInstructions.cs
@@ -29,10 +29,7 @@ public int Method(string input)
 		public class Patch
 		{
 			[HarmonyPatch(typeof(InstructionTest), nameof(Method))]
-			static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
-			{
-				return Transpilers.Manipulator(instructions, instr => instr.OperandIs((int)' '), instr => instr.operand = (int)'*');
-			}
+			static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) => Transpilers.Manipulator(instructions, instr => instr.OperandIs((int)' '), instr => instr.operand = (int)'*');
 		}
 	}
 
diff --git a/HarmonyTests/Traverse/Assets/TraverseFields_AccessModifiers.cs b/HarmonyTests/Traverse/Assets/TraverseFields_AccessModifiers.cs
index 9a619531..5526a377 100644
--- a/HarmonyTests/Traverse/Assets/TraverseFields_AccessModifiers.cs
+++ b/HarmonyTests/Traverse/Assets/TraverseFields_AccessModifiers.cs
@@ -6,20 +6,12 @@ public class TraverseFields
 		public static string[] fieldNames = ["publicField", "privateField", "protectedField", "internalField"];
 	}
 
-	public class TraverseFields_AccessModifiers
+	public class TraverseFields_AccessModifiers(string[] s)
 	{
-		public string publicField;
-		readonly string privateField;
-		protected string protectedField;
-		internal string internalField;
-
-		public TraverseFields_AccessModifiers(string[] s)
-		{
-			publicField = s[0];
-			privateField = s[1];
-			protectedField = s[2];
-			internalField = s[3];
-		}
+		public string publicField = s[0];
+		readonly string privateField = s[1];
+		protected string protectedField = s[2];
+		internal string internalField = s[3];
 
 		public string GetTestField(int n)
 		{
@@ -38,9 +30,6 @@ public string GetTestField(int n)
 			}
 		}
 
-		public override string ToString()
-		{
-			return "TraverseFields_AccessModifiers";
-		}
+		public override string ToString() => "TraverseFields_AccessModifiers";
 	}
 }
diff --git a/HarmonyTests/Traverse/Assets/TraverseMethods.cs b/HarmonyTests/Traverse/Assets/TraverseMethods.cs
index 9f46ea38..6f3db93a 100644
--- a/HarmonyTests/Traverse/Assets/TraverseMethods.cs
+++ b/HarmonyTests/Traverse/Assets/TraverseMethods.cs
@@ -6,40 +6,22 @@ public class TraverseMethods_Instance
 	{
 		public bool Method1_called;
 
-		void Method1()
-		{
-			Method1_called = true;
-		}
+		void Method1() => Method1_called = true;
 
-		string Method2(string arg1)
-		{
-			return arg1 + arg1;
-		}
+		string Method2(string arg1) => arg1 + arg1;
 	}
 
 	public static class TraverseMethods_Static
 	{
-		static int StaticMethod(int a, int b)
-		{
-			return a * b;
-		}
+		static int StaticMethod(int a, int b) => a * b;
 	}
 
 	public static class TraverseMethods_VarArgs
 	{
-		static int Test1(int a, int b)
-		{
-			return a + b;
-		}
+		static int Test1(int a, int b) => a + b;
 
-		static int Test2(int a, int b, int c)
-		{
-			return a + b + c;
-		}
-		static int Test3(int multiplier, params int[] n)
-		{
-			return n.Aggregate(0, (acc, x) => acc + x) * multiplier;
-		}
+		static int Test2(int a, int b, int c) => a + b + c;
+		static int Test3(int multiplier, params int[] n) => n.Aggregate(0, (acc, x) => acc + x) * multiplier;
 	}
 
 	public static class TraverseMethods_Parameter
@@ -56,22 +38,13 @@ static string WithOutParameter(out string refParameter)
 			return "ok";
 		}
 
-		static T WithGenericParameter<T>(T refParameter)
-		{
-			return refParameter;
-		}
+		static T WithGenericParameter<T>(T refParameter) => refParameter;
 	}
 
 	public class TraverseMethods_Overloads
 	{
-		public bool SomeMethod(string p1, bool p2 = true)
-		{
-			return !p2;
-		}
+		public bool SomeMethod(string p1, bool p2 = true) => !p2;
 
-		public int SomeMethod(string p1, int p2, bool p3 = true)
-		{
-			return 0;
-		}
+		public int SomeMethod(string p1, int p2, bool p3 = true) => 0;
 	}
 }
diff --git a/HarmonyTests/Traverse/Assets/TraverseProperties_AccessModifiers.cs b/HarmonyTests/Traverse/Assets/TraverseProperties_AccessModifiers.cs
index eab74c98..b9a12db0 100644
--- a/HarmonyTests/Traverse/Assets/TraverseProperties_AccessModifiers.cs
+++ b/HarmonyTests/Traverse/Assets/TraverseProperties_AccessModifiers.cs
@@ -11,15 +11,10 @@ public class TraverseProperties
 		public static string[] propertyNames = ["PublicProperty", "PublicPrivateProperty", "AutoProperty", "BaseProperty1", "BaseProperty2", "BaseProperty3", "ImmediateProperty"];
 	}
 
-	public class Traverse_ExtraClass
+	public class Traverse_ExtraClass(string val)
 	{
-		public readonly string someString = "-";
+		public readonly string someString = val;
 		public readonly Traverse_BaseClass baseClass = new();
-
-		public Traverse_ExtraClass(string val)
-		{
-			someString = val;
-		}
 	}
 
 	public class Traverse_BaseClass
@@ -50,7 +45,7 @@ public string BaseProperty3
 		static string StaticProperty => "test1";
 		private string BaseProperty => "base-property";
 
-		private string BaseMethod() { return "base-method"; }
+		private string BaseMethod() => "base-method";
 	}
 
 	public static class TraverseFields_Static
@@ -161,10 +156,7 @@ public void SetTestProperty(int n, string value)
 			}
 		}
 
-		public override string ToString()
-		{
-			return "TraverseProperties_AccessModifiers";
-		}
+		public override string ToString() => "TraverseProperties_AccessModifiers";
 	}
 
 	public class TraverseProperties_SubClass : Traverse_BaseClass
diff --git a/HarmonyTests/Traverse/Assets/TraverseTypes.cs b/HarmonyTests/Traverse/Assets/TraverseTypes.cs
index 567349b3..5282b05f 100644
--- a/HarmonyTests/Traverse/Assets/TraverseTypes.cs
+++ b/HarmonyTests/Traverse/Assets/TraverseTypes.cs
@@ -45,20 +45,14 @@ class InnerClass2
 #pragma warning restore CS0414
 #pragma warning restore IDE0052
 
-				public InnerClass2()
-				{
-					field = "helloInstance";
-				}
+				public InnerClass2() => field = "helloInstance";
 			}
 
 #pragma warning disable IDE0052
 			readonly InnerClass2 inner2;
 #pragma warning restore IDE0052
 
-			public InnerClass1()
-			{
-				inner2 = new InnerClass2();
-			}
+			public InnerClass1() => inner2 = new InnerClass2();
 		}
 
 		class InnerStaticFieldClass1
diff --git a/HarmonyTests/Traverse/TestTraverse_Basics.cs b/HarmonyTests/Traverse/TestTraverse_Basics.cs
index 150bbeea..6d53d572 100644
--- a/HarmonyTests/Traverse/TestTraverse_Basics.cs
+++ b/HarmonyTests/Traverse/TestTraverse_Basics.cs
@@ -64,7 +64,7 @@ public void Traverse_SilentFailures()
 
 			var trv4 = new Traverse(new FooBar()).Field("field");
 			AssertIsEmpty(trv4.Method("", new object[0]));
-			AssertIsEmpty(trv4.Method("", new Type[0], new object[0]));
+			AssertIsEmpty(trv4.Method("", [], []));
 		}
 
 		// Traverse should handle basic null values
diff --git a/TestLibrary/TestPatch.cs b/TestLibrary/TestPatch.cs
index 1bb5b9c4..e8754f92 100644
--- a/TestLibrary/TestPatch.cs
+++ b/TestLibrary/TestPatch.cs
@@ -14,17 +14,11 @@ private static void Method(ref Assembly prefix, ref Assembly original, ref Assem
 		original = Assembly.GetExecutingAssembly();
 	}
 
-	private static void Prefix(ref Assembly prefix)
-	{
-		prefix = Assembly.GetExecutingAssembly();
-	}
+	private static void Prefix(ref Assembly prefix) => prefix = Assembly.GetExecutingAssembly();
 
-	private static void Postfix(ref Assembly postfix)
-	{
-		postfix = Assembly.GetExecutingAssembly();
-	}
+	private static void Postfix(ref Assembly postfix) => postfix = Assembly.GetExecutingAssembly();
 
-	private static void Finalizer(Exception __exception) { _ = __exception; }
+	private static void Finalizer(Exception __exception) => _ = __exception;
 
 	private static IEnumerable<CodeInstruction> EmptyTranspiler(IEnumerable<CodeInstruction> instructions) => instructions;