Microsoft. Net framework Arash Ebrahimpour

Email: Arash.Ebrahimpour@abo.fi

Department of Computer Science

Åbo Akademi University, FIN-20520 Turku, Finland

The aim of this article is to provide a general introduction to the .NET platform. We will also introduce C# the new programming language from Microsoft that targets the .NET platform. We will cover the features of C#, and will try to compare it with other programming languages like C++, Java and Visual Basic.

This is an important strategy for Microsoft and in their own words they are betting the company on this strategy.

The .NET platform provides an infrastructure for object-oriented programming. It is built from the ground up to include garbage collection, exception handling and type safety.

Managed Applications (Applications that target the .NET platform)
	.NET Framework class library
The CLR
Operating system and hardware

The Common Language Runtime is Microsoft's development platform of the future. In Microsoft's vision, most future software will be written to make use of the CLR features.

One can compare the CLR with Java Virtual Machine. The CLR manages code at execution time, providing core services such as code safety verification, compilation, code execution, memory management, thread management, remoting and other system services.
When developing applications for the .NET Framework, source code (in C# and other programming languages that target the .NET Framework) is compiled into metadata and Intermediate Language (IL), which is a CPU-independent set of instructions that can be efficiently converted into native code. IL is compiled to native code at run time by the CLR (A process called Just In Time compilation or JITing for short) and then this native code is executed. This means that code can be compiled to IL once and be run on different platforms. Also the JIT compiler can optimize the code for the specific CPU that the code is running on.
Code that targets the CLR is called managed code, because the CLR is taking care of it, providing the services that it needs and ensuring that it does not do anything that it is not supposed to do.
1.2 .NET Framework Class Library

The .NET Framework class library is a collection of object oriented reusable types that tightly integrate with the common language runtime. These types enable you to accomplish a range of common programming tasks, including tasks such as file access, string management, data collection and database connectivity. In addition to these common tasks, the class library includes types that support a variety of specialized development scenarios, e.g. there are classes for developing Windows GUI applications (Windows Forms), ASP.NET applications, Web Services, etc.

Microsoft ships five languages for .NET Framework developers: C#, Visual Basic.NET, IL (Intermediate Language), C++, and JScript.NET. All of these languages are interoperable. Language interoperability is the ability of code to interact with code that is written using a different programming language. It means that types can inherit implementation from other types, pass objects to another type's methods, and call methods defined on other types, regardless of the language the types are implemented in. For example in your C# code you can use a class that is implemented in Visual Basic.NET.

C# is a new programming language in the C/C++ family from Microsoft. It borrows a lot of features from C++ but is generally simpler and there are some other big differences.

The CLR is a component-based environment, and C# that targets the CLR is designed to make component creation easier. C# is a component-centric language, in that all classes are written as components.

Software must have good performance, build on existing code, and be practical to write in terms of time and budget. A well designed environment is of little use if it does not provide enough power for real-world use.

We will briefly cover some important and new features of C# and will provide some examples, so that we can better compare C# with other programming languages and technologies.

In the .NET CLR, all objects are derived from the ultimate base class named object, and only single inheritance is provided (i.e. an object can only be derived from one base class). This does prevent us from using multiple-inheritance that is available in other programming languages like C++, but it also eliminates many abuses of multiple-inheritance and makes things simpler. It is of course a tradeoff, and designers of the language believe that it a good tradeoff. Multiple-inheritance in the form of Interfaces is possible, but interfaces cannot contain implementation.

Heap allocation in .NET framework is very fast. All that the system has to do is make sure that there’s enough room in the managed heap for the requested object, return a pointer to that memory, and increment the pointer to the end of the object.

In languages without garbage collection, adding exception handling is very expensive, since all objects within a function must be tracked to make sure that they are properly destroyed at any time that an exception could be thrown. The required tracking code both adds execution time and code size to a function.

The C# language is designed such that versioning between base and derived classes in different libraries can evolve and maintain backwards compatibility. This means, for example, that the introduction of a new member in a base class with the same name as a member in a derived class is not an error. It also means that a class must explicitly state whether a method is intended to override an inherited method, or whether a method is a new method that simply hides a similarly named inherited method.

In the CLR data types are separated into “value types” and “reference types”. Value types are either stack-allocated or allocated inline in a structure. Reference types are heap-allocated. In C# classes are reference type and heap allocated but structs are value types and stack allocated.

The statements in C# are close to C++, with a few modifications. The foreach statement is used to iterate over members of an array or a collection. The lock statement is used for mutual exclusion in threading scenarios. The checked and unchecked statements are used to control overflow checking in arithmetic operations and conversions.

Delegates are a type-safe, object oriented implementation of function pointers and are used in many situations where a component needs to call back to the component that is using it. They are used as the basis for events.

Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked.
A delegate declaration defines a type that encapsulates a method with a particular set of arguments and return type. For static methods, a delegate object encapsulates the method to be called. For instance methods, a delegate object encapsulates both an instance and a method on the instance. If you have a delegate object and an appropriate set of arguments, you can invoke the delegate with the arguments.
An interesting and useful property of a delegate is that it does not know or care about the class of the object that it references. Any object will do; all that matters is that the method's argument types and return type match the delegate's. This makes delegates perfectly suited for anonymous invocation.
This example shows a simple use of delegates:
public class Book

{

private string title;

{

this.title = title;

}
public override string ToString()

{

return this.title + "\t" + this.author;

}// class Book

{

private ArrayList books = new ArrayList();

{

books.Add(book);

{

foreach(Book book in books)

processBook(book);

}

}

}// class BookDb

{

public static void Main()

BookDb bookDb = new BookDb();

bookDb.Add(new Book("title1", "author1"));

// add more books

bookDb.ProcessBooks(new ProcessBookCallback(PrintBook));

}
private static void PrintBook(Book book)

{

Console.WriteLine(book);

}// class Test

Delegates and interfaces are similar in that they enable the separation of specification and implementation. Multiple independent authors can produce implementations that are compatible with an interface specification. Similarly, a delegate specifies the signature of a method, and authors can write methods that are compatible with the delegate specification. When should you use interfaces, and when should you use delegates?

• 
  A single method is being called.
  
• 
  A class may want to have multiple implementations of the method specification.
  
• 
  It is desirable to allow using a static method to implement the specification.
  
• 
  An event-like design pattern is desired.
  
• 
  The caller has no need to know or obtain the object that the method is defined on.
  

Interfaces are useful when:

• 
  The specification defines a set of related methods that will be called.
  
• 
  A class typically implements the specification only once.
  
• 
  The caller of the interface wants to cast to or from the interface type to obtain other interfaces or classes.
  

Delegates are ideally suited for use as events (notifications from one component to "listeners" about changes in that component). Events in the .NET Framework are based on the delegate model and are first class citizens. Here is a simple example:

{

static void Main()

Button button = new Button();

ClickListener listener = new ClickListener();
// subscribe for the Click event

button.Click += new ClickHandler(listener.ButtonClicked);

button.SimulateClick();

}

}

{

public event ClickHandler Click;

{

if(Click != null)

}

}

{

public void ButtonClicked(object sender, EventArgs args)

Console.WriteLine("Event was fired");

}

}
Output:

