Anwendungen der nächsten Generation Die Microsoft .NET Plattform - Überblick und Grundlagen Anwendungen der nächsten Generation Anwendungen werden WebServices Other Services XML Public Web Services Building Block Internal XML Biz Logic & Web Service OS Services OS Services Biz Tier Logic Smarter Clients Smarter Devices XML Standard Browsers HTML Servers Data, Hosts XML Offene Internet Protokolle (HTTP, SMTP, XML, SOAP) Anwendungen rufen weltweit lose gekoppelte Dienstleistung auf

Die 3. Generation von Internet-Apps Die Microsoft .NET Plattform - Überblick und Grundlagen Die 3. Generation von Internet-Apps 1. Generation 1994-96 2. Generation 1996-2000 Statische Seiten Dyn. Seiten E-mail, einfache Info Personalisation, E-Commerce IE, IIS Windows DNA 3. Generation 2000+ Mehr als Surfen Web Services Microsoft .NET

Service Federation Lose gekoppelte Dienstleistungen XML Business Partners .NET Building Block Services EDIFACT Open Standards: TCP/IP XML HTTP SMTP SOAP X12 Finance WebService Provider News Enterprise Applikationen B2B Website Order/ Sales Dept. SQL Server XML .NET Enterprise Server Knowledge Management Accounting BizTalk Messaging Exchange WebStorage

.NET Building Block Services Die Microsoft .NET Plattform - Überblick und Grundlagen .NET Building Block Services Verteilte, XML-basierte Dienste Arbeiten online oder offline (Intranet) Identity Notification, Messaging Personalization XML Storage Calendar Directory and Search Software Delivery

Die Microsoft .NET Plattform - Überblick und Grundlagen WebServices Internal Corporate Services Your Sales Data Service Your Internal Billing Service Open Internet Protocols Passport – Identity Service Directory and Search Service Microsoft Building Block Services Personalization Service Software Delivery Service Firewalls können für den Zugriff auf WebServices konfiguriert werden. Calendaring Service Schematized Storage Service Notification & Msg Service Geographic Mapping Service Web Services Built by 3rd Parties Greenwich Mean Time Service Credit Card Statement Service …

Die Microsoft .NET Plattform - Überblick und Grundlagen .NET Framework Base Classes Data & XML User Interface Common Language Runtime Web Services COM Interfaces Web Service Web Service XML

Framework, Languages and Tools Die Microsoft .NET Plattform - Überblick und Grundlagen Framework, Languages and Tools VB C++ C# JScript … Visual Studio.NET Common Language Specification Web Services User Interface Data and XML Base Class Library Common Language Runtime

Common Language Runtime Die Microsoft .NET Plattform - Überblick und Grundlagen Common Language Runtime Thread Support COM Marshaler Type Checker Exception Manager Security Engine Debug Engine IL to Native Compilers Code Manager Garbage Collector Class Loader

Warum eine Runtime? Einheitliches Integrationsmodell Die Microsoft .NET Plattform - Überblick und Grundlagen Warum eine Runtime? Einheitliches Integrationsmodell Layer (VBRUNxx.DLL) (MSVCRT.DLL) Layer (VBRUNxx.DLL) (MSVCRT.DLL) Common Language Runtime (MSCOREE.DLL) (MSCORLIB.DLL) Loader Remoting Kontext Concurrency Transaktionen Typsystem Microsoft Transaction Server (MTXEX.DLL) COM+ Runtime (OLE32.DLL) COM Runtime (OLE32.DLL)

Die Microsoft .NET Plattform - Überblick und Grundlagen Übersicht VB C# C++ ASM Code Compiler Compiler Compiler IL Code IL Code IL Code Common Language Runtime JIT Compiler Betriebssystem

Basics Managed Code Sämtlicher Code wird unter Aufsicht der Common Language Runtime ausgeführt Runtime führt Sicherheitsüberprüfungen aus Runtime übernimmt Speicherverwaltung und Fehlerbehandlung (à GC, Exceptions) Runtime führt Versionsprüfungen aus Dieser Code wird als Managed Code bezeichnet

