Coding for Fun mit C# - s3-eu-west-1.amazonaws.com · Uwe Klappert Coding For Fun mit C# 1484.book Seite 1 Montag, 7. Juni 2010 12:21 12

Uwe Klappert

Coding For Fun mit C#

1484.book Seite 1 Montag, 7. Juni 2010 12:21 12

Auf einen Blick

1 Einleitung ............................................................................ 9

2 Die Sache mit .NET ............................................................. 13

3 Ausgeschlafen – das Wecker-Tool ...................................... 41

4 Alles Täuschung oder was? Herr Hermann und sein Gitter ............................................ 69

5 Mit Argusaugen – der nächtliche Sternenhimmel .............. 101

6 Garantiert ungefährlich – Manipulationen am DAX ........... 141

7 Im Labyrinth des Minotaurus ............................................. 187

8 Pokern ................................................................................. 235

A Visual C# 2010 Express ....................................................... 327


5

Inhalt

1 Einleitung ....................................................................................... 9

1.1 Grundlegendes zu diesem Buch .......................................................... 101.2 Abseits von Klassen und Methoden ................................................... 101.3 Eine notwendige Frage: Die Zielgruppe? ............................................ 11

2 Die Sache mit .NET ....................................................................... 13

2.1 Intelligent, aber nicht unergründlich – das .NET-Framework .............. 142.1.1 Sprachgewaltig: die Laufzeitumgebung .................................. 142.1.2 Ein Meer von Klassen – die Base Class Library (BCL) .............. 15

2.2 Zwischengeschoben – der IL-Code ..................................................... 172.2.1 Kein Fabelwesen – der Jitter .................................................. 18

2.3 Ein Raum ohne Tür – der Namensraum .............................................. 202.4 Ein Wort wie ein Kosename – Assembly ............................................. 212.5 Die »digitale Müllabfuhr« – der Garbage Collector .............................. 242.6 Das Salz in der Suppe – Steuerelemente ............................................. 272.7 .NET und kein Ende? .......................................................................... 292.8 Aus der Art geschlagen – die Sprache C# ............................................ 29

2.8.1 Musik im Namen ................................................................... 302.8.2 Ein Kessel Buntes – die Ursprünge der .NET-Sprache C# ........ 312.8.3 Ein heikler Punkt – Pointer .................................................... 312.8.4 Ein geheimnisvoller Verein – Delegates .................................. 35

2.9 Ereignisbehandlung ............................................................................ 39

3 Ausgeschlafen – das Wecker-Tool ............................................ 41

3.1 Als der Computer die Zeit entdeckte .................................................. 423.2 Die Entwicklung der Bedienoberfläche ............................................... 45

3.2.1 Anlegen eines neuen Projekts ................................................ 473.2.2 Die benötigten Steuerelemente ............................................. 503.2.3 Ein EventHandler für das Beenden der Anwendung ... ........... 523.2.4 Implementierung und Test der Zeitanzeige ............................ 533.2.5 Von der Zeitanzeige zur Implementierung einer Uhr .............. 553.2.6 Zahlen für das »NumericUpDown«-Control ............................ 573.2.7 Mehr Lärm als Melodie – »tada« und »ir« ............................... 583.2.8 In einem Aufwasch – Einstellen der Weckzeit und

Auslösen des Wecktons ......................................................... 603.2.9 Stop and Go – das Beenden des Wecktons ............................ 64

3.3 Hätten Sie’s gewusst? ......................................................................... 68


Inhalt

6

4 Alles Täuschung oder was? Herr Hermann und sein Gitter ................................................... 69

4.1 Die Entdeckung der geheimnisvollen Punkte ...................................... 694.1.1 Kaffeestunde beim Optiker – woher die Punkte kommen ...... 71

4.2 Entwicklung der Benutzeroberfläche .................................................. 724.2.1 Was beabsichtigt ist .............................................................. 724.2.2 Die beteiligten Controls ......................................................... 73

4.3 Entwicklung der Programmierlogik .................................................... 764.3.1 Viel Aufwand für den Hintergrund ......................................... 774.3.2 Zeichnung und Positionierung der Gitterquadrate .................. 794.3.3 Der Schalter für das Hermann-Gitter ...................................... 824.3.4 Ganz schön blass geworden – die Regelung des

Alpha-Werts .......................................................................... 834.3.5 Aus groß mach klein – Skalierung der Quadrate durch ein

TrackBar-Steuerelement ........................................................ 864.3.6 Die Verhältnisse auf den Kopf gestellt – Umkehrung der

Farben ................................................................................... 944.4 Hätten Sie’s gewusst? ......................................................................... 99

5 Mit Argusaugen – der nächtliche Sternenhimmel ................. 101

5.1 Wie alles begann – Stippvisite in Padua .............................................. 1015.2 Subtil und verspielt – wo wir hin wollen ............................................. 103

5.2.1 Weitere Anforderungen an die Anwendung ........................... 1055.3 Entwicklung der Benutzeroberfläche .................................................. 1055.4 Entwicklung der Programmierlogik ..................................................... 108

5.4.1 Ein Klasse mit Ambitionen – Creating .................................... 1115.4.2 Zurück zur Klasse »Form1« .................................................... 1185.4.3 Sterne der 1. Kategorie .......................................................... 1195.4.4 Sterne der 2. Kategorie .......................................................... 1225.4.5 Zu guter Letzt – ein Stern der 3. Kategorie ............................. 1295.4.6 Verzögertes Schließen der Anwendung .................................. 1345.4.7 Aufgehoben ist nicht aufgeschoben – die Klasse

»DelayTime« .......................................................................... 1345.5 Hätten Sie’s gewusst? ......................................................................... 140

6 Garantiert ungefährlich – Manipulationen am DAX .............. 141

6.1 Im Schmelztiegel des großen Geldes .................................................. 1416.1.1 Xetra – das elektronische Hirn der Börse ................................ 1436.1.2 Am Puls der Wirtschaft – der DAX ......................................... 143


Inhalt

7

6.2 Was angedacht ist .............................................................................. 1446.3 Entwicklung der Benutzeroberflächen ................................................ 146

6.3.1 Das Fenster »Data« ................................................................ 1466.3.2 Das Fenster »DAX« ................................................................ 150

6.4 Entwicklung der Programmierlogik ..................................................... 1516.4.1 Das große Zeichnen – die Klasse »Chart« ............................... 159


7 Im Labyrinth des Minotaurus ..................................................... 187

7.1 Und dann kam Dijkstra ... .................................................................. 1887.1.1 Ein Quäntchen Graphentheorie ............................................. 1897.1.2 Dijkstra in Worten ................................................................. 1917.1.3 Listenplätze ........................................................................... 192

7.2 »Verworrene« Absichten .................................................................... 1927.2.1 »Schwaches Knotenkriterium« ............................................... 1947.2.2 Nullsummenspiel ................................................................... 1957.2.3 Wie es weiter geht ................................................................ 195

7.3 Entwicklung der Benutzeroberfläche .................................................. 1967.3.1 Ein Fall für sich – das »TableLayoutPanel« .............................. 1967.3.2 Labels am laufenden Band ..................................................... 1987.3.3 Drei Buttons und ein Textfeld ................................................ 200

7.4 Entwicklung der Programmierlogik ..................................................... 2017.4.1 Gute Eigenschaften ................................................................ 2027.4.2 Definition der Knoten im EventHandler

»button1_Click()« .................................................................. 2067.4.3 Ausblenden der Knoten im EventHandler

»button2_Click()« .................................................................. 2097.4.4 Die Schaltfläche zum kürzesten Weg ..................................... 210


8 Pokern ............................................................................................. 235

8.1 Die Hand am Colt – Five Card Draw ................................................... 2368.1.1 Die Regeln beim Five Card Draw ........................................... 2378.1.2 Gewichtete Hände ................................................................. 238

8.2 Draw Poker Light – unser Spiel ........................................................... 2408.2.1 Die Wahl des Gegners ........................................................... 2408.2.2 Erzwungener Tausch .............................................................. 2418.2.3 Die Frage des Geldes ............................................................. 241

8.3 Entwicklung der Benutzeroberfläche .................................................. 2418.3.1 Vom Ordner zur Bedienoberfläche ......................................... 242


Inhalt

8

8.4 Entwicklung der Programmierlogik ..................................................... 2538.4.1 Addition und Subtraktion – der Ereignisbehandler

»numericUpDown1_ValueChanged()« .................................... 2548.4.2 PictureBoxen aufgelistet – die Methode »pictureboxList()« .... 2568.4.3 Einsatz des Kartengebers ....................................................... 2568.4.4 Basisarbeit – die Klasse »kartenListe« ..................................... 2598.4.5 Zurück in der Klassendatei »Poker.js« .................................... 2708.4.6 Tauschgeschäfte 1 – EventHandling für fünf PictureBoxen ...... 2748.4.7 Tauschgeschäfte 2 – die Klasse »tauscheKarten« .................... 2768.4.8 Tauschgeschäfte 3 – das finale Ereignis .................................. 2838.4.9 Reduzierte Menge – die Klasse »kartenKombinationen« ........ 2868.4.10 Wie viel auf dem Spiel steht – die Struktur

»wertigkeitHand« .................................................................. 2898.4.11 Schnelles Plätzetauschen – die Klasse »permutKarten« ........... 2948.4.12 Gewonnen oder verloren – die Klasse »evaluiereHand« .......... 3078.4.13 Letzte Schritte im EventHandler »tauschen_Click()« ............... 3158.4.14 Die »Konditionierung« des Spiels ........................................... 3228.4.15 Mit »this« und »Close()« zum geschlossenen Fenster .............. 324

8.5 Hätten Sie‘s gewusst? ......................................................................... 3248.6 Zum guten Schluss ............................................................................. 325

A Visual C# 2010 Express ............................................................... 327

A.1 Anwendungen, die mit Visual C# 2010 Express erstellt werden können .................................................................................. 327

A.2 Reduzierter Funktionsumfang ............................................................. 328A.3 Neues bei Visual C# 2010 Express ...................................................... 329A.4 Der Weg zu Visual C# 2010 Express ................................................... 330

A.4.1 Was ist ein ISO-Image? .......................................................... 331A.4.2 Brennen einer Visual C# 2010 Express-CD ............................. 331A.4.3 Die Alternative – virtuelle Festplatte ...................................... 334

A.5 Installation von Visual C# 2010 Express ............................................. 335A.6 Das Prinzip der integrierten Entwicklungsumgebung .......................... 336

A.6.1 Projekte mit System ............................................................... 337A.6.2 Quell- versus Entwurfsmodus ................................................ 338A.6.3 Unverzichtbar – das »Eigenschaften«-Fenster ......................... 338

A.7 Veröffentlichung einer Anwendung .................................................... 339

Index ............................................................................................................ 343


69

Auch wenn die Biene einen gestreiften Rücken hat, ist sie noch lange kein Tiger.(Chinesisches Sprichwort)

4 Alles Täuschung oder was? Herr Hermann und sein Gitter