Attributes are used in C# and .NET Framework to communicate declarative information from the writer of the code to other code that is interested in the information. This could be used to specify which fields of an object should be serialized, which transaction context to use when executing a method, how to display a class in a class browser or declaring design time information for a control.

A very simple attribute usage might look like this:
public class Employee

{

[XmlAttribute]

public string name;

}
Here XmlAttribute is applied to member variable id. The process of XML Serialization will use this attribute at runtime. Without applying this attribute the result of XML serialization of an Employee object will be something like this:


1234

John Smith


But after applying the attribute the result of XML Serialization will be like this:


John Smith


Attribute information is retrieved at runtime through reflection. New attributes can be written and applied to elements of the code (such as classes, members, etc) and retrieved through reflection.
2.3.9 Reflection and Execution-Time Code Generation

If you are a C++ programmer, it is likely that you have a compile-time view of the world. Because a C++ compiler does all the code generation when the code is compiled, C++ programs are static systems that are fully known at compile time. In the .NET framework the compile-time world still exists, but it is also possible to build more dynamic systems where new code is loaded at runtime or even code is created on the fly, although runtime code generation is rarely used in most software projects.

Security is one of the most important issues to consider when moving from traditional program development, where administrators often install software to a fixed location on a local disk, to an environment that allows for dynamic downloads and execution and even remote execution. To support this model, the Microsoft .NET Framework provides a rich security system, capable of confining code to run in tightly constrained, administrator-defined security contexts.

