Namespace

Objectives

• Present namespace
– definition
– use
– advantages

2
Motivation: related types

• Types often closely related

– group of related types often called library

shape class Shape

library {
...
}

class Circle:Shape class Rectangle:Shape class Line:Shape

{ { {
... ... ...
} } }

3
 Motivation: library client

• Client code typically uses many types from same library

– library designer should indicate types are related
– simplifies search for appropriate type

Circle range = new Circle ();

use many types
Rectangle border = new Rectangle();
from same library
Line tangent = new Line ();

4
Motivation: name collision

• Error to multiply define symbol within same scope

– Shape, Rectangle, Type, Device, etc. are common names
– same name often used in different libraries
– duplicate names collide if libraries used together

geometric shape class Shape

{
int area;
...
}

athletic shape class Shape

{
int fitness; error, which
Shape s;
... shape?
}

5
Namespace advantages

• Namespace provides two main advantages

– logical grouping of source code
– name management

6
Namespace

• Namespace definition:
– keyword namespace
– name
– contents enclosed in { and }
– can contain class, struct, interface, enum, delegate

namespace namespace Shapes

{
class Shape { ... }
class Circle :Shape { ... }
contents
class Rectangle:Shape { ... }
class Line :Shape { ... }
}

7
 Discontinuous namespace

• Namespace members can be added separately

– all logically merged into single namespace
Shape.cs
namespace Shapes
{
class Shape
{
...
}
}

Circle.cs Rectangle.cs Line.cs

namespace Shapes namespace Shapes namespace Shapes
{ { {
class Circle:Shape class Rectangle:Shape class Line:Shape
{ { {
... ... ...
} } }
} } }

8
Logical grouping

• Namespace provides logical grouping

– user knows namespace members related

namespace Shapes

Shape

Circle

Rectangle

Line

9
 Qualified access

• Members accessed with name of namespace and dot operator

– called fully qualified name
– required when accessed from outside namespace

access with
fully qualified bool Overlap(Shapes.Circle c, Shapes.Rectangle r)
names {
...
}

10
Access from same namespace

• Qualification not needed when in same namespace

namespace Shapes
Shape and Circle {
in same namespace class Circle:Shape
so no qualification
{
needed
...
}
}

11
Name management

• Namespace provides name management

– classes in different namespaces can have same name

namespace Shapes namespace Fitness

Shape Shape

Circle
Athlete
Rectangle
Workout
Line

12
Name management details

• Fully qualified names are unique

– avoids name collision in user code

void Process()
{
ok Shapes.Shape a;

ok Fitness.Shape b;

...
}

13
 Using directive

• Using directive allows unqualified access to namespace

– syntax: using namespaceName;
– convenient when members used repeatedly

using directive using Shapes;

class Layout
{
unqualified access
bool Overlap(Circle c, Rectangle r)
to all members
{
...
}
...
}

14
Multiple using directives

• Multiple using directives do not cause an error

– even if each namespace contains member with same name

ok, even though

using Shapes;
both contain class
named Shape using Fitness;

15
Ambiguity with using directives

• Multiple using directives may result in ambiguity

– error to attempt unqualified access to duplicated name
– must use fully qualified name
both contain class using Shapes;
named Shape using Fitness;

class Layout
{
void Draw()
{
error Shape a;

ok Shapes.Shape b;

ok Fitness.Shape c;
...
}
...
}

16
Using alias for class

• Using allows creation of alias for class

– syntax: using newClass = oldClass;
– can yield more convenient or more meaningful name
– helps resolve ambiguity created by multiple using directives

create alias for

using MyCircle = Shapes.Circle;
Shapes.Circle
class Layout
{
void Draw()
{
use alias MyCircle a;
...
}
...
}

17
Using alias for namespace

• Using allows creation of alias for namespace

– syntax: using newNamespace = oldNamespace;
– can create more convenient or meaningful name
– can allow easier switch to different namespace

create alias for

using MyShapes = Shapes;
Shapes namespace
class Layout
{
void Draw()
{
use alias MyShapes.Circle c;
...
}
...
}

18
Using placement

• Using statements typically placed at top of file

– can put inside other namespace definition
– cannot go after any namespace definition
– cannot put inside class or method

ok using Shapes;

class Layout
{
error using Shapes;

bool Overlap(Circle c, Rectangle r)

{
error using Shapes;
...
}
...
}

19
Nested namespace

• Namespaces can be nested

Shapes

Shape

TwoD ThreeD

Sphere
Circle

Rectangle Cube

Line Tetrahedron

20
Coding nested namespace

• Two options to define nested namespace

– nesting syntax
– shorthand using dot operator

nesting syntax namespace Shapes

{
namespace TwoD
{
class Circle:Shape { ... }
}
}

shorthand namespace Shapes.TwoD

{
class Circle:Shape { ... }
}

21
Qualified access to nested namespace

• Can use fully qualified names to access nested namespace

access with Shapes.TwoD.Circle a;

fully qualified
names Shapes.ThreeD.Sphere b;

22
 Using directive for nested namespace

• Can access nested namespace with using directive

using directive using Shapes.TwoD;

class Layout
{
unqualified access bool Overlap(Circle c, Rectangle r)
to all members
{
...
}
...
}

23
Using is not recursive

• Using directive allows access to just one namespace

– does not give access to nested namespaces
– must have separate directive for each

applies only to
using Shapes;
Shapes namespace
class Layout
{
ok, since class is in Shape a;
Shapes namespace
error, both are in Circle b;
nested namespace Sphere c;
...
}

24
Global namespace

• Types not placed in a namespace go in the global namespace

– members available for use in all other namespaces
– no qualification needed

in global namespace class Color

{
...
}

namespace Shapes
{
class Shape
{
unqualified Color c;
...
}
}

25
Summary

• Namespace provides name management

– use helps avoid name collisions
• Namespace provides logical grouping mechanism
– related types grouped together
• Using provides shorthand access to namespace members
– provided there is no ambiguity

26