Wo findet sich das schon im täglichen Alltagserleben? Regelmäßig, in zwei Di-mensionen angeordnete schwarze Quadrate, die vermeintlich mit Punkten ausge-stattet sind, die auf den Kreuzungen der frei gebliebenen Streifen liegen. Undnicht nur dort: Selbst am Rand, wo die vertikalen Streifen des Gitters auf einenhorizontalen Streifen bzw. wo horizontale Streifen auf einen vertikalen Streifentreffen, sind – wenngleich deutlich schwächer – Punkte erkennbar. Das Dummean der Sache? Auf dem Objekt selbst existiert kein einziger Punkt. Und nehmenSie einen solchen Punkt länger ins Visier, verschwindet er (siehe Abbildung 4.1).

Abbildung 4.1 Das Hermann-Gitter

Kennen Sie einen Ort, an dem obige Seherfahrung regelmäßig ohne Ihr Wollenauf Sie wartet? Dann schreiben Sie mir!

4.1 Die Entdeckung der geheimnisvollen Punkte

Auch Physiologieprofessor Ludimar Hermann (1838–1914) wäre vielleicht nichtauf das seltsame Phänomen gestoßen, wenn er mit anderem als den Naturwissen-schaften sein Geld verdient hätte. Irgendwann im Jahre 1870 blätterte er, warumauch immer, in der deutschen Übersetzung der Tyndall’schen Vorlesungen überden Schall.


70

Alles Täuschung oder was? Herr Hermann und sein Gitter4

Abbildung 4.2 Der Physiologe Ludimar Hermann

Auf Seite 169 stieß er auf die Cladni’schen Klangfiguren, sechsundzwanzig an derZahl, regelmäßig neben- und übereinander angeordnet, und jede der Figuren warvor einem schwarzen quadratischen Hintergrund abgebildet. Der war in diesemFall der springende Punkt, und Punkte (wenngleich verwaschene) waren auchdas, was Hermann an den Kreuzungen der weißen Streifen sah – zu seiner wahr-scheinlichen Freude. An dieser Stelle aber sollte er am besten selbst zu Wort kom-men (Auszug aus »Eine Erscheinung des simultanen Contrastes« von LudimarHermann):

»Die Erscheinung sieht ein jeder, der darauf aufmerksam gemacht wird; für meine Augen scheint sie ganz besonders intensiv zu sein, denn mir erschien sie von Anfang an so auffallend, dass ich mich immer wundere, wenn jemand, dem ich das Blatt zeige, sie nicht ohne weiteres bemerkt.«

Den nächsten Abschnitt würde ich Ihnen (genauso mir selbst) gern ersparen, ichkann es aus Gründen der Vollständigkeit jedoch nicht. Ich versuche im Folgen-den, hochkomplexe physiologische Vorgänge inhaltlich zu verdichten und ineinem programmiersprachenorientierten Buch zu platzieren. Der Schiffbruch istwahrscheinlich vorprogrammiert. Mir Ihrer rettenden Hand sicher und gewiss,wage ich es dennoch.


71

Die Entdeckung der geheimnisvollen Punkte 4.1

4.1.1 Kaffeestunde beim Optiker – woher die Punkte kommen

Die Netzhaut des Menschen besteht aus über 100 Millionen Rezeptoren, derenSignale in sogenannten rezeptiven Feldern (im Weiteren RF genannt) zu funktio-nalen Einheiten zusammengefasst werden. Diese sind entscheidend beim Ver-such, die Punkte des Hermann-Gitters zu verstehen.

Rezeptoren senden Informationen, die im Sehnerv (Nervus Opticus) zusammen-laufen – Biologie Oberstufenkurs. Fällt auf ein solch kreisförmiges RF ein winzi-ger »Lichtfleck«, wird die zugehörige Faser des Sehnervs unter der Bedingungihre Aktivität verringern, dass das rezeptive Feld am Rande vom Licht getroffenwurde. In diesem Falle spricht man von einer lateralen Hemmung (der Faser desSehnervs).

Anderes Szenario: Diesmal wird das RF mittig getroffen. Reaktion des Faser: Ver-stärkung ihrer Aktivität. Drittes und entscheidendes Szenario: Das gesamte, re-zeptive Feld wird getroffen, also nicht nur vereinzelte Punkte irgendwo an derPeripherie oder im Zentrum. Würde nur das getroffen, wäre im Sinne einer nor-malen Lichtempfindung alles okay. Belichtet wurde jedoch alles. In der Folge sindTeile der Sehfaser gehemmt. Theoretisch ist dort für uns die Welt grau und ver-waschen.

Beim Betrachten des Hermann-Gitters erfolgt die Belichtung der rezeptiven Zellein einer ganz speziellen Weise, die davon abhängt, auf welche Stelle des Her-mann-Gitters der Betrachter blickt. Die »schönsten« Punkte befinden sich auf denKreuzungen der weißen Streifen (Hermann selbst sprach von »Straßen«). Keineneinzigen Punkt werden Sie dagegen auf einem Streifen irgendwo zwischen zweiQuadraten finden. Aus guten Grund.

Stellen Sie sich vor, Ihren Augen würden zwei rezeptive Zellen entnommen. Wiridealisieren! Eine rezeptive Zelle soll auf eine der Kreuzungen, die andere in ei-nigem Abstand rechts oder links daneben gelegt werden (siehe Abbildung 4.3).

Abbildung 4.3 Von der Position des rezeptiven Feldes (idealisiert als Kreis) hängt seine Belichtung ab.


72


Betrachten Sie zuerst den rechten Kreis: Ist der weiße Streifen gerade so breit wiedas Zentrum des RF, werden große Teile der Randgebiete von den schwarzenQuadraten belichtet. Und zwar schlecht, weil Schwarz sich außerordentlichwenig zur Reflexion von Lichtstrahlen eignet. Dementsprechend gering ist die la-terale Hemmung im RF. Als Konsequenz erscheinen die Streifen dem Auge so,wie sie vom Urheber des Gitters gedacht sind: weiß.

Anders stellt sich die Situation des RF an der Kreuzung dar (der linke Kreis), woder Schwarzanteil augenscheinlich geringer ist. Im Umkehrschluss ist die Belich-tung stärker, mit der Konsequenz einer auch stärkeren Hemmung. So viel zur Ent-stehung der Punkte.

4.2 Entwicklung der Benutzeroberfläche

Das Hermann-Gitter wollen wir simulieren. Dies wäre ein ehrenhaftes Ansinnen– wenn es nicht so unsinnig wäre. Denn entweder existiert ein Hermann-Gitter,und damit auch die beschriebene Kontrasttäuschung, oder es existiert nicht.

4.2.1 Was beabsichtigt ist

Sehr wohl lassen sich Variationen des »Urgitters« simulieren und damit einherge-hend die Stärke des Effekts. Gezeigt werden soll, dass der Kontrasteffekt (bedingt)abhängig ist

� vom Verhältnis zwischen der Breite der Streifen, genauer gesagt von der Flä-che der Kreuzungen und der Fläche der Quadrate. Je kleiner das Verhältnis ist,umso schwächer ist der Effekt. Das gilt auch dann, wenn die Farben umge-kehrt werden, d. h., wenn weiße Quadrate auf schwarzem Hintergrunderscheinen. Der Kontrasteffekt ist unter den Bedingungen zwar immer nochschwach, gleichwohl – zumindest bei genauerer Betrachtung – ein wenig stär-ker.

� von der Stärke des Kontrasts an sich. Dafür werden wir die Möglichkeit imp-lementieren, das Schwarze der Quadrate in Richtung dunkler und hellerGrautöne zu verändern.

Auch kombinieren sollen sich die Variationen lassen, bis hin zu dem Punkt, andem der Kontrasteffekt (fast) vollständig verschwunden ist. Das heißt genauer ge-sagt: bis hin zu dem Punkt, an dem der Kontrast zwischen Quadrat- und Streifen-farbe minimal und gleichzeitig das Verhältnis zwischen Quadrat- und Kreuzungs-fläche maximal ist.


73

Entwicklung der Benutzeroberfläche 4.2

4.2.2 Die beteiligten Controls

Lassen Sie sich durch Maxima, Minima, Kontraste und Kontrasteffekte nicht irremachen. Bevor das möglicherweise aber doch passiert, fangen wir am besten zu-nächst an. Stichwort: Benutzeroberfläche.

Klicken Sie im Hauptmenü der Entwicklungsumgebung auf Datei und im Kon-textmenü auf Neues Projekt. Die Dialogmaske Neues Projekt erscheint auf derBildfläche. Dort entscheiden Sie sich – natürlich – unter Von Visual Studio in-

stallierte Vorlagen für Windows Forms-Anwendung. Im Editorfeld Name

tragen Sie Hermann_Gitter ein (siehe Abbildung 4.4 ).

Abbildung 4.4 Anlegen eines neuen Projekts, »Hermann_Gitter«, in der Dialogmaske »Neues Projekt«

Nächstes Stichwort: Steuerelemente. Der Einkaufszettel mit dem, was Sie bitteaus der Toolbox an Controls besorgen, liest sich folgendermaßen:

� 3 × Label

� 1 × Panel

� 2 × Button

� 1 × TextBox

� 1 × TrackBar

� 1 × ComboBox


74


Abbildung 4.5 können Sie sowohl die Position der Controls auf der Windows-Form entnehmen als auch die Belegung der Text-Eigenschaft der Steuerelemente– und der WindowsForm selbst (Hermann-Gitter(v.1.0)). Ferner ist Ihnen aufge-fallen, dass sich das Formelement nicht maximieren lässt. Zu Recht schreiben Siedas der auf False gesetzten MaximizeBox-Eigenschaft zu. Zur Dimensionierungder WindowsForm lässt sich Folgendes feststellen:

Width: 661Height: 681

Abbildung 4.5 Entwurfsansicht der Hermann-Gitter-Simulation – doch wo ist das Gitter?

Der Abbildung ist ferner zu entnehmen, dass

� die Enabled-Eigenschaft der Controls

� textBox1,

� comboBox1,

� trackBar1

� sowie Button2 auf False gesetzt ist. Starten Sie die Anwendung später, sollzuerst kein Hermann-Gitter erscheinen. Somit macht es Sinn, die Controlszu deaktivieren, die zur Variation und Anzeige der veränderbaren Parame-ter verwendet werden.

� In der ComboBox (comboBox1) gibt es nun fixe Einträge, und zwar neun an derZahl. Ihr Startwert beträgt 25, der Endwert 255. Folglich beträgt die Schritt-


75

Entwicklung der Benutzeroberfläche 4.2

weite 25. Wie das Steuerelement comboBox1 an genannte Werte kommt, istschnell skizziert:

1. Öffnen Sie die Datei Form1.cs im Entwurfmodus.

2. Setzen Sie den Fokus auf das Control ComboBox1.

3. Klicken Sie oberhalb des Steuerelements auf den winzigen Pfeil. Es öffnetsich die Dialogmaske ComboBox-Aufgaben, in der Sie den Link Einträge

bearbeiten auswählen.

