Interface implementation with class member

[user274638]

Hi!

This proposal is about implementing interface by property of class to avoid redundant mappings.

The possible appearance could be the following:

public interface IInterface
{
    public void Method1();
    public void Method2();
}

public class InternalImplementor : IInterface
{
    public void Method1() => Console.WriteLine("Hello1");
    public void Method2() => Console.WriteLine("Hello2");
}

public class ExposedImplementor : IInterface
{
    [DefaultImplementation]
    IInterface Implementation { get; } = new InternalImplementor();

    public void Method2() => Console.WriteLine("Hello3");
}

Which essentially can be translated to:

public class ExposedImplementor : IInterface
{
    IInterface Implementation { get; } = new InternalImplementor();

    public void Method1() => Implementation.Method1();
    public void Method2() => Console.WriteLine("Hello3");
}

Of course, the exact way it is provided may be different, but I guess the general idea is understandable. Also, I believe it'd be cheap to implement due to the possibility of expression with existing elements at the compile time.

Usefulness lies in the fact that such a compact syntax will make it significantly easier to prefer composition instead of inheritance, which is generally beneficial in most cases.

[HaloFour]

See: #234

[CyrusNajmabadi]

This seems easy to achieve with a source generator.

[user274638]

I suppose, currently, this is how you do it. There is a reference to at least one such SG, in the discussion that is mentioned in the answer. Still, to me, this feels too integral to the design flow, enough to be included within the language itself.

[CyrusNajmabadi]

As this is an attribute that would just generate some members, there is literally nothing the language would need to do. This can just be done entirely in a SG with no lang changes at all.

[DavidArno]

Taking your example, this can already be achieved with default interface members (DIM's):

public interface IInterface
{
    public void Method1() => Console.WriteLine("Hello1");
    public void Method2() => Console.WriteLine("Hello2");
}

public class ExposedImplementor : IInterface
{
    public void Method2() => Console.WriteLine("Hello3");
}

Do you have an example of why DIMs don't fully solve your need here?

[user274638]

Yes, I am aware of DIM's. This particular example is just to show the idea. As for the feature, it'd be rather useful in cases when you would like to give the object some existing behavior or many of these (i.e. replacement for inheritance and multiple inheritance with more control).