Historically, process boundaries have been used to isolate applications running on the same computer. Each application is loaded into a separate process, which isolates the application from other applications running on the same computer.

• 
  An application can be independently stopped.
  
• 
  An application cannot directly access code or resources in another application.
  
• 
  A fault in an application cannot affect other applications.
  
• 
  Configuration information is scoped by application. This means that an application controls the location from which code is loaded and the version of the code that is loaded.
  

A lot of things in C# are similar to C++, but there are some big differences. C# borrows a lot of features from C++ but is generally simpler. This simplicity comes at a cost. You get a slight performance tradeoff for better productivity. If you do not have time and resource limitations you will generally do better with C++.

Pointers are not used generally in C#, it is possible to use pointers in unsafe mode, but it is rarely used.

Source code is compiled to assemblies, which contain both the IL and metadata to describe the compiled code. All .NET languages query the metadata to determine the same information that is contained in C++ header files, therefore header files are not needed.

Calling native code requires a bit more work and there is an overhead also.

Exception handling is used instead of error returns.

In C# we have only single inheritance.

In C# objects are allocated on the heap, but note that heap allocation is very fast. Lightweight objects can be declared as structs and they are allocated on the stack instead of the heap.

All the statements that test a Boolean condition now require a variable of type bool. There is no automatic conversion from int to bool.

Arithmetic operations can be checked for overflow using checked and unchecked keywords.

Variables should be assigned a value before being used.

C# is generally more dynamic, a lot of metadata is associated with the code and it is possible to extend this metadata with custom attributes. It is possible to reflect into the code and gather information about types, load code at runtime and generate code on the fly.

C# has no header files, all code is written inline, and while there is preprocessor support for conditional compilation, there is no support for macros. These restrictions make it easier and faster for the compiler to parse code, and also make it easier for development environments to understand C# code.

There is no order dependency in C# code, and no forward declarations and the order of classes in source file is unimportant.
These C++ features are missing in C#:

• 
  const member functions or parameters
  
• 
  Global variables
  
• 
  Typedef
  
• 
  Conversion by construction
  
• 
  Default arguments on function parameters
  

There are a lot of similarities between C# and Java, however there are some differences between them. One of the differences between C# and Java is that design of C# is closer to C++.

In Java, the primitive data types are in a separate world from the object-based types. For primitive types to be used in the object based world they must be put into an instance of a wrapper class. In C# primitive data types are stack-allocated as in Java, but they are also considered to be derived from the ultimate base class object. This means that primitive types can have member functions, e.g. you can write 5.ToString(). Whenever a primitive type is used in a situation where a parameter of type object is required, the compiler will automatically box the primitive type into a heap-allocated wrapper. Here is an example:

object obj = i; // box i into obj

Console.WriteLine("i = {0}", obj);

int j = (int)obj; //unbox obj back to an int

In C#, it is possible to extend the type system by implementing custom value types using the struct keyword. These types are allocated on the stack, are boxed and unboxed as necessary, can have member functions and operators and explicit and implicit conversions defined on them. A struct is written using the same syntax as a class, except that a struct cannot have a base class (other than the implicit base class object), though it can implement interfaces.