4. Die Einträge bearbeiten Sie im nun geöffneten Zeichenfolgen-Editor.

Noch etwas unsicher? Dann schauen Sie sich bitte einmal Abbildung 4.6 an.

Abbildung 4.6 Festlegung der ComboBox-Einträge im »Zeichenfolgen-Editor« der Entwicklungsumgebung

Nicht zu vergessen die TrackBar (trackBar1). Das ist unser Schieberegler. Per De-fault ist er horizontal orientiert. Des Weiteren existieren standardmäßig lediglichzehn Stufen zur Verstellung. Wir benötigen zwölf. Um die Orientierung und dieAnzahl der Stufen festzulegen, nutzen wir zwei Eigenschaften: Orientation undMaximum, die mit vertical beziehungsweise 12 zu belegen sind.

Abgesehen von Fragen der Farbgestaltung (die ich als ausgewiesener Nicht-Desi-gner gerne Ihnen überlasse), sind wir damit im Besitz einer Benutzeroberfläche.Diese funktioniert zwar (noch) nicht, doch ist spätestens hier der Anlass gekom-men, Sie über die Aufgabe einiger Controls zu informieren.


76


Zunächst: Die Position des Schiebereglers (Skalierung der Quadratabstände)wird in der TextBox (textBox1) ausgegeben. Das Control trackBar1 steuert dieBreite der Streifen zwischen den Quadraten, und zwar durch eine einheitlicheSkalierung der Quadratflächen, nicht etwa durch Zusammenrücken der Quadrate.Steht der Regler unten (Position 0), ist die Fläche der Quadrate minimal, der Qua-dratabstand maximal und damit auch die Fläche der Kreuzung maximal. Beimerstmaligen Einblenden des Hermann-Gitters (über den Button Hermann-Gitter

einblenden) ist genau das die Situation.

Diese lässt sich außer mit der TrackBar auch über die ComboBox verändern, inder Sie einen Wert (den sogenannten Alpha-Wert) auswählen, mit dem dasSchwarz der Quadrate zusehends verblasst.

ComboBox und TrackBar sind selbstredend nicht unabhängig voneinander. DieSkalierung der Quadrate muss vor dem Hintergrund dessen geschehen, ob einAlpha-Wert gesetzt ist und wenn ja, welcher. An dem Punkt werde ich Ihnen dasProgrammiererleben absichtlich ein wenig schwer machen – um Ihnen Möglich-keiten aufzuzeigen, abseits zahlreicher Optionen ein Control zu konfigurieren.

Habe ich etwas vergessen? Ja, den umgekehrten Fall: Wenn Sie zuerst die Qua-drate skalieren, um anschließend am Alpha-Wert zu »drehen«, müssen die einge-stellten Größenverhältnisse (Quadratfläche-Kreuzungsfläche) natürlich erhaltenbleiben.

So viel (vielleicht zu viel?) zu dem, was wir wollen. Bitte öffnen Sie die DateiForm1.cs im Quelle-Modus. Dann geht’s los.

4.3 Entwicklung der Programmierlogik

Höchst unspektakulär beginnen wir mit der Deklaration zweier Variablen, derenWichtigkeit Sie trotzdem nicht unterschätzen sollten. Beide sind vom Elementar-typ int, und weil das Private nicht selten besser als die Öffentlichkeit ist, wird dieSichtbarkeit auf private festgelegt (eine Begründung, mit der selbst der fähigsteInformatikstudent in Windeseile durch jede Fachprüfung fallen würde):

private int cindex;private int index;

Die Steigerung folgt auf dem Fuße: Wir erzeugen ein privates Objekt der Klassevom Typ GS durch den Konstruktor GS():

private GS ground = new GS();


77

Entwicklung der Programmierlogik 4.3

Dass die drei Deklarationen im Kopfbereich der Klasse Form1 »fein säuberlich«untereinander geschrieben werden, macht auch deshalb Sinn, weil die beidenint-Variablen (cindex und index) teilweise in einem Zusammenhang mit derKlasseninstanz ground stehen. Doch lassen Sie sich überraschen! So viel vorweg:Hinter cindex verbirgt sich der Alpha-Wert und hinter index die Laufvariable zurSkalierung der Quadrate. Weiter geht es allerdings zunächst woanders: beim Hin-tergrund. Gut, wenn man über den Bescheid weiß.

4.3.1 Viel Aufwand für den Hintergrund

Eine Methode wird benötigt. Privat soll sie sein. Nennen wir die Methode sinni-gerweise Background_Paint(). In ihr wird zwar kein Wert zurückgegeben (void),wohl aber hat Background_Paint() ein gewichtiges Argument, nämlich bc, zuverarbeiten.

bc ist vom Typ Color, wobei Color keine Klasse, sondern eine Struktur ist (im Na-mensraum System.Drawing). Klasse ist Color dennoch, wird durch den komple-xen Typ doch eine ARGB-Farbe (Alpha (!), Rot, Grün, Blau) dargestellt.

Die Methodensignatur sieht so aus:

void Background_Paint(Color bc){}

Farben sind wichtig! Ohne Farbe ist ein Pinsel wenig, auch der, den wir in Gestaltder Klasse SolidBrush finden (sie ist im selben Namensraum wie die Color-Struk-tur organisiert). Ein Objekt der Klasse SolidBrush wird über den Konstruktor derKlasse SolidBrush erzeugt. Dem geben wir etwas mit auf den Weg der Erzeugung– die Variable bc nämlich:

SolidBrush brush = new SolidBrush(bc);

Prima! Nun haben wir einen Pinsel, aber noch nichts, auf dem er seine Farbe hin-terlassen könnte. Für sich genommen, hilft das Formelement uns nicht weiter.Sehr wohl aber die Klasse Graphics (abermals in System.Drawing), die eineGDI+-Zeichnungsoberfläche (das Kürzel GDI steht für Graphics Device Interface)kapselt.

Trivial ist die Angelegenheit nicht. Es geht im Weiteren nämlich nicht darum, einObjekt der Klasse Graphics über den Aufruf des Konstruktors, also auf klassi-schem Wege, zu erzeugen (new Graphics()). Stattdessen soll, als eine von min-destens vier vergleichsweise aufwendigen Möglichkeiten, ein Graphics durchAufruf der CreateGraphics()-Methode zurückgegeben werden (wobei das Gra-


78


phics den Namen formG tragen soll). Abgesehen von this, als einem auf die ak-tuelle Instanz der Klasse Form verweisenden Schlüsselwort, liest sich das dann so:

Graphics formG = this.CreateGraphics();

Eine »normale« Methode ist demnach der Schlüssel zum Erhalt eines Graphics.Stimmt, bloß existiert (natürlich?) keine Methode CreateGraphics() unter denzahlreichen Membern der Klasse Graphics. Wo aber dann? In der Klasse Control.Sollten Sie bislang ein wenig an der Sinnhaftigkeit von Namensräumen gezweifelthaben (vielleicht, weil ich sie nicht gut genug erläutert habe), so tun Sie es inKürze womöglich nicht mehr. Die Klasse Control existiert nämlich zweimal.Beide Versionen sind sehr wichtig – und unverwechselbar: dank zweier, getrenn-ter Namensräume.

Unsere Control-Klasse residiert im Namensraum System.Windows.Forms, die an-dere in System.Web.UI, was schon das ein oder andere aussagt. Durch Controlwerden im Wesentlichen WindowsForms-Steuerelemente definiert, die eine vi-suelle Darstellung haben. Unter den Membern der Klasse entdecken wir dannauch jenes zum Erstellen der Graphics: CreateGraphics().

Zurück zur Klasse Graphics. Diese enthält eine Methode namens FillRect-angle(), die in gleich mehreren Argumentkonstellationen »betrieben« werdenkann. Demnach zählt FillRectangle() zu den überladenen Methoden. Wir ent-scheiden uns für die Version, in der als Argumente der Pinsel brush sowie einRechteck übergeben werden. Hier kommt die Rectangle-Struktur (System.Dra-wing) wie gerufen. Die ersten beiden der insgesamt vier in der Struktur gespei-cherten Zahlen kennzeichnen die Position der oberen linken Ecke des Rechtecks,die beiden letzten bestimmen die Höhe und Breite. Somit schreiben wir:

formG.FillRectangle(brush, new Rectangle(26,8,298,320));

Tieferes Nachdenken über die Zahlenwerte lohnt nicht. Es geht lediglich darum,die Hintergrundfläche so zu dimensionieren und zu positionieren, dass die linkeHälfte der WindowsForm fast vollständig mit einer (von zwei möglichen) Hinter-grundfarben ausgefüllt ist.

Zwei Objekte werden verwendet: brush vom Typ SolidBrush sowie formG alsGraphics. Die Klasse SolidBrush erbt von Brush. Wird Brush nicht mehr benö-tigt, können durch den Aufruf der Methode Dispose()(als Member der KlasseSolidBrush) die vom Brush-Objekt verwendeten Speicherressourcen freigegebenwerden, was in der Umsetzung so aussieht:

brush.Dispose();


79


Was bei SolidBrush ein relativ unbestimmtes Kann ist, ist bei Graphics schlichtein Muss. Dort müssen Sie die vom Graphics-Objekt (formG) verwendeten Res-sourcen freigeben:

formG.Dispose();

Damit wäre die Methode Background_Paint() implementiert. So sieht sie aus:

private void Background_Paint(Color bc){

SolidBrush brush = new SolidBrush(bc);Graphics formG = this.CreateGraphics();formG.FillRectangle(brush, new Rectangle(26, 8, 298,320));brush.Dispose();formG.Dispose();

}

Listing 4.1 Ohne Hintergrund geht wenig – die Methode »Background_Paint()«

4.3.2 Zeichnung und Positionierung der Gitterquadrate

Die Methode zum Zeichnen des Hintergrunds habe ich Background_Paint() ge-nannt. Da ist es nur billig, die zum Zeichnen des Gitters erdachte MethodeGitter_Paint() zu nennen. Für die gibt es allerdings ein paar Argumente mehr.Doch kommen wir am besten gleich zur Signatur:

void Gitter_Paint(int ind, int cin, Color co){}

Auch bei Gitter_Paint() wird nichts zurückgegeben, die Privatheit der Methodebleibt ebenfalls gewahrt. Und was die int-Variablen ind und cin anbelangt:Gerne dürfen Sie sich an cindex und index erinnert fühlen. Bliebe noch co vomTyp Color: co ist einer von nunmehr zwei »konstruktiven Beiträgen« zur Herstel-lung eines digitalen Pinsels. Für den Pinsel zum Zeichnen des Hintergrundsbrauchten wir dem Konstruktor nur die Variable der Farbe zu übergeben. Dochjetzt geht es um mehr.

