C# 4 and .NET 4

Working with Visual studio 2010 ❘ 395
file was generally known as a make file and is still quite standard on UNIX systems. Make files are not
normally needed on Windows, although you can still write them (or get Visual Studio to generate them) if
you need to.
Debugging and release Builds
The idea of having separate builds is very familiar to C++ developers, and to a lesser degree, to those
with a Visual Basic background. The point here is that when you are debugging, you typically want your
executable to behave differently from when you are ready to ship the software. When you are ready to ship
your software, you want the size of the executable to be as small as possible and the executable itself to
be as fast as possible. Unfortunately, these requirements are not compatible with your needs when you are
debugging code, as explained in the following sections.
Optimization
High performance is achieved partly by the compiler doing many optimizations on the code. This means
that the compiler actively looks at your source code as it is compiling to identify places where it can
modify the precise details of what you are doing in a way that does not change the overall effect, but that makes
things more efficient. For example, if the compiler encountered the following source code:
double InchesToCm(double Ins)
{
return Ins*2.54;
}
// later on in the code
Y = InchesToCm(X);
it might replace it with this:
Y = X * 2.54;
Or it might replace this code:
{
}
with this:
string Message = "Hi";
Console.WriteLine(Message);
Console.WriteLine("Hi");
By doing so, it bypasses having to declare an unnecessary object reference in the process.
It is not possible to exactly pin down what optimizations the C# compiler does — nor whether the two
previous examples actually would occur with any particular example — because those kinds of details
are not documented. (Chances are that for managed languages such as C#, the previous optimizations
would occur at JIT compilation time, not when the C# compiler compiles source code to assembly.) For
obvious commercial reasons, companies that write compilers are usually quite reluctant to give too many
details about the tricks that their compilers use. We should stress that optimizations do not affect your
source code — they affect only the contents of the executable code. However, the previous examples should
give you a good idea of what to expect from optimizations.
The problem is that although optimizations like the previous ones help a great deal in making your code
run faster, they are not that helpful for debugging. Suppose that, in the first example, you want to set a
breakpoint inside the InchesToCm() method to see what is going on in there. How can you possibly do that
if the executable code does not actually have an InchesToCm() method because the compiler has removed
it Moreover, how can you set a watch on the Message variable when that does not exist in the compiled
code either
www.it-ebooks.info