Common Type System—Namespace Resolution

Visual C# Tutorials

.NET Framework Tutorials

Common Type System Type Systems Intro § Types and Objects § Type Unification § Reference, Value Types § Accessibility, Visibility § Type Members § Fields § Methods § Locals Overloading Argument Passing Style Pass-by-Value and Pass-by-Reference Output Parameters Managed Pointers Variable Argument Methods Methods, Subclassing Virtuals, Overriding New Slots Exception Handlers Constructors, Instantiation § Default Constructors Value Construction Constructor Chaining Field Initialization Type Initializers Unhandled Exceptions Properties § Indexers Mixed Mode Accessibility Events Operator Overloading Coercion Subclassing, Polymorphism Styles of Inheritance § Implementation Inheritance Interface Inheritance Abstract Classes Interfaces § Method Dispatch Multiple Inheritance Private Interface Inheritance Private Inheritance Accessibility Interface Reimplementation Abstract and Interface? Sealing Types and Methods Runtime Type Checking Namespaces: Organizing Types § Define a Namespace Namespace Resolution Special Types § Delegates § CTS Support Co- and Contravariance Anonymous Delegates Custom Attributes Enumerations § Flags-Style Limitations Helper Methods Generics § Further Reading §

This Book Reviewed!

© 2006 Wiley Publishing Inc.

Namespace Resolution

Different languages resolve references to types inside namespaces in different manners. For example, in C# you can declare that a certain scope uses a namespace with the using keyword (Imports in VB), and you immediately get to access the types within it without having to type the fully qualified names. Without this feature, you’d need to type all of your source files as follows:

class Foo
{
   void Bar()
   {
      System.Collections.Generic.List<int> list =
         new System.Collections.Generic.List<int>();
      // ...
   }
}

Thankfully with the using keyword you can eliminate having to type so much:

using System.Collections.Generic;
 
class Foo
{
   void Bar()
   {
      List<int> list = new List<int>();
      // ...
   }
}

Sometimes imported namespaces can have types whose names conflict defined within them. In such cases, you must resort to fully qualified type names. To alleviate this problem, C# enables you to alias namespaces so that you can save on typing. For example, imagine we imported the Microsoft.Internal.CrazyCollections namespace, which just happened to have a List<T> type in it. This would conflict with System.Collections.Generic and must be disambiguated:

using SysColGen = System.Collections.Generic;
using Microsoft.Internal.CrazyCollections;
 
class Foo
{
   void Bar()
   {
      SysColGen.List<int> list = new SysColGen.List<int>();
      // ...
   }
}