[Proposal] Allow 'has' keyword for properties

[banjouuid]

Currently the framework allows you to:

if( obj is Grid grid) grid.Width = 123;

I have some code with events that looks like:

private async void RightTapped(object sender, RightTappedRoutedEventArgs e)
 {
       e.Handled = true;
       await Logic();
 }

 private async void Holding(object sender, HoldingRoutedEventArgs e)
 {
        e.Handled = true;
        await Logic();
 }

Because TappedRoutedEventArgs and HoldignRoutedEventArgs have the same name property "Handled" but is not inherited it is impossible to reuse code in that case. It would be nice to have something like:

private async void RightTapped(object sender, RightTappedRoutedEventArgs e) => Remove(e);
private async void Holding(object sender, RightTappedRoutedEventArgs e) => Remove(e);

private async void Remove(object args)
{
     if(args has bool Handled) Handled = true;
      await Logic();
}

[GeraudFabien]

impossible

I won't say impossible. But you may not want to.

private async void Remove(object args)
{
     try{ 
           ((dynamic)args).Handled = true;
      }
     catch {/*Code*/}
     await Logic();
}

My concern is the fact that if the frawework is done correctly you should not have this problem. In your exemple both inherit from "RoutedEventArgs" who have Handle property.

[banjouuid]

RoutedEventArgs is sealed class from the .Net framework so it cannot be inherited.

Well I meant an elegant solution, obviously you could put dynamics everywhere as you suggest, but what I was proposing is a better way to do it as we have the "is" keyword.

[Opiumtm]

You are asking for some form of duck typing.
Ideally, there should be "structural interfaces" or interfaces that can be attached to class later even if class is sealed.

Compiler can generate proxy class to emulate "declared later" or "structural" interface and substitute this proxy for original object where structural or "declare later" interface is needed as argument.

Performance of reflection is bad and there is naturally no way to make it comparable with strongly-typed invokes. So reflection is the last hope when anything else fail.

[jnm2]

Shapes would provide an efficient solution. #164

[banjouuid]

How using the shapes solution would look like?

[HaloFour]

@banjouuid

The proposal discussion is in the early stages so the syntax will very likely change but this is what it might look like:

public shape SHandleable {
    bool Handled { get; set; }
}

private async void RightTapped(object sender, RightTappedRoutedEventArgs e) => Remove(e);
private async void Holding(object sender, RightTappedRoutedEventArgs e) => Remove(e);

private async void Remove<T>(T args) where T : SHandleable
{
    args.Handled = true;
    await Logic();
}

You can think of a "shape" as being very similar to an interface except that they support "duck-typing" in that the class doesn't actually have to implement the shape as long as it exposes the compatible members. The compiler will also allow extension methods (and properties, that's a part of the same spec) to be considered.

[banjouuid]

I understand, looks good.