How Is Performance Affected by an Unused Using Directive

How is performance affected by an unused using directive?

An unused using has no impact to the runtime performance of your application.

It can affect the performance of the IDE and the overall compilation phase. The reason why is that it creates an additional namespace in which name resolution must occur. However these tend to be minor and shouldn't have a noticeable impact on your IDE experience for most scenarios.

It can also affect the performance of evaluating expressions in the debugger for the same reasons.

Do unused usings in .net affect performance?

NO, but It effects the IDE performance and the compilation process of your project.
I can give you a short example. If you have ever used coderush http://devexpress.com/Products/Visual_Studio_Add-in/Coding_Assistance/ which is from devexpress, their IDE optimizer and code optimizer will also suggest you to remove unused namespaces.

Update: Here is more use information from Dmitriy's Blog
There are few reasons why you should remove unused usings in you C# code.

•It is useless code, that just creates clutter in your source code and it also confusing for the developer because you don’t know which namespaces are actually used.
•Over time as your code changes it can accumulate a lot of unused using statements which create even more clutter in you code.
•It can make your compiling faster, since compiler does not have to look up all those extra unused namespaces.
•It will help avoid name conflict with new items that you going to add to your solution if both of those have same names.
•It will reduce number of items in your Visual Studio editor auto completion

There are couple ways to remove those unused usings, you can do it individually on each file

http://msdn.microsoft.com/en-us/library/bb514115.aspx

You also can download plugin called batchFormat for Visual Studio 2010 that can help you to remove all unused usings for the whole project.

http://www.addictivetips.com/windows-tips/batch-format-remove-unused-usings-and-format-visual-studio-document/

Performance impact of unused using directives in C#

Extra Using directives will not have any memory/performance impact on final application - they are nothing but compiler provided shortcuts to deal with long type names. Compiler uses these namespaces to resolve unqualified (or partly qualified) type names to correct types.

Why remove unused using directives in C#?

There are a few reasons you'd want to take them out.

• It's pointless. They add no value.
• It's confusing. What is being used from that namespace?
• If you don't, then you'll gradually accumulate pointless using statements as your code changes over time.
• Static analysis is slower.
• Code compilation is slower.

On the other hand, there aren't many reasons to leave them in. I suppose you save yourself the effort of having to delete them. But if you're that lazy, you've got bigger problems!

Regarding using directives and performance

There aren't any performance benefits, if that's what you mean.

All references in an assembly are fully qualified; the compiler merely uses the references you provide in your code to fully qualify identifiers, so the only impact of unused references in your source code is a slight decrease in readability (why is this reference here?), and a trivial increase in compile time.

overhead to unused using declarations?

From The C# Team's answers to frequently asked questions:

When you add assembly references or
make use of the 'using' keyword,
csc.exe will ignore any assembly which
you have not actually made use of in
your code ... Don't [waste] your time stripping out
unused 'using' statements or assembly
references from your application. The
C# compiler will do so for you
automatically.

You can verify that this is actually the case by calling Assembly.GetReferencedAssemblies(); you'll see that anything that isn't used won't actually be included in the list.

The main utility in stripping out unused ones is

• It is easier to see what your code is actually using
• It will keep your Intellisense from being polluted with things that you aren't actually going to use.

Unused using statements

does that have any sort of detrimental performance impact?

No.

How does the compiler deal with them at compile/run time?

At compile time they do what you'd expect, i.e. act as namespace imports. They don't appear in the compiled binary: any reference to a type uses the fully-qualified name.

The compiler does check the namespace in a using statement even if it's not needed; if you remove a namespace, then all the using statements that refer to it will fail.

To me, redundant using statements are like redundant comments. They make no difference to the compiler, but include too many of them, and you risk confusing your developers.

Do unused imported namespace have anything to do with program efficiency?

No, there isn't any problem. You can have unused namespaces, there're not going to be causing any efficiency problems. The only impact it has, is the IDE and compiling process, compiler would look into all files and so on. But the processes are only executed for the code you've written.

However, if you're still trying to get rid of them, read this on MSDN, they're having a method to get rid of them. http://msdn.microsoft.com/en-us/library/7sfxafba(v=vs.80).aspx

Is there a performance gain in removing unnecessary namespace (using) directives?

No, there's no performance advantage.

The compiler doesn't generate IL (executable code) for using statements. IL is only generated for those classes, method calls, etc. that take advantage of the using statements you provide.

Consequently, the only effect unused using statements might have is to slightly increase your build time, or make the next developer after you wonder why they are there.

Do the amount of namespaces affect performance?

The number of namespaces used in code files does not impact the runtime performance of the application. It does have an impact on compile time as the compiler must search those namespaces for additional items such as types and extension methods.

The only runtime impact the number of namespaces I'm aware of are

• Debugging: The set of used namespaces in a given code file is stored in the PDB and consulted by the debugger during name resolution. Having a lot of namespaces could theoretically impact the performance of the debugger but in practice I haven't seen this be a problem.
• Asp.Net: If using the deployment model where pages are compiled on first view by users, the number of namespaces can affect load time the first time a given page is viewed

---

Related Topics