[Proposal]: 'Property' Type to Enable Passing Properties with Getter/Setter

[ReneeGA2020]

Summary

A structure that holds the getter and setter of a property, which any property can implicitly cast to it.

Property Type

Imagine a structure that represents a 'property instance', which holds its getter and setter, allowing you to assign a property to it.

public readonly struct Property<T>
{
    public Func<T>? Getter { get; init; }
    public Action<T>? Setter { get; init; }
    // ...
}

You could implicitly cast any property to this structure:

Property<int> property = testClass.TestProperty;

This could lower to:

Property<int> property = new Property<int>
{
    Getter = testClass.get_TestProperty, // The underlying getter, or simply () => testClass.TestProperty
    Setter = testClass.set_TestProperty, // The underlying setter, or simply value => testClass.TestProperty = value
};

With this, developers could easily pass any property 'by reference' as a parameter or even use extension methods.

public static void StartNumberAnimation<TNumber>(this Property<TNumber> property, TNumber by, double duration)
    where TNumber : struct, INumber<TNumber>
{
    var startValue = property.Getter?.Invoke() ?? default;
    var endValue = startValue + by;
    var currentValue = startValue;
    // Start update loop...
    // ...
    property.Setter?.Invoke(currentValue);
    // ...
}

The compiler would need to recognize the Property<T> type, so it could prioritize it over the actual value type of the property when deciding on extension overloads.

This would allow developers to write:

StartNumberAnimation(label.Width, by: 20, duration: 0.5);

or, using an extension method:

label.Width.StartNumberAnimation(by: 20, duration: 0.5);

Instead of the more verbose:

StartNumberAnimation(getter: () => label.Width, setter: value => label.Width = value, by: 20, duration: 0.5);

It's annoying when you have to pass two different version of label.Width, which breaks the purpose of property.

---

Additional Syntax Sugar

This approach is already quite useful, but if new syntax sugars can be expected, then we can make use of some new keywords. For instance, introducing keywords like propin and propout to represent the getter and setter of a property in function parameter modifiers.

For example:

public void Test(propout int value)
{
    // ...
}

This could lower to:

public void Test(Action<int> i)
{
    // ...
}

At the caller side:

Test(propout testClass.TestProperty);

This could lower to:

Test(value => testClass.TestProperty = value);

And we may finally be able to do things like this:

int.TryParse(txtAge.Text, propout Person.Age);

[TahirAhmadov]

#6191

[bernd5]

I actually don't see much need for this special type handling. Today you can write:

using System;

Property<int> prop = new(() => App.Something, (v) => App.Something = v);
Console.WriteLine(prop.Value);

class App
{
    public static int Something
    {
        get; set;
    }
}

public readonly record struct Property<T>(Func<T> Getter, Action<T>? Setter)
{
    public T Value
    {
        get => Getter();
        set => Setter?.Invoke(value);
    }
}

The only point I see is, that it would be great if we could bind App.Something to Func<T> or Action<T> without wrapping the expression in a lambda...

So we could write: Property<int> prop = new(App.Something, App.Something); instead of Property<int> prop = new(() => App.Something, (v) => App.Something = v);

[TahirAhmadov]

But why not write Property<int> prop = App.Something;?

[ReneeGA2020]

Yeah, that's the point of the whole proposal.

You can argue that property itself is not much needed, as you can write a SetSomething() and a GetSomething() to achieve what properties do.

App.Something contains less characters than new Property<int>(() => App.Something, (v) => App.Something = v)

And you won't be able to do extension methods like label.Width.StartNumberAnimation(by: 20, duration: 0.5); when you have to write 2 versions of Something

[colejohnson66]

As nice as this proposal is, it's definitely in the realm of source generators.

However: what happens if the setter isn't public, but internal or private? Is Property<T>.Setter null just like if it didn't exist? Would getting a Property<T> of myself give me a non-null setter?

Test t = new(42);
// If `p.Setter` null? I'd assume yes.
Property<int> p = propof(t.Value);

public sealed class Test(int value)
{
    public int Value { get; private set; } = value;

    public void DoThing()
    {
        // Is `p.Setter` null?
        Property<int> p = propof(this.Value);
    }
}

For Test.DoThing, if you say the setter should be non-null, what happens if I return that Property<T>:

Test t = new(42);
Property<int> p1 = propof(t.Value); // `p.Setter` is null
Property<int> p2 = t.GetProperty(); // `p.Setter` isn't null?

public sealed class Test(int value)
{
    public int Value { get; private set; } = value;

    public Property<int> GetProperty() =>
        propof(this.Value);
}

While arguably sound — it's the same as if you manually did GetProperty() => new(x => x.Value, (x,v) => x.Value = v), it's not specified.

[TahirAhmadov]

I would prefer ReadProperty<T> and WriteProperty<T> types for those situations.

[ReneeGA2020]

Also @colejohnson66, I'm curious how source generator can help on this case. AFIAK Source generator can only work on things like attributes and/or functions. Is there any way I can make it so 'properof' can be translated into the code I expected?

[ufcpp]

// user code
namespace ConsoleApp1
{
    using static Library.Helper;

    class A
    {
        public int X { get; set; }
    }

    static class Program
    {
        static void Main()
        {
            var a = new A();
            var p = propof(a, a.X);
        }
    }
}

// source generated code
namespace ConsoleApp1
{
    using System.Runtime.CompilerServices;
    using Library;

    internal static class Intercepter
    {
        [InterceptsLocation(1, "data from GetInterceptableLocation")]
        public static Property<int> propof(A x, int property) => new()
        {
            Getter = () => x.X,
            Setter = value => x.X = value
        };
    }
}```

[dotlogix]

Is this actually possible? I thought Interceptors must have the same signature as the original method.
In this example there needs to be a global propof generic method like:

public static Property<TProp> propof<TObj, TProp>(TObj x, TProp property)

which would mean the signature of the interceptor would need to be generic as well. This would mean you couldn't do what you have proposed because you have no access on the specific type properties or am I wrong?

[ReneeGA2020]

It also seemed like I cannot omit the (A x) part since in the interceptor you don't have the same accessibility as the location where you called the propof() function. You cannot just use a.X in the interceptor