C# anhand von ECMA-334. Das große Seminar WS 04/ Daniel Wiese

Transkript

1 C# anhand von ECMA-334 Das große Seminar WS 04/ Daniel Wiese

2 Die Geschichte von C# Standard ECMA 334 Entwicklungsumgebung Sprachelemente von C# Datentypen Variablen und Parameter Ausdrücke Anweisungen (statements) Klassen und Klassenmember Strukturen (structs) Schnittstellen (interfaces) Delegaten (delegate) Enumerationen (enums) Namespaces und Assemblies Attribute (attributes) Fazit Diskussion Übersicht

3 Geschichte von C# 1997 Streit zwischen Sun und Microsoft um Java 1998 Microsoft veröffentlicht Visual J MS beginnt Entwicklung eigener Sprache 2000 Weiterentwicklung von Visual J++ wird aufgegeben 2000 Programmiersprache C# der ECMA vorgelegt 2001 C# wird Hauptsprache von.net Framework 2003 C# wird ISO-Standard

4 Der Standard ECMA-334 ECMA 334 C# Language Specification... legt fest: - Die Struktur der C# Programme - Die Syntax und die Einschränkungen der Sprache C# - Semantische Regeln zur Interpretation der C# Programme - Einschränkungen und Grenzen der standardkonformen Implementierung

5 Der Standard ECMA legt nicht fest: - Mechanismen zur Implementierung der C# Programme für die datenverarbeitende Systeme - Mechanismen für die Ausführung der C# Anwendungen - Mechanismen zur Umwandlung der Eingabe-Daten für die Nutzung von den C# Anwendungen - Mechanismen zur Umwandlung der Ausgabe-Daten nach der Erzeugung von den C# Anwendungen - Den Umfang oder Komplexität eines Programms und seiner Daten, welches die Kapazität der verarbeitenden Systeme übersteigen kann - minimalen Systemanforderungen für die Unterstützung einer konforme Implementierung

6 Entwicklungsumgebung.NET Framework von Microsoft.NET Framework SDK von Microsoft Editor: Microsoft Visual Studio.NET Borland C# Builder ( SharpDevelop (Open Source) ( Mono (Open Source)

7 C# streng objektorientiert Grundlegendes Quellcode in Textdatei mit Endung.cs Compiler: csc bei.net und msc bei Mono Dateinamen unabhängig von Klassennamen Startpunkt immer Main Funktion Alle Bibliotheken in CLI (Common Language Infrastructure) Einsatz von Namespaces

8 Hallo Welt! in C#: Hallo Welt! using System; class Hello { static void Main() { Console.WriteLine("Hallo Welt!"); Ausgabe erfolgt auf der Konsole

9 Datentypen Wertetypen (value types) Behälter für eigentliche Werte Einfache Typen wie int, char, double, enum, struct,... Verweistypen (reference types) Zeiger auf reservierten Speicherblock class, interface, delegate, array

10 Typumwandlung Implizit Bsp: int intvalue = 123; long longvalue = intvalue; - problemlose Konvertierung Explizit Bsp: long longvalue = Int64.MaxValue; int intvalue = (int) longvalue; (int) = -1 - Datenverlust wegen Überlauf

