Add an operator for creating a delegate-like object from a property

[timojch]

Abstract

C# has a typeof operator, which takes a type name as a symbol and returns the corresponding System.Type object.

I propose a similar operator which accesses the reflection of properties and fields, and returns an object similar to a delegate, but for properties instead of methods.

Definition

Consider the following InstanceProperty class

public class InstanceProperty<TOwner, TProperty>
{
  private readonly TOwner Owner;
  private readonly PropertyInfo Property;

  public InstanceProperty(TOwner owner, string propertyName)
  {
    this.Owner = owner;
    this.Property = typeof(TOwner).GetProperty(propertyName);
  }

  public TProperty Get()
  {
    this.Property.Get(this.Owner);
  }

  public void Set(TProperty value)
  {
    this.Property.Set(this.Owner, value);
  }
}

It can be used like so:

var example = new ExampleObject();
var prop = new InstanceProperty<ExampleObject, bool>(example, nameof(example.IsFoo));
prop.Set(false);

This proposal is to add a reflectof operator which generates a binding which can be used in an identical way.

var example = new ExampleObject();
var prop = reflectof(example.IsFoo);
prop.Set(false);

What would this be used for?

The two primary use cases I see for this are for UI property bindings (e.g. binding a UI checkbox to a bool value in the underlying model) and animations (e.g. creating a tween object which changes the value of a property over time).

Why a new operator?

Having a built-in InstanceProperty class and a reflectof operator to create them would have the following advantages:

Compile-time type-checking

In the examples above, three things are currently checked at runtime which could be checked at compile-time:

1. The value of propertyName in InstanceProperty's constructor corresponds to a name of actual property (currently checked during construction).
2. The property type of IsFoo on ExampleObject is a bool (currently checked when unboxing the value from object inside of PropertyInfo.SetValue)
3. The property IsFoo is not read-only.

We also would be able to avoid taking generic arguments, which would make the code easier to modify. For example, changing ExampleObject.IsReadOnly from a boolto another type thatbool` can be assigned into would not require any changes to the code which binds to it.

Performance

There are currently two areas where the existing reflection-based approach potentially loses quite a bit of performance:

• During Construction. Creating bindings currently involves looking up the property by name each time a new binding is created. If you generate 10,000 bindings for 10,000 instances of the same class, the property will be looked up 10,000 times. With this feature, the property lookup could instead be done once (at compile time, load time, or even just lazily at runtime) and the result re-used.
• Boxing, Unboxing, and Type-Checking Calling PropertyInfo.SetValue requires boxing the value to an object and back, which results in a runtime type check before the value is assigned. This feature would allow the type-check to be performed at compile time, and the object could be stored in its original form all the way through.

It's possible to write code that doesn't have these disadvantages, but only by not using reflection, and instead writing unique code for each property that is bound to.

[TahirAhmadov]

#712
dotnet/roslyn#1653
dotnet/roslyn#128

[timojch]

I think this suggestion is slightly different from those, though similar in title. I probably shouldn't have used the word "reflection" in the title.

The feature here is more like a delegate than a PropertyInfo. I've updated the title accordingly.