Question

When implementing the facade pattern in Java, I can easily hide the subsystem of the facade by using the package-private modifier. As a result, there is only a small interface accessible from outside the facade/package, other classes of the sub-system are not visible.

As you already know, there is no package-private modifier in C#, but a similar one called internal. According to the docs, classes defined as internal are only accessible within the same assembly.

From what I unterstand, I have to create at least two assemblies (means practically two .exe/.dll files) in order to hide the subsystem of the facade physically. By physically I mean that the classes a) cannot be instantiated from outside and b) are not shown by intellisense outside the facade.

1. Do I really have to split my small project into one .exe and one .dll (for the facade) so that the internal keyword has an effect? My facade’s subsystem only consists of 2 classes, an own .dll seems to be overkill.
2. If yes, what is the best practice way in Visual Studio to outsource my facade to its own assembly?

Don’t get me wrong, I have no real need to split up my program into several assemblies. I just want to hide some classes behind my facade from IntelliSense and prevent instantiation from outside. But if I’m not wrong, there is no easier way that that.

Answer 1

Using a separate project is the general preferred approach. In fact, you often have interfaces or facades in a third assembly that both the implementation and UI assemblies reference.

That said, you can accomplish this in a single assembly using a nested private subclass.

public interface IMyService {}

public static class MyServiceBuilder
{
    public static IMyService GetMyService()
    {
        //Most likely your real implementation has the service stored somewhere
        return new MyService();
    }

    private sealed class MyService : IMyService
    {
        //...
    }
}

The outer class effectively becomes your ‘package’ for privacy scoping purposes. You probably wouldn’t want to do this for large ‘packages’; in those cases, it’s cleaner to move the code to a separate assembly and use internal.

Note that if you primary objection to multiple assemblies is deployment, you can actually merge multiple assemblies for the purpose of creating a simpler executable or library deployment. This way you can retain the insulation benefits of multiple projects/assemblies without having the headache of multiple files that can potentially be distributed or versioned independently.