Auch ein Gitterquadrat ist nur die Spezialform eines Rechtecks. Wie ein solchesgezeichnet wird, konnten Sie im letzten Abschnitt in »quälender« Ausführlichkeitlesen, weswegen in diesem Abschnitt das Rad nicht neu erfunden werden muss.Dennoch sind wir in Sachen grafikorientierter Programmierbeigaben noch nichtüber den Berg, denn im Gegensatz zum Rechteck des Hintergrunds, der nurSchwarz und Weiß kennt, können die Quadrate des Gitters gleich mehrere Farben(im Sinne der stufenweisen Abschwächung der Basisfarbe Schwarz) annehmen.

Hilfe bekommen wir von der vierfach überladenen Methode FromArgb() derColor-Struktur. In der »Zwei-Argumente-Version« wird FromArgb() ein Int32-


80


Wert (der in Wahrheit auf 8 Bit beschränkt ist) sowie eine Color-Struktur über-geben. Sie haben richtig gelesen: Einer Color-Struktur-Methode wird als Argu-ment eine Color-Struktur übergeben. Das ist nicht halb so ungewöhnlich, wie esvielleicht verwirrend klingt, interessanter ist darüber hinaus das erste Argument.Denn was sich hinter dem Int32-Wert verbirgt, ist nichts weniger als der variableAlpha-Wert, mithin die sogenannte A-Eigenschaft einer Farbe.

Wenn Sie jetzt über

Color customColor = Color.FromArgb(cin, co);

eine aus A-Eigenschaft (die Variable cin) und Basisfarbe (co) bestehende, verän-derbare Farbe definieren, die Sie dem Konstruktor der »Pinselklasse« SolidBrushals Wert übergeben, erhalten Sie:

SolidBrush brush1 = new Solid Brush(customColor);

Nachdem wir mit

Graphics formGraphics = this.CreateGraphics();

für eine weitere Graphics gesorgt haben, können wir theoretisch unter Verwen-dung der FillRectangle()-Methode ein Quadrat zeichnen – eines von 132 be-nötigten Quadraten.

Zweifelsfrei: Es geht aufwärts mit uns, und das noch mehr, wenn wir die erstenbeiden Werte der Rectangle-Struktur (als eines von zwei Argumenten der Fill-Rectangle()-Methode) als klassische i-j-Laufvariablen festlegen. i bezeichnetdie x-Position der rechten oberen Quadratecke, j die y-Position. Solange i und jmit Werten versorgt sind werden fleißig Quadrate gezeichnet, sowohl in horizon-taler als auch in vertikaler Richtung. Bloß skaliert werden sie nicht.

Bitte ziehen Sie abschließend noch einmal die Rectangle-Struktur heran. VierWerte werden in ihr gespeichert: zwei für die Position der linken oberen Quadra-tecke (abgegolten mit den Laufvariablen i und j), zwei für die Kantenlängen.Wenn Sie später auf die Schaltfläche Hermann-Gitter einblenden klicken, ge-schieht genau das, und zwar mit der kleinsten Quadratfläche. Genauer gesagt mit15px. Werden die Quadrate mit dem Schieberegler skaliert, fügen Sie dem Start-wert 15px einen weiteren Wert hinzu, der in der Variablen ind als erstes Argumentder Methode Gitter_Paint() gespeichert ist. So fügt sich eins zum anderen.

Die Methode FillRectangle() wäre damit komplett:

formGraphics.FillRectangle(brush1, new Rectangle(j, i, 15 + ind, 15+ ind));

Abgesehen von der Methode Dispose(), anzuwenden auf brush1 und formGra-phics, fehlen noch Kontrollstrukturen für die Laufvariablen i und j, für die in


81


der Struktur kein Startwert festgelegt wurde. Wir verwenden dazu zwei ineinan-der verschachtelte for-Schleifen.

for (int i = 10; i <= 320; i = i + 27){

for (int j = 30; j <= 320; j = j + 27){

}

}

Listing 4.2 Verschachtelte »for«-Schleifen zur Erzeugung von 132 Quadraten

Auch hier gilt: Halten Sie nicht lange damit auf, wie diese Zahlenwerte wohl zu-stande gekommen sind; sie sind mehr oder weniger durch Versuch und Irrtumentstanden. Das Prinzip ist wichtiger. Für den vertikalen Aufbau des Gitters istdie innere Schleife zuständig (die auch zuerst ausgeführt wird) und für den hori-zontalen Aufbau die äußere. Zusammengefasst, bewirken die for-Schleifen nichtsanderes als das Verschieben der Position der linken oberen Quadratecke. Undjede neue Position entspricht einem Quadrat.

Hier sehen Sie die vollständige Methode Gitter_Paint():

private void Gitter_Paint(int ind, int cin, Color co){

for (int i = 10; i <= 320; i = i + 27){

for (int j = 30; j <= 320; j = j + 27){

Color customColor = Color.FromArgb(cin, co);SolidBrush brush1 = new SolidBrush(customColor);Graphics formGraphics = this.CreateGraphics();formGraphics.FillRectangle(brush1, newRectangle(j, i, 15 + ind, 15 + ind));brush1.Dispose();formGraphics.Dispose();

}

}}

Listing 4.3 Ohne Gitter kein Hermann-Gitter – die Methode »Gitter-Paint()«


82


4.3.3 Der Schalter für das Hermann-Gitter

Wenn Sie den Rumpf der Ereignisbehandlungsroutine für die Schaltfläche Her-

mann-Gitter einblenden durch einen linksseitigen Doppelklick auf das Controlbutton1 erstellt haben, geht es zunächst darum, vier Steuerelemente zu aktivie-ren.

Die Klassen ComboBox, TrackBar, Button und TextBox (jeweils im NamensraumSystem.Windows.Forms zu finden) besitzen alle die Eigenschaft Enabled, die, mittrue festgelegt, zur Aktivierung des Controls führt:

comboBox1.Enabled = true;trackBar1.Enabled = true;button2.Enabled = true;textBox1.Enabled = true;

Eingangs, d. h. nach Betätigung des Schalters, sind die Quadrate nicht skaliert.Der Schieberegler wurde nicht betätigt. Die TextBox Stufe sollte 0 anzeigen:

textBox1.Text = «0«;

Ein wirklich schwarzes Quadrat bekommen wir nur mit einem maximalen Wertder int-Variable cindex:

cindex = 255;

Da die Umkehrung der Farbe keine Auswirkung auf die Größe der Quadratehaben darf, wird der Variablen index der Wert 0 zugewiesen:

index = 0;

Dann geht es ans Zeichnen des Hintergrunds, wofür in Abschnitt 4.3.1 die Me-thode Background_Paint(Color bc) entwickelt wurde. Die Variable bc (vom TypColor) wird mit Color.White festgelegt. Die Methode kann nun aufgerufen wer-den:

Background_Paint(Color.White);

Es folgt der Aufruf der Methode Gitter-Paint(), der als Argumente cindex,index sowie Color.Black übergeben werden:

Gitter_Paint(index, cindex, Color.Black);

Acht Zeilen Code, und das Rumpfinnere des Eventhandlers button1_Click()wäre komplett. Hier sehen Sie das Resultat:

private void button1_Click(object sender, EventArgs e){

comboBox1.Enabled = true;


83


trackBar1.Enabled = true;button2.Enabled = true;textBox1.Enabled = true;


cindex = 255;index = 0;

Background_Paint(Color.White);Gitter_Paint(index, cindex, Color.Black);

}

Listing 4.4 Wie das Hermann-Gitter eingeblendet wird – die Ereignisbehandlungsroutine »button1_Click()«

Nach erfolgreichem Start mit ((F5)) oder ohne Debugging ((Strg)+(F5)) undeinem Klick auf den Button Hermann-Gitter einblenden erwartet Sie der An-blick aus Abbildung 4.7.

Abbildung 4.7 Hermann-Gitter-Variation – abgeschwächter Kontrasteffekt, da das Verhältnis zwischen Kreuzungsfläche und Quadratfläche klein ist.

4.3.4 Ganz schön blass geworden – die Regelung des Alpha-Werts

Dank des letzten Abschnitts sind wir immerhin so weit, das Hermann-Gitter überden Schalter Hermann-Gitter einblenden darstellen zu können. Um den schwar-zen Quadraten »scheibchenweise« die Schwärze zu nehmen, sollten wir zuerstdem Steuerelement comboBox1 einen anständigen Eventhandler spendieren. VielAuswahl haben Sie da nicht, am wenigsten, wenn Sie im Entwurfsmodus zweimal


84


auf comboBox1 klicken. Dann ist er nämlich da, der Ereignisbehandler comboBox1_SelectedIndexChanged(object sender, EventArgs e). Ihn gilt es mit Leben zufüllen.

Auf das Ausgewählte lässt sich über die Text-Eigenschaft der ComboBox-Klasse be-quem zugreifen:

comboBox1.Text

Das ist gut, wenngleich unzureichend. Die ComboBox-Einträge liegen als Textvor. Dagegen ist die cindex-Variable (als Speicherort des Alpha-Werts) vom Typint – was so bleiben soll. Folglich kommen wir nicht darum herum, das Ergebnisvon comboBox1.Text in den Basistyp int zu konvertieren. Das ist eine Aufgabefür die Klasse Convert (Namespace: System). Deren mächtig überladener Funk-tion ToInt16() wird der angeklickte Eintrag übergeben:

cindex = Convert.ToInt16(comboBox1.Text);

Was der ComboBox ihr comboBox1.Text ist, ist der TrackBar ihr trackBar1.Va-lue. Ist der Schiebregler nämlich an einer bestimmten Position, wird ein Wert ge-liefert – vom Typ int. Analog zur ComboBox könnten wir also schreiben:

index = trackBar1.Value;

Wo auch immer sich der Schieberegler im Bezug auf die Skala befindet – der be-treffende int-Wert, gespeichert in der int-Variablen index, sorgt nach dem Auf-ruf der Methode Gitter-Paint(int ind, int cin, Color co)dafür, dass die Com-boBox notwendigerweise Kenntnis darüber erhält, für welche Quadratgröße derneue Alpha-Wert gilt. Wie Sie sehen, ist dieser Satz dreierlei: zu lang, verwirrend– und inhaltlich richtig. Nichtsdestoweniger hat die Angelegenheit einen Haken.

Im Prototyp der Anwendung Hermann-Gitter erfolgte auch die Regelung der Qua-dratgröße über eine ComboBox – was mir schnell missfiel. Als ich die ComboBoxdurch eine TrackBar ersetzte, gefiel mir das Resultat noch viel weniger. Bei Stufe12 des Schiebereglers wurden die Quadrate schlechterdings zu groß, was sich ein-drucksvoll im Verschwinden der weißen Streifen zeigte. Aus 132 kleinen Quadra-ten wurde ein großes. Punkte ade!

Vermutlich war ich in Gedanken schon im Feierabend und habe deswegen dasProgramm nicht an der richtigen Stelle geändert. Anstatt nämlich im Ausdruck

formGraphics.FillRectangle(brush1, new Rectangle(j, i, 15 + ind, 15+ ind));

den Startwert der Quadratkantenlänge (oder die Stufen der TrackBar) um 1 zu re-duzieren, habe ich den Positionswert des Schiebereglers durch den Wert 2 divi-diert. Dabei ist es geblieben. Somit:


