Application: Introducing Namespaces

1. Start Microsoft Visual Studio

2. To create a new project, on the main menu, click File -> New Project
3. In the left list, click Windows
4. In the right list, click Empty Project
5. Change the name to DepartmentStore4
6. Click OK
7. To create a new file, on the main menu, click Project -> Add New Item...
8. In the left list, click Code
9. In the right list, click Code File
10. Change the Name to DepartmentStore and press Add
11. In the empty document, type the following:
12. public class DepartmentStore
13. {
14. static int Main()
15. {
16. return 0;
17. }
}
Manually Creating a Namespace
To create a namespace:
 Type code that starts with the namespace keyword followed by the name of the section
 Right-click the section where you want to create the namespace and double-click Insert
Snippet... Double-click Visual C#. In the list, double-click namespace
Like a class, the section that is part of a namespace starts with an opening curly bracket
"{" and ends with a closing curly bracket "}". Here is an example:
namespace Business
{
}
Between the curly brackets, you can type anything that is part of the namespace. For
example, you can create a class inside of a namespace. Here is an example:
namespace Business
{
class House
{
}
}
Application: Creating a Namespace
 To create a namespace, change the document as follows:
 public class DepartmentStore
 {
 static int Main()
 {
  return 0;
 }
 }

 namespace Store
 {
 public class StoreItem
 {
 public int itemNumber;
 public string itemName;
 public decimal unitPrice;
 }
}
An Automatically Generated Namespace
In Lesson 5, we mentioned that, to create a new class:
 On the main menu, you can click Project -> Add Class...
 In the Solution Explorer, you can right-click the name of the project -> Add -> click Class...
 In the Class View, you can right-click the name of the Project -> Add -> Class...
If you use any of these approaches, Microsoft Visual C# 2010 Express or Microsoft
Visual Studio would create a namespace using the name of the project and wouold add
the new class to it.
Accessing the Members of a Namespace
After creating the necessary members of a namespace, you can use the period operator
to access an item that is part of the namespace. To do this, in the desired location, type
the name of the namespace, followed by a period, followed by the desired member of
the namespace. Here is an example:
namespace Business
{
public class House
{
public string propertyNumber;
public decimal price;
}
}

public class Exercise

{
static void Main()
{
Business.House property = new Business.House();

property.propertyNumber = "D294FF";
property.Price = 425880;
}
}
Application: Accessing Members of a Namespace
1. To access the content of a namespace, change the document as follows:
 2. public class DepartmentStore
3. {
4. static int Main()
5. {
6. Store.StoreItem si = new Store.StoreItem();
7.
8. si.itemNumber = 613508;
9. si.itemName = "Merino Crew Neck Cardigan";
10. si.unitPrice = 80.00M;
11.
12. System.Console.WriteLine("Store Inventory");
13. System.Console.Write("Item #: ");
14. System.Console.WriteLine(si.itemNumber);
15. System.Console.Write("Item Name: ");
16. System.Console.WriteLine(si.itemName);
17. System.Console.Write("Unit Price: ");
18. System.Console.WriteLine(si.unitPrice);
19.
20. System.Console.ReadKey();
21. return 0;
22. }
23. }
24.
25. namespace Store
26. {
27. public class StoreItem
28. {
29. public int itemNumber;
30. public string itemName;
31. public decimal unitPrice;
32. }
}
33. Execute the application to see the result:
34. Store Inventory
35. Item #: 613508
36. Item Name: Merino Crew Neck Cardigan
Unit Price: 80.00
37. Press Enter and return to your programming environment

