Here's how it works in Java:
package com.pc-doctor.mynamespace;
package class Foo { ... }
The class Foo is only visibile within mynamespace.
Even though I'm not a Java programmer, this immediately strikes me as extremely useful. Frequently, helper classes are only needed by code that lives close by.
There are two reasons to want namespace visibility to be enforced by your compiler:
- If you can make those classes invisible outside the namespace, it will make life a lot easier for clients of that namespace. Having only the useful classes appear in Intelisense is a big win.
- Having helper classes be invisible also helps construction of the component that is in the namespace. If the compiler doesn't let anyone make calls to the helper classes, then we can make much stronger assumptions about how our clients use the code.
The Microsoft Way
Microsoft expects you to make the classes internal. This prevents anyone outside of the assembly from using the class.
However, you have to make a separate assembly for each namespace that you want to do this with.
Frankly, that's painful enough that few people do it.
The C++ Way
C++ also lacks namespace visibility. The folks over at Boost use a separate namespace underneath the main namespace for helper classes (and functions). They've standardized on the name "detail" for this namespace, and it works fine for problem #1. It doesn't do anything for #2, though.
This is an easy thing to do, but it doesn't do much in C#. C# programmers use a lot more using directives than C++ programmers should. The only place to put a using directive in C# is at the top of the file. This means that, if a single function needs a namespace, then the whole file will get it.
The end result is that a lot of detail namespaces will be visible. This means that you'll have to make a using directive for the detail namespace that you really want, and you'll have to avoid typing "detail" to get to an element.
Even with those problems, it's probably worth doing in C#. Create a detail namespace under each namespace and put things that you'd like to have package scope in there.
Getting the C# Compiler to Enforce Namespace Visibility
C# does have a feature that can be used to emulate namespace visibility. This solution is a bit weird.
I should point out that it uses a feature of C# that wasn't designed for what we're going to use it for. In C++, this kind of behavior is encouraged and well supported. In C# (and Java), you're not supposed to deviate from the party line.
I'm sure Microsoft doesn't have any tests written for this behavior; I've already found one bug in the compiler from this technique.
What is a namespace? It allows many classes to be placed in the same scope even when they're stored in different files.
A partial class does the same thing, and this can be used to emulate a namespace. Partial classes were designed to allow Microsoft's code generators to create part of a class and put those portions of the code in a separate file. C#'s designer tool makes heavy use of this.
It's also very close to a namespace!
If you use a partial class as a namespace, then you can put multiple classes in different files and have some of them be invisible outside of the "namespace".
A private class inside the "namespace" is visible to other classes in the namespace, but it is not visible outside of the namespace. Likewise, a public class is visible outside of the partial class.
All of this is enforced by the compiler, too. We get both of the benefits of namespace visibility with this technique.
Unfortunately, it doesn't work perfectly.
For example, using declarations don't work for a partial class. If you're not in the namespace, you will always have to use the partial class's name to access public members of the namespace. This may be annoying in some cases, but, if you limit this technique's use to cases where there isn't a lot of access to the namespace from outside of it, then it's not serious.
It also looks wrong in the IDE. The IDE has no idea that your class is really a namespace, so it gets colored incorrectly. The severity of this problem is a matter of opinion. It doesn't bother me.
This is all awkward enough to prevent me from completely replacing namespaces. Instead, I use this when I want to expose an extremely simple API and perhaps a type or two. It's really only worth the trouble if you get to hide a lot by using this.
The syntax is also verbose:
namespace pcdoctor {
partial public class fakeNamespace {
private class NamespaceVisibilityClass {}
}
}
There's actually a hidden benefit of this technique. It's possible to make a "free function" in the fake namespace. A static member function behaves a lot like a free function. It's accessible from any of the classes in the namespace. If it's public, then it's accessible from outside the namespace.
I mentioned that I found a bug in the compiler. Unfortunately, I didn't track down exactly what the bug was. Instead, I just found a solution and moved on.
However, if you find that some of your code gets executed more than once when the fakeNamespace type is instantiated, then you might want to find another solution.
Good luck! Just remember that the central authority that controls C# programmers doesn't want you to do this. You're on your own here.