C# 4 and .NET 4

8 ❘ ChaPTer 1 .net Architecture
This is all quite an ambitious aim, but amazingly, .NET and IL have achieved it. In the case of stepping
between methods in the debugger, this facility is really offered by the Visual Studio integrated development
environment (IDE) rather than by the CLR itself.
distinct Value and reference Types
As with any programming language, IL provides a number of predefined primitive data types. One
characteristic of IL, however, is that it makes a strong distinction between value and reference types. Value
types are those for which a variable directly stores its data, whereas reference types are those for which a
variable simply stores the address at which the corresponding data can be found.
In C++ terms, using reference types is similar to accessing a variable through a pointer, whereas for Visual
Basic, the best analogy for reference types are objects, which in Visual Basic 6 are always accessed through
references. IL also lays down specifications about data storage: instances of reference types are always
stored in an area of memory known as the managed heap, whereas value types are normally stored on the
stack (although if value types are declared as fields within reference types, they will be stored inline on
the heap). Chapter 2, “Core C#,” discusses the stack and the heap and how they work.
strong data Typing
One very important aspect of IL is that it is based on exceptionally strong data typing. That means that all
variables are clearly marked as being of a particular, specific data type (there is no room in IL, for example,
for the Variant data type recognized by Visual Basic and scripting languages). In particular, IL does not
normally permit any operations that result in ambiguous data types.
For instance, Visual Basic 6 developers are used to being able to pass variables around without worrying too
much about their types, because Visual Basic 6 automatically performs type conversion. C++ developers are
used to routinely casting pointers between different types. Being able to perform this kind of operation can
be great for performance, but it breaks type safety. Hence, it is permitted only under certain circumstances
in some of the languages that compile to managed code. Indeed, pointers (as opposed to references) are
permitted only in marked blocks of code in C#, and not at all in Visual Basic (although they are allowed in
managed C++). Using pointers in your code causes it to fail the memory type-safety checks performed by
the CLR. You should note that some languages compatible with .NET, such as Visual Basic 2010, still allow
some laxity in typing, but that it’s possible only because the compilers behind the scenes ensure that the type
safety is enforced in the emitted IL.
Although enforcing type safety might initially appear to hurt performance, in many cases the benefits
gained from the services provided by .NET that rely on type safety far outweigh this performance loss. Such
services include the following:
➤
➤
➤
➤
Language interoperability
Garbage collection
Security
Application domains
The following sections take a closer look at why strong data typing is particularly important for these
features of .NET.
strong Data Typing as a Key to language interoperability
If a class is to derive from or contains instances of other classes, it needs to know about all the data
types used by the other classes. This is why strong data typing is so important. Indeed, it is the absence
of any agreed-on system for specifying this information in the past that has always been the real barrier
to inheritance and interoperability across languages. This kind of information is simply not present in a
standard executable file or DLL.
www.it-ebooks.info