85


index = (trackBar1.Value)/2;

Was bleibt, ist die Methode zum Zeichnen des Hintergrunds sowie die Methode,um die Quadrate aufzurufen:


Hier sehen Sie noch einmal die Ereignisbehandlungsroutine hinter der Combo-Box Alpha-Wert:

private void comboBox1_SelectedIndexChanged(object sender, EventArgs e){

cindex = Convert.ToInt16(comboBox1.Text);index = (trackBar1.Value)/2;


}

Listing 4.5 Regelung des Alpha-Werts in der Ereignisbehandlungsroutine »comboBox1_SelectedIndexChanged()«

Auch hier können Sie testen, beispielsweise durch Auswahl des kleinsten Alpha-Werts (siehe Abbildung 4.8).

Abbildung 4.8 Beinahe vollständig verschwundener Kontrasteffekt aufgrund von a) kleinem Verhältnis zwischen Quadratfläche und Fläche der Kreuzungen sowie b) nicht ausreichendem Kontrast zwischen Quadratfarbe und Streifenfarbe


86


4.3.5 Aus groß mach klein – Skalierung der Quadrate durch ein TrackBar-Steuerelement

Auch das gewichtige TrackBar-Steuerelement lässt sich im Entwurfsmodus derSeite Form1.cs problemlos zweimal anklicken. Tun Sie das, und der Ereignis-handler trackBar1_Scroll(object sender, EventArgs e) ist Ihrer. Und auchhier gilt es, den Rumpf der Routine zu füllen. Bitte kehren Sie also in den Quell-modus zurück.

Gerade im Eventhandler der TrackBar brauchen wir den (aus genannten Gründenhalbierten) Positionswert des Schiebereglers. Hier ist er noch einmal:

index = trackBar1.Value/2;

Die Skalierung der Quadrate sollte mit dem Wissen erfolgen, ob und wenn ja wel-cher Alpha-Wert in der ComboBox Alpha-Wert angeklickt wurde. Die relevanteZeile lautet:

cindex = ground.combo(comboBox1.Text);

Was nun folgt, rechtfertigt ein weiteres Unterkapitel. Schnell werden Sie merken,warum. Es geht um eine programmiertechnische Übertreibung, die wir uns andieser Stelle erlauben.

Eine kleine Serviceklasse

Zu Beginn der Klasse Form1 wurde über

private GS ground = new GS();

eine private Instanz der Klasse GS erzeugt. Das ist gut. Weniger gut ist, dass in derProjektmappe »Hermann_Gitter« bislang keine gleichnamige Klasse existiert.Noch schlimmer kommt es in der Ereignisbehandlungsroutine trackBar1_Scroll(object sender, EventArgs e). Dort wurde in der Zeile


der Rückgabewert der Methode combo(), die ein Member der Klasse GS ist, derVariablen cindex (vom Typ int) zugewiesen. Wenn es keine Klasse GS gibt, siehtdas bei der Methode combo() vermutlich nicht viel anders aus.

Was ist mit dem Argument comboBox1.Text der Methode combo()? Die Aufgabeder Klasse GS ist es, mit der Methode combo() – abhängig davon, ob und wasunter Alpha-Wert ausgewählt ist – einen Wert für die Variable cindex zu gene-rieren.

Unterbrechen wir hier die Erörterung der (zugegebenermaßen etwas hochtra-bend) »Serviceklasse« genannten Klasse GS, die erst dann wieder Sinn macht,


87


wenn wenigstens der Klassenrumpf vorhanden ist. Hier ist schnell Abhilfe ge-schaffen:

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Pro-

jektmappe »Hermann-Gitter«.

2. Wählen Sie im Kontextmenü erst Hinzufügen, anschließend (im Untermenü)Neues Projekt aus. Es öffnet sich die Dialogmaske Neues Projekt hinzufü-

gen.

3. Unter Vorlagen entscheiden Sie sich für Klassenbibliothek, und im Editor-feld Name wäre Gitter_Service einzutragen (siehe Abbildung 4.8). Mit derFestlegung des Projekttitels wird gleichzeitig der Name des Namespace festge-legt. Er lautet also Gitter_Service.

4. Klicken Sie einmal auf Ok, und warten Sie dann gespannt auf das, was sich imProjektmappen-Explorer tut.

Abbildung 4.9 Hinzufügen einer Klassenbibliothek als neues Projekt

Im Projektmappen-Explorer existiert fortan ein neues Projekt, das aus Eigenschaf-ten, Verweisen und, last but not least, aus der Klasse Class1.cs besteht.


88


Ändern Sie zunächst den Klassennamen Class1 in GS. Klicken Sie dazu mit derrechten Maustaste auf die Datei Class1.cs, wählen Sie im Kontextmenü Umbenen-

nen aus, und tun Sie genau das dann auch. Von der Änderung des Namens sollenauch Verweise betroffen sein, was Sie durch einen Klick auf den Button Ja derdiesbezüglichen Meldung bestätigen.

Anschließend öffnen Sie die Datei GS.cs im Codeeditor. Erwarten sollte Sie fol-gendes Codegerüst:

using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace Gitter_Service{

public class GS{

}}

Listing 4.6 »using«-Direktiven, Namespace und vorerzeugter Klassenrumpf in der Datei »GS.cs«

Erste Auffälligkeit: Auch hier stehen vor dem vorerzeugten Klassenrumpf (nichtzu vergessen der übergeordnete namespace Gitter_Service) using-Direktiven –von denen Sie alle außer using System getrost »streichen« können (aber nichtmüssen).

Zweite Auffälligkeit: Der Konstruktor fehlt, was mit

public GS(){}

schnell behoben ist.

Womit gestartet wird