Basics Microsoft Intermediate Language Compiler erzeugen keinen native Code sondern eine prozessorunabhängige Zwischensprache Sprachintegration erfolgt auf Codeebene MSIL – Microsoft Intermediate Language MSIL wird oft auch mit IL bezeichnet 

Basics Code wird kompiliert IL-Code wird vor der Ausführung immer (!) durch Compiler in echten Maschinencode übersetzt Unabhängigkeit von Hardwareplattformen unter Windows CE bereits mit einem IL-Vorläufer im Einsatz

Basics Code wird kompiliert Die Microsoft .NET Plattform - Überblick und Grundlagen Basics Code wird kompiliert Klasse A Methode 1 (IL) Methode 2 (IL) Methode 3 (IL) Methode 4 (IL) (1) Methodenaufruf Klasse B Methode 1 (IL) Methode 2 (IL) (2) IL-Code durch native Code ersetzen Methode 1 (ASM) JIT Compiler

Basics Implikationen Die IL unterscheidet sich von „reinen“ Assemblersprachen komplexe Datentypen und Objekte sind fester Bestandteil Konzepte wie Vererbung und Polymorphie werden von vornherein unterstützt

Basics Implikationen Sprachen werden gleichwertig, da alle Compiler MSIL-Code erzeugen „eine C# Klasse kann von einer VB.NET Klasse abgeleitet sein“ einheitliche Fehlerbehandlung Compilerbau wird einfacher kein eigenes Typsystem keine eigene Standardbibliothek Sprachen sind „per Definition“ interoperabel

Basics Common Type System Das Typsystem wandert vom Compiler in die Runtime Typen werden eindeutig „ein String unter C# und ein String unter VB.NET sind identisch“ Sprachen werden interoperabel, da sie das gleiche Typsystem benutzen CTS – Common Type System

Common Type System Das Objektmodell Object Value Type Boolean Int64 Enum Byte SByte Char Single Type Currency TimeSpan Typen im Namespace System DateTime String TypedRef. Decimal UInt16 Array Double UInt32 Guid UInt64 Exception Int16 Void Int32 Delegate

Common Type System Gleichheit und Identität von Objekten Zwei Objekte sind gleich, wenn deren Inhalte gleich sind Zwei Objekte sind identisch, wenn sie die gleiche Instanz referenzieren Gleichheit definiert sich über die virtuelle Methode System.Object.Equals identisch: System.Object.Equals = true gleich: System.Object.Equals.Value = true

Bestandsaufnahme Die Common Language Runtime ermöglicht unabhängig von Programmiersprachen eine durchgängig objekt- und komponentenorientierte Programmierung .NET Sprachen sollten sich auf die Typen beschränken, die über das Common Type System definiert sind

