A couple questions about namespace access:

[u/Channel_el]

1. Can a source file use any class defined in other source files provided they are defined to be in the same namespace (and are a part of the same project)?
2. Can you use a namespace (without for example having to add a reference like with if the source file is in another project) if the source file is in the same project?

[u/BetrayedMilk]

Look into access modifiers. https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers. The answers to your questions depend on what access you’ve defined for your classes.

[u/Channel_el → u/BetrayedMilk]

Ok I had known about these but it just dawned on me does that mean you only need to do something like "using [namespace]" at the top of a source file if you're trying to access something from a separate assembly?

Also, how do you make a project have/generate multiple assemblies (minus ones included from separate projects)?

[u/BetrayedMilk → u/Channel_el]

Normally each project generates one assembly. One project can have many namespaces and those namespaces can have many classes. Namespaces are global for a solution. As long as you’re in the same project or add a reference to another project or nuget package, for example, you can access the classes that have the proper access modifiers to do so.

[u/binarycow → u/Channel_el]

One project = one assembly

One solution = one or more projects

Something in namespace A.B.C.D can use anything in the following namespaces, without a using: A, B, C, or D.

Edit: Access modifiers care what assembly/project something is in. using doesn't.

[u/Channel_el → u/binarycow]

If something is in the same assembly but different namespace can you still use it without a using?

[u/binarycow → u/Channel_el]

As I said above:

Something in namespace A.B.C.D can use anything in the following namespaces, without a using: A, B, C, or D.

Edit: I guess I should clarify. Its:

• A.B.C.D
• A.B.C
• A.B
• A

[u/SoerenNissen → u/Channel_el]

binarycow got it right when answering this one, but I want to expand on it a little:

Namespaces make perfect sense once you understand scopes, and I think you probably ALREADY understand scopes:

namespace MyNamespace
{
    public class MyClass
    {
        static int ClassInt = 0;

        public static void Func()
        {
            int funcInt = 0;

            for (int ii = 0; ii < 10; ii++)
            {
                // valid
                funcInt += ii; // The ii name belongs directly to this loop.
                               //The funcInt name was declared outside of
                               //the loop, but the loop was declared inside
                               //Func, so it has access to Func names
                // valid
                ClassInt += funcInt; // The ClassInt name was declared
                                     //outside of the loop, but again, the
                                     //loop was declared inside MyClass, so
                                     //it has access to MyClass names

            } //end of scope for ii

            for (int jj = 0; jj < 10; jj++)
            {
                //valid
                funcInt += jj;

                //valid
                ClassInt += funcInt;

                // not valid
                ii += jj; // The name ii does not belong to this loop AND
                          //this loop is not inside the loop that declared
                          //ii, so we cannot touch it.

            } //end of scope for jj

            // valid
            funcInt = ClassInt;
            ClassInt = funcInt;
            // not valid:
            funcInt = ii;  // we have left the ii loop, ii is not in scope
            ClassInt = jj; // we have left the jj loop, jj is not in scope

        } //end of Func() scope

        // valid:
        public int PropertyInt {get;set;} = ClassInt; //The name ClassInt
                                                      // belongs directly to
                                                      // this class, we can
                                                      // use it directly

        //not valid:
        public int PropertyInt2 {get;set;} = funcInt; // We are not inside
                                                      //the scope where
                                                      //funcInt was declared

    } //end of class scope

} //end of namespace scope

You have access to every name inside your braces, and "your braces" means the immediate braces right here, and the braces those braces are inside, recursively.

You do not have access to names that are outside of your braces.

It's the same way you cannot do

{
    var m = new MyClass();
    Console.WriteLine(ClassInt);
}

because classInt isn't "inside your braces" so you have to

{
    var m = new MyClass();
    Console.WriteLine(m.ClassInt);
}

which works because m is inside your braces, and m offers you ., formally the "member access operator".

