C#-intro

Softwareentwicklung mit .NET
Teil 2
Einführung in C#
Dr. Ralph Zeller
1
Einleitung

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
...
2
C# Designziele

Erste C/C++ ähnliche komponentenorientierte Sprache

Garbage Collection


•
Keine Speicherlecks oder „wilde Pointer“
Exceptions
•
Error Handling von Anfang an bedacht
Typsicherheit
•
•
Keine uninitialisierten Variablen
Keine unsichere Casts
3
C# Programmstruktur




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
4
C# Program Struktur
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;
}
}
}
5
Statements und Expr.

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)
//Fehler
WriteLine(“true”);
if (value == 0)
//ok
WriteLine(“true”);
6
Foreach Statement

Iteration von Arrays
public static void Main(string[] args)
{
foreach (string s in args) Console.WriteLine(s);
}

Iteration von selbstdefinierten Collections
foreach (Customer c in customers.OrderBy("name"))
{
if (c.Orders.Count != 0)
{
...
}
}
7
Zwei Arten von Typen
Value (struct)
Reference (class)
Variable enthält
Wert
Referenz
Speicher
Stack
Heap
Initialisiert mit
Alles 0
Konstante: null
kopiert Wert
kopiert Referenz
Zuweisung
int i = 123;
string s = "Hello world";
int j = i;
string t = s;
i
123
"Hello world"
s
j
t
123
8
Boxing und Unboxing

Jeder Datentyp kann als Objekt gespeichert
oder übergeben werden
int
i = 123;
object o = i;
int
j = (int)o;
i
123
123
o
System.Int32
j
123
}
“Boxing”
}
“Unboxing”
9
Selbst definierte Typen



Classes (reference)
•
Wird für die meisten Objekte verwendet
Structs (value)
•
Für Daten-Objekte (Point, Complex, etc.).
Interfaces
10
Classes and Structs
class CPoint { int x, y; ... }
struct SPoint { int x, y; ... }
CPoint cp = new CPoint(10, 20);
SPoint sp = new SPoint(10, 20);
sp
10
20
cp
10
20
CPoint
11
Klassen (class)

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
12
Strukturen (struct)

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
13
Interfaces

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) {...}
}
14
Interfaces
Beispiel 1: C# Interfaces
15
Vererbung

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() {}
}
16
Vererbung

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
17
Parameterübergabe

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
}
18
Parameterübergabe
 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
}
19
Parameterübergabe
 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
}
20
Komponentenentwicklung



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
21
Properties

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
22
Properties Beispiel
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;
23
Indexer

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
a = myDict["ABC"];

Der Index selbst kann von jedem Datentyp
sein
24
Indexer Beispiel
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]);
25
Delegates

Ersatz für Funktionspointer

Objektorientiert, type-safe und gesichert

Delegates sind Objekte

Eine Instanz eines Delegates kapselt

•
•
eine Methode und
eine Referenz auf eine Instanz (nur wenn Methode
nicht statisch)
Grundlage für Events
26
Delegates Beispiel

Definieren der Event Signatur
public delegate void EventHandler(object sender, EventArgs e);

Definieren der Event- und Aufruflogik
public class Button
{
public event EventHandler Click;
protected void OnClick(EventArgs e)
{
if (Click != null) Click(this, e);
}
}
27
Delegates Beispiel

Definieren und Installieren des Event
Handlers
public class MyForm: Form
{
Button okButton;
public MyForm() {
okButton = new Button(...);
okButton.Click += new EventHandler(OkButtonClick);
}
void OkButtonClick(object sender, EventArgs e) {
ShowMessage("You pressed the OK button");
}
}
28
Attribute

Runtime / Design-Time Informationen für
Typen und deren Elemente

Beispiele


•
•
•
URL für Dokumentation einer Klasse
Informationen für COM marshalling
Wie wird in XML persistiert
Bekannte Methoden sind entkoppelt
•
•
Neue Schlüsselwörter oder pragma
Zusätzliche Dateien, z.B.: .IDL, .DEF
C# Lösung: Attribute
29
Attribute

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 …
30
Beispiele Attribute
Attribute sind Klassen

•
•
Abgeleitet von System.Attribute
Klassenfunktionalität = Attributfunktionalität
public class HelpUrlAttribute : System.Attribute
{
public HelpUrlAttribute(string url) { … }
public string Url
public string Tag
{ get {…} }
{ get {…} set {…}
}
}
31
Attribut verwenden
[HelpUrl("http://SomeUrl/MyClass")]
class MyClass {}
[HelpUrl("http://SomeUrl/MyClass”, Tag=“ctor”)]
class MyClass {}

Wenn der Compiler ein Attribut sieht
1. ruft er den Konstruktor auf und übergibt die
Argumente
2. falls weitere Parameter existieren, setze er das
Property auf den entsprechenden Wert
3. speichert die Parameter in den Metadaten
32
Attribute abfragen

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 );
}
}
33
XML Kommentare

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
34
Bsp. XML Kommentare
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) {
...
}
}
35
C# und Pointer

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
36
Beispiel unsafe Code
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", SetLastError=true)]
static extern unsafe bool ReadFile(int hFile,
void* lpBuffer, int nBytesToRead,
int* nBytesRead, Overlapped* lpOverlapped);
}
37
Fragen?
Uff...
38