You're mixing concepts here. In order to use an assembly you must add a reference to it in your project. This is done under the Dependencies node in Solution Explorer (for newer projects). For older projects you use the References node. This is the list of assemblies, COM libraries, other projects and NuGet packages your code relies on. You must add a reference before using code defined outside the project.
Once you add a reference you now have access to all the public types in that assembly. You can now write code that uses the type. However all types must be fully qualified so you'd need to type in the fully qualified namespace name of the type. For example assembly A my have type S under namespace M and type T under namespace N. To use them you must specify the full name.
M.S instanceS = new M.S();
N.T instanceT = new N.T();
Note that you are limited to types that are public and members that are public (or protected if deriving). If a type is internal then it is not accessible outside the assembly it is defined. If there is no accessiblity then it is internal.
Typing the fully qualified namespace name every time is painful, enter the using directive. This directive imports into the current scope (your file) the namespace you specify. Hence if you're using types from namespaces M and N then you can save some typing by adding a using for them.
using M;
using N;
S instanceS = new S();
T instanceT = new T();
Literally the only thing the using directive (here) is bring in the types that are contained in the given namespace into scop so you can reference them directly. When the compiler sees an identifier it tries to resolve the identifier using the current scope and then the file. If it cannot find it then it looks in the namespaces you including (using) in the file. Where those namespaces are defined is completely irrelevant since namespaces don't represent an object at runtime. They are simply used to fully qualify a name. In fact namespaces can (and do) exist in multiple assemblies.
Summary: references give you access to the code in an assembly, using directives import namespaces into a file so you can use the simple name instead of a fully qualified namespace name.