C# class/namespace Access

Question

Hello, I asked this question to multiple people and until now I do not have an answer.

ASP.NET C#

Project tree (files and folders):

> (ROOT) 
>
> Class MyAccess (namespace myproject.core)
> 
> (Directory John)
------> Class MyJohn          (namespace myproject.core.John)
------> Class JohnSecret      (namespace myproject.core.John)
------> Class OtherJohnSecret (namespace myproject.core.John)
> 
> (Directory Paul)
------> Class MyPaul          (namespace myproject.core.Paul)
------> Class PaulSecret      (namespace myproject.core.Paul)

How can I use (public, private, protected, internal) ????? to have have this behavior:

• class MyJohn sees and can create objects from all the classes inside John folder (all his secrets)
• class MyPaul have the same behavior but inside Paul folder
• All this secrets CAN NOT be used OUTSIDE this folders.

Examples:

• MyPaul can use all his secrets, and he can communicate with the classes MyAccess and with MyJohn.
• MyPaul, MyJohn, MyAccess will be public or internal
• MyAccess can not use PaulSecret.

---

Solutions that I do not like:

• BAD Solution 1

Make John secrets as protected and heritage one MyJohn

Example:

> protected JohnSecret
> internal MyJohn:JohnSecret

bad because if i've 100 class secrets I'll need to have something like:

> internal MyJohn:JohnSecret1, JohnSecret2,....,JohnSecret100

• BAD Solution 2

Have classes inside classes:

> internal class MyJohn {
> 
>        internal string DoSomething(){}
>        
>        private class JohnSecret{}
>        private class JohnSecret2{}
>        private class JohnSecret3{}
>
> }

It's not good because, once again, if I've 100 secrets I'll have a HUGE file, I can't split that code in different source code files.

---

Can anyone give a good solution?

I appreciate :)

Thanks a lot.

Answer 1

I think if you change your "Directory"'s to new Projects and then include them as References in your root application you might be able to achieve what you want to achieve.

Once you've created new Projects, setting the accessors as internal will limit the scope to that assembly only.

Answer 2

You should go with the second solution you propose. For the visibility requirements that you have it is most appropriate for JohnSecret, OtherJohnSecret, et. al. to be defined inside the MyJohn class.

If your desire is to split the class file in multiple files, you can use partial classes to achieve that and still maintain the visibility requirements that you have.

For example:

> (Directory John)
> File "MyJohn.cs"
public partial class MyJohn
{
}

> File "JohnSecret.cs"
public partial class MyJohn
{
    private class JohnSecret
    {
    }
}

> File "OtherJohnSecret.cs"
public partial class MyJohn
{
    private class OtherJohnSecret
    {
    }
}

Answer 3

C# has the following access.

• public - everyone can see it
• private - only things inside the class can see it
• protected - only things inside the class, or inside derived classes can see it
• internal - only things inside the assembly (dll or exe) can see it
• protected internal - only things inside the class or derived classes can see it, and only if they are in the same assembly

You have only 2 options:

• As Neil mentioned, you can use internal, and split your code up into 2 assemblies - one for John and one for Paul.
• As you have already mentioned, you can use private, and nest all the JohnSecret classes inside the outer John class. paracycle's tip of using partial classes makes this reasonably nice.

Note: to make multiple assemblies you must make multiple projects inside visual studio.

---

From a pragmatic point of view, does it really matter if the directories are fenced off from each other like that? There are no security benefits in using access modifiers as anyone can always use reflection to easily call your private/internal methods anyway.

The main benefit it gives you is keeping clutter out of your way when coding, but you've already put them in different namespaces, which should help with clutter anyway.

Answer 4

Dryadwoods,

After reading your comment on Orion Edwards' answer, I think you are mixing up the concepts of:

1. structuring your project so that its manageable for you to edit and build on it, and
2. protecting your code from reverse engineering

If its the second that you are actually trying to achieve then look into Dotfuscator or any other C# obfuscation tool. What that does is mix up your code at compile time to make it very difficult to reverse engineer, but allows you to code as you normally would.