Namespace-only class visibility in C#/.NET?

In C#, can you make a class visible only within its own namespace without living in a different assembly? This seems useful for typical helper classes that shouldn't be used elsewhere. (i.e. what Java calls package-private classes)

You can make the classes internal but this only prevents anyone outside of the assembly from using the class. But you still have to make a separate assembly for each namespace that you want to do this with. I'm assuming that is why you wouldn't want to do it.

Getting the C# Compiler to Enforce Namespace Visibility

There is an article here (Namespace visibility in C#) that shows a method of using partial classes as a form of "fake namespace" that you might find helpful.

The author points out that this doesn't work perfectly and he discusses the shortcomings. The main problem is that C# designers designed C# not to work this way. This deviates heavily from expected coding practices in C#/.NET, which is one of the .NET Frameworks greatest advantages.

It's a neat trick… now don't do it.

I don't think that what you want is possible.

internal is assembly (strictly speaking module) privacy. It has no effect on namespace visibility.

The only way to achieve privacy of a class from other classes within the same assembly is for a class to be an inner class.

At this point if the class is private it is invisible to anything not in that class or the outer class itself.

If protected it is visible to everyone that could see it when private but is also visible to sub classes of the outer class.

public class Outer
{
    private class Hidden     { public Hidden() {} }
    protected class Shady    { public Shady() {} }
    public class Promiscuous { public Promiscuous() {} }
}

public class Sub : Outer
{
    public Sub():base() 
    {
        var h = new Hidden();      // illegal, will not compile
        var s = new Shady();       // legal
        var p = new Promiscuous(); // legal
    }
}

public class Outsider 
{
    public Outsider() 
    {
        var h = new Outer.Hidden();      // illegal, will not compile
        var s = new Outer.Shady()        // illegal, will not compile
        var p = new Outer.Promiscuous(); // legal
    }
}

In essence the only way to achieve what you desire is to use the outer class as a form of namespace and restrict within that class.

If you have a single assembly you can define as many namespaces in that assembly as you want but no matter what modifier you apply in the IDE you will always be able to see the classes in other namespaces.

Not sure if it is directly possible, but a few good ways to fake it would be:

1. Have the classes that need this sort of stuff inherit from a single class which has the helper class as an internal class.

2. Use extension methods and then only reference the extension methods within the namespace.

No, it is possible. You can use internal class in another assembly. For example I have a internal string extension class that located in SharMillSoft.Core assembly, if I want use it in another assembly that name is SharpMilSoft.Extension, I must use assembly attribute like as below:

using System;
using System.Linq;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("SharpMilSoft.Extensions")]

namespace SharpMilSoft.Core.Extensions.Strings.Public
{
    internal static class SharpStringExtensions
    {
        public static bool IsNullOrEmpty(this string data)
        {
            return string.IsNullOrEmpty(data);
        }
    }
}

And I use this class in SharpMilSoft.Extension assembly like as below:

namespace SharpMilSoft.Extensions.Strings
{
    public static class SharpStringExtensions
    {
        public static bool IsNullOrEmpty(this string data)
        {
            return Core.Extensions.Strings.Public.SharpStringExtensions.IsNullOrEmpty(data);
        }
    }
}

Note: Then SharpMilSoft.Extensions assembly will be friend assembly for SharpMilSoft.Core assembly

For more details about friend assembly, you can visit this link : Friend assemblies