PropertySelector

[dr1rrb]

Reason

In generic code, it’s common to specify a “property” of an object as a “editable property” in a given “binding like” context written in code. The common usage is to update a sub-property of a root object based on some external trigger. For instance, toggle the T.IsFavorite on an object when the user trigger a generic ToggleIsFavoriteCommand<T>.

The issue is that it usually requires for the user to specify both a getter and a setter, which could be verbose and confusing, eg. Command.CreateToggleCommand(getter: x => x.IsFavorite, setter: (x, isFavorite) => x.IsFavorite = isFavorite).

The common technique is to use an Expression<Func<T, TProperty>>, but this uses reflection which is known to be costly at runtime.

Also when working with immutable records, we need to create a new instance of T to assign the value. This adds few levels of complexity:

1. It makes the delegate syntax even more confusing (setter will be Func<T, TProperty, T> instead of Action<T, Tproperty>)
2. When editing a “multi level” property (t => t.A.B.C) you will have to define setter for the whole tree, and will require that the user handles possible new values.

Proposal

• We will create a specific delegate public delegate TProperty PropertySelector<T, Tproperty>(T entity)
• Using code gen, at compile time we will:
  1. Detect all instantiations of that delegate.
  2. Validate the syntax to ensure it respects the rules and known limitations.
  3. Generate a registry of getter and setter for each usage in an assembly (cf. Resolution key section)
  4. Generate auto registration of that registry (using the AssemblyInitializeAttribute) into a static registry.
• At runtime users of the delegate will be able to use a static PropertySelectors.Get<T, TProperty>(PropertySelector<T, TProperty> selector, string name, string filePath, int lineNumber) In order to get a IPropertyAccessor<T, Tproperty>

IPropertyAccessor

We will work with interface to allow other implementation than the generated from immutable records we are discussing here (like for instance an attached property which uses a Get and Set method).

public interface IPropertyAccessor<T, TProperty>
{
	string Path { get; }
	public TProperty Get(T entity);
	public T Set(T entity, TProperty value);
}

Resolution key

We need to find a way to match a definition resolved at compile time an instance at runtime, but we don’t want to give to the user the responsibility to provide a unique cache key.
The only valid way to automatically generate that cache key will be to use the use file path and line number where the delegate is being declared.
Those can be fulfilled by the CallerFilePathAttribute and the CallerLineNumberAttribute. The issue is that in a common usage MyMethod(PropertySelector selector, [CallerFilePath] string path = “”, [CallerLineNumber] int line = -1) we will get the info for the MyMethod usage, not the selector itself. We might also have conflict if a method has 2 KeySelector parameter. So we will also append the parameter name.

Rules

1. All types, including intermediate types, will have to have a parameter less constructor (or with only nullable properties).
2. The delegate must not have any capture (i.e. state less).
3. The delegate must use only properties accessor (i.e. no method nor fields).
4. The T and all intermediate types must be a record.
5. Public APIs that requires a PropertySelector must also require a cache key

Known limitation

Current limitation that could be resolve in next versions

1. No support of immutable collection.

[dr1rrb]

Difficulties

• The generator will have to dig into all code of the application to find the usage of a method that is using a PropertySelector. We need to use incremental code generator, using as ref the DP generator: https://github.com/unoplatform/uno/blob/master/src/SourceGenerators/Uno.UI.SourceGenerators.Internal/DependencyObject/DependencyPropertyGenerator.cs