Question

In C# we write using System.IO or any other namespace we want to use.

So is it a bad habit, does it affect performance or memory?

Or is it good to create wrapper classes for them and use it to avoid using the same namespace everywhere?

Answer 1

In .Net, the namespace is always an integral part of the name of each type.
However, if you had to specify the entire namespace each time you are declaring a certain type it would have caused tremendous repetition and noise in the code. This is what the using directive is for, it essentially folds all the prefixes into one place, making you specify the “last” section of a type. This can be done only in case there are no ambiguities.

The compiler however, doesn’t care about the above. So there exists a pre-compilation stage where each type declaration that relies on a using directive gets its prefix back.

So when you say:

Using System;

void foo()
{
   String s1 = "bla";
   String s2 = "bli";
}

What happens in pre-compilation is that the is appending the System namespace to each String declaration, like this:

void foo()
{
   System.String s1 = "bla";
   System.String s2 = "bli";
}

And only now the compiler really kicks in.

So about the performance, technically, it can effect performance of the build process. The more usings you have, the more matching needs to be done in the pre-compilation stage: so the compiler sees String. What String is that? Is it System.String or is it SomeOtherNamespace.String? What really happens is that the compiler appends each namespace it finds in using to the type declaration and checks whether such a type exists. If yes- great, if no- it trys the next namespace.

So you see, in case you have many files with unused using declarations, the compiler necessarily does redundant work. In extreme cases, it can significantly degrade the performance of the build itself.

In general, never hesitate Using something that you are using (no pun intended). But you should avoid declaring unnecessary using directives, not just because of the potential (unlikely) performance impact on the build duration but also because you want to keep your code as clean as possible.