Does compiling with a specific .NET version provides any benefits?

Question

My .NET assembly is used in various projects that run on .NET 2.0, 3.5, 4.0, 4.5. 4.5.1, 4.5.2, 4.6.1, 4.6.2.

My .NET assembly does not use any features except provided with .NET 2.0.

Which .NET versions should I compile my .NET assembly with? It looks like only 2 versions make sense: .NET 2.0 and .NET 4.0. Dose compiling with any other .NET versions provide any benefits?

Answer 1

This is a difficult one to determine since there are a few things at play here. .NET 2.0 is of course a lot smaller and less complex than the newer versions. As the framework gets bigger and better it also gets more complicated and in theory slower, but this isn't really the case. Along with new versions of .NET come many performance improvements. The older version might be smaller, but a newer version may have implemented things differently so it uses less system resources when the application is running.

The only way you can get a solid answer is to test it. Compile an app using 2.0 and then try to convert it to whatever newer version you fancy. Run some benchmark tests to see which one performs better and this will give you a definite answer.

While i see where you are coming from with this question. It makes sense that bigger and more complicated means more system resources required to use it, but expansion isn't the only thing that comes with new versions of .NET. As computer architecture changes the framework does too. Lets say for example .NET 2.0 released back before multi core CPUs existed and then .NET 3.0 added support for it. The code will run much better on a machine with a multi core CPU when you are using the newer framework vs using the old framework

Answer 2

Some key factors to concern which .NET version suitable for compiling your apps (not in order):

1) Performance

2) Target platform (x86 or x64)

3) Available assemblies/libraries/packages

4) Migration/backward compatibility, etc.

If you have more concern about performance and resource usage, take a look at these:

http://www.codeproject.com/Articles/92812/Benchmark-start-up-and-system-performance-for-Net (including .NET 1.1-4.0)

http://www.hanselman.com/blog/BenchmarkingNETCode.aspx (guide to benchmark different .NET target platforms)

The higher version usually gives little performance benefit (improvement in just a few milliseconds), depending on app size and used assemblies. However if you want to maintain backward compatibility with older systems, the lowest eligible version should be considered to use (i.e. .NET 2.0).

Different machines emit different benchmark results, of course. The best practices known are "stick with version you're build into", depending on whatever users need.

Version control like SVN/CVS/Git/TFS considered helpul if you want to make breaking changes based on platform-specific target.

Answer 3

Essentially, you need to evaluate at some point the benefit to update versus the downside of some customer might not be able to use the new version. For example, if WPF would make sense for your application, then at some point, you have to stop supporting old customers. By the way, since XP is obsolete and other versions can be installed on newer OS, in many case, it might be preferable to simply update your requirement.

Answer 4

Its probably a good idea to distinguish between versions of the .NET Framework versus versions of the Common Language Runtime

Common Language Runtime

The Common Language Runtime (CLR) is the component that is responsible for running the platform independent IL code on your target machine. You'll need to compile your app against all of the CLR versions that you need to support.

There are the following CLR versions at the time of writing:

• 4.0
• 2.0
• 1.1
• 1.0

.NET Framework

The .NET framework version is basically the version of the system assemblies that make up .NET. Each version of .NET is designed to work against a specific version of the CLR, but more than one .NET framework version uses the same version of the CLR. For example CLR 4.0 is used by .NET 4.0, 4.5 and 4.6.

You can see the versions of .NET Framework, and which CLR versions they use here: https://msdn.microsoft.com/en-us/library/bb822049(v=vs.110).aspx

You shouldn't need to rebuild your library against newer versions of the framework if your already building against an older .NET version that targets the same CLR version. Any system assemblies referenced should have been upgraded in one of the following ways to ensure backward compatibility:

• A 'safe' in place upgrade that behaves in the same way as the previous version unless code specifically opt in to new behavior (e.g. by calling a new method, instantiating a new class etc).

• Adding a new assembly. Because .NET framework uses version numbers as part of the name binding you'll still get the version you compiled against, even if other libraries in the AppDomain are referencing the newer version with the same name.

Note that the opposite doesn't work. You can never assume your class library will work against a older version of .NET than the version compiled against, even if the CLR version is the same.

Answer 5

If your library is used in .Net 2.0 app you could not target a newer version of the Framework.

"Other application not being able to use your Library any more" is not really a performance improvement.

Answer 6

If your target is a higher version than you need and it works, then keep it as is. As for benefit for targeting 2.0 or 4.0, again if it works, does it really matter. I can't imagine you'll get any performance improvements by downgrading your target framework

Answer 7

It's a complicated question. For starter, the official announcements points out that there are performance upgrades too, of course. This is mostly true, although I doubt it's always true, especially when it comes to projects with extreme complexity.

I would only recommend not to "Convert" a project to a different version from the version it started though. The .Net changed the project structures a lot of times, not only the libraries. And I highly doubt that any converter will be able successfully convert a project on the perspective of performance.

When it comes to upgrades, "Don't touch anything that works properly" is my motto.

Answer 8

Compiling with the latest version is always good becoz 1. As a developer you get to use newer features that were introduced 2. Any optimization made to the framework like "profile optimization" is available to your application.

2.0 to 3.5 is an in-place upgrade. So is 4.0 to 4.5 to 4.5.1 to 4.5.2 to 4.6.1. Which means if you install 4.6.1 it replaces any earlier versions in the 4.X family.

The only time you would compile against a specific older version is if you are going to deploy your code on a machine that does not have the latest version. For example you as a developer could be using Visual Studio 2015 Update 2 which ships with 4.6.1 but your server is still at 4.0. But doing so, you will not be able to use the newer features that were introduced after 4.0 like async/await etc.

Answer 9

There will be no performance difference in compiling a different minor version. If you do not use any of the features that are added in version 4.5, for instance, then there is no reason to compile to that version just for the sake of using the updated version.