Fachbereich
Automatisierung und Informatik
Wernigerode
„Visual Studio mit C#
Grundlagen Stand 31.01.2009
Dipl. Inf., Dipl.-Ing. (FH) Michael Wilhelm Friedrichstraße 57 - 59
38855 Wernigerode
Raum: 2.202
Tel.: 03943/659-338 Fax: 03943/659-399
Email: mwilhelm@hs-harz.de
Inhaltsverzeichnis
1 Einführung in .net und C#... 5
1.1 Überblick 5
1.1.1 C# 5
1.1.2 .net 5
1.2 Eigenschaften 5
2 Beispiele... 7
2.1 Hello World 7
3 Syntax... 8
3.1 Datentypen in C# 8
3.2 String-Befehle 8
3.3 C# Sprache 9
3.3.1 Switch-case 9
3.4 foreach 10
3.5 Enumerationen 10
3.6 Ausgabe in der Console 12
3.7 Eingabe von der Console 12
3.7.1 Formatierte Ausgaben 12
3.8 Parameter-Übergabe 13
3.9 Delegates 14
3.10 Try Catch 15
4 Objektorientierte Programmierung ... 16
4.1 Konstruktor 16
4.2 Dekonstruktor 16
4.3 sealed 16
4.4 Set-Get-Methoden 17
4.5 Überschriebene Methoden 17
4.5.1 Prinzip der überschreibenden Methoden 17
4.6 Neue Klassedatei erzeugen 18
4.7 Operator-Overloading 20
4.8 Interface 20
4.9 OOP-Beispiele 24
4.9.1 Beispiel punkt-linie 24
4.9.2 Koerper 25
4.10 weitere Tipps für Felder 27
5 Grunddialoge... 29
5.1 MessageBox 29
5.1.1 Gesamtüberblick MessageBox.Show 30
6 Eigenschaften der GUI-Elemente ... 33
6.1 Form 33
6.2 Label 34
6.3 Button 34
6.4 TextBox, Editzeile 34
6.5 GroupBox 35
6.6 RadioButton 35
6.7 ListBox 36
6.8 ComboBox 37
6.9 ProgressBar 37
6.10 Menüs 38
6.11 SplitContainer 38
7 FileDialoge... 40
7.1 OpenDialog 40
7.2 SaveFileDialog 40
8 Kommandoparameter... 41
8.1 Installationspfad 41
9 Grafik ... 42
9.1 Draw-Geometrie-Methoden 42
9.1.1 DrawArc 42
9.1.2 DrawBezier 43
9.1.3 DrawBeziers 45
9.1.4 DrawClosedCurve 46
9.1.5 DrawCurve Method 50
9.1.6 DrawEllipse 52
9.1.7 DrawLine 53
9.1.8 DrawLines 54
9.1.9 DrawPath 54
9.1.10 DrawPie 55
9.1.11 DrawPolygon 57
9.1.12 DrawRectangle 58
9.2 DrawString-Methoden 59
9.2.1 DrawString 59
9.2.2 DrawString(String, Font, Brush, PointF, StringFormat) 60
9.3 Fill-Methoden 61
9.3.1 FillClosedCurve 61
9.3.2 FillEllipse 62
9.3.3 FillPath 63
9.3.4 FillPie 64
9.3.5 FillPolygon 66
9.3.6 FillRectangle 67
9.3.7 FillRegion 68
9.4 DrawImage 69
9.4.1 DrawImage 69
9.5 Brush 72
9.5.1 SolidBrush 72
9.5.2 HatchBrush 72
9.5.3 LinearGradientBrush 74
9.6 Font 75
10 Indexverzeichnis... 76
Abbildungsverzeichnis
Abbildung 1Erstellen des ersten Beispiels 7
Abbildung 2Neue Klasse erzeugen 18
Abbildung 3Neue Eintrag: New Item 19
Abbildung 4Neue externe Klasse 19
Abbildung 5Beispiel mit DrawPolygon 58
1 Einführung in .net und C#
Dieses Script bietet einen Einstieg in die Benutzung von Visual Studio. Es soll kein Lehrbuch ersetzen.
Der Entwickler ist Andreas Heilsberg, er zuvor Turbo Pascal und Delphi mit entwickelt hat. Er wechselte nach dem Erfolg von Java zu Mircosoft. Er sollte ein Programmpaket .net / C# mit folgenden Eigenschaften entwickeln:
1.1 Überblick
1.1.1 C#
• C# ist das Äquivalent zu Java, aber auch eine Weiterentwicklung der Sprache C/C++
• Es gibt keine Pointer, (".", "::" und "->") werden nun komplett durch den Punkt ersetzt
• Plattformunabhängig, eher im Sinne MS Desktop, MS PDA, MS Web
1.1.2 .net
• Common language runtime (CLR), Garbage Collection
• Common language subset (CLS), gemeinsame Sprachbasis.
• Es kann jede Sprache verwendet werden. Standardvokabular (Menge von Befehlen)
• Microsoft intermediate language (MSIL), Zwischensprache
• Just in Time Compiler (JIT)
• Windows Forms (Swing)
• ASP.net (Web Services)
• ADO.net (Datenbanken)
• XML, SOAP, UDDI (Kommunikation zw. den Komponenten
1.2 Eigenschaften
• Philosophie weitgehend identisch
• Drag & Drop der GUI
• Propertyfenster mit Property-Methoden kein normales get/set public double x {
set {
m_x = value;
} get {
return m_x;
} }
• Plattform unabhängigkeit
• Sprache C# und viele andere
• Umwandlung in Common Type System (CTS)
• Aktuell Framework 3,5
• Common Language Runtime (CLR)
• Unterschied zu Java: es erfolgt einer Übersetzung, kein Intepreter, übersetzt wird VOR oder während des Programmslaufs
• Unterstützt viele Programmiersprachen( C#, VB, Delphi, C++)
• Umwandlung in einem Zwischencode
• Sehr viele GUI-Elemente, bis zu Listview / Grid
• Datenbank-Anbindung
• Umfang bis zum Web-Server
• Anweisungen sind weitgehend identisch zu Java / C++
• keine Header-Dateien
• statt implement verwendet man using
• Mehr Datentypen (unsigned)
• Arrays mittels Blockstruktur, anders als in Java
2 Beispiele
2.1 Hello World using System;
namespace bsp1 {
public class Programm {
public static void Main(string[] args) {
Console.WriteLine("Hello {0} im Jahr {1}", "ix", 2008);
Console.ReadLine();
} // Main }// Programm } // bsp1
Die Anweisung „using“ bezieht sich auf die verwendeten Klassen. Hier kann man Tipparbeit sparen.
Statt System.Console.WriteLine schreibt man dann einfacher Console.WriteLine. Mit dem Begriff
„namespace“ kann man eigene „Pakete“ definieren.
Die Format-Anweisung ist ähnlich der printf aus C bzw. Java zu lesen. Die Platzhalter sind aber in der Erstellen des Beispiels
• File New Project
• Visual C#
• Console Application
Abbildung 1 Erstellen des ersten Beispiels Die Taste „F5“ startet das Programm.
3 Syntax
3.1 Datentypen in C#
Der wichtigste Unterschied zu Java sind die vorzeichenlosen Datentypen byte, ushort, uint und ulong.
Datentyp Beschreibung Wertebereich
byte vorzeichenlos 0 bis 255
sbyte vorzeichenbehaftet -128 bis +127 short vorzeichenbehaftet -32768 bis +32767
ushort vorzeichenlos 0 bis 65535
int vorzeichenbehaftet -2.147.483.648 bis + 2.147.483.648
uint vorzeichenlos 0 bis 4.294,967,295
long vorzeichenbehaftet -263 bis 263-1
ulong vorzeichenlos 0 bis bis 264-1
single 32 Bit Gleitkommazahl, 7 Stellen
-3,4·1038 bis -1,4·1045 für negative Werte 1,4·1045 bis 3,41038 für positive Werte
double 64 Bit Gleitkommazahl, 16 Stellen
bool boolscher Wert true/false
char Zeichen Uni-Codezeichen, 2 Byte
decimal 96 Bit Dezimalwert
String readonly Zeichenfolge
Object Hauptklasse aller Objekte
3.2 String-Befehle
Methode Beschreibung
Length Länge eines Strings
Clone Liefert Verweis des Strings. Sonst werden String als Referenz
„kopiert“
Compare Vergleicht zwei String. Der Rückgabewert ist true bei Gleichheit, sonst false
CompareTo Vergleicht zwei String ( -1, 0, +1)
Concat Verbindet zwei Strings
Copy Kopieren des Strings
CopyTo Kopieren von Zeichen
EndsWidth Vergleich mit Ende des String (\)
Equals Haben zwei String denselben Inhalt. Die Adresse kann ja unterschiedlich sein.
Format Ähnlich der Printf-Anweisung, statt %d werden Nummer vergeben {0}
GetEnumerator Funktion mit Parameter des String Durchlaufen des String
IndexOf Sucht das erste Vorkommen
IndexOfAny Liefert alle Vorkommen in einer Liste. Ähnlich der split-Anweisung in PHP
Insert Zeichen einfügen
Join Die Methode fügt zwischen je zwei Elementen eines Strings-Arrays
Methode Beschreibung
einen angegebenen trennenden Strings ein und liefert das Ergebnis a,b,c ⇒ a_b_c
LastIndexOf Sucht das letzte Vorkommen
LastIndexOfAny Liefert alle Vorkommen in einer Liste. Es gibt es umgekehrte Reihenfolge
PadLeft Rechtsbündige Ausrichtung, Die Leerstellen sind links PadRight Linksbündige Ausrichtung, Die Leerstellen rechts
Remove Löschen von Zeichen
Replace Ersetzen von Zeichen
Split Aufteilen (Parsen oder \)
StartsWith Prüft die ersten Zeichen auf Übereinstimmung SubString Liefert einen Teilstring
ToCharArray Umwandlung von String in Char-Array ToLower Ergebnis alles in Kleinbuchstaben ToUpper Ergebnis alles in Großbuchstaben
Trim Löschen von Leerzeichen am Anfang und am Ende TrimEnd Löschen von Leerzeichen am Ende
TrimStart Löschen von Leerzeichen am Anfang
3.3 C# Sprache
Die Sprache ist weitgehend identisch mit Java identisch, einige Konstrukte weichen aber von java bzw. C++ ab. In der normalen Syntax, Zuweisungen, if-Bedingung und Schleifen mit Java identisch.
3.3.1 Switch-case
Unterschiedlich ist aber ist Switch-case-Anweisung
Das untere Listing liefert eine Fehlermeldung, da zwischen den Case-Anweisung die break´s fehlen.
switch (i) {
case 0: erg = a + b;
case 1: erg = a - b;
case 2: erg = a * b;
}
Das untere Listing ist fehlerfrei. Leere Case-Anweisungen können verbunden werden.
switch (i) { case 0:
case 1: erg = a - b; // korrekt ohne Anweisung case 2: erg = a * b;
}
3.4 foreach
Die zweite Variante der For-Schleife, ist die For-each-Schleife. Diese ist aus diversen anderen Programmiersprachen bekannt (Avenue, D, Java ab JDK 1.5).
Beispiel:
int [] array = { 1,2,3,4,5 };
foreach (int i in array) { Console.WriteLine(i);
}
3.5 Enumerationen
Verwendet man eine Auflistung, kann man diverse Konstanten definieren oder man benutzt eine Enumerationen, mit der die Konstanten mit ganzzahligem Wert automatisch definiert werden.
Beispiel enum FB { AI, VW, W }
Normalerweise werden die Konstanten von Null hochgezählt. Der Vorteil ist, wenn man einen Fachbereich hinzufügt. Der komplette Sourcecode bleibt korrekt.
enum FB { AI=0x0000FF, VW=0xFF0000, W=0x00FF00 }
Wie die Enumerationen ausgewertet wird, zeigt das untere Beispiel:
// Definition enum FB
{
AI, VW, W }
// Deklaration
FB f; // Deklaration eines FB
// Anweisungen
f = FB.AI; // Zuweisung
int i = (int)f; // Zuwesiung an ein int i = (int)FB.W;
// Ausgabe
void testfor() {
foreach (int j in Enum.GetValues(typeof(FB))) {
Console.WriteLine("FB: {0} {1}",Enum.GetName(typeof(FB),j),j);
}
} // Ausgabe
Ergebnis der Ausgabe:
Fachbereich AI 0 Fachbereich VW 1 Fachbereich W 2
Problem:
// Diese Verteilung hat Lücken, in einer For-Schleife gibt es dann Probleme, siehe unten enum FB
{
AI=1, VW=3, W=5 }
// Diese For-SAchleife funktioniert nicht richtig for (int k = (int)FB.AI; k <= (int)FB.W; k++) {
Console.WriteLine("FB {0} {1}", Enum.GetName(typeof(FB), k), k);
}
Console.WriteLine();
// bessere Variante
foreach (int j in Enum.GetValues(typeof(FB))) {
Console.WriteLine("FB {0} {1}", Enum.GetName(typeof(FB), j), j);
}
Abhilfe schafft folgende Funktionen. Diese testet ob FB.IsDefined(typeof(FB),i)
for (int k = (int)FB.AI; k <= (int)FB.W; k++) {
if ( FB.IsDefined(typeof(FB),k) )
Console.WriteLine("FB {0} {1}", Enum.GetName(typeof(FB), k), k);
}
3.6 Ausgabe in der Console
Zur Ausgabe dient die Funktion „Console.WriteString“. Der erste Parameter bezieht sich auf den Text mit den Platzhaltern für die Variablen.
Beispiel:
Console.WriteLine("d: {0}", d);
Console.Write("d: {0}", d);
3.7 Eingabe von der Console
Zur Eingabe dient die Funktion „Console.ReadString“. Der erste Parameter bezieht sich auf den Text mit den Platzhaltern für die Variablen.
Beispiel:
Console.WriteLine("d: {0}", d);
3.7.1 Formatierte Ausgaben
Folgende Platzhalter definieren eine formatierte Ausgaben:
• # beliebige Zahl oder Leerzeichen
• 0 beliebige Zahl oder eine Null
Es muss immer ein Dezimalpunkt eingegeben werden.
double d = 1.0 / 3.0;
// 0 0 oder zahl besser ###0.00 als ###.##
Console.WriteLine("d: {0:##0.00}", d);
Format-Code Beschreibung
{0} Zahl mit mehreren Nachkommastellen
{0:##0.00} Mit zwei Nachkommastellen
Dezimaltrennzeichen ist ein Punkt
{0:p2} Mit zwei Nachkommastellen
Dezimaltrennzeichen ist ein Komma
{0,7:c} Ausrichtung
("").PadRight(24, '-') Ergibt 24 waagerechte Striche
("123").PadRight(24, '-') Ergibt die Zahl 123 und danach 24 waagerechte Striche
("123").PadLeft(10, 'x') Insgesamt 10 Zeichen. Linksbündig werden „x“
eingetragen.
Ergebnis: „xxxxxxx123“
3.8 Parameter-Übergabe C# kennt 4 Parameter-Übergabe-Typen
• Parameter per Value, eine Kopie wird übergeben
• Parameter per Referenz (ref), kann gelesen und gesetzt werden
• Parameter für die Ausgabe (out), kann nur gesetzt werden
• Parameter für Arrays (params), immer am Ende der Liste,
Wichtig, die Typen müssen AUCH in der Aufrufliste stehen.
Beispiele:
// Funktion mit einem Out-Parameter
// erg darf nicht vor dem Setzen gelesen werden static void add2(int a, int b, out int erg) { erg = a + b;
}
// Funktion mit einem Out-Parameter // b darf gelesen und gesetzt werden static void add3(int a, ref int b) { b = a + b;
}
// dieses Beispiel zeigt die Verarbeitung von Parametern //
static void ShowNumbers (params int[] numbers) { foreach (int x in numbers) {
Console.Write (x+" ");
}
Console.WriteLine();
}
main() {
int a,b, c;
a = 11;
b = 22;
add2(a, b,out c); // out signalisiert Ausgabeparameter Console.WriteLine("Erg1: a {0} b {1} c{2}", a, b, c);
a = 11;
b = 22;
add3(a, ref b); // ref signalisiert Referenzparameter Console.WriteLine("Erg2: a {0} b {1}", a, b);
.. int[] x = {1, 2, 3};
ShowNumbers (x);
ShowNumbers (4, 5);
ShowNumbers (4, 5, 6, 7);
} // bsp3
Ergebnis:
Erg1: a 11 b 22 c33 Erg2: a 11 b 33 1 2 3
4 5 4 5 6 7
3.9 Delegates
Delegates sind der Ersatz für Pointerfunktionen. Delegates können sowohl statische als auch Instanzmethoden referenzieren. Sie müssen aber denselben Rückgabewert und dieselben Parametertypen besitzen wie die zu referenzierenden Methoden.
Prinzip:
1) Deklaration der delegate-Protyp-Funktion
public delegate int Del_methode(int val);
2) Definition einer speziellen delegate-Funktion
public static int Addint(int a, int b) {
return a + b;
}
public static int Multint(int a, int b) {
return a * b;
}
Die obigen Anweisungen definieren zwei „Funktionspointer“. Damit erreicht man eine hohe Flexibilität bezüglich der Funktionalität. Man kann Funktionen schreiben, die eine Funktion übergeben bekommen, und so weitgehend unabhängig programmiert werden können (Framework).
3) Zuweisung und Aufruf int a,b;
a=1;
b=2;
Del_methode calc1 = new Del_methode(Addint);
Del_methode calc2 = new Del_methode(Multint);
c = calc1(a, b);
c = calc2(a, b);
Ein Delegate erzeugt man wie eine Instanz einer Klasse. Als Parameter erwartet sie eine Methode.
3.10 Try Catch
Die Exception ist fast identisch mit Java bzw. C++
Beispiele:
// Konvertierung eines Strings in einem Integer-Wert try
{
Int32 iValue = Convert.ToInt32(sValue);
}
catch (Exception me) {
Console.WriteLine(me.ToString() );
}
public double calc(double d) {
try {
double j = sqrt(d);
} catch (MyException me) {
Console.WriteLine(me.m_msg);
} catch {
/* alle restlichen Exceptions */
} finally {
/* Aufraeumen */
} } // calc
4 Objektorientierte Programmierung
Dieses Kapitel zeigt die Unterschiede zwischen den Java, C++ und C# beim Objektorientierten programmieren. Es wird vorrausgesetzt, dass man Grundkenntnisse besitzt.
Die Definition der Klasse ist ein Mix ein Java und C++.
Der Zugrif auf die Member-Variablen erfolgt durch vier Stufen
• private
• internal // nur in Assembly, Packages
• public
• protected // Zugriff nur in abgeleiteten Klassen
Modifizierer Innerhalb der Klasse
Innerhalb der Ableitungen
Außerhalb der Klasse
Außerhalb der Anwendung
public Ja Ja Ja Ja
internal Ja Ja Ja Nein
protected Ja Ja Nein Nein
private ja Nein Nein Nein
4.1 Konstruktor
Der Konstruktor ist ganz normal wie in Java oder C++. Der Unterschied tritt erst bei Vererbungen zu Tage. Hier wird „base“ und „this“ verwendet.
Mit base wird der Konstruktor der oberen Klasse aufgerufen. Die Position stammt aus C++, statt base verwendet Java super.
Die statische Erzeugung eines Objektes à la C++ ist nicxht möglich. Man muss immer den new- Operator benutzen.
4.2 Dekonstruktor
Der Dekonstruktor ist ähnlich wie in Java.
~student() {
}
4.3 sealed
Mit dem Zusatz „sealed“ kann man verhindern, das man von der aktuellen Klasse ableiten kann. Dies kann ja sinnvoll sein, wenn man Zugriff auf private Variablen haben möchte.
Beispiel:
sealed class klasse1 {
…
} // klasse1
4.4 Set-Get-Methoden
Die set- und get-Methoden werden eher im Delphi-Stil programmiert. Man definiert die variable und beschreibt dann die Methoden:
private int m_Matrnr;
public int Matrnr {
get {
return m_Matrnr;
} set {
if ( value>0 && value < 99999 ) m_Matrnr=value;
}
} // int Matrnr
Die Variable ist vor einem Zugriff geschützt. Man definiert nach der Deklaration die Methode, die aber im Code wie eine normale Variable aussieht. Der Compiler verarbeitet den Zugriff auf die get/set-Methoden. Für das obige Beispiel wäre dann folgender Code möglich:
public void test {
int k;
student std = new student();
std.Matrnr=17421; // ruft die set-Methode auf k = std.Matrnr; // ruft die get-Methode auf }
4.5 Überschriebene Methoden
Dieses Kapitel zeigt die Besonderheiten bezüglich Methoden, die vererbt bzw. überschrieben werden sollen.
In Java können die Methoden einfach überschrieben werden. In C++ muss man das Prefix „virtual“ in der Basis-Klasse benutzen. In C# muss man beide Methoden mit einem Prefix versehen. In der Oberklasse das Prefix „virtual“, in der abgeleiteten Klasse das Prefix „override“.
4.5.1 Prinzip der überschreibenden Methoden
class Pflanze {
virtual public void print()
{
Console.WriteLine("in Pflanze");
} }
class Blume : Pflanze {
override public void print() {
Console.WriteLine("in Bume");
} }
4.6 Neue Klassedatei erzeugen
Mit rechter Maustaste auf dem Projektnamen in linken Baum gehen.
Abbildung 2 Neue Klasse erzeugen
Im Popupmenü wählt man erst den Eintrag „Add“ und dann „New Item…“ aus.
Abbildung 3 Neue Eintrag: New Item
Abbildung 4 Neue externe Klasse
Rumpf der neuen Klasse:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace OOP2a {
class Koerper2 {
} }
4.7 Operator-Overloading
In Java ist dieses noch nicht erlaubt, in C++ ist dieses eine gängige Eigenschaft.
Syntax:
public static Klasse operator +(Klasse k1, Klasse k2) {
Klasse temp = new Koerper();
temp.member = k1.member + k2.member;
return temp;
}
Folgende Operatoren können überladen werden:
Operatoren Overloadbar
+, -, *, /, %, &, |, <<, >> Alle binären Operatoren können überladen werden +, -, !, ~, ++, --, true, false Alle unären Operatoren können überladen werden
==, !=, <, >, <= , >= Alle relationalen Operatoren können, paarweise, überladen werden
&&, || Keine Überladung
() Cast-Operator
+=, -=, *=, /=, %= Können überladen werden. Funktioniert aber automatisch
=, . , ?:, ->, new, is, as, sizeof Keine Überladung
4.8 Interface
Interfaces, die im Deutschen auch oft als Schnittstellen bezeichnet werden, haben eine ähnliche Aufgabe wie abstrakte Klassen. Sie implementieren weder Datenelemente noch ausführbaren Code, sondern lediglich Deklarationen von Methoden. Ein Interface kann nicht als Instanz erzeugt werden, sondern nur von Klassen, die dieses Interface implementieren. Interfaces können auch hierarchisch aufgebaut sein.
Der Unterschied zu einer abstrakten Klasse ist, dass eine Klasse lediglich eine Basisklasse haben kann, aber beliebig viele Interfaces implementieren kann. Interfaces können also als Ersatz zur zur Mehrfachvererbung dienen.
Falls eine Klasse neben einer Basisklasse noch von mindestens einem Interface abgeleitet ist, so muss bei der Klassendeklaration die Basisklasse vor den Interfaces angegeben werden:
class klasse1: overklasse, interface1
Die Syntax eines Interfaces unterscheidet sich von der einer abstrakten Klasse nur dadurch, dass das Schlüsselwort class durch interface ersetzt ist und das Schlüsselwort abstract entfällt, da Interfaces per Definition abstrakt sind.
Wichtig:
Eine Subklasse erbt die Methoden von der Oberklasse. Das ist der Vorteil der Vererbung. Bei komplexen Klassen bzw. bei mehreren Klassenfamilien, ist es sinnvoller, die Schnittmenge möglichst klein zu halten. Eine Klasse, die eine Schnittstelle implementiert, verpflichtet diese neu zu imple- mentieren, also keine Vererbung. Eine Funktion, die ein Objekt einer Klasse mit einer Schnittstelle hat, weiß nun, dass man diese Funktion aufrufen kann.
Syntax:
interface IInterface1 {
void print();
}
class Klasse1 : IInterface1 {
void print() {
} }
public void test() {
Klasse1 kl1 = new Klasse1();
kl1.print(); // Aufruf einer Schnittstellenmethode }
Der Vorteil der Verwendung von Schnittstellen gegenüber einer Klasse, ist die Unabhängigkeit im Klassenbaum. Keine Methode, keine Klasse muss angepasst werden.
Der Nachteil ist der erhöhte Aufwand, alle Methoden in jedem Klassenbaum zu implementieren.
In Java ist es möglich, ein Array mit Interfaces zu erzeugen. In C# kann man dieses nur mit der Deklaration erreichen. Alternative dazu ist eine ArrayList. Damit kann man beliebige „Objekte“ in einem Array speichern (siehe Beispiel unten).
Das Beispiel definiert eine Interface, IPrint und diverse Klassen. Dabei sind einige als Klassenbaum implementiert. In der main-Methode werden diese unterschiedlichen Klassen in einem „Interface“- Array gespeichert und dann wird in einer For-Schleife bzw. in einer foreach-Schleife die print- Methode aufgerufen. In diesen Schleifen ist nicht bekannt, aus welcher Klasse das Objekt kommt.
Quellcode:
// Interface Deklaration interface IPrint
{
void print();
}
// 1. Klasse, die die Schnittstelle implementiert class bsp1 : IPrint
{
string m_name;
public bsp1(string name) {
this.m_name = name;
}
public void print() {
Console.WriteLine("Name bsp1: {0}", m_name);
} }
// 2. Klasse, die die Schnittstelle implementiert class bsp2 : IPrint
{
string m_name;
public bsp2(string name) {
this.m_name = name;
}
public void print() {
Console.WriteLine("Name bsp2: {0}", m_name);
} }
// 3. Klasse, die die Schnittstelle implementiert // Diese Klasse ist Oberklasse
class fahrzeug : IPrint {
protected int ps;
public fahrzeug(int ps) {
this.ps = ps;
}
// hier wichtig das virtual virtual public void print() {
Console.WriteLine("Fahrzeug PS: {0}", ps);
}
} // fahrzeug
// 4. Klasse, die die Schnittstelle implementiert // Schnittstelle mittels Vererbung !
class pkw : fahrzeug {
string farbe;
public pkw(int ps, string farbe) : base(ps)
{
this.farbe = farbe;
}
override public void print() {
Console.WriteLine("PKW: Ps: {0} farbe: {1}", ps, farbe);
} } // pkw
// 5. Klasse, die die Schnittstelle implementiert // Schnittstelle mittels Vererbung !
class lkw : fahrzeug {
int volumen;
public lkw(int ps, int volumen) : base(ps) {
this.volumen = volumen;
}
override public void print() {
Console.WriteLine("LKW: Ps: {0} vol: {1}", ps, volumen);
} } // lkw
// 6. Klasse, die die Schnittstelle implementiert class schiff : IPrint
{
int passagiere;
public void print() {
Console.WriteLine("Schiff: passagiere: {0}", passagiere);
}
public schiff(int passagiere) {
this.passagiere = passagiere;
}
} // schiff
class Program {
static void Main(string[] args) {
bsp1 b1;
bsp2 b2;
b1 = new bsp1("bsp1");
b2 = new bsp2("bsp2");
fahrzeug f1 = new fahrzeug(122);
fahrzeug f2 = new fahrzeug(132);
fahrzeug f3 = new fahrzeug(142);
fahrzeug f4 = new fahrzeug(125);
pkw p1 = new pkw(12, "rot");
pkw p2 = new pkw(122, "blau");
schiff s1 = new schiff(12345);
s1.print();
// Diese Zuwesiung funktioniert
IPrint[] schl = { b1, f1, f2, f3, f4, p1, p2, b2 };
for (int i = 0; i < 7; i++)
{
schl[i].print();
}
Console.WriteLine();
// using System.Collections
ArrayList schl2 = new ArrayList();
schl2.Add(b1);
schl2.Add(f1);
schl2.Add(f2);
schl2.Add(f3);
schl2.Add(f4);
schl2.Add(p1);
schl2.Add(p2);
schl2.Add(b2);
// Nun die Ausgabe
foreach (IPrint item in schl2) {
item.print();
}
Console.ReadLine();
} } }
4.9 OOP-Beispiele
4.9.1 Beispiel punkt-linie
class punkt {
protected int m_x, m_y;
public punkt(int x, int y) {
this.m_x = x;
this.m_y = y;
} }
class linie : punkt {
private int m_strichdicke;
public linie(int strichdicke): this(strichdicke,0,0) {
m_strichdicke = strichdicke;
}
public linie(int strichdicke, int x, int y): base(y,x) {
m_strichdicke = strichdicke;
} }
static void Main(string[] args) {
punkt p1;
linie l1, l2;
p1 = new punkt(1, 2);
l1 = new linie(22,3,4);
l2 = new linie(11);
}
Dieses Beispiel zeigt alle Varianten, die man im OOP benötigt. Mit „this(…)“ wird ein anderer Konstruktor aufgerufen. Mit „base“ wird die Oberklasse
4.9.2 Koerper
Dieses Beispiel zeigt den vollständigen Quellcode einer Vererbung mit Operator-Overlaoding. Die Klasse Koerper ist die Grundklasse. Hier wird die Variable m_volumen deklariert. Außerdem ist in dieser Klasse die Methode „print“, die in den weiteren Ableitungen „überschrieben“ werden soll. Dazu muss das Prefix „virtual“ benutzt werden. In Koerper sind zwei Konstruktoren definiert. Dabei ist es guter Stil, nur einen echten Konstruktor zu benutzen. Dazu ruft man den zweiten einfach mit this auf.
Die Klasse Koerper2 überschreibt die print-Methode, während „Koerper3“ die normale Methode übernimmt. Den Konstruktor der Oberklasse erreicht man mit „base“. Auch hier sollte man zwischen this und base trennen, siehe Quellcode.
Für die Klasse Koerper wurde noch der Plus-Operator überladen. Hier werden einfach zwei Volumen addiert.
Hinweis:
Die Methode + ist nur für die Klasse Korper definiert. Genauer, die linke Seite darf nur vom Typ Koerper sein. Die rechte Seite kann Typen der Klassen (Koerper, Koerper2 und Koerper3) haben.
using System;
using System.Text;
namespace OOP2 {
class Koerper {
private int m_volume;
public Koerper() : this(0) {
//m_volume = 0;
}
public Koerper(int volume) {
m_volume = volume;
}
public int volume
{
get {
return m_volume;
} set {
if (value > 0 && value < 99999) m_volume = value;
} }
virtual public void print() // für Ableitung {
Console.WriteLine("Koerper "+m_volume);
}
// Operator overloading
public static Koerper operator +(Koerper k1, Koerper k2) {
Koerper temp = new Koerper();
temp.volume = k1.volume + k2.volume;
return temp;
}
} // Koerper
class Koerper2 : Koerper {
private string m_name;
public Koerper2(int volume):this("noname",volume) {
m_name = name;
}
public Koerper2(string name, int volume):base(volume) {
m_name = name;
}
public string name {
get {
return m_name;
} }
override public void print() {
Console.WriteLine(
"Koerper2 Name: {0} Volumen {1}", m_name, volume);
}
} // Koerper2
class Koerper3 : Koerper {
private string m_name;
public Koerper3(string name, int volume): base(volume)
{
m_name = name;
}
public string name {
get {
return m_name;
} }
} // Koerper3
class Program {
static void Main(string[] args) {
Koerper kugel, ziegel, kegel; // keine Erzeugung, kein C++
kugel = new Koerper();
kugel.volume = 14721;
kugel.print();
ziegel = new Koerper(12345);
ziegel.print();
Console.WriteLine("Operator Overlaoding!");
kegel = kugel + ziegel;
kegel.print();
Console.WriteLine();
Koerper2 kugel2, ziegel2; // keine Erzeugung, kein C++
Koerper3 kugel3; // keine Erzeugung, kein C++
kugel2 = new Koerper2("kugel",14721);
kugel2.print();
ziegel2 = new Koerper2("ziegel",12345);
ziegel2.print();
kugel3 = new Koerper3("kugel",14721);
kugel3.print();
Console.ReadLine();
} } }
4.10 weitere Tipps für Felder
string [] names = { "Herbert", "Gerhard", "Angela"};
Regelmäßige mehrdimensionale Felder werden mit folgender Notation vereinbart:
double [,] matrix = new double [2,3];
Unregelmäßige, mehrdimensionale Felder (jagged arrays) schließlich definiert man in C# wie folgt:
double [][] jagged_matrix = new double[2][];
jagged_matrix[0] = new double[3];
// der erste Vektor hat 3 Elemente jagged_matrix[1] = new double[5]:
// der zweite Vektor hingegen 5
Mittels Methoden wie GetLength oder Eigenschaften wie Rank lassen sich wichtige Informationen von Feldern abrufen, beispielsweise ihre Länge und Dimension.
5 Grunddialoge
5.1 MessageBox
1) MessageBox.Show("text");
2) MessageBox.Show("text\n2. Zeile", "Caption");
3) MessageBox.Show("text\n2. Zeile", "Caption", MessageBoxButtons.Buttonsauswahl);
Optionen:
• MessageBoxButtons.AbortRetryIgnore
• MessageBoxButtons.OK
• MessageBoxButtons.OKCancel
• MessageBoxButtons.RetryCancel
• MessageBoxButtons.YesNo
• MessageBoxButtons.YesNoCancel
3) MessageBox.Show("text", "Caption", MessageBoxButtons, MessageBoxIcon)
Displays a message box with the specified text, caption, buttons, icon, and default button.
4) MessageBox.Show("text", "Caption",
MessageBoxButtons, MessageBoxIcon, MessageBoxDefaultButton)
:
MessageBoxIcon
• Optionen für
• Asterisk
• Error
• Exclamation
• Hand
• Information
• None
• Question
• Stop
• Warning
:MessageBoxDefaultButton MessageBoxDefaultButton:
• Button1
• Button2
• Button3
Beispiele:
result = MessageBox.Show( "Text", "Caption",
MessageBoxButtons.RetryCancel, MessageBoxIcon.Asterisk);
result = MessageBox.Show( "Text", "Caption",
MessageBoxButtons. YesNoCancel, MessageBoxIcon. Question,
MessageBoxDefaultButton.Button2);
5) MessageBox.Show("text", "Caption",
MessageBoxButtons, MessageBoxIcon, MessageBoxDefaultButton, MessageBoxOptions) MessageBoxOptions:
• DefaultDesktopOnly
• RightAlign // Ausrichtung des Textes rechts
• RtlReading
• ServiceNotication
MessageBox.Show( "Text", "Caption",
MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2,
MessageBoxOptions.ServiceNotification);
5.1.1 Gesamtüberblick MessageBox.Show :Gesamtüberblick
Name Beschreibung
MessageBox.Show ("Text") Zeigt ein Meldungsfeld mit angegebenem Text an. Wird von .NET Compact Framework unterstützt.
MessageBox.Show (IWin32Window,
"Text")
Zeigt vor dem angegebenen Objekt ein Meldungsfeld mit dem angegebenen Text an.
MessageBox.Show (
"Text ", "Caption")
Zeigt ein Meldungsfeld mit dem angegebenen Text und der angegebenen Beschriftung an. Wird von .NET Compact Framework unterstützt.
MessageBox.Show (IWin32Window,
"Text", "Caption")
Zeigt vor dem angegebenen Objekt ein Meldungsfeld mit dem angegebenen Text und der angegebenen Beschriftung an.
MessageBox.Show ("Text",
"Caption" , MessageBoxButtons)
Zeigt ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung und den angegebenen Schaltflächen an.
MessageBox.Show (IWin32Window,
"Text", "Caption", MessageBoxButtons)
Zeigt vor dem angegebenen Objekt ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung und den angegebenen Schaltflächen an.
MessageBox.Show (
"Text", "Caption", MessageBoxButtons, MessageBoxIcon)
Zeigt ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen und dem angegebenen Symbol an.
Name Beschreibung MessageBox.Show (IWin32Window,
"Text", "Caption", MessageBoxButtons, MessageBoxIcon)
Zeigt vor dem angegebenen Objekt ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen und dem angegebenen Symbol an.
MessageBox.Show (
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton)
Zeigt ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, dem angegebenen Symbol und der Standardschaltfläche an.
Wird von .NET Compact Framework unterstützt.
MessageBox.Show (IWin32Window,
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton)
Zeigt vor dem angegebenen Objekt ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol und der Standardschaltfläche an.
MessageBox.Show (
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton, MessageBoxOptions)
Zeigt ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, dem angegebenen Symbol, der Standardschaltfläche und Optionen an.
Ausrichtung des Textes MessageBox.Show (IWin32Window,
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton, MessageBoxOptions)
Zeigt vor dem angegebenen Objekt ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol, der Standardschaltfläche und Optionen an.
MessageBox.Show (
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton, MessageBoxOptions, Boolean)
Zeigt ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol, der angegebenen Standardschaltfläche, den angegebenen Optionen und der Schaltfläche Hilfe an.
MessageBox.Show (
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton, MessageBoxOptions, String)
Zeigt unter Verwendung der angegebenen Hilfedatei ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol, der angegebenen Standardschaltfläche, den angegebenen Optionen und der Schaltfläche Hilfe an.
MessageBox.Show (IWin32Window,
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton, MessageBoxOptions, String)
Zeigt unter Verwendung der angegebenen Hilfedatei ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol, der angegebenen Standardschaltfläche, den angegebenen Optionen und der Schaltfläche Hilfe an.
MessageBox.Show (
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton,
MessageBoxOptions, String, HelpNavigator)
Zeigt mithilfe der angegebenen Hilfedatei und HelpNavigator ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol, der angegebenen Standardschaltfläche, den angegebenen Optionen und der Schaltfläche Hilfe an.
MessageBox.Show (
"Text", "Caption", MessageBoxButtons,
Zeigt mithilfe der angegebenen Hilfedatei und des angegebenen Hilfeschlüsselworts ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung,
Name Beschreibung MessageBoxIcon,
MessageBoxDefaultButton,
MessageBoxOptions, „Text“,
„Caption“)
den angegebenen Schaltflächen, dem angegebenen Symbol, der angegebenen Standardschaltfläche, den angegebenen Optionen und der Schaltfläche Hilfe an.
MessageBox.Show (IWin32Window,
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton,
MessageBoxOptions, String, HelpNavigator)
Zeigt mithilfe der angegebenen Hilfedatei und HelpNavigator ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol, der angegebenen Standardschaltfläche, den angegebenen Optionen und der Schaltfläche Hilfe an.
MessageBox.Show (IWin32Window,
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton,
MessageBoxOptions, „Text“,
„Caption“)
Zeigt mithilfe der angegebenen Hilfedatei und des angegebenen Hilfeschlüsselworts ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol, der angegebenen Standardschaltfläche, den angegebenen Optionen und der Schaltfläche Hilfe an.
MessageBox.Show (
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton,
MessageBoxOptions, String, HelpNavigator, Object)
Zeigt mithilfe der angegebenen Hilfedatei, HelpNavigator und des angegebenen Hilfethemas ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol, der angegebenen Standardschaltfläche, den angegebenen Optionen und der Schaltfläche Hilfe an.
MessageBox.Show (IWin32Window,
"Text", "Caption", MessageBoxButtons, MessageBoxIcon,
MessageBoxDefaultButton,
MessageBoxOptions, String, HelpNavigator, Object)
Zeigt mithilfe der angegebenen Hilfedatei, HelpNavigator und des angegebenen Hilfethemas ein Meldungsfeld mit dem angegebenen Text, der angegebenen Beschriftung, den angegebenen Schaltflächen, dem angegebenen Symbol, der angegebenen Standardschaltfläche, den angegebenen Optionen und der Schaltfläche Hilfe an.
Quelle:
http://msdn.microsoft.com/de-de/library/system.windows.forms.messagebox.show(VS.80).aspx
6 Eigenschaften der GUI-Elemente
6.1 Form
• Name
• AutoScroll False/True
• AutoSize False/True
• AutoSizeMode: GrowOnly, GrowAndShrink
• BackColor
• BackGroundImage
•• CancelButton
• MaximizeBox
• MinimizeBox
• Cursor
• DoubleBuffered
• Enabled
• Font
• ForeColor
• FormBoderStyle:
o None o FixedSingle o Fixed3D o FixedDialog o Sizable
o FixedToolWindow o SizableToolWindow
• Icon
• IsMDIContainer
• KeyPreview
• Location
• Locked
• MainMenuStrip
• Opacity
• ShowIcon
• Size
• StartPosition:
o Manual o CenterScreen
o WindowsDefaultLocation o WindowsDefaultBounds o CenterParent
• Tag
• Text: (Caption)
• TopMost False/True (Top of the Stay, Toolfenster)
• WindowState: Normal, Minimized, Maximized
(System.Windows.Forms.FormWindowState.Minimized)
6.2 Label
• Name
• Anchor Top/Left
• BackColor
• BorderStyle
• Cursor
• Enabled False/True
• Font
• ForeColor
• Image
• ImageAlign
• Location: x y
• Locked True False
• Margin
• Size: Width Height
• TabIndex
• TabStop
• Tag
• Text: Beschriftung
• TextAlign: 9 Varianten
• Visible
6.3 Button
• Name
• Anchor Top/Left
• AutoSize: True/False
• BackColor
• Cursor
• DialogResult: Ok Cancel Abort Retry Ignore Yes No
• Enabled False/True
• Font
• ForeColor
• Location: x y
• Locked True False
• Size: Width Height
• TabIndex
• TabStop
• Tag
• Text
• TextAlign: 9 Varianten MidleCenter
• Visible
6.4 TextBox, Editzeile
• Name
• Anchor Top/Left
• BackColor
• Cursor
• Enabled False/True
• Font
• ForeColor
• Lines
• Multiline False/true
• Location: x y
• Locked True False
• PasswordChar
• ReadOnly False/True
• Size: Width Height
• TabIndex
• TabStop
• Tag
• Text: Inhalt
• Visible
• WordWrap False/True
6.5 GroupBox
• Name
• Anchor Top/Left
• BackColor
• BorderStyle
• Cursor
• Enabled False/True
• Font
• ForeColor
• Location: x y
• Locked True False
• Margin
• Size: Width Height
• TabIndex
• TabStop
• Tag
• Text: Beschriftung
• Visible
6.6 RadioButton
• Name
• Anchor Top/Left
• AutoCheck
• BackColor
• CheckAlign 9 Varianten
• Checked
• Cursor
• DataBindings
• Enabled False/True
• Font
• ForeColor
• Image
• ImageAlign
• Location: x y
• Locked True False
• Margin
• Size: Width Height
• TabIndex
• TabStop
• Tag
• Text: Beschriftung
• TextAlign
• Visible
6.7 ListBox
• Name
• Anchor Top/Left
• BackColor
• Cursor
• DataSource
• Enabled False/True
• Font
• ForeColor
• FormatString
• FormattingEnabled
• Items (Collection), Inhalt der Texte
• Location: x y
• Locked True False
• Margin
• MultiColumn
• SelectionMode:
o None o One
o MultiSimple o MultiExtended
• Size: Width Height
• TabIndex
• TabStop
• Tag
• UsesTabStop
• Text: Beschriftung
• TextAlign
• ValueMember (DBS)
• Visible liste.Items.Clear();
liste.Items.add("eintrag1");
liste.Items.add("eintrag2");
liste.SelectedIndex = 0;
6.8 ComboBox
• Name
• Anchor Top/Left
• BackColor
• Cursor
• DataSource
• DrawMode normal, OwnerDrawFixed, OwnerDrawVariable
• DropDownHeight
• DropDownStyle:
o Simple Einfacher Editor
o DrownDown ComboBox mit Editor o DrownDownList Nur ComboBox
• Enabled False/True
• Font
• ForeColor
• FormatString
• FormattingEnabled
• ItemHeight
• Items (Collection)
• Location: x y
• Locked True False
• Margin
• MaxDropDownItems
• Size: Width Height
• Sorted
• TabIndex
• TabStop
• Tag
• Text: Inhalt, bei Simple und Dropdown
• TextAlign
• Visible cmb1.Items.Clear();
cmb1.Items.add("eintrag1");
cmb1.Items.add("eintrag2");
cmb1.SelectedIndex = 0;
6.9 ProgressBar
Minimum: Minmaler Wert Maximum: Maximaler Wert Value: Aktueller Wert
Style: Blocks // große Blöcke
Continuous // feine Striche
Marquee // autom. laufender ProgressBar
6.10 Menüs
• Name
• Aligment
• AutoSize
• BackColor
• BackgroundImage
• Checked False/True
• DisplayStyle: ImageAndText
• DropDown
• DropDownItems
• Enabled
• Font
• ForeColor
• Image
• ImageAlign
• ImageScaling
• ShortCutKeys
• Size
• Tag
• Text
• TextAlign
• TextDirection
• ToolTipText
• Visible
6.11 SplitContainer
• Name
• Anchor: Top, Left (Fullsize)
• BaclColor
• BackgroundImage
• BorderStyle
• Enabled
• FixedPanel
• Font
• ForeColor
• IsSplitterFixed
• Location
• Orientation: Vertical / Horizontal
• Panel1
• Panel2
• Panel1MinSize
• Panel2MinSize
• Size
• SplitterDistance, Abstand vom linken Rand
• SplitterIncrement
• SplitterWidth
• TabIndex
• TabStop
• Tag
• Visible
7 FileDialoge
7.1 OpenDialog
OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.Filter = "txt files (*.txt)|*.txt|pdf files (*.pdf)|*.pdf|All files (*.*)|*.*";
openFileDialog1.FilterIndex = 2;// zählt von 1 ! openFileDialog1.DefaultExt = ".txt";
openFileDialog1.InitialDirectory="c:\\daten\\0";
openFileDialog1.Multiselect=true;
openFileDialog1.RestoreDirectory = true;
if (openFileDialog1.ShowDialog() == DialogResult.OK) {
string[] sFiles;
sFiles = openFileDialog1.FileNames;
foreach (string sFile in sFiles) {
MessageBox.Show(sFile, Application.ProductName);
} }
OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.Filter = "txt files (*.txt)|*.txt|pdf files (*.pdf)|*.pdf|All files (*.*)|*.*";
openFileDialog1.FilterIndex = 2;// zählt von 1 ! openFileDialog1.DefaultExt = ".txt";
openFileDialog1.InitialDirectory="c:\\daten\\0";
openFileDialog1.Multiselect=false;
openFileDialog1.RestoreDirectory = true;
if (openFileDialog1.ShowDialog() == DialogResult.OK) {
string sFile = openFileDialog1.FileName.ToString();
MessageBox.Show(sFile, Application.ProductName);
}
7.2 SaveFileDialog
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.Filter = "txt files (*.txt)|*.txt|pdf files (*.pdf)|*.pdf|All files (*.*)|*.*";
saveFileDialog1.FilterIndex = 1;// zählt von 1 ! saveFileDialog1.DefaultExt = ".txt";
saveFileDialog1.InitialDirectory = "c:\\daten";
saveFileDialog1.RestoreDirectory = true;
if (saveFileDialog1.ShowDialog() == DialogResult.OK) {
string sFile = saveFileDialog1.FileName.ToString();
MessageBox.Show(sFile, Application.ProductName);
}
8 Kommandoparameter
// The Length property is used to obtain the length of the array.
// Notice that Length is a read-only property:
Console.WriteLine("Number of command line parameters = {0}", args.Length);
for(int i = 0; i < args.Length; i++) {
Console.WriteLine("Arg[{0}] = [{1}]", i, args[i]);
}
oder
Console.WriteLine("Number of command line parameters = {0}", args.Length);
foreach(string s in args) {
Console.WriteLine(s);
}
8.1 Installationspfad
Bestimmen des Installationspfads
String sProgramm = Application.ExecutablePath;
int ipos=sProgramm.LastIndexOf("\\");
String sPath = sProgramm.Substring(0, ipos+1);
9 Grafik
Quelle: http://msdn.microsoft.com/en-us/library/zy3kce13.aspx
9.1 Draw-Geometrie-Methoden
9.1.1 DrawArc public void DrawArc(
Pen pen, Rectangle rect, float startAngle, float sweepAngle )
public void DrawArc(
Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle )
public void DrawArc(
Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle )
Parameters pen
Type: System.Drawing..::.Pen
Pen that determines the color, width, and style of the arc.
rect
Type: System.Drawing..::.Rectangle
RectangleF structure that defines the boundaries of the ellipse.
startAngle
Type: System..::.Single
Angle in degrees measured clockwise from the x-axis to the starting point of the arc.
sweepAngle
Type: System..::.Single
Angle in degrees measured clockwise from the startAngle parameter to ending point of the arc.
private void DrawArcRectangle(PaintEventArgs e) {
// Create pen.
Pen blackPen= new Pen(Color.Black, 3);
// Create rectangle to bound ellipse.
Rectangle rect = new Rectangle(0, 0, 100, 200);
// Create start and sweep angles on ellipse.
float startAngle = 45.0F;
float sweepAngle = 270.0F;
// Draw arc to screen.
e.Graphics.DrawArc(blackPen, rect, startAngle, sweepAngle);
}
9.1.2 DrawBezier
public void DrawBezier(
Pen pen, Point pt1, Point pt2, Point pt3, Point pt4 )
public void DrawBezier(
Pen pen, PointF pt1, PointF pt2, PointF pt3, PointF pt4 )
Parameters pen
Type: System.Drawing..::.Pen
Pen structure that determines the color, width, and style of the curve.
pt1
Type: System.Drawing..::.Point
Point structure that represents the starting point of the curve.
pt2
Type: System.Drawing..::.Point
Point structure that represents the first control point for the curve.
pt3
Type: System.Drawing..::.Point
Point structure that represents the second control point for the curve.
pt4
Type: System.Drawing..::.Point
Point structure that represents the ending point of the curve.
private void DrawBezierPoint(PaintEventArgs e) {
// Create pen.
Pen blackPen = new Pen(Color.Black, 3);
// Create points for curve.
Point start = new Point(100, 100);
Point control1 = new Point(200, 10);
Point control2 = new Point(350, 50);
Point end = new Point(500, 100);
// Draw arc to screen.
e.Graphics.DrawBezier(blackPen, start, control1, control2, end);
}
public void DrawBezier(
Pen pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4 )
Parameters pen
Type: System.Drawing..::.Pen
Pen that determines the color, width, and style of the curve.
x1
Type: System..::.Single
The x-coordinate of the starting point of the curve.
y1
Type: System..::.Single
The y-coordinate of the starting point of the curve.
x2
Type: System..::.Single
The x-coordinate of the first control point of the curve.
y2
Type: System..::.Single
The y-coordinate of the first control point of the curve.
x3
Type: System..::.Single
The x-coordinate of the second control point of the curve.
y3
Type: System..::.Single
The y-coordinate of the second control point of the curve.
x4
Type: System..::.Single
The x-coordinate of the ending point of the curve.
y4
Type: System..::.Single
The y-coordinate of the ending point of the curve.
9.1.3 DrawBeziers
public void DrawBeziers(
Pen pen, Point[] points )
Parameters pen
Type: System.Drawing..::.Pen
Pen that determines the color, width, and style of the curve.
points
Type: array<System.Drawing..::.Point>[]()[]
Array of Point structures that represent the points that determine the curve.
private void DrawBeziersPoint(PaintEventArgs e) {
// Create pen.
Pen blackPen = new Pen(Color.Black, 3);
// Create points for curve.
Point start = new Point(100, 100);
Point control1 = new Point(200, 10);
Point control2 = new Point(350, 50);
Point end1 = new Point(500, 100);
Point control3 = new Point(600, 150);
Point control4 = new Point(650, 250);
Point end2 = new Point(500, 300);
Point[] bezierPoints =
{
start, control1, control2, end1, control3, control4, end2 };
// Draw arc to screen.
e.Graphics.DrawBeziers(blackPen, bezierPoints);
}
public void DrawBeziers(
Pen pen, PointF[] points )
private void DrawBeziersPointF(PaintEventArgs e) {
// Create pen.
Pen blackPen = new Pen(Color.Black, 3);
// Create points for curve.
PointF start = new PointF(100.0F, 100.0F);
PointF control1 = new PointF(200.0F, 10.0F);
PointF control2 = new PointF(350.0F, 50.0F);
PointF end1 = new PointF(500.0F, 100.0F);
PointF control3 = new PointF(600.0F, 150.0F);
PointF control4 = new PointF(650.0F, 250.0F);
PointF end2 = new PointF(500.0F, 300.0F);
PointF[] bezierPoints = { start, control1, control2, end1, control3, control4, end2 };
// Draw arc to screen.
e.Graphics.DrawBeziers(blackPen, bezierPoints);
}
9.1.4 DrawClosedCurve public void DrawClosedCurve(
Pen pen, Point[] points )
Parameters pen
Type: System.Drawing..::.Pen
Pen that determines the color, width, and height of the curve.
points
Type: array<System.Drawing..::.Point>[]()[]
Array of Point structures that define the spline.
private void DrawClosedCurvePoint(PaintEventArgs e) {
// Create pens.
Pen redPen = new Pen(Color.Red, 3);
Pen greenPen = new Pen(Color.Green, 3);
// Create points that define curve.
Point point1 = new Point(50, 50);
Point point2 = new Point(100, 25);
Point point3 = new Point(200, 5);
Point point4 = new Point(250, 50);
Point point5 = new Point(300, 100);
Point point6 = new Point(350, 200);
Point point7 = new Point(250, 250);
Point[] curvePoints = {
point1, point2, point3, point4, point5, point6, point7 };
// Draw lines between original points to screen.
e.Graphics.DrawLines(redPen, curvePoints);
// Draw closed curve to screen.
e.Graphics.DrawClosedCurve(greenPen, curvePoints);
}
public void DrawClosedCurve(
Pen pen, PointF[] points )
Parameters pen
Type: System.Drawing..::.Pen
Pen that determines the color, width, and height of the curve.
points
Type: array<System.Drawing..::.PointF>[]()[]
Array of PointF structures that define the spline.
private void DrawClosedCurvePointF(PaintEventArgs e) {
// Create pens.
Pen redPen = new Pen(Color.Red, 3);
Pen greenPen = new Pen(Color.Green, 3);
// Create points that define curve.
PointF point1 = new PointF(50.0F, 50.0F);
PointF point2 = new PointF(100.0F, 25.0F);
PointF point3 = new PointF(200.0F, 5.0F);
PointF point4 = new PointF(250.0F, 50.0F);
PointF point5 = new PointF(300.0F, 100.0F);
PointF point6 = new PointF(350.0F, 200.0F);
PointF point7 = new PointF(250.0F, 250.0F);
PointF[] curvePoints = {point1, point2, point3, point4, point5, point6, point7};
// Draw lines between original points to screen.
e.Graphics.DrawLines(redPen, curvePoints);
// Draw closed curve to screen.
e.Graphics.DrawClosedCurve(greenPen, curvePoints);
}
public void DrawClosedCurve(
Pen pen, Point[] points, float tension, FillMode fillmode )
Parameters pen
Type: System.Drawing..::.Pen
Pen that determines the color, width, and height of the curve.
points
Type: array<System.Drawing..::.Point>[]()[]
Array of Point structures that define the spline.
tension
Type: System..::.Single
Value greater than or equal to 0.0F that specifies the tension of the curve.
fillmode
Type: System.Drawing.Drawing2D..::.FillMode
Member of the FillMode enumeration that determines how the curve is filled. This parameter is required but ignored.
private void DrawClosedCurvePointTension(PaintEventArgs e) {
// Create pens.
Pen redPen = new Pen(Color.Red, 3);
Pen greenPen = new Pen(Color.Green, 3);
// Create points that define curve.
Point point1 = new Point(50, 50);
Point point2 = new Point(100, 25);
Point point3 = new Point(200, 5);
Point point4 = new Point(250, 50);
Point point5 = new Point(300, 100);
Point point6 = new Point(350, 200);
Point point7 = new Point(250, 250);
Point[] curvePoints = {point1, point2, point3, point4, point5, point6, point7};
// Draw lines between original points to screen.
e.Graphics.DrawLines(redPen, curvePoints);
// Create tension and fill mode.
float tension = 1.0F;
FillMode aFillMode = FillMode.Alternate;
// Draw closed curve to screen.
e.Graphics.DrawClosedCurve(greenPen, curvePoints, tension, aFillMode);
}
public void DrawClosedCurve(
Pen pen, PointF[] points, float tension, FillMode fillmode )
Parameters pen
Type: System.Drawing..::.Pen
Pen that determines the color, width, and height of the curve.
points
Type: array<System.Drawing..::.PointF>[]()[]
Array of PointF structures that define the spline.
tension
Type: System..::.Single
Value greater than or equal to 0.0F that specifies the tension of the curve.
fillmode
Type: System.Drawing.Drawing2D..::.FillMode
Member of the FillMode enumeration that determines how the curve is filled. This parameter is required but is ignored.
private void DrawClosedCurvePointFTension(PaintEventArgs e) {
// Create pens.
Pen redPen = new Pen(Color.Red, 3);
Pen greenPen = new Pen(Color.Green, 3);
// Create points that define curve.
PointF point1 = new PointF(50.0F, 50.0F);
PointF point2 = new PointF(100.0F, 25.0F);
PointF point3 = new PointF(200.0F, 5.0F);
PointF point4 = new PointF(250.0F, 50.0F);
PointF point5 = new PointF(300.0F, 100.0F);
PointF point6 = new PointF(350.0F, 200.0F);
PointF point7 = new PointF(250.0F, 250.0F);
PointF[] curvePoints = {point1, point2, point3, point4, point5, point6, point7};
// Draw lines between original points to screen.
e.Graphics.DrawLines(redPen, curvePoints);
// Create tension and fill mode.
float tension = 1.0F;
FillMode aFillMode = FillMode.Alternate;
// Draw closed curve to screen.
e.Graphics.DrawClosedCurve(greenPen, curvePoints, tension, aFillMode);
}
9.1.5 DrawCurve Method
Draws a cardinal spline through a specified array of Point structures.
public void DrawCurve(
Pen pen, Point[] points )
Parameters pen
Type: System.Drawing..::.Pen
Pen that determines the color, width, and height of the curve.
points
Type: array<System.Drawing..::.Point>[]()[]
Array of Point structures that define the spline.
private void DrawCurvePoint(PaintEventArgs e) {
// Create pens.
Pen redPen = new Pen(Color.Red, 3);
Pen greenPen = new Pen(Color.Green, 3);
// Create points that define curve.
Point point1 = new Point(50, 50);
Point point2 = new Point(100, 25);
Point point3 = new Point(200, 5);
Point point4 = new Point(250, 50);