Die Entwicklungsumgebung hat es sich gespart, die Datei Programm.cs zu erzeugen.Folglich gibt es keine Methode Main() (die, nebenbei bemerkt, wohl das stärksteIndiz für den C-Ursprung der Sprache C# ist), keinen Einstiegspunkt für die Laufzeit-umgebung und somit keine Möglichkeit, die Datei Class1.cs direkt auszuführen – woraufsich auch verzichten lässt. Schließlich haben wir ein ausführbares Projekt Hermann_Git-ter, mit dem gestartet werden kann. Dazu klicken Sie bitte mit der rechten Maustasteauf das Projekt Hermann_Gitter. Das Kontextmenü enthält die Option Als Startprojekt

festlegen. Klicken Sie bitte auf diesen Eintrag.


89


Der Methode combo() soll ein Wert, gespeichert in der Variablen cb, vom Typstring übergeben werden – eben das, was in der ComboBox Alpha-Wert ausge-wählt ist. Um nichts anderes als den Alpha-Wert geht es. Zurückgeliefert wird einin der Variablen cd gespeicherter Wert, der vom Typ int ist. Auch hinter, bessergesagt in der Variablen cd verbirgt sich der Alpha-Wert. Zwischen cb und cd mussirgendetwas passiert sein. Werfen wir zunächst jedoch einen Blick auf die Metho-densignatur:

int combo(string cb){ }

Über


erfolgt die Speicherung dessen, was die Methode combo(comboBox1.Text) zu-rückgibt, in der Variablen cindex, mit der die Methode zum Zeichnen der Qua-drate aufgerufen wird. Wurde unter Alpha-Wert nichts ausgewählt, hat die Me-thode combo() einen Leerstring zu verarbeiten, was in dem Augenblickunangenehm wird, in dem Sie ihn konvertieren müssen. Und wir müssen konver-tieren. Nämlich so:

cd = Convert.ToInt16(cb);

Übergeben Sie ToInt16() einen Leerstring, handeln Sie sich eine unbehandelteFormatException ein. Fangen Sie stattdessen genau diesen Fall – zuvor – in einerif-else-Struktur ab, vielleicht so:

if (cb == ""){

cd = 255;}else{

cd = Convert.ToInt16(cb);}

Die komplette Methode sieht so aus:

Für den Fall der Fälle

Einen Konstruktor (als unbedingte Voraussetzung zum Erzeugen eines Klassenobjekts)in der »Grundversion« zu erstellen, ist manchmal einfacher, als ihn zu verstehen. Docheigentlich müssen Sie gar nichts tun, erzeugt der Compiler doch automatisch für Klassenohne eigenen Konstruktor einen Ersatz- bzw. Standardkonstruktor. Dennoch ist es dieschönere Variante, die Aufgabe selbst zu erledigen – finde ich zumindest.


90


public int combo(string cb){

if (cb == ""){

cd = 255;}else{


return cd;

}

Listing 4.7 Die Methode combo()

Hier sehen Sie die vollständige Klasse GS:

using System;

namespace Gitter_Service{

public class GS{

private int cd;

public int combo(string cb){

if (cb == ""){

cd = 255;}else{


return cd;

}}

}

Listing 4.8 Die selbst entworfene Serviceklasse »GS«


91


Bliebe das Erstellen der Serviceklasse GS, im Sinne einer Assembly Gitter_Ser-vice.dll. Klicken Sie dazu im Projektmappen-Explorer auf Gitter_Service und imKontextmenü auf Erstellen. Zuvor jedoch sollten Sie überprüft haben, an wel-chem Ort die erstellte Assembly abgelegt wird. Idealerweise wäre das der Ordnerbin im Projekt Gitter_Service. Der Ordner existiert, bloß sehen Sie ihn vermut-lich nicht, weil in der Projektmappe Hermann_Gitter nicht alle Dateien einge-blendet sind. Das korrigieren Sie rasch durch einen Klick auf die mittlere Schalt-fläche im Projektmappen-Explorer (Tooltip: Alle Dateien Anzeigen).

Klicken Sie nun mit der rechten Maustaste auf das Projekt Gitter_Service. Aller-dings wählen Sie diesmal die Option Eigenschaften, woraufhin sich der ReiterGitter_Service öffnet. Hier geht es um den Menüpunkt Erstellen und im Wei-teren um das Editorfeld Ausgabepfad, in dem bin\Debug\ zu lesen sein sollte(siehe Abbildung 4.10).

Abbildung 4.10 Festlegung des Ausgabepfads für die Assembly »Gitter_Service.dll«

Jetzt können Sie das Projekt erstellen, starten können Sie es nicht. Denn zurzeithat das WindowsForm-Projekt Hermann_Gitter keine Kenntnis über Inhalte desProjekts Gitter_Service, geschweige denn weiß das zuerst erstellte Projekt von derExistenz der Assembly Gitter_Service.dll im Projektverzeichnis bin\Debug\. Woherauch? Die gemeinsame Projektmappe »Hermann_Gitter« genügt nicht, um dieProjektgrenzen zu öffnen. Vielmehr muss im Ordner Verweis des ProjektsHermann_Gitter ein Verweis auf die unter bin\Debug\ liegende Assembly Gitter_Servive.dll eingefügt werden (ein sogenannter Assembly-Verweis). Die Schritte imEinzelnen:


92


1. Rechtsklicken Sie im Projekt Hermann_Gitter auf Verweise.

2. Im Kontextmenü wählen Sie Verweis hinzufügen. Es öffnet sich eine Dialog-maske desselben Namens, in der Sie auf den Reiter Durchsuchen klicken.

3. Im Dateisystem »hangeln« Sie sich bis zum Ort der Assembly Gitter_Service.dllvor (C:\Projekte\Gitter_Service\bin\Debug; siehe Abbildung 4.11).

Abbildung 4.11 Auswahl der Assembly-Datei »Gitter_Service.dll« im Reiter »Durchsuchen« der Dialogmaske »Verweis hinzufügen«

4. Die Wahl der Assembly Gitter_Service.dll bestätigen Sie durch einen Klick aufden Button Ok.

Im Ordner Verweise des Projekts Hermann_Gitter wurde die Liste der Verweiseum den Verweis Gitter_Service erweitert (siehe Abbildung 4.12). Die gute Nach-richt: So und nicht anders soll es sein.

Die schlechte Nachricht lautet: Es fehlt noch eine Kleinigkeit. Zwar hat das Pro-jekt Hermann-Gitter zwischenzeitlich Kenntnis von der Existenz der AssemblyGitter_Service.dll erhalten – mehr aber auch nicht. Nichts und niemand hat der»Hauptklasse« Form1 den Gebrauch des Namensraums Gitter_Service »verord-net« – bis jetzt. Indem Sie in der Datei Form1.cs die Liste der using-Direktiven umdie Anweisung

using Gitter_Services;

ergänzen, beheben Sie nicht nur das Versäumnis, Sie schließen auch die Entwick-lungsarbeit an der Serviceklasse GS ab. Kehren wir also zum EventhandlertrackBar1_Scroll() der Klasse Form1 zurück.


93


Abbildung 4.12 Verweis auf den Namensraum »Gitter_Service« im Projekt »Hermann_Gitter«

TrackBar und TextBox sind derart synchronisiert, dass im Endergebnis der Posi-tionswert (0–12) des Reglers unter Stufe dargestellt wird. Der Positionswert istein int-Wert; TextBox-Ausgaben dagegen setzen das Format string voraus.Schon einmal hatten wir ein solches Problem mittels der Convert-Klasse gelöst.Konvertiert wird diesmal allerdings mit der Methode ToString(), der wir alsWert den Ausdruck trackBar1.Value übergeben:

textBox1.Text = Convert.ToString(trackBar1.Value);

Abschließend werden auch hier die Methoden für den Hintergrund und die Qua-drate aufgerufen. Fertig wäre der Eventhandler:

private void trackBar1_Scroll(object sender, EventArgs e){

index = trackBar1.Value/2;cindex = ground.combo(comboBox1.Text);textBox1.Text = Convert.ToString(trackBar1.Value);


}

Listing 4.9 Die Ereignisbehandlung hinter dem Schieberegler »trackBar1«


94


Ein weiterer Testlauf wird zeigen, dass TextBox, TrackBar sowie ComboBox tat-sächlich gekoppelt sind. Starten Sie die Anwendung. Skalieren Sie bei einem mitt-leren Alpha-Wert von 125 die Quadrate maximal (Stufe: 12). Das Ergebnis sehenSie in Abbildung 4.13.

Abbildung 4.13 Maximale Quadratfläche, minimale Streifenbreite. Die Punkte sind trotz verringertem Kontrast (Alpha-Wert = 125) zu erkennen.

4.3.6 Die Verhältnisse auf den Kopf gestellt – Umkehrung der Farben

Um die Farben umzukehren, erstellen Sie zunächst und notwendigerweise denEventhandler für button2, was sich übrigens auch manuell erledigen lässt. Das istallerdings ein wenig aufwendig, gehen Sie also wie gehabt vor: Zweifacher»Linksklick« auf das betreffende Control (button2), und die Klasse Form1 hat Zu-wachs in Gestalt einer weiteren Methode (button2_Click()) bekommen. TröstenSie sich: Danach ist Schluss.

Nach einem Klick auf die Schaltfläche Farbumkehr soll genau das geschehen, wasauf dem Button steht: Die Farben werden umgekehrt. Aus weißen Streifen wer-den schwarze, aus schwarzen Quadraten weiße. Mehr nicht. In diesem »Modus«soll weder die Skalierung der Quadratflächen durch die TrackBar möglich seinnoch eine Variation des Alpha-Werts in der ComboBox erfolgen. Die betreffen-den Elemente der Benutzeroberfläche (TrackBar, ComboBox, Editorfeld) stehendemnach nicht zur Verfügung, sollten also für die Dauer der Farbumkehr deakti-viert bzw. auf null gesetzt werden:


95


comboBox1.Enabled = false;trackBar1.Enabled = false;textBox1.Enabled = false;

Die Stellung des Schiebereglers (trackBar1) bei der Farbumkehr auf null zu set-zen, ist dank der Eigenschaft Value der Klasse TrackBar ein Kinderspiel:

trackBar1.Value = 0;

Ist der Schieberegler sozusagen auf dem Nullpunkt, sollte es der TextBox auchnicht besser gehen:

textBox1.Text = "0";

Um das geforderte Weiß der Quadrate zu realisieren, wird der volle cindex-sprich Alpha-Wert erwartet (anderenfalls würde auch das Weiß in ein Grau über-gehen):

cindex = 255;

Quadratflächen (somit auch die Streifenbreite) bleiben von der Farbumkehr un-berührt. Deshalb verwenden wir einen minimalen index-Wert:

index = 0;

Der Hintergrund des Hermann-Gitters soll schwarz sein, deshalb schreiben wir inbekannter Manier:

Background_Paint(Color.Black);

Zum Schluss werden die Quadrate gezeichnet – und diesmal sind sie weiß:

Gitter_Paint(index, cindex, Color.White);

Damit wäre die Ereignisbehandlungsroutine button2_Click() vollständig:


comboBox1.Enabled = false;trackBar1.Enabled = false;textBox1.Enabled = false;trackBar1.Value = 0;textBox1.Text = "0";



96


Background_Paint(Color.Black);Gitter_Paint(index, cindex, Color.White);

}

Listing 4.10 Implementierung der Farbumkehr im EventHandler »button2_Click()«

Abbildung 4.14 Farbumkehr bei kleinstmöglicher Quadratfläche. Schauen und beurteilen Sie selbst.

Mit der Implementierung der letzten Methode ist auch die Klasse Form1 vollstän-dig. Sie soll der Vollständigkeit halber noch einmal wiedergegeben werden:

using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Windows.Forms;using Hermann_Gitter;

namespace Hermann_Gitter{

public partial class Form1 : Form{


97


private int cindex;private int index;private GS ground = new GS();

public Form1(){

InitializeComponent();

}

private void Background_Paint(Color bc){

SolidBrush brush = new SolidBrush(bc);Graphics formG = this.CreateGraphics();formG.FillRectangle(brush, new Rectangle(26, 8, 298,320));brush.Dispose();formG.Dispose();

}

private void Gitter_Paint(int ind, int cin, Color co){

for (int i = 10; i <= 320; i = i + 27){

for (int j = 30; j <= 320; j = j + 27){

Color customColor = Color.FromArgb(cin, co);SolidBrush brush1 = newSolidBrush(customColor);Graphics formGraphics = this.CreateGraphics();formGraphics.FillRectangle(brush1, newRectangle(j, i, 15 + ind, 15 + ind));brush1.Dispose();formGraphics.Dispose();

}

}

}



98


comboBox1.Enabled = true;trackBar1.Enabled = true;button2.Enabled = true;textBox1.Enabled = true;




}

private void comboBox1_SelectedIndexChanged(objectsender, EventArgs e){

cindex = Convert.ToInt16(comboBox1.Text);index = (trackBar1.Value)/2;


}

private void trackBar1_Scroll(object sender, EventArgs e){

index = trackBar1.Value/2;cindex = ground.combo(comboBox1.Text);textBox1.Text = Convert.ToString(trackBar1.Value);


}


comboBox1.Enabled = false;trackBar1.Enabled = false;textBox1.Enabled = false;trackBar1.Value = 0;textBox1.Text = "0";



99

Hätten Sie’s gewusst? 4.4

Background_Paint(Color.Black);Gitter_Paint(index, cindex, Color.White);

}}

}

Listing 4.11 »Form1« – die um diverse Funktionalitäten erweiterte »Hauptklasse«

4.4 Hätten Sie’s gewusst?

Programmierer sind kreative Zeitgenossen. Im eher künstlerischen Sinne nochschöpferischer sind Webdesigner mit ihren hoch performanten Bildbearbeitungs-und Zeichenprogrammen, deren virtuoser Gebrauch mir schon so manchen be-wundernden Blick abgerungen hat.

Ein Vertreter der Zunft (der sich seit geraumer Zeit ganz eigene Gedanken zumHermann-Gitter macht) klopft Ihnen mit diebischem Ausdruck im Gesicht auf dieSchulter. Verdächtig höflich bittet er Sie, vor einem Computer Platz zu nehmen.Im Weiteren werden Sie aufgefordert, ein Bildbearbeitungsprogramm zu starten,mit dem Sie den Täuschungscharakter der Punkte des Hermann-Gitters beweisensollten. Quod erat demonstrandum.

Um welches Grafikprogramm es sich handelt, ist irrelevant. In beinahe jederWerkzeugleiste existiert nämlich ein Standardfeature, mit dem Sie den Beweissehr leicht führen können. Weitere Tipps würden unweigerlich zur richtigen Lö-sung führen, weswegen ich Sie zunächst sich selbst und Ihrem fruchtbaren Nach-denken überlasse.

Sie haben die Lösung bereits gefunden, stimmt’s? Dann auf zur zweiten und letz-ten Knobelei: Auch Punkte, die es nicht gibt, können zum Verschwinden ge-bracht, zumindest abgeschwächt werden. Die »Simulation« des Hermann-Gitters,bei der Größenverhältnisse und Farben sowie Farbkombinationen variiert wur-den, hat es zumindest ansatzweise gezeigt. Was wäre, wenn Sie plötzlich all dasnicht mehr dürften, aber dennoch die Punkte verschwinden sollen? Augen zuund durch? Der Sehapparat muss »eingeschaltet« bleiben. Die Variationen erfol-gen am Gitter.

Ihnen hier eine massive Hilfestellung zu verweigern, wäre unfair. Abgesehen da-von, dass es etliche Möglichkeiten zur Variation des »Urgitters« gibt, existierenauch mehrere Optionen zum Unterdrücken des berühmten Kontrasteffekts. Unsgeht es nur um eine, bei der


100


� erstens (außer der des Gitters) keine einzige Gerade mehr existiert (1.Tipp)und

� zweitens die Seiten der Quadrate durch eine elementare trigonometrischeFunktion ersetzt sind, die – 5 Zeichen lang – mit dem gleichen Buchstabenbeginnt wie sie endet (2.Tipp).

Ein letzter Tipp: Vielleicht schnuppern Sie gerne Meeresluft. Im Meer gibt es, malhoch, mal weniger hoch ...

