# Namespaces

## Content

Namespaces organize the objects defined in an assembly. Assemblies can contain multiple namespaces, which can in turn contain other namespaces. Namespaces prevent ambiguity and simplify references when using large groups of objects, such as class libraries.

For example, the namespace for the **C1BarCode** component is **C1.Win.BarCode**. The following code fragment shows how to declare a **C1BarCode** component using the fully qualified name for this class:

```vbnet
Dim barcode1 As C1.Win.BarCode.C1BarCode
```

```csharp
C1.Win.BarCode.C1BarCode barcode1;
```

Namespaces address a problem sometimes known as *namespace pollution*, in which the developer of a class library is hampered by the use of similar names in another library. These conflicts with existing components are sometimes called *name* **collisions**.

For example, if you create a new class named **C1BarCode**, you can use it inside your project without qualification. However, the **C1BarCode** assembly also implements a class called **C1BarCode**. So, if you want to use the **C1BarCode** class in the same project, you must use a fully qualified reference to make the reference unique. If the reference is not unique, Visual Studio produces an error stating that the name is ambiguous. The following code snippet demonstrates how to declare these objects:

```vbnet
' Define a new C1BarCode object
Dim MyBarCode as C1BarCode
' Define a new C1BarCode.C1BarCode object.
Dim C1BarCode as C1.Win.BarCode.C1BarCode
```

```csharp
// Define a new C1BarCode object
C1BarCode MyBarCode;
// Define a new C1BarCode.C1BarCode object.
C1.Win.BarCode.C1BarCode C1BarCode;
```

Fully qualified names are object references that are prefixed with the name of the namespace where the object is defined. You can use objects defined in other projects if you create a reference to the class (by choosing **Add Reference** from the **Project** menu) and then use the fully qualified name for the object in your code.

Fully qualified names prevent naming conflicts because the compiler can always determine which object is being used. However, the names themselves can get long and cumbersome. To get around this, you can use the **Imports** statement (**using** in C#) to define an alias — an abbreviated name you can use in place of a fully qualified name. For example, the following code snippet creates aliases for two fully qualified names, and uses these aliases to define two objects:

```vbnet
Imports C1BarCode = C1.Win.BarCode
Imports MyBarCode = MyProject.C1BarCode 
Dim s1 As C1BarCode
Dim s2 As MyBarCode
```

```csharp
using C1BarCode = C1.Win.BarCode;
using MyBarCode = MyProject.C1BarCode;
C1BarCode s1;
MyBarCode s2;
```

If you use the **Imports** statement without an alias, you can use all the names in that namespace without qualification, provided they are unique to the project.