Microsoft .

NET Basics
Daragh Byrne EPCC

http://www.epcc.ed.ac.uk/~ogsanet ogsanet-queries@epcc.ed.ac.uk January 14th-15th 2004

Purpose
Microsoft .NET Framework:
Microsoft Intermediate Language (MSIL) Common Language Runtime (CLR) Class Libraries Language Compilers Distributed and Web-based computing

.NET Programming with C#

Microsoft .NET Framework

.NET Framework
Microsoft .NET is a set of Microsoft software technologies for connecting information, people, systems and devices
http://www.microsoft.com/net/basics/whatis.asp

In real terms to the developer:

A new platform for building applications that run in stand-alone mode or over the Internet

Evolution
Next Generation of COM:
Component oriented software is a good thing:
Win32/C-style APIs are outdated COM was step in right direction, but painful to program with COM was restricted to VB, C++ Binary compatibility/portability an issue: x86 version of COM component needed to be compiled for e.g. PowerPC Memory management also a pain

Common Object Runtime:

An execution environment for components written in any language:
Eventually became .NET with incorporation of Web Services Standardised API

Web Services:
Interoperability is key in the connected world:
Require open standards for interoperability and leveraging legacy code

Whats in the .NET Framework?

Microsoft Intermediate Language (MSIL):
Specification for a platform independent, low-level, stack-based assembly-like language

Common Language Runtime (CLR):

A common runtime for all .NET applications, compiles and executes MSIL

Class libraries:
Common functionality that can be used by all languages Includes Windows Forms for GUI development

Language compilers:
C#, C++, VB

Distributed computing:
Networking using sockets, Remoting, Web Services and Applications using ASP.NET

Targeting .NET

Compiled to

