Why does adding a namespace alias in C# remove ambiguity?

Question

I have two distinct namespaces, each with a Thing class:

namespace First.Second.Third
{
    public class Thing { }
}

namespace Fourth.Fifth.Sixth
{
    public class Thing { }
}

Now I try to use Thing elsewhere, and of course the compiler complains due to the ambiguous reference to that class:

namespace ConsoleApp1
{
    using First.Second.Third;
    using Fourth.Fifth.Sixth;

    internal static class MainEntryPoint
    {
        internal static void Main(string[] args)
        {
            var x = new Thing(); // Complaint.
        }
    }
}

If I add an alias to one of the namespaces in the using directive, the compiler error goes away:

using MyAlias = First.Second.Third;
using Fourth.Fifth.Sixth;

Now the compiler thinks I'm referring to Fourth.Fifth.Sixth.Thing when I do var x = new Thing();.

Why does the compiler resolve the ambiguity simply by adding an alias to one of the namespaces? Why does it automatically pick the namespace that I did not alias?

I expected this to be well documented and covered many times before on SO and elsewhere, but I can't find the answer. Can someone help me find the dupe if there is one?

EDIT: I'm not on the same page as everyone I guess. Here's a real-world example that might help:

If I have two people named "Bob", and I just say "here, give this to Bob", you won't know whom to give it to. If I say, well one is "Bob Smith" and the other is "Bob Johnson", of course I can now say "here, give this to Bob Smith." Now, if I say, "let's call Bob Smith by a new name: Bob Brady". If I then say "here, give this to "Bob", that is still ambiguous. See my point?

Answer 1

I think your misconception is that you believe that aliasing automatically imports the types of a namespace.

using Fourth.Fifth.Sixth;

makes all types in this namespace visible without additional qualification.

using MyAlias = First.Second.Third;

does nothing besides giving the namespace a new name, without importing it. So, if you change using First.Second.Third; into using MyAlias = First.Second.Third; the ambiguity is removed because Thing from First.Second.Third is no longer visible without further qualification. But obviously the other using is still importing Thing from Fourth.Fifth.Sixth.

Also see the corresponding definitions in the C# 5.0 Language Specification:

A using-alias-directive (§9.4.1) introduces an alias for a namespace or type.

A using-namespace-directive (§9.4.2) imports the type members of a namespace.

Answer 2

Here's the thing, you do:

using First.Second.Third;
using Fourth.Fifth.Sixth;

Now everything in First.Second.Third and Fourth.Fifth.Sixth can be referenced without their fully qualified name. This includes Thing however since both contain Thing then doing new Thing() is ambiguous.

If you do:

using First.Second.Third;
using MySixth = Fourth.Fifth.Sixth;

Then only First.Second.Third can be referenced without their fully qualified name, the namespace Fourth.Fifth.Sixth is just also known as MySixth, therefore no ambiguity.

Note the wording in: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/using-directive

For the first case it does say:

using System.Text;

To allow the use of types in a namespace so that you do not have to qualify the use of a type in that namespace

For the alias it does not mention qualifying of namespace use:

using Project = PC.MyCompany.Project;

To create an alias for a namespace or a type

Answer 3

I believe you're confusing the x alias with the x variable. Since you use x for alias in First.Second.Third if you want to use the Thing from that then you should use

var aThing = new x.Thing();

HTH, Mike

Answer 4

By putting an alias on the first option, you have effectively resolved the ambiguity (there aren't two Thing now - there is a Thing and a MyAlias.Thing).

If you refer to Thing it will default to using the non-aliased version (unless you specifically use the alias). This is exactly the same way that Console.ReadLine works if you use using System.

See below.

namespace Test
{
    using MyAlias = First.Second.Third;
    using Fourth.Fifth.Sixth;

    public class Program
    {
        static void Main()
        {
            var x = new Thing(); // non aliased
            var y = new MyAlias.Thing(); // aliased
            Console.ReadLine();
        }

    }
}

See also:

• https://msdn.microsoft.com/en-us/library/aa664765(v=vs.71).aspx
• https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/using-directive
• C# namespace alias - what's the point?