Das sollte Ihnen genügen, um die verwaschenen grauen Flecken der ursprüngli-chen Täuschung zu neutralisieren – was zudem eine wunderbare Programmier-aufgabe wäre. Experimentieren Sie, auch wenn es knifflig anmutet! Die KlasseGraphics hält auch Methoden zur Darstellung unterschiedlicher Linien bereit (imGrunde war das der vierte Tipp).


343

Index

@-Zeichen 59

A

Accessormethode 164Add() 212, 215, 256, 262, 298Adresse 108, 135A-Eigenschaft 80Algorithmus 25, 109, 189, 240, 295Aliasnamensraum 164Alpha-Wert 76, 95Anchor-Eigenschaft 198AND-Operator 300Anwendung 134Application Manifest 341Application-Klasse 136, 173Arbeitsspeicher 24, 26Architektur 18ARGB-Farbe 77Argument 35Array 173, 175, 215Array-Klasse 311Assembly 91

Assemblierung 21Assembly-Manifest 22, 23Assembly-Metadaten 22Assembly-Name 23Assembly-Verweis 91AT

Advanced Technologie 44AT-System 43Auf-Ab-Steuerelement

NumericUpDown.Control 57Aufrufliste 37Aufrufparameter 311Ausführungsgeschwindigkeit 19, 25Automatische Speicherbereinigung

Garbage Collector 25

B

BackColor-Eigenschaft 150, 199, 243BackgroundImageLayout-Eigenschaft 164Base Class Library

BCL 15

base-Schlüsselwort 170Basisdatentyp 16Basisklasse 37, 155, 160, 244Basistyp 54BCL-Support

Base Class Library 17Bedienelement 27Bedienoberfläche 27, 244Benutzer 28Benutzereingabe 28Benutzerführung 276Benutzergebietsschema 23Benutzersteuerelement 328Berechtigung 22Betriebssystem 23, 34, 44Bezeichner 164Bibliothek 16Bilddatei 163Bildschirmfoto 129BindingNavigator 28BIOS 45

Basic Input/Output System 44Bitmap 22Block 32Blue-Eigenschaft 167Bold-Enumerationsmember 167Boolean 279Boolean-Struktur 301BorderStyle-Eigenschaft 206, 244break 312Brush-Klasse 116Brush-Objekt 168Button 21, 39, 51

Standardschaltfläche 28Bytecode 18

P-Code 17

C

C-Dialekt 18C# 31C#-Anweisung 18C#-Compiler 24, 38, 58C#-Derivat 30C#-Klasse 202


344

Index

C++ 31C_ò 29Canvas 21CheckBox 21, 39, 152

Bedingung 28CheckBox-Control 146CheckBox-Objekt 164Checked-Eigenschaft 152, 164CheckedListBox

Kontrollkästchen 28CL

BCL 15Class 290Click-Ereignis 274, 324Clientrechteck 150Client-Server-Kommunikation 21Close() 155, 174, 324CLR 14, 17, 23Codeedititor 329Color-Struktur 77, 114, 129, 167, 229ComboBox

Dropdown-Kombinationsfeld 28ComboBox-Aufgaben 149ComboBox-Control 108, 145ComboBox-Klasse 84COM-Interoperabilität 17COM-Komponente 29Common Language Runtime 22, 25CompareTo() 301Compiler 18, 31, 38, 49, 89Compiler-Direktive 33Component Object Model

COM 29Computer 42Container 196ContentAlignment-Enumeration 207ContextMenu-Steuerelement 28ContextMenuStrip

Kontextmenü 28Control 78, 82, 106, 167, 328

Steuerelement 27Control-Klasse 166, 244Convert-Klasse 93, 125, 160, 254Copy and Paste 198CopyTo() 311Count-Eigenschaft 263CPU

Prozessor 18CreateGraphics() 118, 166

CSC-Compiler 33C-Sharp

C# 13Cursor 39

D

DataGridDataGrid-Steuerelement 28

DataGridViewTabellendaten 28

Datei 22Dateiname 253, 331Dateinamenextension 271Dateioperation 153Dateisystem 23, 153, 196, 242, 247, 331Dateityp 336Daten 21, 28, 128, 155, 166Datenbank 289Datenbankersatz 153Datenbankverbindung 24, 337Datenelement 202Datenhaltung 153Datenquelle 21, 28Datenstruktur 38DateTime-Objekt 159DateTimePicker 28, 51DateTime-Struktur 53, 159, 161Debug 153, 321Debugger 31, 59, 185Debugging 55Default-Wert 51Deklaration 32, 36, 135, 217Delay-Befehl 134DelayTime 108Delegate 32, 35, 36, 108, 123,

135, 138Delegatentyp 37, 38Delegate-Objekt 127Delegate-Objekt tst 124Delegate-Schlüsselwort 38Delphi 31Derivat 30Designentwurf 152Designer 338Destruktor 24Dictionary 201, 216, 217Dictionary(TKey, TValue)-Klasse 211, 291Dictionary(TKey, TValue)-Objekt 213


345

Index

die TapePages-Eigenschaft 148Dijkstra-Algorithmus 189Dispose() 114, 271DllMain 22Dock-Eigenschaft 198DockStyle-Enumeration 198DoEvents() 136, 173DomainUpDown

Textzeichenfolge 28do-while-Ablaufsteuerung 266do-while-Anweisung 280Drag&Drop 50, 197Drawing 108DrawLine() 116DrawLines() 183DrawRectangle() 167DrawString() 168Drehfeld 149, 272

NumericUpDown-Steuerelement 254Dropdown-Listenfeld 39, 122, 242, 243,

315Dropdownlistenfeld 339Dualsystem 42Dynamic Link Library

DLL 16

E

Echtzeit 44Echtzeitbedingung

Echtzeitsystem 25Echtzeitsystem 26Editor 31Editorbereich 336Eigenschaft 32, 50, 87, 114, 128, 164,

202, 203, 220Eigenschaften-Fenster 201, 243Einsprungspunkt 23Einstiegspunkt 22, 88, 146Einzeldatei-Assembly 23

Single-File-Assembly 22Element 18, 28, 37Elementartyp 76Enabled-Eigenschaft 74, 245EncoderFallbackException 155Entwicklungsumgebung 31, 88, 111, 198Entwurfsmodus 106, 196Environment-Klasse 136Equals() 263

Ereignis 32, 38, 59Ereignisbehandlung 39, 283Ereignisbehandlungsmethode 122, 128Ereignisbehandlungsroutine 52Ereignishandler 86, 166Escape-Sequenz 59Escapesequenz 257Event

Ereignis 39EventHandler

Ereignisbehandlungsroutine 39EventHandler-Delegate 128EventHandling 52EventSink 39Exception 155

F

Feld 32, 203, 220Fensterstil 243Festplatte 146FillEllipse() 115FixedSingle 244FixedSingle-Enumerationsmember 207float-Variable 159FlowLayoutPanel 28FontFamily-Klasse 168Font-Klasse 168Font-Objekt 168FontStyle-Enumeration 167for-Anweisung 185, 271, 278foreach-Anweisung 216, 218, 228, 262ForeColor 108ForeColor-Eigenschaft 148, 207Form 37Form_Klasse 150Format 331FormatException 89Formatierung 197FormBorderStyle-Eigenschaft 106Formelement 50, 74, 113Form-Klasse 146, 160, 164, 244Formular 28, 34, 52, 146, 147for-Schleife 81, 176, 256, 298Framework 29

.NET-Framework 13, 155Frequenzgeber 44FromArgb() 119FromFile() 257, 271


346

Index

FTP-Server 339Funktionszeiger 36

Delegate 35

G

Garbage Collector 25, 26, 35, 44Speicherbereinigung 24

GDIGraphics Device Interface 77

GDI+ 113GDI+-Zeichnungsoberfläche 77Generationszahl 27Generic 201, 217get 202Gleitkommazahl 160global-Schlüsselwort 164Grafik-Framework 328Graph 189Graphentheorie 190Graphic Device Interface

GDI 113Graphics-Klasse 77, 166Graphics-Objekt 113, 126, 167Graphics-Zeichenoberfläche 113, 129,

138Graphics-Zeichenobjekt 118, 134GroupBox 28, 198GroupBox-Control 148GroupBox-Steuerelement 246, 250GUI

Graphical User Interface 51Gültigkeitsbereich 24

H

HandlerEreignisbehandlungsroutine 39

Hardwaretreiber 29Hardware-Uhr

Echtzeit-Uhr 44Hash Map 211Hash Table 211Hashalgorithmus 211Hashtabelle 211Hashverfahren 211Hauptmenü 45Hauptplatine 44Heap 290

Hintergrundbild 146Hochsprache 31HotTrack 199Hour-Eigenschaft 53HScrollBar

Elementliste 28

I

IBMInternational Business Maschines 43

Icomparable-Schnittstelle 301IDE

Integrated Development Environment 336Integrierte Entwicklungsumgebung 33

if-Anweisung 164if-else-Struktur 89, 124, 292IL-Code 18ImageButton 39Image-Eigenschaft 247, 257, 271Image-Klasse 257ImageLayout-Enumeration 164Index 176, 181, 214Indexer 32Indexposition 181, 223Infrastruktur 148Initialisierung 59, 61, 154, 160Initialisierungsmethode 50, 110InitializeComponent() 152, 160Inkrement 127Insert() 223, 261Installationsverzeichnis 16Instanz 24, 36, 38, 86, 109, 128, 155, 300Instanzkonstruktor 32Instanzmethode 35, 38int-Array 176Interface 21, 32, 49, 128, 328Intermediate Language

IL 17Internationales Zeichencodierungssystem

Unicode 30Internet 143Interpreter 18Interrup 44Interruptroutine 44Interval-Eigenschaft 55int-Typ 262, 291IO

Input/Output 153


347

Index

IO-FunktionInput/Output 16

ISO 9660 331ISO Datei 331

ISO Image 330ISO-Abbild 331Iteration 223

J

Java 31Java-Anwendung 328JIT-Compiler

Just-In-Time-Compiler 19Jitter

Just-In-Time-Compiler 19

K

Kanten 189keine Escapesequenz 175Klasse 20, 21, 24, 32, 33, 36, 39, 87, 289

Programmelement 18Klassenbibliothek 14, 16, 327Klassendatei 111, 135, 146, 163, 297, 338Klassenimplementierung 49Klassenmember 128Klassenobjekt 89, 213, 290Klassenrumpf 87, 88Knoten 189Kommandozeile 34, 192Kompilat 20Kompilierung 18Komplexer Datentyp 33Konsole 328Konsolenanwendung 328Konsolenausgabe 295Konstruktor 24, 59, 88, 108, 135, 152,

154, 159, 203, 212, 260, 311Kontrollstruktur 312Konvertierung 124, 160Kultur

Länderspezifische Festlegungen 23

L

Label 28, 51Label-Control 148Label-Klasse 254

Label-Objekt 161Label-Steuerelement 196, 252Laufindex 185Laufvariable 77, 121Laufzeit 16, 18, 19, 25, 31, 36, 150, 196,