Source Code (C#, VB.NET)

MSIL

Runs on

CLR
Compiled to

Native Code (x86 etc)

Microsoft Intermediate Language (MSIL)

A machine-independent assembly language:
Similar in nature to Java byte-code

Target language for all .NET compilers JIT-compiled (Just-In-Time) by the CLR to native code:
Very efficient late compilation approach

Collection of IL known as a managed Assembly:

Library or executable (JAR in Java-speak)

Can examine with ILDasm:

Disassembler Comes with the framework

Possible to implement interpreter/runtime on any platform:

Open standards

MSIL Example
Example: method body:
// Code size 21 (0x15) .maxstack 2 .locals init ([0] string CS$00000003$00000000) IL_0000: ldarg.0 IL_0001: ldfld string NDoc.Core.HtmlHelp::_projectName IL_0006: ldstr ".hhk IL_000b: call string [mscorlib]System.String::Concat(string, string) IL_0010: stloc.0 IL_0011: br.s IL_0013 IL_0013: ldloc.0 IL_0014: ret

Yuck! Thankfully we dont have to deal with this:

Thats what compilers are for! You could do it though!

Common Language Runtime

The environment in which all .NET applications run Somewhat like the Java Virtual Machine:
With explicit multi-language support With explicit version control at assembly level JIT-compiles to native code

Deals in the abstract with types:

classes, structs, interfaces etc. Handles instances, interactions between instances

Provides runtime services for Managed Code:

Type control, exception handling, garbage collection threading etc. Removes mundane/dangerous tasks from the programmer

10

Running a .NET Application

Bind to runtime library

.NET Executable
(Stored as Windows Portable Executable file)
Execute MSIL entry point (verifies code, starts compilation and execution)

mscoree.dll

11

Types and Assemblies

Fundamentally the CLR deals with instances of types:
Has a unified type system Everything descends from System.Object type

Divided into value types or reference types:

Value types are primitives, structs, enums etc and live on the stack
Derived from the System.ValueType type

Reference types are instances of classes, interfaces, arrays, delegates that the programmer deals with via references

Assemblies are essentially collections of type definitions:

Including all metadata about those types

12

Type Metadata and the CLR

Every CLR type has metadata associated with it:
Field names and sizes, type name, type size etc

Used system-wide:
Serialization of objects to network, disk, in Web Services Cross-language interoperability Intellisense in Visual Studio We use it in our Grid Services software

Possible to use Reflection API to access metadata at runtime:

Plug and play components, late binding

Possible to define application-specific metadata:

Very useful, more later
13

Metadata Addresses COM Shortcomings

Type system was fragmented External representation of a component had little bearing on its internal structure:
Interface Definition could not tell you about internals Needed to use things called Type Libraries to store metadata separately

.NET type system is common among all languages:

Common Type System C++ string == C# string == VB.NET string

14

CLR Standards and Implementations

Open standard (ECMA) CLR will run on any Windows computer:
95/98, ME, 2000 Built in to XP

Based on open standards:

Ports to Linux underway:
Mono, dotGNU

Microsoft have a shared-source, cross-platform version known as Rotor:

Runs on FreeBSD http://msdn.microsoft.com/net/sscli

15

Class Library (1/2)

IO GUI Programming (naturally!) System Information Collections Components Application Configuration Connecting to Databases (ADO.NET) Tracing and Logging Manipulating Images/Graphics

16

Class Library (2/2)

Interoperability with COM Globalization and Internationalization Network Programming with Sockets Remoting Serialization XML Security and Cryptography Threading Web Services

17

Language Compilers
Over 20 different languages supported to date:
C#, VB, C++ Perl, Python, Scheme, F#, Fortran, J#, write your own!

All produce IL Cross-language compatibility is a feature of the runtime:

Write component in VB and use from C++, C#, Must adhere to the Common Language Specification:
Limits things you can use e.g. unsigned types, operator overloading

18

Web Application Development

ASP.NET provides a rich platform for developing Web applications and Web Services A huge leap forward from traditional ASP:
Aimed towards enterprise class, industrial-strength Web applications Fully integrated with all areas of .NET

Our software is based on this framework

19

Distributed Computing
Remoting and Web Services allow remote procedure calls Remoting is used to make calls between .NET Application Domains:
Built-in to CLR

Web Services are used to provide cross-platform RPC in an interoperable manner:

ASP.NET and CLR support

20

Obtaining the Framework

Download the Framework SDK via
http://msdn.microsoft.com/netframework/

~110 Mb Support at http://msdn.microsoft.com Visual Studio .NET is available at a reduced rate for academic institutions

21

.NET Programming with C#

22

C# Features (1/2)
Programming language of choice for the .NET platform:
Microsofts preferred language

Java-like, but has much in common with C++:

70% Java, 10% C++, 5% VB, 15% new

Strongly-typed:
Enforced by the compiler and the runtime As are all .NET languages

Object-oriented:
Every object is an instance of a particular Type Types are class, interface, enum, struct

Single implementation inheritance, multiple interface inheritance a la Java

23

C# Features (2/2)
Close coupling with managed code services:
Garbage collection, threading

Operator overloading allowed:

C++ heritage

Can access raw pointers using unsafe code blocks Properties are a first class language feature:
Unlike Java where accessor methods must be coded Syntactic sugar, but nice!

Supports strongly-typed callback mechanisms directly using events/delegates:

Unlike Java, where callback support is indirect (interface based, anonymous inner classes etc)

24

Supports call by reference:

Use of out and ref keywords

Really New C# Features (compared to Java)

Supports stack-allocated objects (structs) Value Types Supports enumerations directly:

Can use as C/C++ style bit-mask/flags

Explicit versioning control:

More a feature of the framework but accessible using C#

True multi-dimensional arrays:

More efficient

Semi-deterministic finalization:
Using IDisposable

25

Namespaces
Means of dividing related classes logically Avoid name clashes Analogous to Java packages, C++ namespaces:
MyCompany.MyApplication.Module

Declare using braces:

namespace MyNamespace { // classes etc }

Import namespace with using directive:

using System.Xml Must include assembly where classes belonging to a namespace reside:
/reference command line option on csc (C# compiler)

Classes from a namespace do not have to all live in same assembly

System namespace is root of .NET framework classes

26

Sample Program
//Person.cs: using System; using SomeLib; namespace MyApplication { class Person { private string name_; public string Name { get { return name_; } set { if(value == null) throw new ArgumentNullException(name); name_ = value; } } public static void Main { Person p = new Person(); p.Name = Daragh; Console.WriteLine(p.Name); } } }

Compile as follows:
Produces Person.exe C:/> csc Person.cs /reference:SomeLib.dll

Execute:
C:/> person output: Daragh

27

Using C#
Very intuitive at first if you are a Java programmer:
Some differences will soon be noticed

Command-line is good for learning:

csc.exe, vbc.exe, cl.exe

Best way to use is with Visual Studio .NET:

Nice for GUI apps, great designer for forms, Web applications Integrates with source control (Source Safe) Good for large multi-component projects If you do not have it, there is always the command-line:
Good to know your way around this way

28

Useful Things (1/2)

Boxing and unboxing:
Primitive (value) types can be treated as reference types without explicitly wrapping them:
Java : C# Integer I = new Integer(5); int i = 5 object o = i; o += 1; // i = 5, o = 6;

foreach
foreach(element e in array) foreach(element e in somethingEnumerable)

29

Useful Things (2/2)

Exception safe casts using as
Employee e = new Employee() Person p = e as Person; if(p != null) { ... }

Properties are integral:

Dont define field, accessor, setter Looks like field to client: public int MyProperty { get { // logic } set { myField_ = value; } } x.MyProperty = 2;

30

Attributes
Can add custom metadata to your types:
public class SomeType { [WebMethod] public string SomeMethod() { } }

31