Microsoft .NET Basics : Microsoft .NET Basics Daragh Byrne – EPCC
Purpose : 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#
Slide3 : 3
Microsoft .NET Framework
.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
Evolution : 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
What’s in the .NET Framework? : 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
Targeting .NET : 7 Targeting .NET Source Code (C#, VB.NET) MSIL CLR Native Code (x86 etc) Compiled to Runs on Compiled to
Microsoft Intermediate Language (MSIL) : 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
MSIL Example : 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!
Common Language Runtime : 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
Running a .NET Application : 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)
Types and Assemblies : 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
Type Metadata and the CLR : 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
Metadata Addresses COM Shortcomings : 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
CLR Standards and Implementations : 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
Class Library (1/2) : 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
Class Library (2/2) : 17 Class Library (2/2) Interoperability with COM
Globalization and Internationalization
Network Programming with Sockets
Remoting
Serialization
XML
Security and Cryptography
Threading
Web Services
Language Compilers : 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
Web Application Development : 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
Distributed Computing : 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
Obtaining the Framework : 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
Slide22 : 22
.NET Programming with C#
C# Features (1/2) : 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
C# Features (2/2) : 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)
Really New C# Features (compared to Java) : 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
Namespaces : 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
Sample Program : 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
Using C# : 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
Useful Things (1/2) : 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)
Useful Things (2/2) : 30 Useful Things (2/2) Exception safe casts using as
Employee 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;
Attributes : 31 Attributes Can add custom metadata to your types:
public class SomeType
{
[WebMethod]
public string SomeMethod() { …
}
}