198Laufzeitbedingung 59Laufzeitumgebung 17, 18, 22, 29, 33Leerstring 64, 89, 138, 279, 309Leseeigenschaft 202Lesezugriff 21, 218LinearGradientBrush-Klasse 114LinearGradientMode-Enumeration 114LinkLabel

Hyperlink 28Linux 44List(T)-Klasse 213, 256, 261, 263, 291ListBox 21

Liste 28Liste 28, 161, 242List-Klasse 218, 223ListView

Windows Explorer 28Literal 271Location 151Location-Eigenschaft 257, 271, 274

M

Main 22Main() 88, 146, 156, 173Mainboard

Hauptplatine 44Maschinenbefehl

Native Code 18Maschinencode 18, 29MaskedTextBox

Format 28Mauscursor 147Maxima-Eigenschaft 75MaximizeBox 146MaximizeBox-Eigenschaft 74, 106MC C#

Multiprodessor C# 30Mehrfachdatei-Assembly 23

Multi-File-Assembly 23Member 148Menü 330Menüleiste 336


348

Index

menuStrip 50MenuStrip-Control 107Metadaten 331

Informationsdaten 18Metaphor 30Methode 20, 32, 35, 38, 128Methodenaufruf 108Methodenkopf 311Methodenrump 36MFC

Microsoft Foundation Classes 328Microprozessor 43Microsoft Intermediate Language

MSIL 17Minimalprogramm 44MinimizeBox 146Modul 23, 49Modula 2 31MulticastDelegate 37Multitasking-System 134

N

Name-Eigenschaft 198Namensraum 20, 21, 22, 38, 164

Namespace 20Namespace 87Namespace-Aliasqualifizierer 164Native Code 18

Maschinencode 20.NET 17, 22, 29.NET Framework Class Library

FCL 15.NET-Bibliothek 37.NET-Framework 16, 17, 18, 27, 31, 32,

113, 146, 290, 301, 328.NET-Framework-Anwendung 21, 23.NET-Framework-Klassenbibliothek 155.NET-Klassenbibliothek 36NET-Framework-Klassenbibliothek 203.NET-Komponente 29.NET-Laufzeitumgebung 24, 33.NET-Plattform 29.NET-Sprache 11, 17, 23.NET-System 31.NET

.NET-Technologie 13Netzwerkfunktion 16new-Operator 38

Next() 126, 320None-Enummerationsmember 209Now-Eigenschaft 53, 159Nullverweis 220NumericUpDow-Control 254NumericUpDown 51NumericUpDown-Control

Drehfeld 145NumericUpDown-Klasse 57, 154, 254

O

O(1)-Operation 211Object-Klasse 154Objekt 11, 24, 26, 108, 154, 211Objekterzeugung 108, 212Objektreferenz 24Objektvariable 24, 114, 135OnClick-Ereignis 274Onlineinstallation 330OnPaint() 166, 167Opacity-Eigenschaft 146, 161Operator 32, 164Orientation-Eigenschaft 75OS2 44override-Schlüsselwort 166

P

Paint-Ereignis 166PaintEvent 166PaintEventArgs-Klasse 166, 167PaintEventArgs-Typ 166Panel 50

Registerkarte 145Parameter 35, 39, 74, 114, 156, 159, 166,

277, 290Paramter 311partial-Schlüsselwort 49P-Code 18PDA

Personal Digital Assistant 328Pen-Klasse 116, 167Permutation 294Permutationselement 295Personal Computer 44Pfad 59, 154Physikalischer Prozessor 18PictureBox-Control 113


349

Index

PictureBox-Klasse 274PictureBox-Steuerelement 243, 252Plattformabhängigkeit 19Point-Struktur 182, 257, 271Polyphonic C# 30private-Feld 202Programmcode 17Programmiermodell 14Programmiersprache 17, 20Projekordner 337Projektmappe 146, 242, 337Projektmappen-Explorer 33, 50, 91, 105,

150, 337Prozess 134Prozessor 17Prozess-Scheduling

Zeitplanerstellung 45Punktoperator 21, 57, 300

Q

Qualifizierung 58Quellcode 20Quellcode-Verwaltungssystem 328

R

RadioButton 39, 46, 51, 198, 247RadioButton-Control 145RadioButton-Klasse 152RadioButton-Objekt 152Random 109Random-Klasse 119, 180, 260, 265, 276,

280Rautezeichen 30ReadToEnd() 174Real-Time-System

Echtzeitsystem 25Rechenleistung 26, 44Rectangle() 80, 114Rectangle-Struktur 78, 113Referenz 24, 35, 39Referenztyp 220, 289, 308Reflection API 18Reflection-API 16Regex-Klasse 174Registerkarte 145, 151, 196Regular-Enumerationsmember 168Remote-Debugging 328

Remoting 17Resources-Klasse 163Ressource 22, 24, 79, 164, 174, 289Ressourcendatei 22, 162, 328Ressourceneditor 328RTC

Real Time Clock 44Rückgabewert 308Runtime Environment 17

JRE 15Laufzeitumgebung 14

RW-Medium 331

S

Schaltfläche 46Schieberegler 95Schlüssel 211Schlüssel-Wert-Paar 291Schlüsselwort 32Schnittstelle

Interface 301Schreibeigenschaft 202Schreibgeschwindigkeit 332Schriftartenfamilie

Schrifthöhe 168SelectedIndex-Eigenschaft 152sender 39set 202Show() 156Sicherheitskonfiguration 17Sichtbarkeit 36, 76, 135Signatur 36, 159Sing# 30Size-Eigenschaft 200Sleep() 134Smaltalk 31Softwareplattform 14Software-Uhr 44, 53SolidBrush-Klasse 77, 167Sort() 311SoundPlayer-Klasse 58Spec# 30Speicher 24, 289Speicherbereich 33Speicherbereinigung 25, 26Speicherlecks

Memory Leak 25Speicherressource 26, 78, 183


350

Index

Speichersegment 25Speicherstelle 24Speicherüberlauf 43Speicherverwaltung 26Split() 174SQL

Datenbankabfragesprache 31Stack 290Stackverwaltung 290Stammverzeichnis 146, 162, 163, 202,

243Standardanwendungstyp 47Standardkonstruktor 135, 276, 286, 290

Konstruktor 89Standardsysmbolleiste 336Starker Name 23Startleiste 42Steuerelement 50, 73, 156, 166, 244, 339

Control 39Steuerelementklasse 244, 274StopTimer 108Stream 154, 155StreamReader-Klasse 174StreamWriter-Klasse 154StreamWriter-Objekt 154Stretch 164Streuwerttabelle 211string-Array 174, 286, 295, 298, 307, 311string-Element 298string-Format 254String-Klasse 174, 176string-Variable 154, 202, 265struct 290struct-Objekt 290Struktur 20, 32, 33, 49, 289Strukturvorlage 290Submenü 45Substring() 161System 38System.Sounds-Klasse 59Systemfarbe 167SystemSound-Klasse 59Systemzeit 44, 62Systemzeitgeber 136

T

TabControl-Klasse 148Tabelle 211

TableLayoutPanel 196TableLayoutPanel-Aufgaben-Menü 197TableLayoutPanel-Container

TableLayoutPanel 196TableLayoutPanel-Steuerelement 148TabPage-Klasse 148Taktgeber 44Taktsignal 44TapControl-Steuerelement 147Tape-Pages-Auflistungs-Editor 148Teilzeichenfolge 176TextAlign-Eigenschaft 200, 207TextBox 21, 196TextBox-Control 108, 228Textdatei 154Text-Eigenschaft 54, 62, 200Textfeld 39TextWriter-Klasse 155Textzeichenfolge 168this 53, 290this-Schlüsselwort 160Thread

Selbstständige Ausführungseinheit 26Threading 17Thread-Klasse 134TickCount-Eigenschaft 136Tick-Ereignis 128Timer 55Timer-Chip 44Timer-Klasse

Timer 56ToInt16() 125, 160Toolbox 50, 51, 147, 196, 246ToString() 154, 161, 255TrackBar-Control

Schieberegler 75TrackBar-Steuerelement 86Turbo Pascal 31Typ 18, 21, 22, 35, 38Typdeklaration 49Typimplementierung 49Typsicherheit 36Typverletzung 31

U

Überladungsliste 61UML

Modellierungssprache 20


351

Index

unsafe 33C#-Modifizierer 32

unsafe-Anweisung 32Unsicherer Code 32Unsicherer Kontext 32Unterarray 181, 286, 308, 322using-Direktive 49, 59, 112, 153, 286UTF-8 154

V

ValueChanged-Ereignis 254Value-Eigenschaft 57Values-Eigenschaft 216Variable 20Vererbungshierachie 37Vergleichsmethode 301Versionsnummer 23Verteilte Systeme 44Verweis 18, 22, 24, 87, 88, 92, 337Virtuelle Festplatte 334Virtuelle Maschine 14Visible-Eigenschaft 156Visual Basic.NET 17Visualisierung 144void 153von Array-Grenze 33Vorlage 162Vorlagen 87VScrollBar

Elementliste 28

W

WAV-Datei 58Web Installer 330Webanwendung 16Web-Applikation 34, 39Webpublishing-Assistent 339Webservice 16Website 339

Webapplikation 27Wert 211Wert-Schlüssel-Paar 212Werttyp 257, 280, 301while-do-until 188while-Schleife 121, 136, 173, 223, 300,

301, 312Width-Eigenschaft 179

Window 199Windows 44Windows Explorer 50, 337Windows Forms-Anwendung 47, 196Windows Presentation Foundation 21Windows-Applikation 34Windows-Drehfeld

NumericUpDown-Control 57WindowsForm 74, 107, 113, 144, 160,

196WindowsForm -Steuerelement 166WindowsForms-Anwendung 105, 136,

146, 241, 327Windows-Forms-Steuerelement 27WindowsForms-Steuerelement 21, 78Windows-Meldung 136, 173Windows-Startleiste

Startleiste 44Windows-Steuerelement 21WinForm 328WinMain 22World Wide Web 37WPF

Windows Presentation Foundation 328WPF-Anwendung 328Write() 154

X

XAMLExtensible Application Markup Langu-

age 328XC#

eXtensible C# 30Xetra

Exchange Elektronic Trading 143XML 328

Markup-Sprache 20XML-Datei 342

Z

Zähler 44Zeichen 154Zeichenbereich 114Zeichenfolge 174, 291Zeichenfolgedarstellung 154Zeichenfolgeliteral 175, 257Zeichenfolgen-Editor 75, 108, 149


352

Index

Zeichenfolgenliteral 59, 310Zeichenlogik 166Zeichennoberfläche 166Zeichenoberfläche 179Zeiger 32

Pointer 31

Zeigertyp 34Zielobjekt 35Zugriffsmodifizierer 178Zwischencode

IL-Code 18


Documents

Coding for Fun mit C# - s3-eu-west-1.amazonaws.com · Uwe Klappert Coding For Fun mit C# 1484.book Seite 1 Montag, 7. Juni 2010 12:21 12