ParamArrayAttribute not generated for local function with params argument

[Joy-less]

I'm trying to check whether an argument for a function is params using reflection. It seems like the only way to do this is find a ParamArrayAttribute. However, it seems this is not generated for local functions! Is there another way?

using System;
using System.Reflection;
using System.Linq;
					
public class Program {
	static void ClassMethod(params object[] Args) {

	}
	public static void Main() {
		static void LocalMethod(params object[] Args) {
			
		}
		
		Console.WriteLine(((Delegate)ClassMethod).Method.GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
		Console.WriteLine(((Delegate)ClassMethod).Method.GetParameters()[0].GetCustomAttribute<ParamArrayAttribute>() is not null);
		Console.WriteLine(((Delegate)ClassMethod).Method.GetParameters()[0].CustomAttributes.Count());

		Console.WriteLine(((Delegate)LocalMethod).Method.GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
		Console.WriteLine(((Delegate)LocalMethod).Method.GetParameters()[0].GetCustomAttribute<ParamArrayAttribute>() is not null);
		Console.WriteLine(((Delegate)LocalMethod).Method.GetParameters()[0].CustomAttributes.Count());
	}
}

Output (tested only for .NET 7 and .NET 8):

True
True
1
False
False
0

[HaloFour]

Additional metadata isn't necessary in the case of local functions as the member isn't accessible outside of the assembly and the compiler is well aware that it accepts params.

Why would you need to know this through reflection? How the method is encoded should be treated as implementation details and anything not explicitly stated in the specification should never be relied upon.

[Joy-less]

I'm making a Ruby interpreter, which is a language with splat arguments (*) that function exactly like params in C#. To interop C# methods without pain, checking for params is not a "brittle strategy" but by definition the only way to implicitly interop. Why should the user have to specify the last argument is params (with a bool) when it should be done automatically by the compiler (and normally is)?

[HaloFour]

Because your interpreter is interacting with a delegate, not the underlying method. The delegate signature should be the only signature that matters. The fact that the delegate might point to a method that has params shouldn't matter.

[HaloFour]

Anyway, I guess it's up to the language team if they want to explicitly support that path. Without explicitly including it into the language spec I would consider it as undefined. You could make the argument that since private methods do include the attribute that it should apply to local functions as well, although the actual signature of a local function can differ from how it is declared based on what it does and how it's used.

[HaloFour]

Actually, as of C# 12, the natural type of the delegate would include the params parameters directly. This is true for class methods, local functions and lambdas:

using System;
using System.Reflection;
using System.Linq;

public class Program {
    static void ClassMethod(params object[] Args) {

    }
    public static void Main() {
        static void LocalMethod(params object[] Args) {

        }

        var Lambda = (params object[] Args) => { };

        Console.WriteLine(((Delegate)ClassMethod).GetType().GetMethod("Invoke").GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
        Console.WriteLine(((Delegate)ClassMethod).GetType().GetMethod("Invoke").GetParameters()[0].GetCustomAttribute<ParamArrayAttribute>() is not null);
        Console.WriteLine(((Delegate)ClassMethod).GetType().GetMethod("Invoke").GetParameters()[0].CustomAttributes.Count());

        Console.WriteLine(((Delegate)LocalMethod).GetType().GetMethod("Invoke").GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
        Console.WriteLine(((Delegate)LocalMethod).GetType().GetMethod("Invoke").GetParameters()[0].GetCustomAttribute<ParamArrayAttribute>() is not null);
        Console.WriteLine(((Delegate)LocalMethod).GetType().GetMethod("Invoke").GetParameters()[0].CustomAttributes.Count());

        Console.WriteLine(Lambda.GetType().GetMethod("Invoke").GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
        Console.WriteLine(Lambda.GetType().GetMethod("Invoke").GetParameters()[0].GetCustomAttribute<ParamArrayAttribute>() is not null);
        Console.WriteLine(Lambda.GetType().GetMethod("Invoke").GetParameters()[0].CustomAttributes.Count());
    }
}

prints:

True
True
1
True
True
1
True
True
1

Although if you look at the target method for the lambda it also is not declared with ParamArrayAttribute.

[Joy-less]

That's very interesting, that it only works when reflecting through the method name of "Invoke". Thanks for the workaround!

[CyrusNajmabadi]

If you want to check if a delegate has a params array, you should be checking the .Invoke method of the original delegate type that you have declared. The information about the actual method being passed along is not relevant.

[Joy-less]

What do you mean?

[CyrusNajmabadi]

I mean that the final pointer to the method being passed in isn't what should be examined.

Instead, your code should be taking in some delegate type. Like:

delegate void JoyDel(params int[] ints);
void JoyMethod(JoyDel d) { ... }
...

JoyMethod(JoyLocalFunc);

Here you want to examine the JoyDel delegate type. Look at it's Invoke method to make the determination. Don't look at the JoyLocalFunc function. That's not relevant. It's an implementation detail.

[Joy-less]

That would work if the method signature was known at compile time, but it's not because it needs to support every method type. I already tried passing in Func<T...>s and Action<T...>s instead of Delegates, but it's a very long process to support every overload of Func<T...>/Action<T...> and it also requires generics to be explicitly passed (which is annoying), for example:

public class Program {
	delegate void JoyDel<T1, T2, T3>(T1 a, T2 b, T3 c);
	public static void Main() {
		void MyExampleMethod(int a, bool b, string c) {
			
		}
		JoyMethod(MyExampleMethod); // The type arguments for method 'Program.JoyMethod<T1, T2, T3>(Program.JoyDel<T1, T2, T3>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
	}
	static void JoyMethod<T1, T2, T3>(JoyDel<T1, T2, T3> Thing) {
		
	}
}

Yes you could go JoyMethod<int, bool, string>(MyExampleMethod); but I don't want to do that, and it removes support for Delegate.
Also, this is still a bug, regardless of what I "should" be doing.

[HaloFour]

Also, this is still a bug, regardless of what I "should" be doing.

That's up to the language team to decide. If the spec doesn't state that the method should be emitted with those attributes, then it's not a bug. Relying on internal implementation details via reflection is an inherently brittle strategy.

[CyrusNajmabadi]

because it needs to support every method type

If you need to support every method type, then it's irrelevant how the original local function was declared. Just allow splatting of the final value was an array.

Also, this is still a bug, regardless of what I "should" be doing.

It is not. The original signature of a local function is a hidden detail. It can't be directly observed, and the language explicitly considers it a local. So the compiler is free to implement things as long as it is compliant with that.

[Joy-less]

I'd like to add that attributes are usually included for local function arguments (just not ParamArrayAttribute) making this a bug. Observe:

using System;
using System.Reflection;
using System.ComponentModel;
					
public class Program {
	public static void Main() {
		static void MethodA([DefaultValue("Default")] object[] Args) {
			
		}
		static void MethodB(params object[] Args) {
			
		}
		
		Console.WriteLine(((Delegate)MethodA).Method.GetParameters()[0].IsDefined(typeof(DefaultValueAttribute)));
		Console.WriteLine(((Delegate)MethodB).Method.GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
		Console.ReadLine();
	}
}

Output:

True
False

[Joy-less]

Thanks to @HaloFour for the workaround, but it only works with ParamArrayAttribute... bizarre!

using System;
using System.Reflection;
using System.ComponentModel;

public class Program {
    static void ClassMethod(params object[] Args) {

    }
    static void ClassMethod2([DefaultValue("Default")] object[] Args) {

    }
    public static void Main() {
	Console.WriteLine("Local ParamArrayAttribute");
        static void LocalMethod(params object[] Args) {

        }
        Console.WriteLine(((Delegate)LocalMethod).GetType().GetMethod("Invoke").GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
        Console.WriteLine(((Delegate)LocalMethod).Method.GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
		
	Console.WriteLine("\nLocal DefaultValueAttribute");
        static void LocalMethod2([DefaultValue("Default")] object[] Args) {

        }
        Console.WriteLine(((Delegate)LocalMethod2).GetType().GetMethod("Invoke").GetParameters()[0].IsDefined(typeof(DefaultValueAttribute)));
        Console.WriteLine(((Delegate)LocalMethod2).Method.GetParameters()[0].IsDefined(typeof(DefaultValueAttribute)));
		
	Console.WriteLine("\nClass ParamArrayAttribute");
        Console.WriteLine(((Delegate)ClassMethod).GetType().GetMethod("Invoke").GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
        Console.WriteLine(((Delegate)ClassMethod).Method.GetParameters()[0].IsDefined(typeof(ParamArrayAttribute)));
		
	Console.WriteLine("\nClass DefaultValueAttribute");
        Console.WriteLine(((Delegate)ClassMethod2).GetType().GetMethod("Invoke").GetParameters()[0].IsDefined(typeof(DefaultValueAttribute)));
        Console.WriteLine(((Delegate)ClassMethod2).Method.GetParameters()[0].IsDefined(typeof(DefaultValueAttribute)));
    }
}

Output (.NET 8):

Local ParamArrayAttribute
True
False

Local DefaultValueAttribute
False
True

Class ParamArrayAttribute
True
True

Class DefaultValueAttribute
False
True