Interface Notification without own Method

[JuC0de]

Hi, i'm kinda new here, and really like C# and VS but I've found some points where it can be improved(or I think so ^^).

Interfaces - it would be nice to have some warning or notification in VS2017 that(document as ICopy).Copy(); going to use Main Void Method if none of his own is declared.

Visual Studio have its own Notification by Debug it could be placed here.

For example a notification or warning by Visual Studio in Debuging mode(at Warnings or Notifications):
"Interface ICopy have none of its own Copy.Method and will use main method from Class.Document"

using System;

class Program
{
    static void Main(string[] args)
    {
        var document = new Document();
        document.Copy();

        (document as ICopy).Copy();
        (document as IAdress).Copy();
    }
}
public interface ICopy
{
    void Copy();
}
public interface IAdress
{
    void Copy();
}
class Document : ICopy, IAdress
{
    public void Copy() // This main method will be use as long ICopy have none of own.
    {
        Console.WriteLine("Main void");
    }
    // void ICopy.Copy()
    // {
    //     Console.WriteLine("ICopy void");
    //}
    void IAdress.Copy()
    {
        Console.WriteLine("Adress void");
    }
}

[huoyaoyuan]

I think it's more responsible for the text editor.
When selecting ICopy, it should highlight the methods implementing it. Currently only an explicit implementation will be highlighted.
For runtime tracing, you can set break point/write to debug output.

[svick]

I don't think there should be any kind of notification about this, because implicit implementation (like public void Copy()) is the most common way to implement interfaces in C#.

Why do you think this requires a notification? Why did it confuse you?

[JuC0de]

It confused me when I used (document as ICopy).Copy(); and I've forgotten about writing that Method and it used the main Copy.Method from the same class, it took me a while to find a problem because I tho I did it 0o (the code wasnt that simple of course) simple notification about would be just awsome, sometimes you are just tired and do stupid mistakes that is all. Thanks for the comment tho°!

[CyrusNajmabadi]

Interfaces - it would be nice to have some warning or notification in VS2017 that(document as ICopy).Copy(); going to use Main Void Method if none of his own is declared.

First: if this is a suggestion for a behavioral change in VS2015, then this should go to /dotnet/roslyn. /dotnet/csharplang is for suggestions to changes in the C# language itself.

Second: this suggestion for the IDE needs to be much more fleshed out. Say we did this:

Visual Studio have its own Notification by Debug it could be placed here.

1. Enormous amounts of C# programs use 'implicit interface implementation' (teh feature you're talking aout here). And they will have hundreds of implementations with thousands of implemented members. This would lead to an absolute deluge of messages shown to the user.

2. Why is this notification helpful. It's basically saying "the program is operating in the standard way C# has operated in since inception." The way this has worked has not been deemed to be a problem, and it seems like most developers have no issue with this part of the language. So this suggestion would be enormously annoying for all of them.

3. Suggestions of the form: "i would like it if something in the system told me X" can already be solved today with the Roslyn-Analyzer plugin system. The Language and Compiler add features they think are broadly useful and will be beneficial to most of the ecosystem. For these type of one-off features, the best thing to do would be for you to write your own analyzer that looks for thsi and tells you about it. You could even put this on nuget. If people found it valuable they could then use it.

Thanks much!

[huoyaoyuan]

@CyrusNajmabadi Could the IDE provide a built-in support of finding "all methods implementing the interface"? I think this is useful in some scenarios.

[CyrusNajmabadi]

Yes. FindAllReference on the interface method will list all the implementations. It even finds weird stuff like this:

interface IFoo { void Foo(); }
class C { public void Foo(); }
class D : C, IFoo { }

In this case, it will find the implementation in C, even though C never actually specifies that it implements IFoo.  Indeed, C.Foo only becomes an implementation due to D's implementation of IFoo.

[DavidArno]

For:

interface IFoo
{
    void Bar();
}

class Foo : IFoo
{
    public void Bar() { }
    void IFoo.Bar() { }
}

it possibly would be nice to have something warn that both an implicit and explicit implementation of Bar are defined. But surely that is a classic an example of where analyzers could be used?

[yaakov-h]

@DavidArno it does sound a lot like an Analyzer to me.

[Joe4evr]

both an implicit and explicit implementation of Bar are defined.

Even then, it always binds to the explicit implementation as far as the interface is concerned. I've done some neat tricks with that in the past. 🙃

[DavidArno]

@Joe4evr,

Absolutely. SuccincT makes heavy use of that. The pattern expressions are created via the builder pattern; using around a dozen interfaces and explicit implementations of those interfaces to only expose valid methods depending on the context of the fluent chain.

[svick]

ReSharper adds an icon into the margin telling you that a method implements an interface:

Do you think this is good enough for you? If so, have you considered using ReSharper? Or do you think VS itself should show such an icon?

[DavidArno]

@svick,

I've been using R# for years and never noticed it did that! 😀

[CyrusNajmabadi]

it possibly would be nice to have something warn that both an implicit and explicit implementation of Bar are defined.

This is a pretty common and normal pattern. Warning in this case would break a lot of code. Note: you don't actually have an implicit implementation of 'Bar' here. You have the explicit implementation, and you have a public method with a matching signature.

But surely that is a classic an example of where analyzers could be used?

Yup. There is nothing wrong with this code. If you don't want it in your domain, then it's best to write your own analyzer to catch this.