{

static void Main()

Employee employee = new Employee("John", "Address", 30);

Console.WriteLine("Name: {0}\tAddress: {1}\tAge: {2}",

employee.Name, employee.Address, employee.Age);

employee.Address = "New Address";

employee.Age += 1;

Console.WriteLine("Name: {0}\tAddress: {1}\tAge: {2}",

employee.Name, employee.Address, employee.Age);

}

}// class Test

{

private string name;

private byte age;

{

this.name = name;

this.age = age;

}
public string Name

{

get { return name; }

{

get { return address; }

}
public byte Age

{

get { return age; }

}

}// class Employee

C# and Visual Basic 6 are very different programming languages. C# is a powerful object-oriented language while Visual Basic 6 has only limited object-oriented features.

In C# we have inheritance, overloading, constructors and destructors, interfaces, delegates, static members, attributes and multithreading support.
There are a lot of differences in the syntax of these two languages.

One important difference is that C# is stricter on variable declaration and usage. All variables must be declared with a specific type. In C# there is not a Variant data type, the object type can contain any type but it knows exactly what type it contains. There are some differences in primitive types also.

Visual C++ and Visual Basic have been extended to work in the .NET framework.

Visual C++ .NET extends the standard C++ language to make it easy to add support for the .NET framework to new and existing applications. A set of “Managed Extensions” have been added to the language to allow programmers to produce and consume components that target the CLR. The visual C++ model allows programmer more control than the C# model, in that the user is allowed to write both managed and unmanaged code. It is not compulsory to use Managed Extensions but there are advantages to doing so. A program written using managed code using Managed Extensions for C++, for example, can operate with the CLR to provide services such as memory management, cross-language interoperation, code access security, and automatic lifetime control of objects.
A .NET component is created by using keywords to modify the meaning of existing C++ constructs. For example, when the __gc keyword is placed in front of a class definition, it enables the creation of a managed class and restricts the class from using constructs that are not allowed in the .NET world (such as multiple-inheritance).
Visual Basic has also seen considerable improvements. It now has object-oriented features such as inheritance, encapsulation, overloading and interfaces.
3.5 .NET vs. COM
3.5.1 Easier deployment and the end of DLL hell

The .NET Framework introduces several new features aimed at simplifying application deployment and solving DLL Hell.

A principle design guideline in .NET is that of isolated components (or assemblies). Isolating an assembly means that an assembly can only be accessed by one application (i.e. it is not shared by multiple applications). Isolation gives a developer absolute control over the code that is used by his application. Isolated, or application-private, assemblies are the default in .NET applications.

However, there are cases where sharing an assembly between applications is necessary.

In .NET, sharing code between applications is an explicit decision. Assemblies that are shared have some additional requirements. In the .NET framework it is possible to install and run multiple versions of the same assembly on the same machine.
In addition, the .NET Framework allows applications and administrators to override the version of an assembly that is used by the application by specifying version policies.
The main features of the .NET Framework regarding deployment includes:

• 
  Application-Private components by default.
  By default, components are deployed to the application directory and are visible only to the containing application.
  
• 
  Side-by-side versioning.
  Multiple versions of a component or application can coexist, you can choose which versions to use, and the common language runtime enforces versioning policy.
  
• 
  XCOPY deployment and replication.
  Self-described and self-contained components and applications can be deployed without registry entries or dependencies.
  

While COM supports only limited object-oriented features, the .NET platform provides a powerful infrastructure for object-oriented programming. In C# we have inheritance, overloading, constructors and destructors, interfaces, delegates, static members, attributes and multithreading support.

Programming Languages (SIGPLAN)

Software Engineering (SIGSOFT)
4.2 The ACM Computing Classification System

D.3.2 Object-oriented languages

D.2.11 Languages

D.1.5 Object-oriented Programming

D.3.3 Language Constructs and Features (Classes and objects, Data types and structures, Inheritance, Modules, packages, Polymorphism)

D.2.7 Portability

D.2.13 Reuse models

D.2.7 Extensibility

Gunnerson, Eric - Programmer's introduction to C#

http://www.msdn.microsoft.com/

http://www.gotdotnet.com/