Die .NET Common Language Runtime Softwareentwicklung mit .NET Teil 2 Einführung in C# Dr. Ralph Zeller

Die .NET Common Language Runtime Einleitung Die .NET Common Language Runtime Viele Entwickler wünschen sich eine Programmiersprache, die so einfach ist wie Visual Basic und so mächtig und flexibel wie C++ C# ist die beste Wahl für das .NET Framework Ideal für .NET Applikationen Web Services ...

Die .NET Common Language Runtime C# Designziele Die .NET Common Language Runtime Erste C/C++ ähnliche komponenten- orientierte Sprache Garbage Collection Keine Speicherlecks oder „wilde Pointer“ Exceptions Error Handling von Anfang an bedacht Typsicherheit Keine uninitialisierten Variablen Keine unsichere Casts

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

Die .NET Common Language Runtime C# Program Struktur Die .NET Common Language Runtime using System; namespace System.Collections { public class Stack Entry top; public void Push(object data) { top = new Entry(top, data); } public object Pop() { if (top == null) throw new InvalidOperationException(); object result = top.data; top = top.next; return result;

Die .NET Common Language Runtime Statements und Expr. Die .NET Common Language Runtime If, while, do benötigen eine boolsche Bedingung Mit goto kann nicht in Blöcke gesprungen werden Switch Statement Kein “fall-through“ im Switch Statement “break”, “goto case” or “goto default” notwendig Checked und unchecked Statement Ausdrücke müssen etwas tun if (value == 0) //ok WriteLine("true"); if (value) //Fehler WriteLine("true");

Die .NET Common Language Runtime Foreach Statement Die .NET Common Language Runtime Iteration von Arrays Iteration durch selbst definierte Collections public static void Main(string[] args) { foreach (string s in args) Console.WriteLine(s); } foreach (Customer c in customers.OrderBy("name")) { if (c.Orders.Count != 0) ... }

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

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

Selbst definierte Typen Die .NET Common Language Runtime Classes (reference) Wird für die meisten Objekte verwendet Structs (value) Für Daten-Objekte (Point, Complex, etc.). Interfaces

Die .NET Common Language Runtime Classes and Structs Die .NET Common Language Runtime class CPoint { int x, y; ... } struct SPoint { int x, y; ... } CPoint cp = new CPoint(10, 20); SPoint sp = new SPoint(10, 20); 10 sp 20 cp 10 20 CPoint

Die .NET Common Language Runtime Klassen (class) Die .NET Common Language Runtime Einfachvererbung (single inheritance) Implementierung von beliebig vielen Interfaces Elemente einer Klasse Konstanten, Felder, Methoden, Operatoren, Konstruktoren, Destruktoren Properties, Indexer, Events Verschachtelte Typen Statische Elemente (static) Zugriffsschutz public, protected, internal, private

Die .NET Common Language Runtime Strukturen (struct) Die .NET Common Language Runtime Sind immer “value types“ Ideal für “kleine” Objekte Keine Allokierung auf dem Heap Weniger Arbeit für den Garbage Collector Effizientere Speicherbenutzung Benutzer können “primitive” Typen selbst erzeugen Syntax und Semantik sehr eingängig Operator Overloading, Conversion Operators .NET Framework nutzt diese auch int, float, double, … sind alles structs

Die .NET Common Language Runtime Interfaces Die .NET Common Language Runtime Enthalten Methoden, Properties, Indexer, und Events Explizite Implementierung möglich Löst Interface Probleme bei Namenskollisionen Ausblenden der Implementierung vor dem Benutzer interface IDataBound { void Bind(IDataBinder binder); } class EditBox: Control, IDataBound void IDataBound.Bind(IDataBinder binder) {...}

Interfaces Beispiel 1: C# Interfaces Die .NET Common Language Runtime

