http://www.epcc.ed.ac.uk/~ogsanet
January 14th-15th 2004
Microsoft .NET Basics
Daragh Byrne – EPCC
2
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#
3
Microsoft .NET Framework
4
.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
5
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
6
What’s 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
7
Targeting .NET
Source Code (C#, VB.NET) MSIL
CLR
Native Code (x86 etc)
Compiled to
Runs on
Compiled to
8
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
9
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 don’t have to deal with this:
– That’s what compilers are for!– You could do it though!
10
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
11
Running a .NET Application
.NET Executable(Stored as Windows Portable
Executable file)mscoree.dll
Bind to runtime library
Execute MSIL entry point (verifies code,
starts compilation and execution)
12
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
13
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
14
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
15
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
16
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
17
Class Library (2/2)
Interoperability with COM Globalization and Internationalization Network Programming with Sockets Remoting Serialization XML Security and Cryptography Threading Web Services
18
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
19
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
20
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
21
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
22
.NET Programming with C#
23
C# Features (1/2)
Programming language of choice for the .NET platform:– Microsoft’s 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
24
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)
25
Really New C# Features (compared to Java)
Supports call by reference:– Use of out and ref keywords
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
26
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
27
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
28
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
29
Useful Things (1/2)
Boxing and unboxing:– Primitive (value) types can be treated as reference types without
explicitly wrapping them:• Java : Integer I = new Integer(5);• C# int i = 5 object o = i; o += 1; // i = 5, o = 6;
foreach• foreach(element e in array)• foreach(element e in somethingEnumerable)
30
Useful Things (2/2)
Exception safe casts using asEmployee e = new Employee()Person p = e as Person;if(p != null){...}
Properties are integral:– Don’t define field, accessor, setter– Looks like field to client:public int MyProperty{ get { // logic } set { myField_ = value; }} x.MyProperty = 2;
31
Attributes
Can add custom metadata to your types:
public class SomeType
{
[WebMethod]
public string SomeMethod() { …
}
}
Top Related