Creating and Using Many Namespaces

 
Introduction
In the above example, we created one namespace in a file. In the same way, you can
create many namespaces in the same file, as long as the body of each namespace is
appropriately delimited. Here is an example:
namespace RealEstate
{
public class House
{
public string propertyNumber;
public decimal price;
}
}
namespace Dealership
{
public class Car
{
}
}
You can also create namespaces in various files. For example, you can create each
namespace in its own file, or you can create a group of namespaces in one file and one
or a group of namespaces in another file. After creating the files, to access the content
of a namespace, you can qualify the name of the class.
Application: Creating Many Namespaces
1. To create a new file, on the main menu, click Project -> Add New Item...
2. If necessary, in the left list, click Code.
In the right list, click Code File
3. Change the Name to Records and press Add
4. Change the document as follows:
5. namespace Store
6. {
7. public class StoreItem
8. {
9. public int itemNumber;
10. public string itemName;
11. public decimal unitPrice;
12. }
}
13. To create a new file, on the main menu, click Project -> Add New Item...
14. If necessary, in the left list, click Code.
In the right list, click Code File
15. Change the Name to Suppliers and press Add
16. Change the document as follows:
17. namespace Supply
18. {
19. public class Manufacturer
20. {
21. public string companyName;
22. public string contactName;
23. public string contactPhone;
24. }
}
25. To access the other file, click the DepartmentStore.cs label
26. To use the namespaces, change the document as follows:
27. public class DepartmentStore
28. {
29. static int Main()
30. {
31. Supply.Manufacturer dealer = new Supply.Manufacturer();
32. dealer.companyName = "Peel Corp";
 33. dealer.contactName = "Sylvain Yobo";
34. dealer.contactPhone = "(602) 791-8074";
35.
36. Store.StoreItem si = new Store.StoreItem();
37.
38. si.itemNumber = 613508;
39. si.itemName = "Merino Crew Neck Cardigan";
40. si.unitPrice = 80.00M;
41.
42. System.Console.WriteLine("Store Inventory");
43. System.Console.Write("Item #: ");
44. System.Console.WriteLine(si.itemNumber);
45. System.Console.Write("Item Name: ");
46. System.Console.WriteLine(si.itemName);
47. System.Console.Write("Unit Price: ");
48. System.Console.WriteLine(si.unitPrice);
49.
50. System.Console.ReadKey();
51. return 0;
52. }
}
Using a Namespace
We saw that, to call an object or a method that is part of a namespace, you must
"qualify" the object using the period operator. Instead of using this approach, if you
already know the name of a namespace that exists or has been created in another file,
you can use a special keyword to indicate that you are using a namespace that is
defined somewhere. This is done with the using keyword. To do this, on top of the file
(preferably), type using followed by the name of the namespace.
With the using keyword, you can include as many external namespaces as necessary.
Whether you use the using keyword or not, you can still access a member of a
namespace by fully qualifying its name. In fact, when there is name conflict (it's usually
not a conflict; it could just be the way the namespace was created; a common example
is in Visual Basic where the Switch() function sometimes conflicts with the Switch
keyword), even if you use using, you must still qualify the name of the class.
Application: Using Namespaces
1. To use the using keyword, change the document as follows:
2. using Supply;
3. using Store;
4.
5. public class DepartmentStore
6. {
7. static int Main()
8. {
9. Manufacturer dealer = new Manufacturer();
10. dealer.companyName = "Peel Corp";
11. dealer.contactName = "Sylvain Yobo";
12. dealer.contactPhone = "(602) 791-8074";
13.
14. StoreItem si = new StoreItem();
15.
 16. si.itemNumber = 613508;
17. si.itemName = "Merino Crew Neck Cardigan";
18. si.unitPrice = 80.00M;
19.
20. System.Console.WriteLine("Manufacturer Information");
21. System.Console.Write("Company Name: ");
22. System.Console.WriteLine(dealer.companyName);
23. System.Console.Write("Contact Name: ");
24. System.Console.WriteLine(dealer.contactName);
25. System.Console.Write("Contact Phone: ");
26. System.Console.WriteLine(dealer.contactPhone);
27.
28.
System.Console.WriteLine("---------------------------------------");
29.
30. System.Console.WriteLine("Store Inventory");
31. System.Console.Write("Item #: ");
32. System.Console.WriteLine(si.itemNumber);
33. System.Console.Write("Item Name: ");
34. System.Console.WriteLine(si.itemName);
35. System.Console.Write("Unit Price: ");
36. System.Console.WriteLine(si.unitPrice);
37. System.Console.WriteLine("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=-=");
38.
39. System.Console.ReadKey();
40. return 0;
41. }
}
42. Execute the application to see the result:
43. Manufacturer Information
44. Company Name: Peel Corp
45. Contact Name: Sylvain Yobo
46. Contact Phone: (602) 791-8074
47. ---------------------------------------
48. Store Inventory
49. Item #: 613508
50. Item Name: Merino Crew Neck Cardigan
51. Unit Price: 80.00
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
52. Press Enter and return to your programming environment
Nesting a Namespace
You can create one namespace inside of another namespace. Creating a namespace
inside of another is referred to as nesting the namespace. The namespace inside of
another namespace is nested. To create a namespace inside of another, simply type it as
you would create another namespace. Here is an example:
namespace Business
{
public class House
{
public string propertyNumber;
public decimal price;
}
 namespace Dealership
{
}
}
In the example above, the Dealership namespace is nested inside of the Business
namespace. After creating the desired namespaces, nested or not, you can create the
necessary class(es) inside of the desired namespace.
To access anything that is included in a nested namespace, you use the period operator
before calling a member of a namespace or before calling the next nested namespace.
Here is an example:
namespace Business
{
public class House
{
public string propertyNumber;
public decimal price;
}

namespace Dealership
{
public class Car
{
public decimal price;
}
}
}