Metadaten und Reflection Übersetzen von Sourcen Die Microsoft .NET Plattform - Überblick und Grundlagen Metadaten und Reflection Übersetzen von Sourcen Source Code Typ A {…} Compiler (C#, VB.NET, etc.) Typ B {…} Typ C {…} Metadaten für die Typen A, B und C MSIL-Code für Typ A MSIL-Code für Typ B MSIL-Code für Typ C Modul

Metadaten und Reflection Ein Modul dient als Container für Typen Ein Modul enthält den IL-Code der Typen Beschreibung der Typen Die Beschreibung der Typen wird mit Metadaten bezeichnet Jedes Modul enthält Metadaten Compiler erstellt Metadaten „on the fly“

Metadaten und Reflection Metadaten sind für alle Module auf die gleiche Art und Weise aufgebaut Einheitliches Format !!! Metadaten eines Moduls können zur Laufzeit ausgelesen und geändert werden Diesen Vorgang nennt man Reflection .NET Framework stellt entsprechende Klassen über den Namespace System.Reflection bereit

Warum ein Framework? Einheitliches Programmiermodell Die Microsoft .NET Plattform - Überblick und Grundlagen Warum ein Framework? Einheitliches Programmiermodell .NET Framework VB Forms MFC & ATL ASP Windows API

Die Microsoft .NET Plattform - Überblick und Grundlagen Base Class Library System.Web System.WinForms Services UI Design ComponentModel Description HtmlControls Discovery WebControls Protocols System.Drawing Caching Security Drawing2D Printing Configuration SessionState Imaging Text System.Data System.Xml ADO SQL XSLT Serialization Design SQLTypes XPath System Collections IO Security Runtime InteropServices Configuration Net ServiceProcess Remoting Diagnostics Reflection Text Serialization Globalization Resources Threading

Hello, World! C# VB.NET using System; Imports System namespace HelloWorld { public class Class1 public static void Main() Console.WriteLine("Hello, World!"); } VB.NET Imports System Namespace HelloWorld Class Class1 Shared Sub Main() Console.WriteLine("Hello, World!") End Sub End Class End Namespace Alternativ: Module Module1 Sub Main() Console.WriteLine("Hello, World!") End Sub End Module

Hello, World: C# IL .namespace HelloWorld { .class public auto ansi Class1 extends [mscorlib]System.Object .method public hidebysig static void Main() il managed .entrypoint .maxstack 8 IL_0000: ldstr "Hello, World!" IL_0005: call void [mscorlib]System.Console::WriteLine(class System.String) IL_000a: ret } .method public hidebysig specialname rtspecialname instance void .ctor() il managed IL_0000: ldarg.0 IL_0001: call instance void [mscorlib]System.Object::.ctor() IL_0006: ret

C# und VB.NET Gemeinsamkeiten Namespaces Enthalten Typdefinitionen und Namespaces Typdefinitionen Klassen, Strukturen, Interfaces, Delegates ... Elemente von Typen Konstanten, Felder, Methoden, Properties, Events, Operatoren, Konstruktoren, Destruktoren Organisation der Dateien Keine Header-Dateien, Programmcode ist “in-line” Die Reihenfolge der Deklarationen ist ohne Bedeutung

Stabile und dauerhafte Software Die Microsoft .NET Plattform - Überblick und Grundlagen Stabile und dauerhafte Software Automatisches Speichermanagement Keine Speicherlecks oder „wilde Pointer“ Garbage Collection C# und VB.NET kommen ohne Pointer aus Eingebauter Typ: String Benutzerdefinierte Referenztypen Große Auswahl an Kollektionen Referenz- und Ausgabeparameter (out , ref) 99% der Pointer werden nicht mehr benötigt C#: Dennoch sind Pointer über unsafe-Code verfügbar Exceptions Error Handling von Anfang an bedacht Typsicherheit (type safety) Keine uninitialisierten Variablen Keine unsichere Casts Versionsverwaltung Wurde von Grund auf berücksichtigt

Alles ist wirklich ein Objekt C#/VB.NET vereinen Klassen und „primitive types“ Alles ist ein Objekt ohne die Performance-Probleme anderer Systeme Dim s as String, o as Object o = s Einfach und erweiterbar Man kann neue „primitive types“ erzeugen Intuitiv in Syntax und Semantik VB.NET: Variant entfällt COM-Interop: Transparenter Zugriff auf COM-Objekte .NET-Objekte über COM nutzbar

Zwei Arten von Typen Value (struct) Reference (class) Variable enthält Wert Referenz Speicher Stack Heap Initialisiert mit Alles 0 Konstante: null Zuweisung kopiert Wert kopiert Referenz int i = 123; string s = "Hello world"; 123 i s "Hello world" 123 j t int j = i; string t = s;

} } Boxing und Unboxing “Boxing” “Unboxing” Jeder Datentyp kann als Objekt gespeichert oder übergeben werden int i = 123; object o = i; int j = (int)o; 123 i } “Boxing” o 123 System.Int32 } “Unboxing” 123 j

