Why can a class implement its own private nested interface in C#?

Question

The following code is a valid C# construct that compile juste fine.

public class Weird : Weird.IWeird
{
    private interface IWeird
    {
    }
}

What would be the possible uses of this?

Edit: This question is more specific that this one: "What is a private interface?". It shows that it's possible to implement a private interface from the parent type itself, which seems to be rather pointless. The only use I can think of would be a weird case of interface segregation where you would want to pass an instance of the parent class to a nested class instance as IWeird.

Possible duplicate of [What is a private interface?](http://stackoverflow.com/questions/792908/what-is-a-private-interface) — Dovydas Šopa, Feb 18 '16 at 10:23
If you have a nested private class that implements the interface, too, you might want to pass around `this` or an instance of that class by the private interface? Rather esoteric stuff, though :-) — Haukinger, Feb 18 '16 at 10:23
What's the issue? That a public class can implement a private interface? That a class can implement a nested interface? Just the conjunction of those two? — Damien_The_Unbeliever, Feb 18 '16 at 10:23
You are using a [Marker Interface](https://en.wikipedia.org/wiki/Marker_interface_pattern) using an inner interface. Although its valid and it has no purpose outside. Short answer - There are no Uses — Carbine, Feb 18 '16 at 10:25
Does it compile? [Mono's C# reports an error](http://ideone.com/o1VUEt). — Sergey Kalinichenko, Feb 18 '16 at 10:27
@Damien_The_Unbeliever The conjunction of the two. There is no issue though, its just surprising. — Romain Verdier, Feb 18 '16 at 10:28
Gives an error when compiled: Circular base class dependency — stamhaney, Feb 18 '16 at 10:42
I can confirm it *does* compile under Roslyn. It's *almost* circular but I don't think it is. The interface definition doesn't seem to have any dependencies. — Damien_The_Unbeliever, Feb 18 '16 at 10:43

score 3 · Answer 1 · answered Feb 18 '16 at 10:50

This is probably one of these situations in compiler development when prohibiting something has a higher cost than allowing it. Prohibiting this use would require writing and maintaining code to detect this situation, and report an error; if the feature works as-is, this is an additional work for the team, and it could be avoided. After all, perhaps someone with good imagination could figure out a way to use the feature.

As far as a useful example goes, one potential use is to make another implementation in the class, and use it as an alternative without exposing it to the users of the API:

public class Demo : Demo.Impl {
    // Private interface
    private interface Impl {
        public bool IsValidState {get;}
        void DoIt();
    }
    // Implementation for the error state
    private class Error : Impl {
        public bool IsValidState { get { return false; } }
        public void DoIt() {
            Console.WriteLine("Invalid state.");
        }
    }
    private readonly string name;
    // Implementation for the non-error state
    public bool IsValidState { get { return true; } }
    public void DoIt() {
        Console.WriteLine("Hello, {0}", name);
    }
    // Constructor assigns impl depending on the parameter passed to it
    private readonly Impl impl;
    // Users are expected to use this method and property:
    public bool IsValid {
        get {
            return impl.IsValidState;
        }
    }
    public void SayHello() {
        impl.DoIt();
    }
    // Constructor decides which impl to use
    public Demo(string s) {
        if (s == null) {
            impl = new Error();
        } else {
            impl = this;
            name = s;
        }
    }
}

As far as best practices go, this design is questionable at best. In particular, I would create a second nested class for the non-error implementation, rather than reusing the main class for that purpose. However, there is nothing terribly wrong with this design (apart from the fact that both IsValidState and DoIt are visible) so it was OK of the C# team to allow this use.

Why can a class implement its own private nested interface in C#?

1 Answers1