[Proposal] async getter/setter

[fawdlstty]

example:

class A {
	public B mod_b { async get; async set; }
	public string name { get; set; }
};
class B {
	public A mod_a { async get; async set; }
	public int age { get; set; }
};

Applicable scenarios: for example, in the database ORM domain, the one-to-one relationship between the two object models of AB exists. When accessing B through the variable of model A (that is, the getter), the database is asynchronously inquired, and other background HTTP requests developed based on this ORM framework are not blocked.

call async get/set:

A a = new A ();
B b = new B ();
// async set
await a.mod_b = b; // or new grammar likes:   a.mod_b await= b;
// async get
B b2 = await a.mod_b;

[fawdlstty]

Similarly, setter are used in special situations to modify the database, and the function returns if the modification is successful

[svick]

What would be the syntax to invoke the setter?

[jnm2]

Also, how does either the getter work without returning an instance of Task<B> or some other awaitable type with a result type of B?

In order for waiting to be asynchronous, the member being called must return before there is a B instance to hand back. It must return an object that is capable of subscribing a delegate to be called back as soon as there is an instance of B available.

[fawdlstty]

What would be the syntax to invoke the setter?

good question, I have no idea

[fawdlstty]

may new grammar await= likes a.mod_b await= b;

[HaloFour]

Similarly, setter are used in special situations to modify the database, and the function returns if the modification is successful

Fallible and/or time sensitive operations should not be hidden behind properties. The setter should set local state and a separate method used to initiate the asynchronous operation back to the database.

https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/property

That aside, there's technically nothing in the CLR that would forbid asynchronous properties. A property declared as type Foo can have a getter that returns a Task<Foo> or ValueTask<Foo>, and the setter could return Task or ValueTask. The CLR doesn't care what the accessor method signature is, that's entirely up to the language. However, absolutely none of the existing .NET ecosystem would understand how to work with these properties. Existing frameworks that don't explicitly defend against the accessor method signature not matching the property type would probably explode or behave in an undefined manner.

[fawdlstty]

The database object model is like this:

public class A : Model {
	public Guid? ModbId { get; set; }
	public B Modb { async get; async set; }
	public string name { get; set; }
};
public class B : Model {
	public Guid? ModaId { get; set; }
	public Task<A> Modb { get; }
	public async Task set_a (A a) {}
	public int age { get; set; }
};

Semantically, the setter of Task<A> means to assign A Task, and async set means to assign A primitive value, but the assignment process needs to wait

[IS4Code]

I don't really see an issue with having await a.mod_b = b; as the syntax for assignment. If a normal assignment "returns" the assigned value, an async assignment can well return a Task thereof.

[zetroot]

The case this feature would be great to use is binding in WPF. For example you have such XAML:

<DataGrid ItemsSource="{Binding Collection}" SelectedItem="{Binding SelectedElement}">
....
</DataGrid>

And you want to perform some async operations in setter of SelectedElement (lazy reading details from db, for example). Now the way to do it is using async void wrappers:

object SelectedElement 
{
    get => selectedElement;
    set
    {
        selectedElement = value;
        AsyncOperationWrapper();
    }
}

async void AsyncOperationWrapper() => await AsyncOperation();
async Task AsyncOperation() { ... }

Not the best C# code, but i have no idea how to do this in a better way without async setters

[jnm2]

@zetroot The better way that I settled on after years of trying other things is https://github.com/Techsola/AmbientTasks.