Implementation Inheritance Einfachvererbung (single inheritance) Auch über Sprachgrenzen hinweg Abstrakte Klassen, finale Klassen Implementierung von beliebig vielen Interfaces Elemente einer Klasse Konstanten, Felder, Methoden, Konstruktoren, Destruktoren, Operatoren (C#) Properties, Indexer (C#), Events (VB.NET) Verschachtelte Typen Statische Elemente Virtuelle Methoden VB.NET: Alle Methoden immer virtuell Zugriffsschutz public, protected, internal, private public class Person { private int YOB; public int YearOfBirth { get { return YOB; }; set { YOB = value; }; } public int GetAgeToday() { return Today()-YearOfBirth; } }

Operator Overloading (C#) Die meisten Operatoren können überladen werden Arithmetische, Vergleichs-, Logik- und Bedingungsoperatoren Allerdings nicht: Zuweisungsop., Spezialop. (sizeof, new, is, typeof) class Matrix { ... Matrix operator +(Matrix l, Matrix r) { Matrix e = new Matrix(); e = l mit r verknüpfen return e; } } Matrix a = new Matrix(...), b = new Matrix(...); Matrix c = a + b;

Interface Inheritance Interface erbt von Interface Public Interface Interface1 End Interface Public Sub M1() Public Property P1 As String Public Interface Interface2 End Interface Inherits Interface1 Public Sub M2() Public Property P2 As String

Die Microsoft .NET Plattform - Überblick und Grundlagen Property public class Button: Control { private string caption; public string Caption { get { return caption; } set { caption = value; Repaint(); Button b = new Button(); string s = b.Caption; b.Caption = "OK";

Die Microsoft .NET Plattform - Überblick und Grundlagen Indexer (C#) public class ListBox: Control { private string[] items; public string this[int index]{ get { return items[index]; } set { items[index] = value; Repaint(); ListBox listBox = new ListBox(); string s = listBox[0] listBox[0] = "hello"; listBox[1] = "world";

Strukturen Zusammenschluss von Daten und Code Werttyp Keine Vererbung struct Point { private double m_x, m_y; public Point(double x, double y) { m_x = x; m_y = y; } public double x { get { return m_x; } set { m_x = value; } ... public static Point operator+(Point l, Point r) { return new Point(l.x+r.x, l.y+r.y); public override string ToString() { return "(" + m_x + ", " + m_y + ")"; Zusammenschluss von Daten und Code Werttyp Keine Vererbung Leichtgewichtiger Datencontainer

Die Microsoft .NET Plattform - Überblick und Grundlagen Attribute public class OrderProcessor { [WebMethod] public void SubmitOrder(PurchaseOrder order) {...} } [XmlRoot("Order", Namespace="urn:acme.b2b-schema.v1")] public class PurchaseOrder [XmlElement("shipTo")] public Address ShipTo; [XmlElement("billTo")] public Address BillTo; [XmlElement("comment")] public string Comment; [XmlElement("items")] public Item[] Items; [XmlAttribute("date")] public DateTime OrderDate;

Ausnahmebehandlung Try auszuführende Anweisungen Catch e As COMException Fehlerbehandlung Catch e As Exception ... Catch When Err.Number = 5 Catch Finally Abschließende Behandlung, auch ohne Fehler End Try

Delegates 1:1 Delegate Empfänger MulticastDelegate 1:n Empfänger n:m Empfänger MulticastDelegate Empfänger

C# und VB.NET C# VB.NET

WebForms Keine Scriptsprachen mehr! Verwenden „echter“ Sprachen: VB.NET, C#, ... Seite wird beim ersten Aufruf komplett auf dem Server kompiliert Kompiliat wird beim Aufruf gerendert Browser bekommen „reines“ HTML zu sehen Seiten können serverseitige UI-Controls verwenden Diese Controls werden WebControls genannt

Die Microsoft .NET Plattform - Überblick und Grundlagen ADO.NET Architektur Web/Windows Form Controls VS.NET Designers myDataSet Item Cust Order VS.NET Class Generator TextReader String Stream <xml> … </xml> “<xml> … </xml>” Managed Provider DataSet- Command DataReader Command Connection XmlReader XmlText- Reader XmlNode- XmlDocument

Assemblies .NET Anwendungen bestehen aus Assemblies Assembly = Komponente Ein Assembly ist ein Container für Module Sämliche Sicherheits- und Versionsüberprüfungen durch die CLR erfolgen auf der Basis von Assemblies !!!

Assemblies Übersetzen von Sourcen Die Microsoft .NET Plattform - Überblick und Grundlagen Assemblies Übersetzen von Sourcen (app1.vb) Manifest Assembly (app1.dll) Typ A {…} Source Code Typ B {…} Typ C {…} Compiler (C#, VB.NET, etc.) Metadaten für die Typen A, B und C MSIL-Code für Typ A MSIL-Code für Typ B MSIL-Code für Typ C Modul

Assemblies Sobald ein Modul kompiliert ist, gehört es zu einem Assembly Compiler erstellt Assembly „on the fly“ .NET Framework stellt entsprechende Klassen über den Namespace System.Reflection.Emit bereit Die im Modul vorhandenen Typen sind nur innerhalb des Assemblies bekannt

Assemblies Container für mehrere Module Die Microsoft .NET Plattform - Überblick und Grundlagen Assemblies Container für mehrere Module Metadaten für D und E Modul 1 (app2.dll) Manifest Assembly (app1.dll) MSIL-Code für Typ D MSIL-Code für Typ E Metadaten für F und G Modul 2 (app3.dll) MSIL-Code für Typ F MSIL-Code für Typ G

Die Microsoft .NET Plattform - Überblick und Grundlagen Assemblies Manifest Jedes Assembly enthält genau ein Manifest Das Manifest beschreibt das Assembly Keine Headerdateien Keine Typenbibliothek

Assemblies Manifest Das Manifest beinhaltet Assembly-Identität = Name + Version + Ländercode Liste der Module, aus denen das Assembly besteht Referenzierte Assemblies Exportierte Typen und Resourcen Attribute

Assemblies Kategorien Private Assembly Assembly kann nur von genau einer Anwendung benutzt werden Shared Assemby Assembly kann global von allen Anwendungen benutzt werden

Assemblies Private Assembly Die Microsoft .NET Plattform - Überblick und Grundlagen Assemblies Private Assembly Identifikation anhand eines einfachen Namens, z.B. “Reverse” Keine Versionsüberprüfung Installation per Filecopy Standardmäßig befinden sich Assembly und Anwendung im gleichen Verzeichnis Verzeichnis kann per CFG-Datei definiert werden

Assemblies Shared Assembly Die Microsoft .NET Plattform - Überblick und Grundlagen Assemblies Shared Assembly Identifikation über einen Strong Name Eindeutig per Public-Key-Verschlüsselung Strong Name = Identität + Public Key Versionsüberprüfung durch die Runtime Installation im Global Assembly Cache (à SDK-Tool al.exe oder gacutil.exe) systemweiter “Speicherbereich” normale Dateien keine Registry-Einträge, o. ä.

Versionierung Aufbau der Versionsnummer Die Microsoft .NET Plattform - Überblick und Grundlagen Versionierung Aufbau der Versionsnummer

Versionierung Vorgaben per CFG-Datei definieren Die Microsoft .NET Plattform - Überblick und Grundlagen Versionierung Vorgaben per CFG-Datei definieren <Configuration> <BindingMode> <AppBindingMode Mode="safe"/> <!-- normal | safe --> </BindingMode> </ Configuration> <Configuration> <BindingPolicy> <BindingRedir Name=“[Assembly Name]" Originator="[Public Key]" Version="*" VersionNew=“[Versionsnummer]" UseLatestBuildRevision=“no"/> <!-- no | yes --> </BindingPolicy> </Configuration>

Die Microsoft .NET Plattform - Überblick und Grundlagen Mehr Informationen http://www.microsoft.com/net http://msdn.microsoft.com/net http://www.gotdotnet.com http://www.dotnetgerman.com http://www.devx.com/dotnet/ http://discuss.develop.com/dotnet.html