public class Exercise

{
static void Main()
{
Business.House property = new Business.House();

property.propertyNumber = "D294FF";
property.price = 425880;

Business.Dealership.Car vehicle = new Business.Dealership.Car();

vehicle.price = 38425.50M;

}
}
In the same way, you can nest as many namespaces inside of other namespaces as you
judge necessary.
Another technique used to nest a namespace consists of starting to create one. Then,
after its name, type a period followed by a name for the nested namespace. Here is an
example:
namespace Geometry.Quadrilaterals
{

}
After creating the nested namespace, you can access its contents by qualifying it. Here
is an example:
namespace Geometry.Quadrilaterals
{
public class Square
{
public double side;
}
}

public class Exercise

{
public static void Main()
{

Geometry.Quadrilaterals.Square sqr = new

Geometry.Quadrilaterals.Square();

sqr.side = 25.85;
}
}
In the same way, you can nest other namespaces inside of one. Here are examples:
namespace Geometry.Quadrilaterals
{

namespace Geometry.Rounds
{

}
In the same way, you can create as many namespaces as necessary inside of others.
After nesting a namespace, to access its content, you can qualify the desired name.
Here is an example:
namespace Geometry.Quadrilaterals
{
public class Square
{
public double side;
}
}

namespace Geometry.Volumes.Elliptic
{
public class Cylinder
{
public double radius;
}
}

public class Exercise

{
 public static void Main()
{
Geometry.Quadrilaterals.Square sqr = new
Geometry.Quadrilaterals.Square();
Geometry.Volumes.Elliptic.Cylinder cyl = new
Geometry.Volumes.Elliptic.Cylinder();

sqr.side = 25.85;
cyl.radius = 36.85;
}
}
Application: Nesting Namespaces
1. Click the Records.cs label to access its document and change it as follows:
2. namespace Store
3. {
4. namespace Inventory
5. {
6. public class StoreItem
7. {
8. public int itemNumber;
9. public string itemName;
10. public decimal unitPrice;
11. }
12. }
13.
14. namespace Personel
15. {
16. namespace PayrollRecords
17. {
18. public class Employee
19. {
20. public string firstName;
21. public string lastName;
22. public decimal HourlySalary;
23. }
24.
25. public class Contractors
26. {
27. public string FullName;
28. public int ContractStatus;
29. }
30. }
31. }
}
32. Access the DepartmentStore.cs file and change it as follows:
33. using Supply;
34. using Store.Inventory;
35.
36. public class DepartmentStore
37. {
38. static int Main()
39. {
40. . . . No Change
41.
 42. return 0;
43. }
}
Class Overloading? No Way! Way
Unlike the methods of a class, you cannot overload the name of a class in a file. That is,
you cannot have two classes with the same name in the same scope. One alternative is
to put each class in its own namespace. Here is an example:
namespace Arithmetic
{
public class Numbers
{
public int value;
}
}

namespace Algebra
{
public class Numbers
{
public int value;
}
}
Another alternative will be available when we study generics. That is, in the same
namespace, one of the classes can be a generic and the other not. Here is an example:
namespace Arithmetic
{
public class Numbers
{
public int value;
}

public class Numbers<T>

{
public int value;
}
}
Application: Using a Commonly Named Class
1. Access the Suppliers.cs file and change it as follows:
2. namespace Supply
3. {
4. public class SalesPerson
5. {
6. public string fullName;
7. public string expertise;
8. public string phoneNumber;
9. }
10. }
11.
12. namespace Manufacturers.Domestic
13. {
14. public class Manufacturer
15. {
 16. public string companyName;
17. public string contactName;
18. public string contactPhone;
19. }
20. }
21.
22. namespace Manufacturers.Foreign.Asia
23. {
24. public class Manufacturer
25. {
26. public string country;
27. public string companyName;
28. public string contactName;
29. public string contactPhone;
30. public string webSite;
31. }
}
32. Access the DepartmentStore.cs file and change it as follows:
33. using Supply;
34. using Manufacturers.Foreign.Asia;
35. using Store.Inventory;
36.
37. public class DepartmentStore
38. {
39. static int Main()
40. {
41. . . . No Change
42.
43. return 0;
44. }
}
The Alias of a Namespace
If you have to access a namespace that is nested in another namespace, that too is
nested, that is also nested, etc, the access can be long. As an alternative, you can create
a shortcut that makes it possible to access a member of the nested namespace with a
shorter label. That shortcut is called an alias. To create an alias for a namespace, in the
top section where the inside member is needed, type using, followed by the desired
name, followed by =, followed by the complete namespace. After doing this, you can
then use the alias in place of the namespace.
Application: Creating and Using an Alias
1. Access the DepartmentStore.cs file and change it as follows:
2. using Supply;
3. using Asian = Manufacturers.Foreign.Asia;
4. using Store.Inventory;
5.
6. public class DepartmentStore
7. {
8. static int Main()
9. {
10. Asian.Manufacturer dealer = new Asian.Manufacturer();
11. dealer.companyName = "Peel Corp";
 12. dealer.contactName = "Sylvain Yobo";
13. dealer.contactPhone = "(602) 791-8074";
14.
15. StoreItem si = new StoreItem();
16.
17. si.itemNumber = 613508;
18. si.itemName = "Merino Crew Neck Cardigan";
19. si.unitPrice = 80.00M;
20.
21. System.Console.WriteLine("Manufacturer Information");
22. System.Console.Write("Company Name: ");
23. System.Console.WriteLine(dealer.companyName);
24. System.Console.Write("Contact Name: ");
25. System.Console.WriteLine(dealer.contactName);
26. System.Console.Write("Contact Phone: ");
27. System.Console.WriteLine(dealer.contactPhone);
28.
29.
System.Console.WriteLine("---------------------------------------");
30.
31. System.Console.WriteLine("Store Inventory");
32. System.Console.Write("Item #: ");
33. System.Console.WriteLine(si.itemNumber);
34. System.Console.Write("Item Name: ");
35. System.Console.WriteLine(si.itemName);
36. System.Console.Write("Unit Price: ");
37. System.Console.WriteLine(si.unitPrice);
38. System.Console.WriteLine("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=-=");
39.
40. System.Console.ReadKey();
41. return 0;
42. }
}
43. Execute the application to see the result
44. Close the DOS window and return to your programming environment

Managing Namespaces
 
Inserting a Namespace
If you have existing code already, you can include it in a namespace. To do that:
 Click above the section of code, type namespace followed by a name and {. Locate the end of
the section and type }
 Select the code that you want to include in a namespace. Right-click the selection and click
Surround With... In the list, double-click namespace
Renaming a Namespace
Renaming a namespace follows the same logic we reviewed for variables, classes, and
methods: you can manually rename it or benefit from the assistance of the Code Editor.
To rename a namespace:
  In the Code Editor, locate its name and change it. Then click the arrow of its tag and choose
an option from the menu
 