11 Arrays ein- oder mehrdimensional rechteckig oder verzweigt (jagged) int[] a1=new int[] {1, 2, 3; int[,] a2=new int[,] {{1, 2, 3,{4, 5, 6; int[,,] a3=new int[10, 20, 30]; int[][] j2 = new int[3][];//array von(array von int) j2[0] = new int[] {1, 2, 3; j2[1] = new int[] {1, 2, 3, 4, 5, 6; j2[2] = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9;

12 Basis aller Datentypen Alle Datentypen sind Objekte System.Console.WriteLine(3.ToString()); boxing Konzept reference type < > value type class Test { static void Main() { int i = 123; object o = i; int j = (int) o; // boxing // unboxing

13 Variablen Variablen Speicherplätze für Werte 7 Typen: static, instance, array elements, value parameters, reference parameters, output parameters und local variables Bsp: class A { public static int x; int y; void F(int[] v, int a, ref int b, out int c) { int i = 1; c = a + b++;

14 Speicherverwaltung Garbage Collector - Automatische Speicherbereinigung Arbeit mit Zeigern trotzdem möglich! class Test { static void WriteLocations(byte[] arr) { unsafe { fixed (byte* parray = arr) { byte* pelem = parray; for (int i = 0; i < arr.length; i++) { byte value = *pelem; System.Console.WriteLine("arr[{0] at 0x{1:X is {2", i, (uint)pelem, value); pelem++; static void Main() { byte[] arr = new byte[] {1, 2, 3, 4, 5; WriteLocations(arr);

15 Anweisungen (statements( statements) for, while, if etc. wie in C/C++ Neu eingeführte: - labeled statements und goto statements - foreach statements ( foreach (string s in args) ) - throw statements und try statements (wie in Java) - checked und unchecked statements (Überlaufsteuerung) - lock statements (Synchronisation von Threads) - using statement: static void Main() { using (Resource r = new Resource()) { r.f();

16 Klassen Definieren neue Referenztypen Nur Einfachvererbung möglich Können mehrere Interfaces implementieren Haben Klassenmember: Konstanten (constants) Felder (fields) Methoden (methods) Eigenschaften (properties) Ereignisse (events) Indizierer (indexers) Operatoren (operators) Instanzkonstruktoren (instance constructors) Destruktoren (destructors) statische Konstruktoren (static constructors) geschachtelte Typen (nested types)

17 Konstanten Konstanten und Felder repräsentieren einen konstanten Wert kein static Attribut nötig Felder Variablen auf der Klassenebene statische (static) Variablen oder Instanzvariablen

18 Methoden - implementieren Berechnungen oder Aktionen - haben eine Parameterliste - haben einen Rückgabewert (bei void nicht) - sind statisch oder nicht-statisch (Zugriff: Klasse oder Objekt) - können überladen werden Beispiel für Methoden: public class Stack { public static Stack Clone(Stack s) { public static Stack Flip(Stack s) { public object Pop() { public void Push(object o) { public override string ToString() {

19 Eigenschaften - liefern Zugang zu Merkmalen eines Objekts - sind natürliche Erweiterung von Feldern - definieren Accessoren Bespiel public class Button { private string caption; // Feld public string Caption { // Eigenschaft get { return caption; set { caption = value; Repaint();...

20 Ereignisse - ermöglichen das Bereitstellen der Benachrichtigungen -Schlüsselwort event -Ereignis -Deklaration muss vom Typ Delegat sein public delegate void EventHandler(object sender, public class Button { public event EventHandler Click; public void Reset() { Click = null; Button Button1 = new Button(); System.EventArgs e); Button1.Click += new EventHandler(Button1_Click);

21 Operatoren - definieren die Bedeutung der Ausdrucksoperatoren - drei Kategorien: unäre, binäre, Konvertierungsoperatoren using System; public struct Digit { byte value;... public Digit(byte value) {this.value = value; public static explicit operator Digit(byte b) { return new Digit(b); public static Digit operator+(digit a, Digit b) { return new Digit(a.value + b.value); public static bool operator==(digit a, Digit b) { return a.value == b.value; public static bool operator!=(digit a, Digit b) { return a.value!= b.value;...

22 Indizierer ermöglichen die Indizierung eines Objekts wie bei einem Array Public class Stack {... public object this[int index] { get { //get Accessor if (!ValidIndex(index)) throw new Exception("Index out of range."); else return GetNode(index).Value; set { //get Accessor if (!ValidIndex(index)) throw new Exception("Index out of range."); else GetNode(index).Value = value;...

23 Instanzkonstruktoren - implementieren Aktionen zur Initialisierung einer Klasseninstanz using System; class Point { public double x, y; public Point() { this.x = 0; this.y = 0; public Point(double x, double y) { this.x = x; this.y = y;...

24 Destruktoren - implementieren Aktion zur Zerstörung einer Klasse - haben keine Argumente, keine Modifizierer und nicht explizit aufrufbar using System; class Point { public double x, y; public Point() { this.x = 0; this.y = 0; ~Point() { Console.WriteLine("Destructed {0", this);...

25 Statische Konstruktoren - sind wie Instanzkonstruktoren mit folgenden Eigenschaften: - keine Argumente erlaubt - besitzen keine Zugriffsmodifizierer - sind nicht explizit aufrufbar using Personnel.Data; class Employee { private static DataSet ds; static Employee() { ds = new DataSet( ); public string Name; public decimal Salary;

26 Vererbung Nur Einfachvererbung möglich Typ object ist die ultimative Basisklasse abstract, virtual und override using System; abstract class A { public void F() { Console.WriteLine("A.F"); public abstract void G(); class B: A { public override void G() { Console.WriteLine("B.G"); class Test { static void Main() { B b = new B(); b.f(); b.g(); // geerbt von A // enthalten in B

27 Strukturen sind den Klassen ähnlich, aber... Strukturen sind Wertetypen Vererbung ist bei Strukturen nicht möglich verhalten sich wie einfache Datentypen Punkt als Struktur: struct Point { public int x, y; public Point(int x, int y) { this.x = x; this.y = y;

28 definieren einen Vertrag Schnittstellen können Methoden, Eigenschaften, Ereignisse und Indizierer enthalten Mehrfachvererbung und Mehrfachimplementierung möglich interface Iexample { void F(int value); string P { get; set; event EventHandler E; string this[int index] { get; set; public delegate void EventHandler(object sender, EventArgs e);

29 entsprechen Funktionszeigern Delegaten sind objektorientiert und typensicher delegate void SimpleDelegate(); class Test { static void F() { System.Console.WriteLine("Test.F"); static void Main() { // Instanziierung // Deklaration SimpleDelegate d = new SimpleDelegate(F); d(); // Aufruf

30 Enumerationen deklarieren benannte Konstanten sind Wertetypen enum Color { Red, Blue, Green class Shape { public void Fill(Color color) { switch(color) { case Color.Red: break;

31 Namespaces und Assemblies dienen der besseren Organisation von Projekten using Direktive für Namespaces interne und externe Strukturierung using System; namespace CSharp.Introduction { public class HelloMessage { public string Message { get { return "Hallo Welt!";

32 Attribute Ermöglichen eigene Deklarationsinformationen Eins der wichtigsten Attribute ist sysimport class Test { [sysimport(dll="user32.dll")] public static extern int MessageBoxA(int h, string m,string c, int type); public static void Main() { int ret = MessageBoxA(0,"Hallo Welt!","Caption",0);

33 Fazit - ECMA ein Standard als Lernmittel + Spezifikation genau beschrieben und strukturiert + in der Regel einfach zu verstehen + viele anschauliche Beispiele - setzt gewisse Kenntnisse voraus - erschreckt mit seinem Umfang - ein Standard ermöglicht freie Implementierungen

34 Diskussion

35 Ende Danke für die Aufmerksamkeit!