[BUG] Compile can't resolve namespace class differences

[Matt Mastracci]

It seems like the C# compile can't resolve the difference between a
namespace and a class in a situation that is clearly unambiguous. Note
that it sees the namespace "C" before the class "C". I believe it
should see the class "C" first.

test1.cs:
=============

using System;
using A.C;

namespace A.B
{
public class D
{
D() { C c = new C(); }
}
}

test2.cs:
=============

using System;

namespace A.C
{
public class C
{
int X;
}
}

=============

C:\>csc /target:library test1.cs test2.cs
Microsoft (R) Visual C# .NET Compiler version 7.00.9466
for Microsoft (R) .NET Framework version 1.0.3705
Copyright (C) Microsoft Corporation 2001. All rights reserved.

test1.cs(8,9): error CS0118: 'A.C' denotes a 'namespace' where a 'class' was
expected

 

[Nicholas Paldino [.NET/C# MVP]]

Matt,

It is not unambiguous, and it is actually disallowed. You can not have
a class in a namespace with the same name as the namespace explicitly
because of this. What if you had a nested type in class C? The compiler
would have to guess without knowing what C is, and I wouldn't put my trust
in any compiler that did that.

Hope this helps.

 

[Christian]

Classes can not have same name of namespaces.
Christian.

 

[Matt Mastracci]

Nope... Give it a shot.

BTW, after some thought, I think it's only ambiguous if you have both a
namespace "C" and a class "C" off the namespace "A.B". If I have a
class C with an inner class C in namespace C, the compiler can throw the
ambiguous reference error and I have:

A.B.C.C <- outer class
A.B.C.C.C <- inner class

If I have class C (1) with inner class C in namespace A.B and a class C
(2) in namespace A.B.C, it gets ambiguous:

A.B.C.C <- C (1)
A.B.C.C <- C (2)

Matt.

Of course.
Doesn'it?

Should the C# compiler then be marking the class with the same name as
the namespace as an error?

Nicholas Paldino [.NET/C# MVP] wrote:

Matt,

It is not unambiguous, and it is actually disallowed. You can not

have

a class in a namespace with the same name as the namespace explicitly
because of this. What if you had a nested type in class C? The

compiler

would have to guess without knowing what C is, and I wouldn't put my

trust

in any compiler that did that.

Hope this helps.

 

[Matt Mastracci]

Here's an example of more buggy (IMHO, of course) behaviour. Note that
in this case, a namespace higher the "current" namespace is interfering
with a reference from yet another namespace.

test1.cs
===========

using System;
using A.B;

namespace NA.NB.NC.ND
{
public class XXX
{
XXX() { Configuration c = new Configuration(); }
}
}


namespace NA.Configuration
{
}

test2.cs
===========

using System;

namespace A.B
{
public class Configuration
{
public Configuration() { X = 3;}
public int X;
}
}

Of course.
Doesn'it?

Should the C# compiler then be marking the class with the same name as
the namespace as an error?

Nicholas Paldino [.NET/C# MVP] wrote:

Matt,

It is not unambiguous, and it is actually disallowed. You can not

have

a class in a namespace with the same name as the namespace explicitly
because of this. What if you had a nested type in class C? The

compiler

would have to guess without knowing what C is, and I wouldn't put my

trust

in any compiler that did that.

Hope this helps.

 

[Matt Mastracci]

What about this case. This looks like the ambiguous "nested class"
situation you've mentioned, but compiles fine. Note that the output of
this program is "NA.Configuration.Inner".

test1.cs
=============

using System;
using A.B;

namespace NA.NB.NC.ND
{
public class XXX
{
static void Main() { Configuration.Inner c = new
Configuration.Inner(); c.Write(); }
}
}


namespace NA.Configuration
{
public class Inner
{
public void Write() { Console.WriteLine( this.GetType().FullName ); }
}
}

test2.cs
============

using System;

namespace A.B
{
public class Configuration
{
public Configuration() { X = 3;}
public int X;

public class Inner
{
public void Write() { Console.WriteLine(
this.GetType().FullName ); }
}
}
}

 

[Grant Richins [MS]]

Neither of these are ambiguous. The language spec is very clear about
things that make this unambiguous. When doing name resolution namespaces
are searched before using clauses (and outer namespaces with outer using
clauses). Thus in this example namespace NA is searched for a name
"Configuration" before even looking at your outermost using clauses.
Secondly name resolution occurs without consideration for the context of
where the name is used. In your example it is obvious that you expect
Configuration to be a type-name, but name lookup does not include that
information, it simply looks for the first "Configuration", it is then an
error if the name that it finds is not used properly. The exact same
reasons apply to your original example.

--
--Grant
This posting is provided "AS IS" with no warranties, and confers no rights.

Here's an example of more buggy (IMHO, of course) behaviour. Note that
in this case, a namespace higher the "current" namespace is interfering
with a reference from yet another namespace.

test1.cs
===========

using System;
using A.B;

namespace NA.NB.NC.ND
{
public class XXX
{
XXX() { Configuration c = new Configuration(); }
}
}


namespace NA.Configuration
{
}

test2.cs
===========

using System;

namespace A.B
{
public class Configuration
{
public Configuration() { X = 3;}
public int X;
}
}

Of course.
Doesn'it?

Should the C# compiler then be marking the class with the same name as
the namespace as an error?

Nicholas Paldino [.NET/C# MVP] wrote:


Matt,

It is not unambiguous, and it is actually disallowed. You can not
have

a class in a namespace with the same name as the namespace explicitly
because of this. What if you had a nested type in class C? The
compiler

would have to guess without knowing what C is, and I wouldn't put my
trust

in any compiler that did that.

Hope this helps.

 

[Grant Richins [MS]]

Not entirely true. Types SHOULD not have the same name as their enclosing
namespace. The language does allow them to be the same, but then callers of
the class have to be careful when writing code to make sure they always bind
to the class and not the namespace.

It is true that inner types cannot have the same name as their outer type.