 Right-click the name and click Rename... Then follow the dialog boxes as we have reviewed
already
1.
Namespaces and Inheritance
Imagine you had created a class named Person in a namespace named People as
follows:
using System;

namespace People
{
public class Person
{
private string _name;
private string _gdr;

public Person(string name = "Not Available",

string gender = "Unknown")
{
this._name = name;
this._gdr = gender;
}

private string FullName

{
get { return _name; }
set { _name = value; }
}

private string Gender

{
get { return _gdr; }
set { _gdr = value; }
}
}
}
If you decide to derive a class from it, remember that this class belongs to a namespace.
To inherit from this class, the compiler will need to know the namespace in which the
class was created. Class inheritance that involves namespaces relies on qualification,
like the calling of the members of a namespace. To derive a class from a class member
of a namespace, type the name of the namespace, followed by the period operator ".",
and followed by the name of the base namespace. Here is an example:
Source File: StaffMembers.cs
using System;

namespace HighSchool
{
public class Teacher : People.Person
{
private string _pos;

public Teacher(string pos = "Staff Member")

{
this._pos = pos;
}

private string Position

{
get { return _pos; }
set { _pos = value; }
}
}
}
If you need to call the class that was defined in a different namespace, remember to
qualify its name with the period operator. Here is an example:
Source File: Exercise.cs
using System;

class Exercise
{
public static int Main()
{
People.Person man = new People.Person("Herman Sandt", "Male");
HighSchool.Teacher staff = new HighSchool.Teacher("Vice Principal");

Console.WriteLine();
return 0;
}
}
Alternatively, to use the contents of a namespace, prior to calling a member of that
namespace, you can type the using keyword followed by the name of the namespace.
Here is an example:
Source File: Exercise.cs
using System;
using People;
using HighSchool;

class Exercise
{
public static int Main()
{
Person man = new Person("Herman Sandt", "Male");
Teacher staff = new Teacher("Vice Principal");

Console.WriteLine();
return 0;
}
}
 
Application: Using Inheritance With Namespaces
1. To create a new application, on the main menu, click File -> New Project...
2. In the middle list, click Empty Project
3. Set the Name to Geometry3 and press Enter
4. To create a new class, on the main menu, click Project -> Add Class...
5. Set the Name to Square and press Enter
6. Change the file as follows:
7. using System;
8. using System.Collections.Generic;
9. using System.Linq;
10. using System.Text;
11.
12. namespace Geometry3
13. {
14. public class Square
15. {
16. private double sd;
17.
18. public Square(double s = 0.00D)
19. {
20. this.sd = s;
21. }
22. }
}
23. To create a new class, on the main menu, click Project -> Add Class...
24. Set the Name to Rectangle and press Enter
25. Change the file as follows:
26. using System;
27. using System.Collections.Generic;
28. using System.Linq;
29. using System.Text;
30.
31. namespace Geometry3
32. {
33. public class Rectangle
34. {
35. double len;
 36. double hgt;
37.
38. public Rectangle(double L = 0.00D, double H = 0.00D)
39. {
40. this.len = L;
41. this.hgt = H;
42. }
43. }
}

Introduction to Built-In Namespaces

 
The Object Browser
The .NET Framework is a very rich, powerful, and expanded library. Its primary power
is in its large set of classes. To organize these classes, the .NET Framework provides
many namespaces. Each namespace is used to provide a specific set of classes.
To help you examine the namespaces of the .NET Framework, Microsoft Visual Studio
(not Microsoft Visual C# 2010 Express) provides the Object Browser. To access it
 On the main menu, click View -> Object Browser

 On the Standard toolbar, click the Object Browser button 

 Press F2
The Object is made of three frames:
The left frame shows a list of libraries. Notice that some nodes show a series of
numbers between square brackets. This represents the version of the .NET Framework.
When different nodes with the same name have square brackets, it means the library
has been created or updated in different versions. For example, 4.0.0.0 represents
Microsoft .NET Framework 4.0
Because most libraries contain more than one namespace, each node is equipped with a
+ button. To expand a node, click the + button. After expanding a library, the
namespaces it contain appear as nodes. Because most namespaces contain more than
one class, each namespace is equipped with a + button. To expand it, you can click the
+ button. After expanding a namespace, its list of classes appear. To show the members
of a class, in the left frame, click it:

To get an explanation or description of a member of the class, in the top-right frame,

click that member. The bottom-right frame presents some information about the
selected item.
Introduction to the System Namespace
The most regularly used namespace in the .NET Framework is called System. So far,
to use theSystem namespace, we typed it inside a method. Here is an example:
public class Exercise
{
static int Main()
{
System.Console.WriteLine("The wonderful world of C# programming");

return 0;
}
}
You can also precede System with global and the :: operator. Here is an example:
public class Exercise
{
static int Main()
{
global::System.Console.WriteLine("The wonderful world of C#
programming");

return 0;
}
}
We learned that, to access a namespace, you can use the using keyword. In the same
way, you can use using to refer to the System namespace. Here is an example:
using System;

public class Exercise

{
static int Main()
{
System.Console.WriteLine("The wonderful world of C# programming");

return 0;
}
}
This time too, you can precede System with global::
using global::System;

public class Exercise

{
static int Main()
{
System.Console.WriteLine("The wonderful world of C# programming");

return 0;
}
}
Once you have used using System or using global::System, you can use or
omit System in the body of the function. Here is an example:
using System;

public class Exercise

{
static int Main()
 {
Console.WriteLine("The wonderful world of C# programming");

return 0;
}
}
Introduction to Other Namespaces
The .NET Framework provides an incredibly long list of namespaces. We cannot review
all of them now. Eventually, when we have to use a class, we will indicate in which
namespace it exists.
As mentioned already, we saw in Lesson 5 that we could create a new class using the
Add New Class option from the main menu, the Solution Explorer, or the Class View. If
you use one of those techniques, the studio will also add other namespaces. For now,
we will accept that code "as is".
.NET Data Types
All of the data types we have used so far are represented by classes in the .NET
Framework. This means that they are equipped with methods. These classes are
defined in the System namespace. The classes of these data types are defined as:
C# Data Type Equivalent .NET Class C# Data Type Equivalent .NET Class
bool Boolean char Char
byte Byte sbyte SByte
short Int16 ushort UInt16
int Int32 uint UInt32
long Int64 ulong UInt64
float Single   double Double
decimal Decimal      
This means that, if you don't want to use the data types we have reviewed so far, you
can use the class that is defined in the System namespace. To use one of those classes,
type its name. Here is an example:
class Operations
{
public double Addition()
{
Double a;
Double b;
Double c;

a = 128.76;
b = 5044.52;
c = a + b;

return c;
}
}
Because the regular names of data types we introduced in the previous lessons are more
known and familiar, we will mostly use them.
Because the data types are defined as classes, they are equipped with methods. One of
the methods that each one of them has is called ToString. As its name implies, it is
used to convert a value to a string.