perf: avoid LINQ chains in TestDependency equality and MethodDataSourceAttribute method matching

TUnit.Core/Attributes/TestData/MethodDataSourceAttribute.cs

@@ -182,7 +182,7 @@ public MethodDataSourceAttribute(
 
         // Try to find a method first
         var methodInfo = targetType.GetMethods(BindingFlags).SingleOrDefault(x => x.Name == MethodNameProvidingDataSource
-                && x.GetParameters().Select(p => p.ParameterType).SequenceEqual(Arguments.Select(a => a?.GetType())))
+                && ParameterTypesMatchArguments(x.GetParameters(), Arguments))
             ?? targetType.GetMethod(MethodNameProvidingDataSource, BindingFlags);
 
         object? methodResult;
@@ -324,6 +324,27 @@ public MethodDataSourceAttribute(
         }
     }
 
+    // Matches a candidate method's parameter types against the runtime types of the supplied arguments.
+    // A null argument has no runtime type, so it never matches a (non-null) parameter type, preserving
+    // the previous SequenceEqual(parameterTypes, arguments.Select(a => a?.GetType())) behavior.
+    private static bool ParameterTypesMatchArguments(ParameterInfo[] parameters, object?[] arguments)
+    {
+        if (parameters.Length != arguments.Length)
+        {
+            return false;
+        }
+
+        for (var i = 0; i < parameters.Length; i++)
+        {
+            if (parameters[i].ParameterType != arguments[i]?.GetType())
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     // MethodInfo.Invoke does not auto-fill optional parameters the way a C# call site does.
     private static object?[] BuildInvokeArgs(MethodInfo methodInfo, object?[] suppliedArguments)
     {

TUnit.Core/TestDependency.cs

@@ -142,11 +142,18 @@ public bool Matches(TestMetadata test, TestMetadata? dependentTest = null)
             {
                 var testParams = test.MethodMetadata.Parameters;
 
-                if (testParams.Length != MethodParameters.Length
-                    || !testParams.Select(x => x.Type).SequenceEqual(MethodParameters!))
+                if (testParams.Length != MethodParameters.Length)
                 {
                     return false;
                 }
+
+                for (var i = 0; i < testParams.Length; i++)
+                {
+                    if (testParams[i].Type != MethodParameters[i])
+                    {
+                        return false;
+                    }
+                }
             }
         }