Die .NET Common Language Runtime Vererbung Die .NET Common Language Runtime Methoden sind standardmäßig NICHT virtual Eine Methode kann nur mit „override“ überschrieben werden class B { public virtual void foo() {} } class D : B { public override void foo() {}

Die .NET Common Language Runtime Vererbung Die .NET Common Language Runtime Methoden sind standardmäßig NICHT virtual Überschreiben einer nicht-virtual Methode  Compilerfehler! Außer man verwendet „new“ class N : D { public new void foo() {} } N n = new N(); n.foo(); // call N’s foo ((D)n).foo(); // call D’s foo ((B)n).foo(); // call D’s foo

Die .NET Common Language Runtime Parameterübergabe Die .NET Common Language Runtime in Parameter: Entspricht einer Übergabe „ByVal“. Es wird der Wert an die Methode übergeben static void Foo(int p) {++p;} Static void Main() { int x = 8; Foo(x); // Kopie von x wird übergeben Console.WriteLine(x); // x = 8 }

Die .NET Common Language Runtime Parameterübergabe Die .NET Common Language Runtime ref Parameter: Man übergibt die Referenz an die Methode static void Foo(ref int p) {++p;} Static void Main() { int x = 8; Foo(ref x); // Referenz von x wird übergeben Console.WriteLine(x); // x = 9 }

Die .NET Common Language Runtime Parameterübergabe Die .NET Common Language Runtime out Parameter: Erhält einen Wert von Methode zurück (Variable muss vorher nicht initialisiert werden) static void Foo(out int p) {p = 3;} Static void Main() { int x; Foo(out x); // x ist bei Übergabe nicht initialisiert Console.WriteLine(x); // x = 3 }

Komponentenentwicklung Die .NET Common Language Runtime Was macht eine Komponente aus? Properties, Methoden, Events Design-Time und Run-Time Information Integrierte Hilfe und Dokumentation C# hat die beste Unterstützung Keine “naming patterns“, Adapter, ... Keine externen Dateien Komponenten sind einfach zu erstellen und zu verwenden

Die .NET Common Language Runtime Properties Die .NET Common Language Runtime Eine Mischung aus Feldern und Methoden (= smart fields) Properties sind: für Read-Only Felder für Validierung für berechnete oder zusammengesetzte Werte Eine Ersatz für Felder in Interfaces

Die .NET Common Language Runtime Properties Beispiel Die .NET Common Language Runtime public class Button: Control { private string caption; public string Caption { get { return caption; } set { caption = value; Repaint(); Button b = new Button(); b.Caption = "OK"; String s = b.Caption;

Die .NET Common Language Runtime Indexer Die .NET Common Language Runtime Praktische Möglichkeit, Container zu implementieren Erweitern die Idee der Properties (= smart properties) Erlauben Indexierung von Daten innerhalb des Objekts Zugriff ist wie bei Arrays Der Index selbst kann von jedem Datentyp sein a = myDict["ABC"];

Die .NET Common Language Runtime Indexer Beispiel Die .NET Common Language Runtime 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(); listBox[0] = "hello"; Console.WriteLine(listBox[0]);

Die .NET Common Language Runtime Delegates Die .NET Common Language Runtime Ein Delegate Objekt repräsentiert eine Funktion. Dadurch kann ein Delegate als Funktionsparameter oder Mitglied einer Klasse fungieren. Ersatz für C++ Funktionspointer Objektorientiert, type-safe und sicher Grundlage für Events

Die .NET Common Language Runtime Delegates Beispiel Die .NET Common Language Runtime using System; delegate void Delg(string sTry); public class Example1{ // function which uses the delegate object private static void Func1(Delg d){ d("Passed from Func1"); } // function which is passed as an object private static void Func2(string sToPrint){ Console.WriteLine("{0}",sToPrint); // Main execution starts here public static void Main(){ Delg d = new Delg(Func2); Func1(d);

Delegates Beispiel 2: Check Person Die .NET Common Language Runtime

Die .NET Common Language Runtime Attribute Die .NET Common Language Runtime Runtime / Design-Time Informationen für Typen und deren Elemente Beispiele // Klasse serialisierbar machen [Serializable] class MyClass { … } // Security Einstellungen [assembly:EnvironmentPermissions( SecurityAction.RequestRefuse, UnmanagedCode = true)] namespace Perms { class ReadConfig { … } }

Die .NET Common Language Runtime Attribute Die .NET Common Language Runtime Für Typen und deren Elemente Zugriff zur Laufzeit über “reflection“ Vollständig erweiterbar Ein Attribut ist eine Klasse, die von System.Attribute abgeleitet wurde Wird im .NET Framework oft benutzt XML, Web Services, Security, Serialization, Component Model, COM und P/Invoke Interop …

Die .NET Common Language Runtime Beispiele Attribute Die .NET Common Language Runtime Attribute sind Klassen Abgeleitet von System.Attribute Klassenfunktionalität = Attributfunktionalität public class HelpUrlAttribute : System.Attribute { public HelpUrlAttribute(string url) { … } public string Url { get {…} } public string Tag { get {…} set {…} } }

Die .NET Common Language Runtime Attribut verwenden Die .NET Common Language Runtime [HelpUrl("http://SomeUrl/MyClass")] class MyClass {} [HelpUrl("http://SomeUrl/MyClass", Tag="ctor")] Wenn der Compiler ein Attribut sieht ruft er den Konstruktor auf und übergibt die Argumente falls weitere Parameter existieren, setze er das Property auf den entsprechenden Wert speichert die Parameter in den Metadaten

Die .NET Common Language Runtime Attribute abfragen Die .NET Common Language Runtime Mittels Reflection können Attribute abgefragt werden Type type = typeof(MyClass); foreach(object attr in type.GetCustomAttributes() ) { if ( attr is HelpUrlAttribute ) HelpUrlAttribute ha = (HelpUrlAttribute) attr; myBrowser.Navigate( ha.Url ); }

Die .NET Common Language Runtime XML Kommentare Die .NET Common Language Runtime Konsistente Art, um Dokumentation aus dem Code zu erzeugen "///" Komentare werden exportiert Dokumentation wird vom Compiler durch /doc: extrahiert werden Ein „kleines“ Schema ist eingebaut

Die .NET Common Language Runtime Bsp. XML Kommentare Die .NET Common Language Runtime class XmlElement { /// <summary> /// Returns the attribute with the given name and /// namespace</summary> /// <param name="name"> /// The name of the attribute</param> /// <param name="ns"> /// The namespace of the attribute, or null if /// the attribute has no namespace</param> /// <return> /// The attribute value, or null if the attribute /// does not exist</return> /// <seealso cref="GetAttr(string)"/> /// public string GetAttr(string name, string ns) { ... }

Die .NET Common Language Runtime C# und Pointer Die .NET Common Language Runtime C# unterstützt Eingebauter Typ: String Benutzerdefinierte Referenztypen Große Auswahl an Collection-Klassen Referenz- und Ausgabeparameter (out , ref) 99% der Pointer werden nicht mehr benötigt Dennoch sind Pointer verfügbar, wenn Programmcode mit unsafe markiert ist

Die .NET Common Language Runtime Beispiel unsafe Code Die .NET Common Language Runtime class FileStream: Stream { int handle; public unsafe int Read(byte[] buffer, int index, int count) int n = 0; fixed (byte* p = buffer) ReadFile(handle, p + index, count, &n, null); } return n; [DllImport("kernel32.dll", SetLastError=true)] static extern unsafe bool ReadFile(int hFile, void* lpBuffer, int nBytesToRead, int* nBytesRead, Overlapped* lpOverlapped);

Die .NET Common Language Runtime Fragen? Die .NET Common Language Runtime Uff...

Die .NET Common Language Runtime Glossar Die .NET Common Language Runtime Boxing/Unboxing: Die Boxing- und Unboxing-Operationen sind zentrale Konzepte im C# Typsystem. Sie verbinden die sogenannten value-types und reference-types miteinander indem sie es ermöglichen, jeden value-type in einen Wert vom Typ Object umzuwandeln und umgekehrt. Dies ermöglicht, dass jeder Wert als Wert vom Typ object gesehen werden kann. Garbage Collection: Automatisches Speichermanagement entbindet den Programmierer davon, Speicher explizit freizugeben. Die Programmumgebung räumt automatisch den nicht verwendeten Speicher auf, um ihn später wieder zu nutzen. Dies wird als Garbage Collection bezeichnet. Interface: Ein Interface ist eine Art Vertrag zwischen einer Klasse, die das Interface implementiert, und dem Programmcode der diese Klasse nutzt. Eine Schnittstelle legt nicht nur fest, welche Funktionen verfügbar sind, sondern auch, was das Objekt tut, wenn die Funktionen aufgerufen werden Interoperabilität: Die Fähigkeit eines oder mehrer Systeme, Informationen auszutauschen und diese zu verwenden Multiple Interface Implementation: (Auch multiple interface inheritance) Ein Konzept in der Objektorientierten Programmierung um Multiple Inheritance zu vermeiden, indem zwar nur von einer Klasse abgeleitet werden kann aber mehrere Interfaces von einer Klasse implementiert werden. Hierdurch wird ebenfalls Polymorphie erreicht. Single Inheritance: Die Tatsache, daß eine Klasse nur von einer einzigen Basisklasse abgeleitet werden kann. XML: Ex(tensible) M(arkup) L(anguage) ist ein W3C (http://www.w3c.org) Standard. Dieser Standard beschreibt ein universelles Format zur Beschreibung von strukturierten Dokumenten und Daten im Web