AddParams(x) now sends the members of the runtime type when x is typed object (#90)

A variable typed object, or the result of a Func<T, object>, used to send
nothing because it has no members of its own. AddParams now uses the members of
the object's runtime type, found once per type and remembered.

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>

Author: electricessence

Source/Core/ExpressiveCommandBase.cs

@@ -379,7 +379,8 @@ public TThis AddParamIf<T>(bool condition, T value, [CallerArgumentExpression(na
 	/// When the real names are known, a member that the procedure does not declare is not sent, so one object can serve several procedures; parameters the procedure declares that no member matches are left to default values or to explicit <c>AddParam</c> calls.
 	/// A parameter you add with <c>AddParam</c>, by name or from an argument, wins over a member that resolves to the same name.</para>
 	/// <para>Every public readable property and field is read when this method is called, whether or not the procedure declares it, so a getter that throws or loads lazily runs then. Static members and indexers are ignored.
-	/// The members are those of the static type <typeparamref name="T"/>, not of the object's runtime type: a variable typed <see cref="object"/> has no members and adds nothing, and an interface adds only its own. Nested objects are not flattened (pass <c>order.Customer</c> itself).</para>
+	/// The members are those of the static type <typeparamref name="T"/>, not of the object's runtime type: an interface adds only its own. The one exception is <see cref="object"/>: a variable typed <see cref="object"/>, or the result of a <c>Func&lt;T, object&gt;</c>, has no members of its own, so the members of its runtime type are used.
+	/// There, the members of each type are found once and remembered. Nested objects are not flattened (pass <c>order.Customer</c> itself).</para>
 	/// </remarks>
 	/// <typeparam name="T">The type of the object whose members are the parameters.</typeparam>
 	/// <param name="source">The object to read the values from.</param>
@@ -391,6 +392,21 @@ public TThis AddParams<T>(T source)
 		if (source is null) throw new ArgumentNullException(nameof(source));
 		Contract.EndContractBlock();
 
+		// A source typed object has no members of its own: its runtime type's are used (a Func<T, object> result, a boxed anonymous object).
+		if (typeof(T) == typeof(object))
+		{
+			RuntimeParamSource members = RuntimeParamSource.Of(source.GetType());
+			if (members.Names.Length == 0) return (TThis)this;
+
+			// A new list is made at the size of the members, not at the default of four slots of a large struct.
+			List<Param> own = _params ??= new(members.Names.Length);
+			for (int i = 0; i < members.Names.Length; i++)
+				own.Add(Param.OfObject(members.Names[i], members.Getters[i](source), members.Types[i]));
+
+			EnsureOptions().HasDerivedParams = true;
+			return (TThis)this;
+		}
+
 		string[] names = ParamSource<T>.Names;
 		Func<T, object?>[] getters = ParamSource<T>.Getters;
 		Type[] types = ParamSource<T>.Types;

Source/Core/RuntimeParamSource.cs

@@ -0,0 +1,51 @@
+using System.Linq.Expressions;
+
+namespace Open.Database.Extensions;
+
+/// <summary>
+/// The public instance properties and fields of a RUNTIME type and a compiled getter for each, built once per type, for <c>AddParams(object)</c> when the argument is typed <see cref="object"/>
+/// and the static type has no members of its own. The members are found the way <see cref="ParamSource{T}"/> finds them.
+/// </summary>
+/// <remarks>One immutable entry per type, kept for as long as the type is alive (so a type that is unloaded takes its entry with it); the getters take the object, so no reflection runs after the first time a type is seen.</remarks>
+sealed class RuntimeParamSource
+{
+	static readonly ConditionalWeakTable<Type, RuntimeParamSource> Cache = new();
+	static readonly ConditionalWeakTable<Type, RuntimeParamSource>.CreateValueCallback Create = type => new RuntimeParamSource(type);
+
+	internal static RuntimeParamSource Of(Type type) => Cache.GetValue(type, Create);
+
+	internal string[] Names { get; }
+	internal Func<object, object?>[] Getters { get; }
+	internal Type[] Types { get; }
+
+	RuntimeParamSource(Type type)
+	{
+		var names = new List<string>();
+		var getters = new List<Func<object, object?>>();
+		var types = new List<Type>();
+		var seen = new HashSet<string>(StringComparer.Ordinal);
+		ParameterExpression source = Expression.Parameter(typeof(object), "source");
+		UnaryExpression typed = Expression.Convert(source, type);
+
+		foreach (MemberInfo member in type.GetMembers(BindingFlags.Public | BindingFlags.Instance))
+		{
+			// Readable properties without index parameters, and fields; a member hidden by name keeps the first.
+			bool usable = member is PropertyInfo { CanRead: true } property
+				? property.GetIndexParameters().Length == 0 && property.GetGetMethod() is not null
+				: member is FieldInfo;
+			if (!usable) continue;
+
+			Type memberType = member is PropertyInfo p ? p.PropertyType : ((FieldInfo)member).FieldType;
+			if (!seen.Add(member.Name)) continue;
+
+			Expression value = Expression.Convert(Expression.MakeMemberAccess(typed, member), typeof(object));
+			names.Add(member.Name);
+			types.Add(memberType);
+			getters.Add(Expression.Lambda<Func<object, object?>>(value, source).Compile());
+		}
+
+		Names = [.. names];
+		Getters = [.. getters];
+		Types = [.. types];
+	}
+}

Tests/Open.Database.Extensions.Core.Tests/ParameterNameAddParamsTests.cs

@@ -46,20 +46,125 @@ readonly struct Point
 		public int X { get; init; }
 	}
 
+	sealed class NoPublicMembers
+	{
+		internal int Hidden { get; } = 1;
+	}
+
 	static SyncNameRun TextCommand() => new(CommandType.Text, "@never");
 
-	// ---- the static type counts ----
+	// ---- the static type counts, except for object: then the members are those of the runtime type ----
+
+	[Fact]
+	public static void AnObjectVariable_SendsTheMembersOfItsRuntimeType()
+	{
+		object boxed = new { Region = "west", Secret = "x" };
+
+		Assert.Equal(["Region", "Secret"], TextCommand().Run(c => c.AddParams(boxed)));
+
+		var procedure = new SyncNameRun("@region");
+		Assert.Equal(["@region"], procedure.Run(c => c.AddParams(boxed))); // matched like the members of any other type: the undeclared one is left out
+		Assert.Equal("west", procedure.Values["@region"]);
+		Assert.Equal(1, procedure.Lookups);
+	}
+
+	[Fact]
+	public static void TheResultOfAFuncOfObject_SendsItsMembers_ReadAtEveryCall()
+	{
+		static object Make(int id) => new { Id = id, Name = "n" + id };
+		var run = TextCommand();
+
+		Assert.Equal(["Id", "Name"], run.Run(c => c.AddParams(Make(3))));
+		Assert.Equal(3, run.Values["Id"]);
+		Assert.Equal("n3", run.Values["Name"]);
+
+		Assert.Equal(["Id", "Name"], run.Run(c => c.AddParams(Make(4)))); // the members are found once per type, the values are read every time
+		Assert.Equal(4, run.Values["Id"]);
+		Assert.Equal("n4", run.Values["Name"]);
+	}
+
+	[Fact]
+	public static void DifferentRuntimeTypesInARow_EachSendItsOwnMembers()
+	{
+		object[] sources = [new { A = 1 }, new { B = "b", C = 2.5 }, new { A = 3 }, new WithRegion(), new Hiding()];
+		string[][] expected = [["A"], ["B", "C"], ["A"], ["Region", "Secret"], ["Id", "Inherited"]];
+
+		for (int i = 0; i < sources.Length; i++)
+			Assert.Equal(expected[i], TextCommand().Run(c => c.AddParams(sources[i])).Order());
+
+		var both = TextCommand();
+		Assert.Equal(["A", "B", "C"], both.Run(c => c.AddParams(sources[0]).AddParams(sources[1])));
+		Assert.Equal(1, both.Values["A"]);
+		Assert.Equal("b", both.Values["B"]);
+		Assert.Equal(2.5, both.Values["C"]);
+	}
+
+	[Fact]
+	public static void AHiddenMember_OfARuntimeType_KeepsTheMostDerivedOne_AsItDoesForTheStaticType()
+	{
+		object boxed = new Hiding();
+		var run = TextCommand();
+
+		Assert.Equal(["Id", "Inherited"], run.Run(c => c.AddParams(boxed)).Order());
+		Assert.Equal("derived", run.Values["Id"]);
+	}
+
+	[Fact]
+	public static void ABoxedStruct_SendsItsMembers()
+	{
+		object boxed = new Point { X = 7 };
+		var run = TextCommand();
+
+		Assert.Equal(["X"], run.Run(c => c.AddParams(boxed)));
+		Assert.Equal(7, run.Values["X"]);
+	}
 
 	[Fact]
-	public static void AnObjectVariable_HasNoMembersOfItsOwn_AndSendsNothing()
+	public static void ATypeWithNoMembers_AddsNothing_AndNobodyIsAsked()
 	{
-		object boxed = new { Region = "west" };
+		object nothing = new();
+		object noPublic = new NoPublicMembers();
 
-		Assert.Empty(TextCommand().Run(c => c.AddParams(boxed)));
+		Assert.Empty(TextCommand().Run(c => c.AddParams(nothing)));
+		Assert.Empty(TextCommand().Run(c => c.AddParams(noPublic)));
 
 		var procedure = new SyncNameRun("@region");
-		Assert.Empty(procedure.Run(c => c.AddParams(boxed)));
-		Assert.Equal(0, procedure.Lookups); // nothing was added, so there is nothing to match and nobody is asked
+		Assert.Empty(procedure.Run(c => c.AddParams(nothing)));
+		Assert.Equal(0, procedure.Lookups); // nothing was added, so there is nothing to match
+	}
+
+	[Fact]
+	public static void ANullObject_StillThrowsArgumentNullException()
+	{
+		var command = new ConnectionProbe(ConnectionState.Open).Connection.Command("select 1");
+
+		var ex = Assert.Throws<ArgumentNullException>(() => command.AddParams<object>(null!));
+
+		Assert.Equal("source", ex.ParamName);
+	}
+
+	[Fact]
+	public static void EveryPublicGetter_OfTheRuntimeType_IsReadWhenAddParamsIsCalled()
+	{
+		var command = new ConnectionProbe(ConnectionState.Open).Connection.Command("select 1");
+		object boxed = new LazyMember();
+
+		var ex = Assert.Throws<InvalidOperationException>(() => command.AddParams(boxed));
+
+		Assert.Equal("lazy", ex.Message);
+	}
+
+	[Fact]
+	public static void AStaticTypeOtherThanObject_KeepsItsOwnMembers_WhateverTheObjectIs()
+	{
+		IHasRegion region = new WithRegion();
+		Base derived = new Hiding(); // the static type is Base: Id is the int, and the runtime type's own members are not sent
+
+		Assert.Equal(["Region"], TextCommand().Run(c => c.AddParams(region)));
+
+		var run = TextCommand();
+		Assert.Equal(["Id", "Inherited"], run.Run(c => c.AddParams(derived)).Order());
+		Assert.Equal(1, run.Values["Id"]);
 	}
 
 	[Fact]