Allow ArgumentsSource to reference methods in other types (#2748)

* Allow ArgumentsSource to reference methods in other types

* Update docs for custom ArgumentsSource type

* Allow ParamsSource to reference methods in other types

* Update docs for custom ParamsSource type

* Add test for ArgumentsSource with custom type

* Add test for ParamsSource with custom type

Author: JimmyCushnie

docs/articles/samples/IntroArgumentsSource.md

@@ -11,7 +11,7 @@ You can mark one or several fields or properties in your class by the
   [`[ArgumentsSource]`](xref:BenchmarkDotNet.Attributes.ArgumentsSourceAttribute) attribute.
 In this attribute, you have to specify the name of public method/property which is going to provide the values
   (something that implements `IEnumerable`).
- The source must be within benchmarked type! 
+The source may be instance or static. If the source is not in the same type as the benchmark, the type containing the source must be specified in the attribute constructor.
 
 ### Source code
 

docs/articles/samples/IntroParamsSource.md

@@ -10,7 +10,7 @@ You can mark one or several fields or properties in your class by the
   [`[Params]`](xref:BenchmarkDotNet.Attributes.ParamsAttribute) attribute.
 In this attribute, you have to specify the name of public method/property which is going to provide the values
   (something that implements `IEnumerable`).
-The source must be within benchmarked type!
+The source may be instance or static. If the source is not in the same type as the benchmark, the type containing the source must be specified in the attribute constructor.
 
 ### Source code
 

samples/BenchmarkDotNet.Samples/IntroArgumentsSource.cs

@@ -20,9 +20,12 @@ public class IntroArgumentsSource
         }
 
         [Benchmark]
-        [ArgumentsSource(nameof(TimeSpans))]
+        [ArgumentsSource(typeof(BenchmarkArguments), nameof(BenchmarkArguments.TimeSpans))] // when the arguments come from a different type, specify that type here
         public void SingleArgument(TimeSpan time) => Thread.Sleep(time);
+    }
 
+    public class BenchmarkArguments
+    {
         public IEnumerable<object> TimeSpans() // for single argument it's an IEnumerable of objects (object)
         {
             yield return TimeSpan.FromMilliseconds(10);

samples/BenchmarkDotNet.Samples/IntroParamsSource.cs

@@ -20,7 +20,16 @@ public class IntroParamsSource
         // public static method
         public static IEnumerable<int> ValuesForB() => new[] { 10, 20 };
 
+        // public field getting its params from a method in another type
+        [ParamsSource(typeof(ParamsValues), nameof(ParamsValues.ValuesForC))]
+        public int C;
+
         [Benchmark]
-        public void Benchmark() => Thread.Sleep(A + B + 5);
+        public void Benchmark() => Thread.Sleep(A + B + C + 5);
+    }
+
+    public static class ParamsValues
+    {
+        public static IEnumerable<int> ValuesForC() => new[] { 1000, 2000 };
     }
 }

src/BenchmarkDotNet.Annotations/Attributes/ArgumentsSourceAttribute.cs

@@ -6,7 +6,18 @@ namespace BenchmarkDotNet.Attributes
     public class ArgumentsSourceAttribute : PriorityAttribute
     {
         public string Name { get; }
+        public Type? Type { get; }
 
-        public ArgumentsSourceAttribute(string name) => Name = name;
+        public ArgumentsSourceAttribute(string name)
+        {
+            Name = name;
+            Type = null;
+        }
+
+        public ArgumentsSourceAttribute(Type type, string name)
+        {
+            Name = name;
+            Type = type;
+        }
     }
 }

src/BenchmarkDotNet.Annotations/Attributes/ParamsSourceAttribute.cs

