Namespace 2 Present namespace advantages definition Objectives - - PDF document

Namespace

Objectives

• Present namespace

– definition – use – advantages

2

Motivation: related types

• Types often closely related

– group of related types often called library

3

class Shape { ... } shape library class Circle:Shape { ... } class Rectangle:Shape { ... } class Line:Shape { ... }

Motivation: library client

• Client code typically uses many types from same library

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

4

Circle range = new Circle (); Rectangle border = new Rectangle(); Line tangent = new Line ();

use many types from same library

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

class Shape { int area; ... }

geometric shape

class Shape { int fitness; ... }

athletic shape

Shape s;

error, which 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

7

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

namespace contents

Discontinuous namespace

• Namespace members can be added separately

– all logically merged into single namespace

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

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

bool Overlap(Shapes.Circle c, Shapes.Rectangle r) { ... }

access with fully qualified names

10

Access from same namespace

• Qualification not needed when in same namespace

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

Shape and Circle in same namespace so no qualification needed

11

Name management

• Namespace provides name management

– classes in different namespaces can have same name

12

namespace Shapes

Shape Circle Rectangle Line

namespace Fitness

Shape Athlete Workout

Name management details

• Fully qualified names are unique

– avoids name collision in user code

void Process() { Shapes.Shape a; Fitness.Shape b; ... }

• k
• k

13

Using directive

• Using directive allows unqualified access to namespace

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

using Shapes; class Layout { bool Overlap(Circle c, Rectangle r) { ... } ... }

using directive unqualified access to all members

14

Multiple using directives

• Multiple using directives do not cause an error

– even if each namespace contains member with same name

using Shapes; using Fitness;

• k, even though

both contain class named Shape

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

16

using Shapes; using Fitness; class Layout { void Draw() { Shape a; Shapes.Shape b; Fitness.Shape c; ... } ... } error

• k
• k

both contain class named Shape

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

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

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

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

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

using Shapes; class Layout { using Shapes; bool Overlap(Circle c, Rectangle r) { using Shapes; ... } ... }

• k

error error

19

Nested namespace

• Namespaces can be nested

TwoD

Shape Circle Rectangle Line

ThreeD

Sphere Cube Tetrahedron

Shapes

20

Coding nested namespace

• Two options to define nested namespace

– nesting syntax – shorthand using dot operator

21

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

nesting syntax

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

shorthand

Qualified access to nested namespace

• Can use fully qualified names to access nested namespace

Shapes.TwoD.Circle a; Shapes.ThreeD.Sphere b;

access with fully qualified names

22

Using directive for nested namespace

• Can access nested namespace with using directive

using Shapes.TwoD; class Layout { bool Overlap(Circle c, Rectangle r) { ... } ... }

using directive unqualified access 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

using Shapes; class Layout { Shape a; Circle b; Sphere c; ... }

applies only to Shapes namespace

• k, since class is in

Shapes namespace error, both are in nested namespace

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

class Color { ... }

in global namespace

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

unqualified

25

Summary

26

• 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