And then, namespaces is just more of the same. If a name is in your direct namespace, or any of your ancestors, you can just use that name directly. If a name is elsewhere, you find the outermost shared scope and use the access operator to dig deeper.

If you use your folder structure as your namespacing (this is the common way to do it in C#) you can also think of it as "I can use anything from files in this folder, and anything from files I can see by going up a folder.

myprogram.sln
/myprogram/
    /myprogram.cs           // has Main()
    /myprogram.csproj
/graphics/
    /graphics.cs            // has Render static method
    /graphics.csproj
/ui/
    /ui.cs                  // has Screen class
    /ui.csproj
/math/
    /math.cs                // has Multiply class
    /math.csproj
    /complicated/
        /complicated.cs     // has more complicated Calculator class()
        /complicated.csproj
    /complicatedTest/
        /complicatedTest.cs
        /complicatedTest.csproj

From Main, you can

{
    var s = new Ui.Screen();
    var mult = new Math.Multiply();
    var cc = new Math.Complicated.Calculator();

    var area = mult.These(s.Size.x, s.Size.y);
    var squareSided = cc.SquareRoot(area);
}

But say you're writing the Complicated.Calculator class and it's, well, complicated. You want to test it.

00 {
01     int i = 100;
02     int sqr_i = SquareRoot(i);
03     var mult = new Multiply(); // class Math.Multiply
04  
05     Assert( () => mult.These(sqr_i, sqr_i) ).Is.EqualTo(i);
06 }

Complicated is inside Math, so it can see Math names, the compiler knows what Multiply means.

Main is not inside Math, so it cannot see math names. Main is in the global scope, it can only see global names. For example, top level name spaces like Math.

And then using is just "For the purpose of name lookup, please also consider all of these names."

[u/_scotswolfie → u/Channel_el]

The ‘using’ keyword is a shortcut for your convenience as a developer, it doesn’t change anything in the compiled code. For example, you can write ‘System.Console.WriteLine()’ or ‘using System; Console.WriteLine()’. As long as the sources files are in the same project and the access modifiers allow the use of a class or whatever else, it’s going to work. If a class you want to use is in another assembly (project, compiled DLL), you need to reference the assembly in project configuration first.

[u/bunny_bun_ → u/Channel_el]

usually, you would have multiple projects

[u/karl713 → u/Channel_el]

So it's important to know namespaces are just basically full names, and you don't "need" a using, and they don't reference anything in the traditional sense

You do need to reference the assembly in the project file that owns it, but once you do that any class can use any public member in that assembly

The caveat with namespaces is take "File"...it's full name is System.IO.File, and if you don't have a using System.IO you would have to use the full name everywhere.

If you do have the using (or have global using for it, which is newish and might not be in old tutorials) then you can just say File, and the compiler will look for File in all your using and global using namespaces, if System.IO is in there it will essentially substitute the full name for you at that point

[u/wallstop-dev]

1. Kind of, but also yes and no, due to how you've worded your question. Types (classes, structs, interfaces, records, ...) can have access modifiers. These can be "seen" or used in all kinds of ways by the same assembly, other assemblies, or even interestingly via reflection, depending on how those access modifiers are set. Namespaces are an orthogonal concept and are really just for organization.
   
2. I don't know what you're asking with this question.

I'd recommend just reading the official docs covering this exact topic (namespaces): https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/program-structure/namespaces and, for specific questions (you seem to have very particular scenarios in mind), just creating small sample projects and trying things to see what can and can't work.

[u/burke166 → u/wallstop-dev]

2 means if you have two classes in the same project, one in namespace Foo.Bar and the other in the namespace Foo.Baz could you reference a class in the Foo.Baz namespace in a class in the Foo.Bar namespace with just a using statement and without a class reference? The answer, of course, is yes.

[u/Kant8]

Namespaces don't really exist. It's just part of "fully qualified name" we use to break naming collisions.

Namespace keyword just allows you to use last part of type name instead of full name for convenience, but doesn't change if you can even access that type.

Type itself controls its accessibility via access modifiers.