@@ -6,7 +6,18 @@ namespace BenchmarkDotNet.Attributes
     public class ParamsSourceAttribute : PriorityAttribute
     {
         public string Name { get; }
+        public Type? Type { get; }
 
-        public ParamsSourceAttribute(string name) => Name = name;
+        public ParamsSourceAttribute(string name)
+        {
+            Name = name;
+            Type = null;
+        }
+
+        public ParamsSourceAttribute(Type type, string name)
+        {
+            Name = name;
+            Type = type;
+        }
     }
 }

src/BenchmarkDotNet/Running/BenchmarkConverter.cs

@@ -198,7 +198,9 @@ IEnumerable<ParameterDefinition> GetDefinitions<TAttribute>(Func<TAttribute, Typ
 
             var paramsSourceDefinitions = GetDefinitions<ParamsSourceAttribute>((attribute, parameterType) =>
             {
-                var paramsValues = GetValidValuesForParamsSource(type, attribute.Name);
+                var targetType = attribute.Type ?? type;
+
+                var paramsValues = GetValidValuesForParamsSource(targetType, attribute.Name);
                 return SmartParamBuilder.CreateForParams(parameterType, paramsValues.source, paramsValues.values);
             });
 
@@ -208,7 +210,7 @@ IEnumerable<ParameterDefinition> GetDefinitions<TAttribute>(Func<TAttribute, Typ
             return new ParameterDefinitions(definitions);
         }
 
-        private static IEnumerable<ParameterInstances> GetArgumentsDefinitions(MethodInfo benchmark, Type target, SummaryStyle summaryStyle)
+        private static IEnumerable<ParameterInstances> GetArgumentsDefinitions(MethodInfo benchmark, Type benchmarkType, SummaryStyle summaryStyle)
         {
             var argumentsAttributes = benchmark.GetCustomAttributes<PriorityAttribute>();
             int priority = argumentsAttributes.Select(attribute => attribute.Priority).Sum();
@@ -244,8 +246,9 @@ private static IEnumerable<ParameterInstances> GetArgumentsDefinitions(MethodInf
                 yield break;
 
             var argumentsSourceAttribute = benchmark.GetCustomAttribute<ArgumentsSourceAttribute>();
+            var targetType = argumentsSourceAttribute.Type ?? benchmarkType;
 
-            var valuesInfo = GetValidValuesForParamsSource(target, argumentsSourceAttribute.Name);
+            var valuesInfo = GetValidValuesForParamsSource(targetType, argumentsSourceAttribute.Name);
             for (int sourceIndex = 0; sourceIndex < valuesInfo.values.Length; sourceIndex++)
                 yield return SmartParamBuilder.CreateForArguments(benchmark, parameterDefinitions, valuesInfo, sourceIndex, summaryStyle);
         }
@@ -303,25 +306,25 @@ private static object Map(object providedValue, Type type)
             return providedValue;
         }
 
-        private static (MemberInfo source, object[] values) GetValidValuesForParamsSource(Type parentType, string sourceName)
+        private static (MemberInfo source, object[] values) GetValidValuesForParamsSource(Type sourceType, string sourceName)
         {
-            var paramsSourceMethod = parentType.GetAllMethods().SingleOrDefault(method => method.Name == sourceName && method.IsPublic);
+            var paramsSourceMethod = sourceType.GetAllMethods().SingleOrDefault(method => method.Name == sourceName && method.IsPublic);
 
             if (paramsSourceMethod != default)
                 return (paramsSourceMethod, ToArray(
-                    paramsSourceMethod.Invoke(paramsSourceMethod.IsStatic ? null : Activator.CreateInstance(parentType), null),
+                    paramsSourceMethod.Invoke(paramsSourceMethod.IsStatic ? null : Activator.CreateInstance(sourceType), null),
                     paramsSourceMethod,
-                    parentType));
+                    sourceType));
 
