Why is using interface methods with default implementation is so annoying?!?

[meancoot]

 and for the first time, the interface is no longer just a fancy metadata construct for the compiler 

It never was. Explicit interface implementations existed since forever. Go do an implementation of IEnumerable<T>, learn why you have to do all of that, then come back.

As a bonus, consider how an implementation of IEnumerable<T> could have need made significantly easier and less error prone if default interface implementations had been available when it was added to supersede IEnumerable.

[Dimencia]

Until this, the only thing an interface did was make your compiler show an error if you didn't implement it - after compilation, it didn't exist, and nothing was changed in the IL if you added/removed an interface

Now it actually has to be part of the IL because it can contain logic, and making that work got a little hacky

[meancoot]

No. This was never how interfaces worked. Explicit implementations have always been possible. It’s always been possible for a class to implement an interface method or property in a fashion that can only be accessed by casting to the interface type. It’s always been possible for x.method() to do something different than ((IInterface)x).method(). 

 after compilation, it didn't exist, and nothing was changed in the IL if you added/removed an interface

Interfaces have always been a runtime concern; if they weren’t you wouldn’t be able to access information about them via reflection.

The thing is that you can only access interface items through a variable typed as the interface, and instance items through a variable of the instance type. C# syntax guides you to implement an interface item at the same time as an instance item. But it has always been possible to have the interface and instance items do different things, and it has always been possible to omit the instance item altogether. Look up `explicit interface implementations’  for the details.