Discussion: implement interface members with different names

[alrz]

Similar to Implements clause in VB:

interface Interface<T> {
  T Property { get; } 
  void Method();
}

class Class : Interface<A>, Interface<B>
{
  public A PropertyA : Interface<A>.Property { get; }
  public B PropertyB : Interface<B>.Property { get; }
  public void MethodA() : Interface<A>.Method {}
  public void MethodB() : Interface<B>.Method {}
}

Open question: should we disrespect access modifiers when we are explicitly implementing a member? (VB does)

[orthoxerox]

What about overriding base class members with different names?

[alrz]

@orthoxerox I didn't find any use cases for that and I'm not sure if clr supports it.

[orthoxerox]

@alrz It definitely supports it.

[YaakovDavis]

I find the : syntax confusing as it's commonly used in other languages to denote the return/declaration type. (Hopefully C# supports this form as well someday).

Why not implements?

void M() implements InterfaceA.M1, InterfaceB.N1
{
}

[alrz]

I find the : syntax confusing as it's commonly used in other languages to denote the return/declaration type.

Well, it means "implements" (and extends/inherits) in C# class C : B. Constructor initializers already use that syntax public C() : base() {} so I don't see how is that confusing.

Hopefully C# supports this form as well someday

Someday.

[svick]

I get that this just exposes an existing capability of .Net, but isn't the workaround of calling a renamed member from an explicitly implemented one sufficient?

class Class : Interface<A>, Interface<B>
{
  public A PropertyA { get; }
  public B PropertyB { get; }
  public void MethodA() {}
  public void MethodB() {}

  A Interface<A>.Property => PropertyA;
  B Interface<B>.Property => PropertyB;
  void Interface<A>.Method() => MethodA();
  void Interface<B>.Method() => MethodB();
}

I get that the above code is tedious and fairly verbose and that the generated assembly will not be exactly the same as with this proposal. But I don't think this happens often enough that it would be worth decreasing the verbosity. And the differences in the generated assembly probably won't cause any issues.

So this doesn't seem worth doing to me.

[alrz]

@svick You need to forward every parameter to the target method. VB just emits .override method.

[jhudsoncedaron]

For this one, I think the best solution doesn't involve changing the language specification at all. Just have the compiler generate the equivalent of Implements when it encounters A Interface<A>.Property => PropertyA;

[DzonnyDZ]

I'd still prefer being explicit about my intents than allowing language magic. Than somebody can be lot surprise why reflection cannot find such a member.
BTW: C++/CLI allows different name even for override which would be very very useful in some cases.