-            var paramsSourceProperty = parentType.GetAllProperties().SingleOrDefault(property => property.Name == sourceName && property.GetMethod.IsPublic);
+            var paramsSourceProperty = sourceType.GetAllProperties().SingleOrDefault(property => property.Name == sourceName && property.GetMethod.IsPublic);
 
             if (paramsSourceProperty != default)
                 return (paramsSourceProperty, ToArray(
-                    paramsSourceProperty.GetValue(paramsSourceProperty.GetMethod.IsStatic ? null : Activator.CreateInstance(parentType)),
+                    paramsSourceProperty.GetValue(paramsSourceProperty.GetMethod.IsStatic ? null : Activator.CreateInstance(sourceType)),
                     paramsSourceProperty,
-                    parentType));
+                    sourceType));
 
-            throw new InvalidBenchmarkDeclarationException($"{parentType.Name} has no public, accessible method/property called {sourceName}, unable to read values for [ParamsSource]");
+            throw new InvalidBenchmarkDeclarationException($"{sourceType.Name} has no public, accessible method/property called {sourceName}, unable to read values for [ParamsSource]");
         }
 
         private static object[] ToArray(object sourceValue, MemberInfo memberInfo, Type type)

tests/BenchmarkDotNet.IntegrationTests/ArgumentsTests.cs

@@ -81,6 +81,28 @@ public IEnumerable<object[]> ArgumentsProvider()
             }
         }
 
+        [Theory, MemberData(nameof(GetToolchains))]
+        public void ArgumentsFromSourceInAnotherClassArePassedToBenchmarks(IToolchain toolchain) => CanExecute<WithArgumentsSourceInAnotherClass>(toolchain);
+
+        public class WithArgumentsSourceInAnotherClass
+        {
+            [Benchmark]
+            [ArgumentsSource(typeof(ExternalClassWithArgumentsSource), nameof(ExternalClassWithArgumentsSource.ArgumentsProvider))]
+            public void Simple(bool boolean, int number)
+            {
+                if (boolean && number != 1 || !boolean && number != 2)
+                    throw new InvalidOperationException("Incorrect values were passed");
+            }
+        }
+        public static class ExternalClassWithArgumentsSource
+        {
+            public static IEnumerable<object[]> ArgumentsProvider()
+            {
+                yield return new object[] { true, 1 };
+                yield return new object[] { false, 2 };
+            }
+        }
+
         [Theory, MemberData(nameof(GetToolchains))]
         public void ArgumentsCanBePassedByReferenceToBenchmark(IToolchain toolchain) => CanExecute<WithRefArguments>(toolchain);
 
@@ -747,6 +769,42 @@ public void TestProperty(int argument)
             }
         }
 
+        [Theory, MemberData(nameof(GetToolchains))]
+        public void MethodsAndPropertiesFromAnotherClassCanBeUsedAsSources(IToolchain toolchain)
+            => CanExecute<ParamsSourcePointingToAnotherClass>(toolchain);
+
+        public class ParamsSourcePointingToAnotherClass
+        {
+            [ParamsSource(typeof(ExternalClassWithParamsSource), nameof(ExternalClassWithParamsSource.Method))]
+            public int ParamOne { get; set; }
+
+            [ParamsSource(typeof(ExternalClassWithParamsSource), nameof(ExternalClassWithParamsSource.Property))]
+            public int ParamTwo { get; set; }
+
+            [Benchmark]
+            public void Test()
+            {
+                if (ParamOne != 123)
+                    throw new ArgumentException("The ParamOne value is incorrect!");
+                if (ParamTwo != 456)
+                    throw new ArgumentException("The ParamTwo value is incorrect!");
+            }
+        }
+        public static class ExternalClassWithParamsSource
+        {
+            public static IEnumerable<int> Method()
+            {
+                yield return 123;
+            }
+            public static IEnumerable<int> Property
+            {
+                get
+                {
+                    yield return 456;
+                }
+            }
+        }
+
         [Theory, MemberData(nameof(GetToolchains))]
         public void VeryLongStringsAreSupported(IToolchain toolchain) => CanExecute<WithVeryLongString>(toolchain);