C# Programmieren für Einsteiger: das fundierte und praxisrelevante Handbuch

Table of contents :
Titelblatt
Inhaltsverzeichnis
Kostenloses E-Book
1 Vorwort – Über das Programmieren mit C#
2 Das Studio für Ihre Komposition
2.1 Microsoft Visual Studio
2.2 Die Entwicklungsumgebung – Erste Schritte
3 Hello World – Das erste Programm
3.1 Debuggen starten
3.2 Projektdateien und Verzeichnisse
3.3 Die Syntax
3.4 Fehlerliste // Codefehler
4 Elementare Strukturelemente
4.1 Datentypen
4.2 Operatoren
4.3 Variablen
4.4 Arrays
4.5 Strings
4.6 System.Console.Read & Write
4.7 Verzweigungen
4.8 Schleifen
4.9 Funktionen / Methoden
5 Objektorientiertes Programmieren | 5.1 Klassen // class
5.2 Objekte, Methoden, Felder
5.3 public & private
5.4 Konstruktor
5.5 Eigenschaften // get; set;
5.6 Vererbung
5.7 Listen
5.7 Fortgeschrittene Projektstruktur
Bonus 1 – Fortgeschrittene Übung | Minesweeper
Bonus 2 – Tipps und Tricks
Abbildungsverzeichnis
Quellenverzeichnis
Buchempfehlung

Citation preview

C# Programmieren für Einsteiger Das fundierte und praxisrelevante Handbuch Wie Sie als Anfänger Programmieren lernen und schnell zum C#-Experten werden

Bonus: Übungen inkl. Lösungen

1. Auflage 2021 Copyright © Adrian Rechsteiner Alle Rechte vorbehalten.

A | S Verlag

Inhaltsverzeichnis Kostenloses E-Book........................................................... 5 1 Vorwort – Über das Programmieren mit C# .................. 6 1.1 Programmieren als logischer Entwicklungsschritt der Menschheit .................................................................. 10 1.2 Die Einsatz- & Nutzungsbereiche von C# ..................... 13 1.3 Sprachen im Überblick .................................................. 13 Gemeinsamkeiten ............................................................ 14 Unterschiede .................................................................... 14 .NET und C# - Ein erstes Fazit ........................................ 15

2 Das Studio für Ihre Komposition ................................. 17 Einschub: Dateiendungen ................................................ 18

2.1 Microsoft Visual Studio ................................................. 19 2.2 Die Entwicklungsumgebung – Erste Schritte ................ 23

3 Hello World – Das erste Programm ............................. 25 3.1 Debuggen starten ......................................................... 27 3.2 Projektdateien und Verzeichnisse ................................ 30 3.3 Die Syntax .................................................................... 33 3.4 Fehlerliste // Codefehler .......................................... 38

4 Elementare Strukturelemente....................................... 40 Kommentare

/*geben die Möglichkeit für Hinweise*/ ... 42

4.1 Datentypen ................................................................... 43 Das Binärsystem .............................................................. 44 Die .NET Datentypen ....................................................... 47 Das Hexadezimalsystem ................................................. 56 Suffix ................................................................................ 57

2

4.2 Operatoren .................................................................... 58 Rechnungsoperatoren ..................................................... 58 Vergleichsoperatoren ....................................................... 59 Boolesche Operatoren ..................................................... 60

4.3 Variablen ....................................................................... 63 4.4 Arrays ........................................................................... 66 Eindimensional ................................................................. 67 Mehrdimensional .............................................................. 69

4.5 Strings ........................................................................... 71 4.6 System.Console.Read & Write ..................................... 72 Ausgabe – Methoden ....................................................... 72 Eingabe – Methoden ........................................................ 75 Exception Handling .......................................................... 79

4.7 Verzweigungen ............................................................. 82 if - Verzweigungen ........................................................... 82 Beispiel 1 // Überprüfen einer ganzen Zahl ................ 84 Beispiel 2 // Passworteingabe ..................................... 87 switch - Verzweigung ....................................................... 89 Übung 1 // Mögliche Nenner einer Zahl .................... 90

4.8 Schleifen ....................................................................... 97 for - Schleifen ................................................................... 97 Beispiel 3 // 7 Schleifendurchläufe ............................. 98 Übung 2 // Fakultät einer Zahl ............................... 100 continue, break, return // Kontrollstrukturen................ 103 while - Schleifen ............................................................. 106 do - while - Schleifen ...................................................... 107 Übung 3 // Arrays und Schleifen ............................. 108 foreach – Schleifen ........................................................ 111

4.9 Funktionen / Methoden ............................................... 112 Beispiel 4 Beispiel 5

// Verwendung von Methoden .................. 113 // Übergabe mit Referenz ........................ 116 3

5 Objektorientiertes Programmieren ............................ 119 5.1 Klassen // class .................................................... 119 5.2 Objekte, Methoden, Felder ......................................... 120 Felder ............................................................................. 121 Methoden ....................................................................... 122 Overloads ....................................................................... 122

5.3 public & private ........................................................... 123 Namenskonventionen .................................................... 123

5.4 Konstruktor ................................................................. 124 5.5 Eigenschaften // get; set; ....................................... 127 5.6 Vererbung ................................................................... 132 5.7 Listen // List .......................................................... 134 5.7 Fortgeschrittene Projektstruktur .................................. 137 Übung 4 // Anlegen einer Bestellliste ........................... 140 Aufgabenstellung ........................................................... 140 Musterlösung ................................................................. 144

Bonus 1 – Fortgeschrittene Übung............................... 163 Minesweeper .................................................................... 163 Aufgabenstellung ........................................................... 163 Musterlösung ................................................................. 170

Bonus 2 – Tipps und Tricks........................................... 198 Debugging Tools ............................................................... 198 Einfach den Überblick behalten ........................................ 204

Abbildungsverzeichnis .................................................. 205 Quellenverzeichnis ......................................................... 209 Buchempfehlung ............................................................ 211

4

Kostenloses E-Book Vielen Dank für den Kauf des Taschenbuchs! Damit Sie sich die Inhalte noch leichter aneignen können, schicke ich Ihnen gerne kostenlos das Buch als E-Book im PDF-Format zu. Schreiben Sie mir hierzu eine E-Mail an [email protected] mit dem Betreff: kostenloses E-Book: „C# für Einsteiger“ und schicken Sie mir in der E-Mail Ihre Kaufbestätigung / die Rechnung / ein Foto von Ihrem Taschenbuch zu. Danach werde ich Ihnen innerhalb von 48 Stunden das E-Book per E-Mail zusenden. Ich wünsche Ihnen viel Erfolg bei Ihrem nächsten IT-Projekt! Adrian Rechsteiner

5

1 Vorwort – Über das Programmieren mit C# Der Titel „C# Programmieren für Einsteiger“ sagt bereits zuallererst, dass dieses Buch für Personen geeignet sein soll, die sich

erstmals

mit

dem

Schreiben

von

Programmen

auseinandersetzen möchten. „Einstieg“ heißt gleichzeitig, dass der Umgang mit einem Computer und das Bedienen von diversen Programmen für den Eigennutz bereits stattgefunden hat. Mit dieser Grundlage werden Sie an der Hand genommen und können vor allem das „Wie?“ im Kontext „Programme“ durchleuchten. Davor sollten die wichtigen Begriffe, die stets im Umgang mit Computern und Programmen fallen, vorweggenommen und zumindest oberflächlich erläutert werden. Das, was den Programmen Leben einhaucht ist die Hardware.

Der Personal Computer, kurz ‚PC‘, umfasst stets ähnliche Komponenten, die real und fassbar sind. Auf Grund dieser Eigenschaft sind sie unter dem genannten Begriff zusammengefasst worden. Dazu gehört z.B. der Hauptverantwortliche namens

Prozessor.

Die einzelnen Hardware Komponenten sind durchaus

vergleichbar 6

mit

bestimmten

biologischen Organen. Der Prozessor stellt gleichzeitig das Herz und das mathematische Gehirn dar, das mit einer bestimmten Frequenz den Aufgabenstapel abarbeitet. Im Englischen hat er daher den Namen Central Processing Unit, kurz CPU, erhalten. Maßgeblich für die Rechenleistung ist nicht nur die maximale Taktfrequenz, sondern auch die Anzahl der Recheneinheiten, den sogenannten Kernen. Nicht jedes Programm unterstützt das Verwenden von mehreren Kernen, denn dieses Verhalten muss ganz bewusst im Quellcode eines

Programms

verankert

werden.

Die

Sinnhaftigkeit der Kernanzahl ist auch dadurch begrenzt, dass es stets eine bestimmte Anzahl von Vorgängen gibt, die zeitgleich stattfinden können. So wie beim Herz kann um Energie zu sparen und die Lebensdauer der Komponenten zu erhöhen die Frequenz gedrosselt werden, falls die

Situation

es

zulässt.

In

enger

Zusammenarbeit steht der Prozessor mit dem Arbeitsspeicher. Dieser ist das Kurzzeitgedächtnis des PCs. Er hat

7

im

Englischen

den

Namen

Random - Access Memory, kurz RAM. Dessen großer

Vorteil

ist

die

hohe

Kommunikationsgeschwindigkeit,

mögliche

nämlich

die

Geschwindigkeit der CPU. Als Nachteil kann betrachtet werden, dass die gespeicherten Informationen verloren gehen, wenn

der

Stromfluss

Hardware - Komponente

zu

dieser

wegfällt.

Beim

Energiesparmodus eines Computers muss daher der Arbeitsspeicher angeschaltet bleiben, was allerdings ein sehr schnelles Wiederhochfahren ermöglicht,

denn das Betriebssystem oder

geöffnete Programme sind sozusagen bereits „im Arbeitsspeicher“. Damit

der

Arbeitsspeicher

überhaupt

mit

Informationen gefüllt werden kann, wird ein fester Speicher, also das Langzeitgedächtnis, benötigt. In der Regel ist das die Festplatte.

Die Bauweise, die sehr lange den Markt eingenommen hat, ist die HDD (Hard Disk Drive) gewesen, welche nun meist von der deutlich schnelleren Solid State Disk (SSD) abgelöst wird. Wird keine schnelle Festplatte benötigt ist die nun

8

günstigere HDD nach wie vor ein hervorragendes Mittel um viele Daten abzulegen. Zu den gespeicherten Inhalten gehört natürlich auch das Betriebssystem,

welches

nach

dem

Starten

des

Computers das erste aufgerufene interaktive Programm ist. Dabei ist die SSD ganz klar als Speichermedium zu empfehlen, da so das Hochfahren sehr schnell von statten gehen kann. Es hat eine Grafische Benutzeroberfläche, was auf Englisch ‚Graphical User Interface‘ (GUI)

heißt. Bekannt sind im Umgang mit PCs „Windows“, „MacOS“ und „Linux“. Solche und alle weiteren

funktionellen

Speichermedien werden Software

genannt.

9

abgelegt

Inhalte werden

die

auf

können,

1.1 Programmieren als logischer Entwicklungsschritt der Menschheit ‚Ja natürlich!‘ denken Sie sich jetzt. Gemeint ist in diesem Fall der Bezug zu programmierähnlichen Denkweisen, die der Mensch schon lange in solcher Art und Weise zu seinem Vorteil nutzt. Ein hervorragendes Beispiel stellt die Dressur von Wölfen dar. Die Fähigkeit durch eine Kommunikation der nicht - eigenen Sprache das Gegenüber zur Kooperation zu bewegen ist ein Ausdruck fortgeschrittener Intelligenz. Es gibt in der Natur zwar oft eine Lebensgemeinschaft zwischen verschiedenen Arten, jedoch sind diese lediglich intuitiv. Das Zusammenleben von Menschen

und

Hunden

hingegen,

ist

durch

ein

Actio- / Reactio - Verständnis des Dressierenden entstanden. Der Mensch weiß, dass das eigene Verhalten in verschiedenen Situationen ebenfalls verschieden ist. Dabei handelt es sich um einen logischen Zusammenhang, welcher in diesem Beispiel in erster Linie das Fressverhalten thematisiert. Der Wolf stellt als Feind eine große Gefahr dar. Zwar kann er überwältigt und in die Flucht geschlagen werden, jedoch hätte er als Freund sogar einen Nutzen. Dazu gehören die Verteidigung und Alarmierung der Gruppe oder die überlegene / nützliche Nase. Mit der Erkenntnis, dass Wölfe eine Begegnung an manchen Tagen meiden und an hungrigen Tagen ans Überleben zu denken 10

scheinen, ist die Idee entstanden dem Wolf gelegentlich einen Knochen zuzuwerfen. Es ist dann nur eine Frage der Zeit gewesen, bis manche schlauen Wölfe ebenfalls den eigenen Vorteil darin erkannt haben, sich mit den Menschen zu verbünden. Die gezielte Züchtung bestimmter Rassen ist ein weiterer

Schritt

der

Programmierung,

da

so

bestimmte

erwünschte Merkmale, wie Zutraulichkeit, verstärkt und isoliert werden können. Die Hunde können nun optimal ganz vielen Zwecken dienen, ob als Jagd-, Hüte- oder Gesellschaftshund. Für warmes, kaltes oder mildes Klima. Dieses Beispiel, welches nur eines von vielen ist, zeigt: Auch Sie, sofern Sie noch kein Informatikprofi sind, verstehen also schon was es heißt zu Programmieren. Es ist etwas das sehr an die Gesetze der Logik gebunden ist. Es handelt sich um ein Prozessdenken, welches durch logische Zusammenhänge abgesichert werden kann. Allerdings ist dazu vorher die Erfindung des Computers, wie wir ihn kennen, notwendig. Die Person, die an dieser Stelle genannt werden soll ist Alan Turing, welcher diesen flexiblen Rechner und dessen Fähigkeiten schon vor der tatsächlichen Erfindung vorhergesagt und entworfen hat. Dabei spricht er von der „universellen Turing - Maschine“, welche dank diverser Programme etliche Probleme lösen kann. Dies sei möglich, durch das Konzept von Hardware, Software und der Speicherprogrammierung. Seine Idee ist in den Jahren 1945 bis 1950 im „National Physical 11

Laboratory“ in London Wirklichkeit geworden. Dort hat er den „Automatic Computing Engine“ („ACE“) gebaut, die reale Turing - Maschine. Darüber hinaus hat er die Frage, ob solche Maschinen eigenständig denken und tatsächliche Intelligenz besitzen können, formuliert und dafür den „Turing - Test“ entworfen. Dabei wird lediglich geprüft, ob ein Proband bei einer testweisen Chatprogrammunterhaltung in der Lage ist zu unterscheiden, ob der Gesprächspartner Computer oder Mensch sitzt. [1] Nun im Jahr 2021, dem digitalen Zeitalter, ermöglicht uns die Fähigkeit des Programmierens und die Unterstützung des Computers komplett neue Lebensweisen. Digitalisierung heißt, dass Vorgänge auf Maschinencode übersetzt werden. Aus einer komplexen Anforderung werden unzählige Nullen und Einsen, welche jedoch von der elektronischen Hardware verstanden werden. ‚Unter Strom oder nicht unter Strom?‘, ist also die moderne Frage unserer Zeit. Schon die ersten Computer haben enormen Komfort bereitet, das menschliche Gehirn ist in vielen Bereichen entlastet worden. In der Freizeit entstehen unzählige Möglichkeiten der digitalen Unterhaltung. Die Tatsache, dass alles nur eine Frage der Rechenleistung ist, beschleunigt den Fortschritt ungemein. Die Kooperation mit

der

Natur

hat

Grenzen,

Digitalisierung

womöglich nur durch die verfügbaren Ressourcen.

12

1.2 Die Einsatz- & Nutzungsbereiche von C# C# ist eine universell einsetzbare Sprache. Es spielt also keine Rolle, ob sie für Spiele-, Web- oder App – Anwendungen verwendet wird. Allerdings wird C# von dem Unternehmen Microsoft entwickelt und wird daher primär beim Betriebssystem Windows

eingesetzt.

Die

Implementierung

in

anderen

Plattformen (Linux, MacOS, Android) wird dennoch weiter vorangetrieben. Auf Grund der Plattformunabhängigkeit ist die Sprache folglich, besonders aber in Kombination mit der Windowsumgebung, für diverse Anwendungen immer in der engeren Auswahl.

1.3 Sprachen im Überblick Neben C# gibt es viele diverse andere Programmiersprachen. Nennenswert sind z.B.: BASIC, C, C++, Java, Javascript, Python, Swift, Delphi. Genauer sollen diese hier nicht betrachtet werden. Allgemein muss jedoch gesagt werden, dass die Gemeinsamkeiten bei der Programmierung eine stärkere Gewichtung haben als die Unterschiede, denn alle Programme werden letztendlich durch sehr ähnliche Hardware – Komponenten umgesetzt. 13

Gemeinsamkeiten So haben Programmiersprachen z.B. einen Sprachkern und eine Standardbibliothek. Darin gibt es eine Auswahl an Funktionen, es ist auch die Rede von Methoden. Es werden Variablen benutzt, welche deklariert, verarbeitet und überprüft werden können. In der Komplexität können Programme dann z.B. durch Schleifen oder Entscheidungen erhöht werden. Sofern der Rechner das Programm ausführen soll, so muss es kompiliert, d.h. in Maschinensprache übersetzt werden. Dazu braucht jede Sprache einen eigenen Kompilierer (eng.: Compiler). Die Syntax selbst verwendet grundsätzlich englische Wörter. Es ist sehr vorteilhaft,

wenn

Englisch

zu

den

persönlichen

Sprachkompetenzen gehört. Als Begleiterscheinung des Fortschritts wird Software stets weiterentwickelt.

Das

betrifft

nicht

nur

Programme

und

Betriebssysteme, sondern auch die Sprache selbst. D.h. es entstehen neue Möglichkeiten Code zu formulieren und die Mechanismen, wie die Sprache in Zusammenhang mit dem Compiler funktioniert, werden den Anforderungen angepasst.

Unterschiede Welche Programmiersprache letztendlich aber für die jeweilige Anwendung die richtige ist, lässt sich trotz allem besser an den Unterschieden festmachen.

14

Nicht alle Sprachen können das Gleiche. Es gibt Sprachen, welche geeignet oder nicht geeignet sind für z.B. objektorientierte Programmierung.

Die

Auswahl

möglicher

Methoden

unterscheidet sich und auch die so genannte Syntax, d.h. mit welchen Schlüsselwörtern der Quellcode formuliert werden muss, ist andersartig. Zeichensetzung, Wortwahl, all das hat immer

eine

bestimmte

Bedeutung.

Außerdem

wird

unterschieden, ob eine Sprache maschinennah ist oder ob es eine unterstützende Laufzeitumgebung gibt.

.NET und C# - Ein erstes Fazit Maschinennah bedeutet, dass die Programmsyntax direkten Einfluss auf die Hardware hat. Fehler können daher fatal sein und schlechte Programmierung wird sich in der Performance des Programms bemerkbar machen. Anders als maschinennahe Sprachen (z.B. C oder C++) ist C# nur in Kombination mit dem .NET – SDK vollwertig und funktional. Ein SDK (Software Development Kit) gibt es auch bei anderen nicht – maschinennahen Programmiersprachen und heißt im deutschen sozusagen Softwareentwicklungsbaukasten. Im Fall von .NET gibt es derzeit .NET – Core, welches die SDK ist, die für alle Plattformen gleichermaßen verwendet werden kann. Das Paket beinhaltet verschiedene Bestandteile, unter anderem

15

auch einen Compiler, der die C# - Syntax in einen Zwischencode (Common Intermediate Language Code) übersetzt. Dieser wird dann

zur

Laufzeit

des

Programms

in

der

virtuellen

.NET – Laufzeitumgebung, welche Common Language Runtime heißt, verarbeitet. Diese

Architektur

ist

ein

grundlegender

Vorteil

der

.NET – Entwicklung. Unter anderem können so nämlich mehrere Sprachen (z.B. F#, VB, …) in einem Projekt verwendet werden, welche dann ebenfalls in Common Intermediate Language Code übersetzt werden. Die zentral agierende Laufzeitumgebung ermöglicht außerdem praktische Mechanismen wie z.B. die automatische Speicherverwaltung. Des Weiteren ist in dem .NET - SDK eine große Klassenbibliothek enthalten, welche das Programmieren

mit

weitreichenden

objektorientierten

Eigenschaften und Möglichkeiten ausstattet. Aktuell (2021) ist die Verwendung von C#9.0 mithilfe von .NET 5.0 möglich. Im folgenden Inhalt sollen Sie lediglich die ersten und wichtigsten Schritte in einer Programmiersprache tätigen und mit den Grundlagen vertraut werden. Dazu ist C# ebenso gut wie eine der genannten Möglichkeiten und auf Grund der genannten Vorteile sogar eine hervorragende Einsteigerprogrammiersprache. Sie können sich zunächst sehr darauf fokussieren wie Programmiercode funktioniert und müssen sich nicht übermäßig mit der dahinterliegenden Speichertheorie auseinandersetzten, da die Laufzeitumgebung für Sie ‚mitdenkt‘. 16

2 Das Studio für Ihre Komposition Das Erstellen von Programmen kann komplex und fehleranfällig sein. Um in einem Projekt den Überblick zu behalten, ist es daher gang und gäbe sich helfen zu lassen. Die Software die dazu genutzt werden kann nennt sich Entwicklungsumgebung oder Code Editor und ist vor allem dafür zuständig, dass die Syntax korrekt ist. Das heißt es findet eine Fehlererkennung statt, ähnlich wie die Rechtschreibhilfe in Text - Programmen. Auch eine angenehme Farbgebung und Hervorhebung von zusammenhängenden Elementen ist üblich. Des Weiteren werden alle Bestandteile des Programms übersichtlich in Projekten sortiert und Sie können sich ausschließlich auf das Programmieren konzentrieren. Sind Sie sich nicht sicher, ob ein Code so funktioniert wie beabsichtigt, so kann dieser mit einem Tastendruck testweise kompiliert und ausgeführt werden. Wie im aktuellen Zeitalter gewohnt gibt es auf dem freien Markt eine diverse Auswahl von verschiedenen Code - Editoren oder Entwicklungsumgebungen, welche auch unter dem englischen Namen IDE (Integrated Development Environment) bekannt sind.

17

Einschub: Dateiendungen

Abbildung 1 – Windows Explorer - Optionen

Es besteht die Möglichkeit, dass die Dateiendungen bestimmter Dateitypen in der Ordnerstruktur des Windows - Explorer ausgeblendet werden. Um sicherzustellen, dass es im Folgenden nicht zur Irritation kommt, sollte unbedingt dieser Haken entfernt werden. ‚Erweiterungen bei bekannten Dateitypen ausblenden‘

Abbildung 2 – Ordneroptionen

18

2.1 Microsoft Visual Studio Es ist bei der Sprache C# sinnvoll die meistverwendete und kostenneutrale

Entwicklungsumgebung

aus

dem

Hause

Microsoft zu verwenden, unter anderem weil .NET – Inhalte bevorzugt für Microsoft Windows Betriebssysteme entwickelt werden. Die IDE kann sowohl mit Windows als auch MacOS verwendet werden

und

ist

somit

für

das

Vorhaben

ausreichend.

Selbstverständlich kann jede andere C# - fähige IDE verwenden werden, sollte eine andere Umgebung besser gefallen. Beispielsweise gibt es die komplett plattformübergreifende Entwicklungsumgebung Rider von JetBrains, welche also auch bei dem Betriebssystem Linux funktioniert, aber leider nur die ersten 30Tage kostenlos testbar ist.

Für die Installation von Visual Studio gibt es folgende unterstützende Hinweise. Unter anderem wird ein standardmäßiger Kenntnisstand zum Umgang mit Ihrem PC vorausgesetzt, um einen schlanken Inhalt dieses Buchs zu gewähren.

19

Schritt 1:

Besuchen Sie die offizielle Website: https://visualstudio .microsoft.com/de/

[2]

(alternativ: QR Code) Schritt 2:

Tätigen Sie den entsprechenden Download. Die Community Edition ist für Lernzwecke und kleine Anwendungen mehr als ausreichend.

Abbildung 3 – Download Visual Studio [2]

Schritt 3:

Führen

Sie

die

Installation

mithilfe

der

setup.exe Datei durch. Es findet der gewohnte Setup – Dialog statt, mit folgender Auswahl.

20

Bei der Installation gibt es eine große Vielzahl an vorbereiteten Paketen, In

alle

Begleitung

für

einen

dieses

bestimmten

Handbuchs

Anwendungszweck.

werden

zunächst

nur

.NET – Desktopanwendungen entwickelt. Daher ist das einzig wirklich notwendige Paket folgendes (siehe Abbildung 4, S.21).

Abbildung 4 – Installation Visual Studio

Das

Paket

.NET-Desktopentwicklung

enthält

bereits

die

essentiellen Entwicklungswerkzeuge für C# (siehe Abbildung, oben rechts). D.h. im Fall von Visual Studio muss die .NET – SDK nicht extra heruntergeladen und installiert werden. Das spart Zeit und Mühe. ü .NET – Desktopentwicklungstools ü .NET Framework x.x.x-Entwicklungstools ü C# und Visual Basic ü IntelliCode 21

Unter anderem wird bei der Installation auch die Möglichkeit zur Voreinstellung der Benutzeroberflächenoptik gegeben. Es werden folgende Einstellungen gewählt.

Abbildung 5 – Visual Studio | Voreinstellungen

22

2.2 Die Entwicklungsumgebung – Erste Schritte Beim Öffnen des Programms wird ein Auswahldialog geführt. Von den vorgeschlagenen Möglichkeiten ist es Teil der ersten Schritte erstmalig ein neues Projekt zu erstellen (siehe Möglichkeit 4 / 4). Die Auswahl ist jeweils mit ‚Weiter‘ zu bestätigen. (In Zukunft können erstellte Projekte über die zweite Option ‚Projekt oder Projektmappe öffnen‘ wieder aufgerufen werden.)

Abbildung 6 – Visual Studio | Neues Projekt

Anschließend gibt es die Möglichkeit eine C# - basierte Konsolen – App zu erstellen (siehe Abbildung 7, S.24). Das ist für

Einsteiger

genau

die

richtige

Programmierhandwerk zu erlernen. 23

Methode

um

das

Abbildung 7 – Visual Studio | Konsolen-App

Zwischeninformation: Die Konsole (eng. ‚Terminal‘) ist stets ein Teil des Betriebssystems. Sie bietet die Möglichkeit dem Computer lediglich über Texteingabe Befehle zu geben oder verschiedene Daten abzufragen. Selbstverständlich braucht jedes Projekt einen Namen und einen Speicherort. Das ist die nächste Einstellung die getroffen werden muss. Das ist alles! Die Vorbereitungen sind abgeschlossen und das Programmieren kann beginnen! 24

3 Hello World – Das erste Programm Nach

dem

Projekterstelldialog

wird

in

der

Entwicklungsumgebung die Datei ‚Program.cs‘ geöffnet. Die Dateiendung ‚.cs‘ ist kurz für ‚.c sharp‘. Darin ist bereits das allgemein bekannte ‚Hello World‘ in traditioneller C# - Syntax formuliert. Dieses Programm hat schon lange Tradition und diese wird voraussichtlich noch lange so weitergeführt werden. Hello World hat die einzige und simple Aufgabe

diesen

Text

auszugeben.

An

diesem

ersten

Codebeispiel sind bereits einige grundlegende Eigenschaften der Programmiersprache erkennbar. Besonders praktisch ist Hello World! außerdem um den Umstieg von einer zur anderen Sprache zu erleichtern.

Abbildung 8 – Mein erstes Programm | Hello World! 25

Abbildung 9 – Projektmappen-Explorer

Standardmäßig befindet sich auf der rechten Seite der Projektmappen – Explorer.

Dieser

umfasst

einige

virtuelle

Ordner, welche innerhalb eines Projekts zur Übersichtlichkeit beitragen. Darunter ist auch die Programm.cs – Datei aufgeführt. Sofern Visual Studio den Text - Editor nicht automatisch anzeigt, kann es dort mit einem Doppelklick geöffnet werden. Außerdem werden verschiedene Abhängigkeiten angezeigt. Da das Programm in der Microsoft Windows - Umgebung entwickelt wird, wird das .NET – Framework einbezogen. Darunter sind im Ordner

Microsoft.NetCore.App

verschiedene

aufgeführt, welche verwendet werden können.

26

Bibliotheken

3.1 Debuggen starten Bevor die Syntax des Programms erklärt wird, soll zunächst geprüft werden, ob das Programm ordnungsgemäß ausgeführt werden kann. Dazu gibt es in der IDE einen integrierten Debugger. Da der Begriff beim ersten Lesen etwas stutzig machen kann, darf eine kurze Erklärung nicht fehlen. Der Begriff Bug (eng.) bedeutet Käfer oder Insekt und hat in der IT - Welt Füßchen gefasst, weil er Programmfehler verbildlicht. Ein Käferbefall, z.B. bei der Kartoffelpflanze, kann klein anfangen und letztendlich verheerende Schäden bringen. Wenn also davon gesprochen wird, dass sich ein Bug eingeschlichen hat, dann muss dieser entfernt werden. Ein Debug - Prozess (= Entkäferung) wird also unbedingt benötigt! Dazu gibt es den Debugger [d/iː/b/⁠ɐ⁠/gger]. Im Fall von Visual Studio genügt das Drücken der F5 – Taste (siehe Abbildung 10, S.28). Wenn seit dem letzten Debug keine Anpassungen vorgenommen worden sind, kann mit der Tastenkombination Strg+F5 auch ein Starten ohne Debuggen stattfinden. Die Änderungen des Programms werden also lediglich neu kompiliert.

27

Abbildung 10 – Debuggen starten | F5; Strg+F5

Nach dem Debuggen wird das Programm automatisch in der Konsole geöffnet. Wenn alles funktioniert hat, ist das Ergebnis die Ausgabe von ‚Hello World!‘:

Abbildung 11 – Debugging-Konsole

Da es sich um die für Visual Studio abgewandelte Konsole handelt, wird im Weiteren ein Texthinweis ausgegeben. Zum einen wird mitgeteilt, dass der Code mit “0“ beendet worden ist. Das bedeutet, dass das Programm erfolgreich beendet worden ist. Zum anderen sei die automatische Schließung der Konsole eine mögliche Option. Der Pfad der Einstellungen wird genannt. In der Toolbar gibt es mit dem grünen Play – Zeichen ebenfalls die Möglichkeit Debuggen starten aufzurufen.

28

Abbildung 12 – Debug und Release

Dabei fällt auf, dass in einem Dropdown – Menü zwischen Debug und Release gewählt werden kann. Die Einstellung ‚Debug‘ wird grundsätzlich verwendet, um das Programm zu optimieren. Am Ende des Projekts, wird der ‚Release‘ - Modus verwendet. Der Hintergrund dazu ist, dass mithilfe der IDE und der Unterscheidung zwischen ‚Debug‘ und ‚Release‘ unter anderem praktische Mechanismen in der Syntax verankert werden können. Bestimmte Debug - Elemente (wie zum Beispiel unterstützende Texthinweise) werden dann im Release - Modus gänzlich ignoriert, wodurch die Benutzerversion realisiert wird. Dabei handelt es sich allerdings um eine fortgeschrittene Verwendung der IDE.

29

3.2 Projektdateien und Verzeichnisse Um dieses Thema nicht ganz außenvor zu lassen, soll ein Blick in die Windowsumgebung geworfen werden. Und zwar auf den Speicherort des Projekts. Dort befinden sich verschiedene Dateien und Unterverzeichnisse.

Als erstes ist die Program.cs - Datei zu nennen. Hierbei handelt es sich um den zwischenzeitlich bekannten Quellcode des Programms ‚Hello World!‘, auf den alles andere aufbaut. Wichtig ist hierbei die Erkenntnis, dass es sich bei den Dateiendungen in erster Linie um eine Möglichkeit handelt um die Bestimmung eines Datensatzes zu definieren bzw eine Übersichtlichkeit beizubehalten. Die C# - Quelldateiendung ist also der Ausdruck dafür, dass es sich um einen C# - Programmcode handelt. Gleichzeitg ist ein Quellcode lediglich unformatierter Text. Das ist ganz einfach aufzeigbar, in dem die Program.cs – Datei mit dem Texteditor 30

geöffnet wird. Dazu ist ein Rechtsklick auf die Datei notwendig:

Abbildung 13 – Program.cs öffnen mit Texteditor

Das Resultat ist bekannt, nur die Darstellung geschieht nun nicht in Visual Studio sondern im Text – Editor von Windows.

Abbildung 14 – Program.cs in Texteditor

31

Abbildung 15 – Projektdateien

Visual Studio legt diese Projektdateien (siehe Abbildung 15) automatisch an. Darin werden diverse Einstellung usw. gespeichert.

Abbildung 16 - Verzeichnisse

Des Weiteren werden zwei Verzeichnisse erstellt, welche entsprechend den verwendeten Einstellungen jeweils das Debug – Unterverzeichnis enthalten. Das erste heißt ‚bin‘, welches die Binär – Daten, also Maschinencode, enthält. Die bekannteste Binär – Datei ist die .exe – Datei, das ist kurz für ‚executable‘ und heißt auf Deutsch ‚ausführbar‘. Das bin – verzeichnis ist also essentiell zur Anwendung des Programms. Ebenso gehört die .dll – Datei (Dynamik Link Library) zu den Binär – Daten, welche von .NET – Anwendungen grundsätzlich verwendet wird. Das zweite Verzeichnis ‚obj‘ enthält Objekt - Daten, welche ein Zwischenergebnis des Kompilierers sind. Für die Ausführung sind diese nicht mehr relevant. 32

3.3 Die Syntax Hello World ist ebenso ein gutes Beispiel um die ersten Syntaxelemente zu erklären. Gute Programme werden nach dem Prinzip ‚So wenig wie möglich, so viel wie nötig‘ formuliert. Im Fall von ‚Hello World!‘ ist aber auch unnötiger Code enthalten, der vorbereitend das Syntaxschema von C# kenntlich macht. Außerdem muss an dieser Stelle eine Frage aus dem Weg geräumt werden. „Warum ist zwischen diesem und jenem das Zeichen ‚Such dir eines aus‘?“ – Die Syntax muss so sein, denn viele Menschen haben daran gearbeitet die Sprache zu standardisieren. So will es der Compiler und so funktioniert das Programm, für alle. Das heißt, manche Dinge sind nicht allein durch Logik lernbar, manches wird ganz automatisch beim Üben antrainiert. Die Syntax lässt nichtsdestotrotz sehr oft mehrere Wege der Formulierung zu, ähnlich wie bei unterschiedlichen Ausdrucksweisen in der menschlichen Sprache. Das Ziel ist, dass der Compiler alles versteht und ggf. auch die anderen Menschen mit denen zusammengearbeitet wird. Im

Folgenden

werden

also

die

einzelnen

Zeilen

der

‚Hello World‘ – Syntax, welcher erstmals auf Abbildung 8 (S.25) gesichtet worden ist, in kompaktem Umfang beschrieben. Ziel ist es das Zeichenwirrwarr auf einzelne Bausteine aufzutrennen.

33

Abbildung 17 – Abbildung 8

using System; Die Anweisung using System; ist dafür zuständig um die Verwendung des ‚namespace‘ ‚System‘ im folgenden Code zu implizieren. So können in erster Linie verschiedene Ausdrücke, welche sich auf die Klasse System beziehen, abgekürzt und dadurch Zeile 9 in der dargestellten Weise formuliert werden. Ohne Zeile 1 müsste dort stehen: System.Console.Writeline(“Hello World!“);

Da Objekte aus der Klasse System standardmäßig verwendet werden, wird sich die Zeitersparnis und die Erleichterung der Lesbarkeit im Laufe des Projekts mehr und mehr anhäufen. Das Ende einer Befehlszeile wird stets mit einem Semikolon ‚ ; ‘ abgeschlossen. 34

namespace MeinErstesProgramm Die Verwendung von namespaces ist wie gesagt völlig optional, aber ermöglicht oftmals eine verkürzte Schreibweise. Außerdem können so gleichnamige Klassen, Variablen oder Funktionen erzeugt

werden,

unterscheidbar

welche sind.

aber

Der

hier

durch

den

namespace

erzeugte

namespace

‚MeinErstesProgramm‘ ist für zukünftige Inhalte vorbereitet. Optional.

{ } Im Fall der Verwendung von ‚namespace‘, einer Methode oder ähnlichem ist stets ein Gültigkeitsbereich anzugeben. Die geschweiften Klammern geben also den Bereich an, in dem Inhalte zusammengehören. Das ist sehr praktisch, denn mit dem Verlassen der Klammern verlieren die meisten Zusammenhänge ihre Gültigkeit und z.B. das Thema Namensgebung wird einfacher.

class Program Bei C# handelt es sich um eine objektorientierte Sprache. Das geht sogar so weit, dass die Verwendung von Klassen quasi obligatorisch ist. Es wird mit dieser Zeile eine Klasse namens ‚Program‘ erstellt. Später mehr dazu.

35

static void Main(string[ ] args) Main() ist die Hauptfunktion und der Einstiegspunkt eines Programms, egal an welcher Stelle dieser Ausdruck steht. Des Weiteren heißen Funktionen, die innerhalb einer Klasse stehen, Methoden. Das Präfix static ist einerseits notwendig, um diesen Einstiegspunkt in das C# - Programm eindeutig zu definieren, andererseits führt die Kennzeichnung generell bei allen Methoden zu bestimmten Eigenschaften. Mehr dazu später. Der Typ des Rückgabewerts der Methode muss grundsätzlich immer definiert werden. Das geschieht durch ein weiteres Präfix, in diesem Fall ‚void‘, wodurch das Verzichten auf eine Rückgabe gekennzeichnet wird. Es gibt also auch Methoden ohne Rückgabewert. Wie bei Methoden üblich, gibt es in den dahinterliegenden, runden Klammern Platz für eventuell verwendete Parameter, bwz. Argumente. Im Fall von Main( ) und diversen weiteren werden keine benötigt, daher könnten die runden Klammern ebenso gut leer stehen. Was der Ausdruck ‚string[ ] args‘ bedeutet, wird später erst klarer. In kurz: Bereits beim Öffnen des Programms in der Konsole könnten Anfangsparameter eingegeben werden. In diesem Fall ist es möglich eine Reihe von Strings, also Zeichenketten, mit dem Namen args, zu übergeben.

36

Die letztendliche Aufgabe der Methode steht in den geschweiften Klammern. Dort heißt es: ‚Feel free.‘ Hinweis: Der Programmablauf innerhalb der geschweiften Klammern geschieht Zeile für Zeile, also von oben nach unten, und kann im restlichen Programm umherspringen. Das ist der Charme und die Freiheit bei der Programmierung. Sollten Sie bestimmte Abläufe nicht mehr überblicken können, dann nutzen Sie am besten die Funktionalitäten des Debuggers. Mehr dazu ist auf Seite 174 zu finden.

Console.WriteLine(“Hello World!“); Die Ausgabemethode WriteLine( ) ermöglicht dem Programm die Ausgabe eines bestimmten Inhalts. Da auch Zahlen und die Variablenwerte ausgegeben werden können, muss Text in Anführungszeichen (“ “) stehen, der Differenzierung zugute. Die verwendete Methode ist Teil der Klasse Console. Daher wird die Information darüber vorangestellt und mithilfe eines Punkts ‚ . ‘ verknüpft.

37

3.4 Fehlerliste

// Codefehler

Mit der richtig formulierten Syntax wird das Programm vom Compiler ordnungsgemäß übersetzt. Andernfalls markiert die IDE die Fehlerstelle symbolisch mit einem Schraubenzieher. Dazu wird die Stelle des Fehlers mit roten Zickzacklinien unterstrichen, wie von Rechtschreibhilfen prinzipiell bereits bekannt.

Abbildung 18 – Beispiel Codefehler

Die zeitgleich ausgegebene Nachricht in der Fehlerliste soll dabei helfen den Fehler zu erkennen. Es wird allerdings stets notwendig

sein,

dass

der

Programmierende

mögliche

Lösungsansätze selbst erkennt, denn die Fehler, Warnungen oder Mitteilungen schlagen nicht immer eine einwandfreie Behebung des Fehlers vor.

Abbildung 19 – 1 Fehler

38

In dem Beispiel aus Abbildung 18 wird vorgeschlagen, dass ein Semikolon erwartet wird. Das ist in diesem Fall genau die richtige Lösung. Der letzte Befehl, nämlich die WriteLine( ) – Funktion ist nicht mit dem Semikolon abgeschlossen worden. In Kombination mit der Beschreibung gibt es einen Fehlercode, der gegebenenfalls bei der Suche nach einer Lösung online helfen soll.

39

4 Elementare Strukturelemente Nachdem das erste Programm eines jeden ausgeführt und ansatzweise verstanden worden ist, kann nun die Vielzahl an Möglichkeiten der Programmierung dargelegt werden. Dieses Kapitel vertieft also das Verständnis der Hello World - Syntax und erweitert es um diverse Struktur- und Logikelemente. Das erste Unterkapitel geht auf Datentypen ein. In Bezug auf das Programmieren sind die diese ähnlich fundamental wie Mathematikkenntnisse aus der Grundschule. Hinweis: Es werden von Anfang an Code - Beispiele aufgeführt, die die dargelegte Theorie unterstreichen sollen. Der Inhalt fängt mit den Grundlagen an und baut im Weiteren auf sich auf. So wird mit jedem genannten Beispiel die Syntax und wie sie funktioniert verständlicher. Danach kann erklärt werden, wie in diesem Zusammenhang Variablen erzeugt werden. Oftmals ist es sinnvoll gleich eine ganze Sammlung von Elementen, nämlich Arrays, zu definieren. Eine weitere Herausforderung stellt das Arbeiten mit Text dar (siehe Kapitel 4.5 Strings). In Kombination dazu ist die Aus- und Eingabe von Werten unerlässlich, um das Programm interaktiv zu gestalten. Nach dieser letzten Säule werden bereits alle nötigen Grundlagen dargelegt sein.

40

Anschließend fängt der kreative Teil des Programmierens an. Mit

den

Operatoren

kann

der

Programmierende

seine

Gedankengebilde in Form von Verzweigungen, Schleifen, Funktionen und Ein- und Ausgaben realisieren. Außerdem muss betont werden, dass die objektorientierte Programmierung fest zum Programmierstil in C# gehört. Bereits in ‚Hello World!‘ ist das bereits erkenntlich geworden. Wie genau die Programmierung anhand von Klassen und Methoden funktioniert muss glücklicherweise nicht von Anfang an verstanden

sein.

Es

genügt,

wenn

verschiedene

Zusammenhänge erkannt werden. Mit der Zeit entwickelt sich, wie bei anderen Weltsprachen auch, ein Sprachgefühl. Das ‚Wie? und ‚Warum?‘ ergibt sich erst aus dem Gesamtbild und Sie werden sehen, die Ausdrucksweise in der Programmiersprache ist zum Teil sehr intuitiv und an die menschliche Sprache angelehnt. Ein guter Schreibstil erfordert dann, dass das Gesagte auf ein sinnvolles Minimum ausgedünnt wird. Das ist die wesentliche Herausforderung, wenn Sie sich das Programmieren erstmals aneignen. Falls erforderlich, ist es möglich im Internet ergänzend Informationen

aufzusuchen.

Microsoft

selbst

bietet

beispielsweise eine Einführung in C#. Dort sind meist sogar mehr Informationen vorhanden, als für die ersten Schritte sinnvoll. https://docs.microsoft.com/de-de/dotnet/csharp/tour-of-csharp/

41

Kommentare

/*geben die Möglichkeit für

Hinweise*/ Den geschriebenen Code zu kommentieren kann Ihnen und anderen, die den Code lesen, eine große Hilfe sein. Es hat keinerlei Nachteil für das Programm. Dazu gibt es die Zeichenkombinationen /* , */ und //. Sie werden folgendermaßen verwendet:

Abbildung 20 – Kommentare – Beispiel 1

Abbildung 21 – Kommentare – Beispiel 2

Tipp: Nutzen Sie die Tastenkombination Strg + K + C nachdem sie einen Textblock markiert haben. So geht das Umwandeln zu einem Kommentar sehr schnell, besonders bei vielen Zeilen. Mit Strg + K + U wird es rückgängig gemacht.

42

4.1 Datentypen Die Unterscheidung zwischen den Datentypen gehört zu den Gemeinsamkeiten der Programmiersprachen, denn es ist notwendig, die Werte mit denen ein Programm arbeitet, zu kategorisieren. Es handelt sich um ein logistisches Thema. Grundsätzlich ist der Arbeitsspeicher des Computers beschränkt. Daher ist die effiziente Nutzung des vorhandenen Volumens anzustreben. Als vergleichendes Beispiel soll der Speicher als Lagerhalle angesehen werden. Dort sind Kisten mit verschiedenen Größen und Farben. Das Programm weiß wo sich diese Boxen befinden, und was darin ist. Es kann den Platz für neue, noch hinzukommende

Schachteln

reservieren

und

nicht

mehr

benötigte Schachteln samt Inhalt aus dem Lager entfernen. Die Farben geben an, wie der jeweilige Inhalt interpretiert werden soll. Wie das Beispiel ohne Metapher zu verstehen ist, wird erst nachvollziehbar werden können, wenn klar ist was ein ‚Byte‘ umfasst. Grundsätzlich ist dieser Begriff wahrscheinlich schon vertrautes Vokabular. So wie es Allgemeinwissen ist, was 1 Liter beinhaltet, ist ein Gefühl für die Speichermenge des Computers vorhanden. Immer wenn die Frage im Raum steht, wie viel Speicherplatz benötigt wird, sei es beispielsweise die Festplatte oder der

43

Arbeitsspeicher, so fallen die Begriffe Megabyte, Gigabyte oder Terabyte.

Aus der Historie der Speicherentwicklung ist hervorgegangen, dass die Größe für ein einzelnes Speicherelement, welches 1 Byte darstellt, aus 8 Bit geformt wird.

Das Binärsystem An dieser Stelle rückt die Binärsprache des Computers in den Mittelpunkt. Ein Bit wird nämlich die Unterscheidungsmöglichkeit der Zustände ‚0‘ und ‚1‘ genannt und ist damit der kleinstmögliche Wert. Durch eine Aneinanderreihung mehrerer Bits kann die Darstellung möglicher Zustände exponentiell gesteigert werden. Im Folgenden sollen deshalb die Gesetzmäßigkeit der binären bzw. 2er - Zählweise und die Grenzen von 8 Bits aufgezeigt werden. Ein Kind lernt bereits wie mit dem Dezimal - bzw. 10er - System gezählt wird. Auch die Zeitscheibe einer Uhr ist eine

Art

des

Zählens.

Bei

folgendermaßen:

44

Binärzahlen

funktioniert

es

Dezimal

Binär

Dezimal

Binär

0

0000 0000

8

0000 1000

1

0000 0001

9

0000 1001

2

0000 0010

10

0000 1010

3

0000 0011

11

0000 1011

4

0000 0100

12

0000 1100

5

0000 0101

…

…

6

0000 0110

254

1111 1110

7

0000 0111

255

1111 1111

Bei größeren Zahlen wird die Umrechnung auf den ersten Blick unnachvollziehbar. Mit der zugrunde gelegten Umrechnungslogik kann Abhilfe geschaffen werden. Zuerst soll das Dezimalsystem mit einem Beispiel bereits Bekanntes erklären: 525= 5*10² + 2*101 + 5*100 = 5*100 + 2*10 + 5*1 = 500 + 20 + 5 Es ist die Einerstelle logisch gesehen die nullte Stelle, da das Zählsystem noch nicht als Faktor eingeht. Denn 100 = 1 und damit hinfällig. Erst bei der Zehnerstelle (101 = 10) wird der Faktor für die Summe relevant.

45

Allgemeingesagt ist also eine beliebige Stelle einer Zahl als Potenz des zugrunde gelegten Zählsystems darstellbar. Beim Umstellen auf Binär wird also lediglich die 10 zu einer 2 geändert. Außerdem, da die möglichen weiteren Faktoren nur 0 oder 1 sind, steht also jede Stelle für das Eingehen oder Nichteingehen der entsprechenden Zweierpotenz in die Summe. Beispiel: 101 ≙ 1*2² + 0*21 + 1*20 = 2² + 20 = 4 + 1 = 5 Die folgenden zwei Schaubilder sollen beim Einprägen helfen.

Abbildung 22 – Binär zu Dezimal

Beim Darstellen der Binärzahl anhand der Dezimalzahl muss rückwärts gedacht werden. Es wird die Frage gestellt, ob die Subtraktion der jeweiligen Zweierpotenz restlos möglich ist. Wenn nein, steht an dieser Stelle eine Null. Am Ende wird der Restwert 0 stehen. 46

Abbildung 23 – Dezimal zu Binär

Die .NET Datentypen Von den Eigenschaften von Zahlensystemen abgesehen ist nun also

bekannt,

dass

1 Byte

aus

8 Bit

besteht

und

256 verschiedene Werte darstellen kann, beispielsweise die Zahlen von 0 bis 255. In der Programmiersprache haben verschiedene

Datentypen

auf

Grund

einer

bestimmten

Speichergrößenzuweisung unterschiedlich große Spannweiten und erhalten durch eine Kategorisierung einen bestimmten Wertebereich. Als Erläuterung dient folgende Tabelle mit den Datentypen der .NET – Programmierung. Es wird unterschieden zwischen Werttypen und Verweistypen. In Bezug auf den Speicherbedarf sollen zunächst die Werttypen genannt werden:

47

Schlüssel-

Kategorie

Speicher

Wertebereich

wort (.NET) Sbyte

-128 ó 127

(SByte)

1 Byte (8 Bit)

byte

0 ó 255

(Byte) short

-32 768 ó 32 767

(Int16)

2 Byte (16 Bit)

ushort (UInt16) int (Int32) uint

0 ó 65 535

Ganze Zahl

-2 147 483 648 4 Byte (32 Bit)

ó 4 294 967 295 0 ó 4 294 967 295

(UInt32) long (Int64) ulong

ca. -9 Trillionen 8 Byte (64 Bit)

ó ca. 9 Trillionen 0 ó ca. 18 Trillionen

(UInt64) [3]

48

Schlüssel-

Kategorie

Speicher

Wertebereich

Boolescher

1 Byte

true (= 1),

Wert

(8 Bit)

false (= 0)

Unicode

2 Byte

0 ó 65 535

Zeichen

(16 Bit)

‘Unicode – Zeichen‘

kommazahl

4 Byte

-3,402823 ⋅ 1038

(7 gültige

(32 Bit)

ó 3,402823 ⋅ 1038

kommazahl

8 Byte

ca. -1,798 ⋅ 10308

(15 gültige

(64 Bit)

ó ca. 1,798 ⋅ 10308

Mathemati-

16 Byte

-7,9 ⋅ 1028

sche Werte

(128 Bit)

ó 7,9 ⋅ 1028

wort bool (Boolean) char (Char)

Fließfloat (Single)

Stellen) Fließdouble (Double)

Stellen) decimal (Decimal)

[3]

49

Die Ganzen Zahlen Um diese Tabellen nicht kommentarlos wieder zu verlassen, sollen die Eigenarten der verschiedenen Kategorien von Datentypen weiter erklärt werden. Beim Typ int ist die größtmögliche Zahl 2 147 483 647. Es ist nicht möglich eine Zahl x

vom

Typ

int

zu

definieren,

die

beispielsweise

2 147 483 648 beträgt. Der Fehler dabei wird sofort erkannt.

Abbildung 24 – Werte außerhalb vom Definitionsbereich

Anders verhält es sich, wenn der Definitionsbereich in einem späteren Schritt, möglicherweise unbemerkt, verlassen wird. Es ist also Vorsicht geboten. Was passiert, wenn der gültige Wertebereich missachtet wird?

Abbildung 25 – Verlassen des Definitionsbereichs 50

In Abbildung 25 wird deutlich, dass der Wertebereich von - 2 147 483 648 bis 2 147 483 647 als Zahlenband definiert ist, dessen Enden bildlich gesprochen miteinander verbunden sind. Mit der Addition der Zahlen x + y wird der gültige Bereich um 1 überschritten. Das hat zur Folge, dass der Ausgabewert am anderen Ende des Spektrums landet (s. Konsole Abbildung 25). Die Zahl x+y+z bestätigt diese These. Es ist also der gleiche Sachverhalt wie etwa die Drehung um einen Winkel. Eine ganze Rotation umfasst 360°. Deshalb liefert z.B. 540° das gleiche Ergebnis wie 180°.

Fließkomma: float, double & decimal: Die Kommazahlendarstellung, die durch diesen Typ mit 4 Byte dargestellt werden kann, ist definiert mit bis zu 7 gültigen Stellen. D.h. obwohl die mögliche Zahlengröße mit bis zu 3,4 ⋅ 1038 sehr weit geht, ist die Genauigkeit sehr begrenzt. Nach den sieben gültigen, wird eine weitere, gerundete Stelle ausgegeben.

Abbildung 26 – Beispiel float - Zahlen

51

Ein weiteres Detail, das ins Auge fällt, ist das Suffix ‚F‘, welches hinter der float – Zahl genannt werden muss. Auch beim decimal – Datentyp ist ein Suffix erforderlich. Außerdem: Das Komma wird bei der Programmiersyntax bereits bei Auflistungen verwendet. Daher geschieht die Unterscheidung von Vorkomma- und Nachkommastelle im Quellcode durch einen Punkt. Hier ist die flache Exponentialdarstellung des Dezimalsystems mit

der

e – Schreibweise

unerlässlich.

Für

eine

kleine

Gedächtnisauffrischung gibt es zwei Beispiele: 4,2e5 = 4,2 *105 = 420 000

|

3,7e-4 = 0,00037

Als Gedächtnisstütze: Die Zahl hinter dem e steht dafür, um wie viele Stellen das Komma verschoben werden muss. Ist sie positiv, wird das Komma nach rechts verschoben, ist sie negativ, nach links. Beim Typ double wird nun der mögliche Bereich und die Anzahl der gültigen Stellen deutlich erhöht. Mit den 8 Bytes können Zahlen bis zu 1,7e308 mit 15 gültigen Stellen formuliert werden. Nur in wenigen Fällen reicht dieser Datentyp nicht mehr aus. Für eine maximal genaue Rechenarbeit gibt es in C# außerdem noch den Datentyp decimal. Er kommt immer dann zum Einsatz, wenn mathematische Genauigkeit oberste Priorität hat. 52

Der Datentyp bool: Boolean stellt den einfachsten Datentyp dar. Wie schon bekannt, ist die einzige Unterscheidung, die getroffen wird, 0 oder 1. Dennoch werden dabei 1 Byte bzw. 8 Bit reserviert. Das liegt wie daran, dass das die kleinstmögliche Speicherzuweisung ist.

Der Datentyp char: Grundsätzlich erwartet der Compiler bei diesem Datentyp ein Zeichen, welches durch die einfachen Anführungsstriche ‘ ‘ kenntlich gemacht wird, und reserviert dafür 2 Byte. Bei anderen Programmiersprachen,

wie

C

oder

C++,

gibt

es

für

char – Zeichen nur 1 Byte. Im Zusammenspiel mit dieser Spannweite ist die ASCII - Tabelle entwickelt worden, welche genau 255 gängige Zeichen umfasst. Jede Zahl wird also fest mit einem

bestimmten

Inhalt

verknüpft.

In

den

folgenden

Abbildungen sind die erste und vierte / fünfte Spalte mit den Dezimal- und Char - Zeichen relevant. http://www.asciitable.com/ | https://unicode-table.com/de/ Bei char (2 Byte) in C# gibt es bereits deutlich mehr verwendbare Symbole. Es können sogar Zeichen verschiedener Weltsprachen untergebracht werden. Die ASCII – Tabelle ist in Unicode integriert, d.h. folgender Auszug aus ASCII (Abbildung 27) ist in C# ebenfalls gültig.

53

Abbildung 27 – ASCII Tabelle 0 - 79 [4] 54

Abbildung 28 – ASCII Tabelle 80 – 127 [4]

Abbildung 29 – ASCII Tabelle - Extended Codes 128 - 255 [4]

55

Das Hexadezimalsystem Neben dem Binärsystem gibt es noch weitere Zahlensysteme. In der zweiten Spalte der obigen Tabelle taucht das bislang unvertraute Hexadezimalsystem erstmals auf. Die Verwendung macht in Verbindung mit Bytes oftmals Sinn, da die Vielfachen davon (8 Bit, 16 Bit, 32 Bit, usw.) sehr gut zur Basis ‚16‘ der Hexzahlen passen. Das System funktioniert so: Die Zählweise von 0 - 9 ist gleich wie beim Dezimalsystem. Anschließend werden die Buchstaben A bis F verwendet um Zahlen zu ersetzen. Der Buchstabe F, steht also für die Zahl 15. Danach wird mit 10 weitergezählt, was dabei gleichbedeutend zu 16 ist. Ein Blick in die Abbildung 27 (S.54) macht die Gesetzmäßigkeit erkenntlich. Auf Grund der größeren Basis kann außerdem der Wert eines Bytes mit nur zwei Stellen angegeben werden. Bis jetzt ist verstanden, dass der Wert eines Byte, abhängig vom Zahlensystem, mit bis zu 8 Bit – Stellen oder 3 Dezimal – Stellen dargestellt werden muss.

56

Suffix Beim Beispiel zum Datentyp float ist erkenntlich geworden, dass bei manchen Datentypen ein anschließender Buchstabe, ein Suffix, erforderlich ist, um diesen eindeutig zu kennzeichnen. Das hat den Hintergrund, dass so Interpretationsfehler in der weiteren Verarbeitung vermieden werden können. Ein weiterer Typ, der ein Suffix benötigt ist der decimal. Datentyp

Suffix

Beispiel

Decimal

M

decimal a = 1.2345M;

Float

F

float b = 9.8764F;

[3] Das Fazit zu diesem Kapitel ist, dass durch zweckorientiertes Verwenden der Datentypen die notwendige Speichermenge optimiert werden kann. Auch wenn es die Möglichkeit gibt mit einem decimal quasi alle benötigten Werte darzustellen, ist es guter Programmierstil bei Gelegenheit

auf

ein

byte

zurückzugreifen.

Bei

großen

Programmen wird so ein merklicher Unterschied entstehen, denn schließlich hat ein decimal - Wert gegenüber dem byte den 16 - fachen Speicherplatzbedarf.

57

4.2 Operatoren Operatoren

sind

bisher

zumindest

aus

dem

Mathematik - Unterricht bekannt. Diese stehen zwischen zwei Elementen und erfüllen damit eine Aufgabe, bzw. Funktion. In der Programmiersprache wird das Thema Operatoren etwas erweitert und mit einer Nomenklatur versehen. Dieses Kapitel soll eine übersichtliche Auflistung gewährleisten.

Rechnungsoperatoren Es seien die Zahlen x = 5 und y = 3 gegeben. Rechnungen bilden Anhand der gegebenen Zahlen einen neuen logischen Wert. Operator

Aufgabe

Beispiel

+

Addition

x+y=8

-

Subtraktion

x–y=2

*

Multiplikation

x ⋅ y = 15

/

Division

y / x = 0,6

++

Erhöhung um Eins

y++ = 4

--

Reduktion um Eins

x-- = 4

58

Operator

Aufgabe

Beispiel

+=

Erhöhung

x += y

Eigenwert (EW)

àx(neu) = x(alt) + y àx(neu) = 8

-=

Reduktion EW

x-=y à x(neu) = 2

*=

Vervielfachen EW

x*=y à x(neu) = 15

/=

Vermindern EW

x/=y à x(neu) = 1,6

%

Restwert (Modulo)

x%y=2

Vergleichsoperatoren Es seien die Zahlen x = 5 und y = 3 gegeben. Die Verwendung eines Vergleichsoperators liefert die Information ‚wahr‘ (‚true‘) oder ‚falsch‘ (‚false‘). Operator

Aufgabe

Beispiel




größer als

(x > y) à wahr

= y) à wahr

==

gleich

(x == y) à falsch

!=

nicht gleich

(x != y) à wahr

Boolesche Operatoren Es seine die Argumente A = true und B = false. Operator

Aufgabe

Beispiel

&&

UND

A && B à false

||

ODER

A || B à true

!

NICHT

!B à true

Angelehnt an die Elektrotechnik können dazu auch Schaltpläne erstellt werden, woraus sich die mathematische Schreibweise für UND bzw. ODER ergibt. Diese wird durch eine Multiplikation bzw. Addition widergespiegelt. Eine Wahrheitstafel hilft dabei alle möglichen Kombinationen aufzulisten.

60

Logisches ‚UND‘: A

B

E=A⋅B

0

0

0

0

1

0

1

0

0

1

1

1 Abbildung 30 – Logisches UND

Logisches ‚ODER‘: A

B

E=A+B

0

0

0

0

1

1

1

0

1

1

1

1 Abbildung 31 – Logisches ODER

Logisches ‚NOT‘: E=Ā A=0

1

A=1

0

61

Zusammenfassung Boolesche Werte Wichtig ist das Verständnis, dass eine Null mit einem false - Ausdruck gleichzusetzen ist. Eine Zahl ungleich Null wird grundsätzlich als true interpretiert. Auch wenn nur 1 Bit für die Booleschen

Werte

nötig

wäre,

wird

grundsätzlich

der

Mindestspeicherbedarf von 1 Byte eingenommen. Rechengesetze mit Booleschen Variablen: Die Rechengesetze, die daraus formuliert werden können, sind für die Programmierung von großer Bedeutung. So können logische Verhältnisse überprüft und Gleichungen gegebenenfalls auch vereinfacht werden. (1) A + A = A

|

A⋅A=A

(2) A + B = B + A

|

A⋅B=B⋅A

(3) A ⋅ 1 = 1 ⋅ A = A

|

A+0=0+A=A

(4) A * (B + C) = A ⋅ B + A ⋅ C |

(B + C) ⋅ A = B ⋅A + C ⋅A

(5) (A + B) + C = A + (B + C)

|

(A ⋅ B) ⋅ C = A ⋅ (B ⋅ C)

(6) A ⋅ 0 = 0 ⋅ A = 0

|

A+1=A+1=1

____ _ _ (7) A + B = A ⋅ B

|

____ _ _ A⋅B=A+B

_ (8) A ⋅ A = 0

|

_ A+A=1

62

4.3 Variablen Mit dem Wissen über Datentypen können nun Variablen deklariert, definiert und verwendet werden. Dabei gehörten die Deklaration und Definition immer zu den notwendigen Schritten. Ob dies in einem Aufwasch passiert oder inhaltlich getrennt stattfindet, hängt vom Schreibstil und der Situation ab.

Deklaration (Variablen) Ersteres bedeutet, dass ein Speicherbereich reserviert wird, was durch das Nennen des zugehörigen Datentyps geschieht. Der Name der Variablen ist frei aus Buchstaben und Zahlen zusammensetzbar, sofern sie mit einem Buchstaben beginnt. Auch Unterstriche o.ä. sind möglich. Der Name ist gleichzeitig eine ID (Identifikator) und ermöglicht dem Compiler das Wiederfinden der Variablen. [Datentyp] [Name der Variablen]; int x123;

//Deklaration Einfach

double BeispielVariable; char A, B,… ;

//Deklaration Mehrfach

63

Definition (Variablen) Durch die ID der Variablen wird der Speicherplatz gefunden und es kann der vorgegebene Wert mit einem Schreibvorgang eingetragen

werden.

Das

einfache

Gleichzeichen

wird

verwendet um der Variablen feste Werte, so genannte Literale, zuzuweisen. [Name der Variablen] = [Wert der Variablen] x123 = 2500; BeispielVariable = 3.33; A = ‘!‘;

Deklaration & Definition (Variablen) Es besteht auch die Möglichkeit die deklarierten Variablen im selben Schritt zu definieren. Dazu müssen die beiden Schritte (Speicherreservierung

&

Schreibvorgang)

aneinandergereiht werden: [Datentyp] [Name] = [Wert der Variablen]; int x123 =2500;

//Definition Einfach

char A = ‘!‘, B = ‘\n‘,… ;

64

//Mehrfach

einfach

Verwendung (Variablen) Die Verwendung der Variablen macht erst Sinn, wenn sie bereits definiert wurde. Bei der Verwendung findet ein Lesevorgang statt. Es ist auch möglich zu lesen und abhängig von dem aktuellen Inhalt einen neuen Wert zu schreiben (Zeile 2). Praktischerweise ist auch das Gegenüberstellen von zwei Werten möglich. Das Prüfen auf Gleichheit kann mit dem doppelten Gleichzeichen durchgeführt werden (Zeile 3). Der if - Ausdruck wird später in Kapitel 4.7 Verzweigungen erklärt. Console.WriteLine(x123); BeispielVariable *= x123; if (WertA == ‘J‘) {

…

};

Allgemeine Formulierung Wenn Variablen deklariert werden sollen, bei denen noch kein definierter, engültiger Zweck vorgesehen wird, ist es in C# auch möglich eine Variable durch ‚var‘ zu kennzeichnen: var [Name der Variablen] = [Inhalt]; var Name = “Petar“; var Einkommen = 5500;

65

4.4 Arrays Es kann vorkommen, dass eine Reihe von Variablen vom selben Datentyp

einer

Zusammengehörigkeit

unterliegen.

Eine

Möglichkeit um in diesem Fall für Ordnung zu sorgen und eine große Zahl an Variablen mit nur einem Namen zu bedienen, stellt der Array dar. Die mögliche Darstellung kann dabei sogar beliebig viele Dimensionen umfassen. Der ein- oder zweidimensionale Array verhält es sich dabei wie die Zeilen und Spalten einer Tabelle. Darin haben alle enthaltenen Werte ihren festen Platz, vergleichbar mit einer Excel - Tabelle. Ein dreidimensionaler Array wiederum spannt sozusagen einen Werteraum auf. Bei vier Dimensionen oder darüber hinaus wird es komplizierter und schwieriger nachzuvollziehen. Analog zu normalen Variablen werden Arrays ebenfalls deklariert und definiert. Im Folgenden werden einige Bespiele genannt.

66

Eindimensional

Deklaration [Datentyp] [ ] [Name des Arrays] = new [Datentyp] [[Anzahl der Werte]]; int [ ] arr1 = new int [10];

//neuer Array mit 10 int – Werten

Wird ein Array deklariert, jedoch noch nicht definiert, dann ist das Vorgehen sehr ähnlich zu Variablen. Nachdem der Datentyp des Arrays genannt worden ist, ist es notwendig den Array durch eckige Klammern [ ] zu kennzeichnen. Danach muss der Name des Arrays folgen. Die Deklaration wird zunächst anhand eines Gleichzeichens ( = ) der Anweisung ‚new‘ zugeordnet. Dabei muss erneut der Datentyp des Arrays genannt werden Die Länge eines Arrays steht in den eckigen Klammern, welche folgen.

Definition Im Beispiel von arr1 wird also eine Reihe von Werten deklariert. Diese 10 Werte sind in den Platzhaltern, auch Indizes genannt, arr1 [0] bis arr1 [9] definierbar. D.h. die Inhalte eines Arrays werden behandelt als wären es durchnummerierte Variablen. Von dem jeweiligen Index abgesehen haben sie sonst eine 67

gleiche

Benennung.

Das

Indexzählen

beginnt

bei

Null,

d.h. arr [10] übersteigt in diesem Fall die Gültigkeit des Arrays! Die Definition der einzelnen Werte erfolgt durch die Nennung der jeweiligen Stelle im Array. Von dieser Neuerung abgesehen verhält es sich gleich wie bei Variablen aus dem vorherigen Kapitel. [Arrayname] [[Index]] = [Indexwert]; arr1 [0] = 3; ... arr1 [9] = 15;

Deklaration & Definition Wie schon von Variablen bekannt, können die beiden Schritte zusammengefasst werden. Entweder werden die Werte in geschwungene Klammern geschrieben und sofort genannt, oder in Einzelschritten definiert. [Datentyp] [ ][Name] = { [Wert 0],[Wert 1], …}; int [ ] arr3 = {4, 6, 3} //Array mit 3 int - Werten

68

Mehrdimensional

Deklaration Als Beispiel soll ein zweidimensionaler Array erklärt werden. Bei weiteren Dimensionen bleibt das Prinzip erhalten. Gegenüber dem eindimensionalen Array ändert sich, dass in den eckigen Klammern, mit Kommas getrennt, die verschiedenen Dimensionen aufgelistet werden. [Datentyp] [ , ] [Arrayname] = new [Datentyp] [[Werteanzahl , Werteanzahl]]; int [ , ] arr2 = new int [2,3];

Es können also 2 ⋅ 3 = 6 Werte mit dieser Anordnung definiert werden. Dim1 / Dim2

Dim2[0]

Dim2[1]

Dim2[2]

Dim1[0]

arr2 [0, 0]

arr2 [0, 1]

arr2 [0, 2]

Dim1[1]

arr2 [1, 0]

arr2 [1, 1]

arr2 [1, 2]

Definition [Arrayname] [[Index 1],[Index 2]] = [Wert D1D2];

69

arr2 [0,1] = 32; arr2 [0,2] = 45;

Definition & Deklaration [Datentyp] [ , ] [Arrayname] = { {[0,0],[0,1],[0,2],…}, {[1,0],[1,1],[1,2],…}, ... }; int [ , ]arr235 = { {1,2,3,4,5}, {5,6,7,8,9}, {11,12,13,14,15} };

Abbildung 32 – Ausgabe TestArray 70

4.5 Strings Buchstaben, Wörter oder andere Zusammensetzungen von Zeichen / Symbolen

haben

in

der

Programmierung

die

Bezeichnung Strings. Das Grundprinzip von Zeichenketten basiert auf Arrays und dem Datentyp char. Nichts anders ist ein String, nämlich eine Reihe von ‚char‘ – Zeichen. In der Sprache C, welche ohne Klassen auskommt, basiert der Umgang mit Strings auf folgender Logik und ist teilweise sehr umständlich. char Textbeispiel [11] = {'M','u','s','t','e','r','t','e','x','t',0};

Das Textbeispiel soll zeigen, wie kompliziert das Arbeiten mit Wörtern beim Programmieren ohne vorbereitete Klassen eigentlich ist. Eine Besonderheit besteht darin, dass das Ende eines Objekts durch eine Null gekennzeichnet wird. Das Beispielwort hat zwar nur 10 Zeichen, jedoch muss für das Char - Array die abschließende Null berücksichtigt werden und somit eine Größe von 11 Zeichen reserviert werden. Dank der Klasse System.String kann die Schreibweise abgekürzt werden. Dadurch werden Zeichenketten sehr ähnlich behandelt wie Variablen oder Arrays. string Textbeispiel = “Mustertext“; 71

4.6 System.Console.Read & Write Gerade in Konsolenanwendungen ist die Ein- und Ausgabe ein sehr zentrales Mittel um Programme zu steuern. Außerdem gibt es mehrere Methoden der Klasse Console um dies zu tun.

Ausgabe – Methoden

WriteLine( ) Diese Methode System.Console.WriteLine( ) wird bereits in Hello World! verwendet. Damit können diverse Inhalte, seien es Variablen oder sogenannte Literale, ausgegeben werden. Die Besonderheit dieser Funktion ist, dass die Ausgabezeile abgeschlossen wird. Der nächste Output geschieht automatisch in der nächsten Zeile. Tipp: geben Sie in der IDE ‚cw‘ ein und drücken Sie zweimal die ‚Tab‘ – Taste. Das ist auf Dauer eine große Zeitersparnis.

Write( ) Ist

dieses

gleichwertige

Verhalten Methode

nicht

erwünscht,

kann

System.Console.Write( )

die

sonst

verwendet

werden. Die Zeile wird nicht abgeschlossen, die nächste Ausgabe passiert direkt im Anschluss.

72

$ { } Zeichenfolgeinterpolation Durch die Verwendung des Dollar – Zeichens kann eine gemischte Ausgabe von Variablen und Literalen stattfinden. Die Position ist direkt vor dem Ausgabestring zu wählen, d.h. vor den ersten Anführungsstrichen ‚ “ ‘. Innerhalb des Strings kann nun mit den geschweiften Klammern eine beliebige Variable eingefügt werden. string Name = “John“; byte Alter = 26; Console.WriteLine($“Das ist {Name}. Er ist {Alter} Jahre alt.“) Konsolenausgabe: Das ist John. Er ist 26 Jahre alt.

\ Escapesequenzen In Kombination mit Strings können durch einen Rückschrägstrich (oder auch ‚Backslash‘) verschiedene Aktionen eingeleitet werden. Zum einen ist das dringend notwendig, beispielsweise um die Ausgabe von Anführungsstrichen zu ermöglichen, zum anderen ist es so möglich den Code übersichtlicher zu gestalten. Es ist die Rede von Escapesequenzen, welche im String eingebaut werden.

73

Escapesequenz

Beschreibung

\n

Neue Zeile

\t

Tab (Tabulator)

\‘

‘ Einfaches Anführungszeichen (Verwendung relevant bei Chars)

\“

“ Doppeltes Anführungszeichen

\\

\ Rückschrägstrich; Backslash

Wie immer ist ein Beispiel zur Visualisierung am besten:

Abbildung 33 – Escapesequenzen

74

Eingabe – Methoden Für die Eingabe gibt es ebenfalls mehrere Methoden. Diese sind Read( ),

ReadKey( )

und

ReadLine( ).

Die

Unterschiede

bestehen darin, wie der gegebene Inhalt interpretiert werden soll. Es wird bei der Konsole der Standardeingabestrom verwendet. Dabei handelt es sich um die gängige und weit verbreitete Tastatur.

Console.ReadLine( ) Die wichtigste Eingabefunktion ist diese (Zeile 3). Egal welche Eingabe stattfindet, sie wird zunächst als String interpretiert. D.h. es macht Sinn eine String – Variable anzulegen (Zeile 1), um die Eingabe zu speichern (Zeile 2). string Name; Name = Console.ReadLine();

//siehe Konsole Z.1

Console.WriteLine($“Der Name ist: {Name}“);

Abbildung 34 – Console.ReadLine( )

75

Convert.To... Danach besteht die Möglichkeit diesen String in egal welchen Datentyp zu wandeln. D.h. im Workflow und in der Lesbarkeit des Codes gibt es die Möglichkeit für ein Muster.

Abbildung 35 – Conver.To…

Sobald ‚Convert.To[…]‘ eingegeben worden ist, erscheint ein Auswahlmenü, in dem die wählbaren Methoden vorgeschlagen werden. Zur Wiederholung sollen erneut die .NET - Datentypen genannt werden, diesmal mit der ausführlichen Bezeichnung. Eine

der

Möglichkeiten

ist

die

Umwandlung

in

eine

Ganze Zahl (int). Der C# - Datentyp dafür heißt Int32, weshalb die zu wählende Methode ‚ToInt32( )‘ ist. In den runden Klammern wird die String - -Variable eingegeben.

76

Convert

.NET - Datentyp

-Methode

Stichwort Deklaration Variable

.ToBoolean

System.Boolean

bool

.ToByte

System.Byte

byte

.ToChar

System.Char

char

.ToDecimal

System.Decimal

decimal

.ToDouble

System.Double

double

.ToSingle

System.Single

float

.ToInt32

System.Int32

int

.ToInt64

System.Int64

long

.ToSByte

System.SByte

sbyte

.ToInt16

System.Int16

short

.ToString

System.String

string

.ToUInt32

System.UInt32

uint

.ToUInt64

System.UInt64

ulong

.ToUInt16

System.UInt16

ushort [3]

77

Beispielhaft, kann also das Alter eingegeben und verrechnet werden. Gegenüber dem letzten Beispiel wird also eine weitere Variable vom

Typ

int

angelegt

und

durch

die

Methode

Convert.ToInt32(Alter) befüllt. Es wird in der nächsten Zeile nicht nur die eigene Eingabe ausgegeben, sondern auch ein verrechneter Wert. Das Rechnen ist in dieser Situation genauso gut möglich und es werden die bekannten Rechenregeln angewandt, wie z.B. „Punkt vor Strich“. Hier: Division vor Addition.

Abbildung 36 – Convert.ToInt32

Ein Nachteil, der dabei entsteht ist die mögliche Abweichung des Zieldatenformats. Der Vorteil ist, dass es die Möglichkeit gibt mit solchen Ausnahmen umzugehen. Im Englischen wird das als ‚Exception‘

bezeichnet

und

der

‚Exception Handling‘. 78

Umgang

mit

solchen

Exception Handling In der Ausführung des Programms sieht eine Falschverwendung so aus:

Abbildung 37 - Exception

Beispielsweise wird ein Buchstabe eingegeben, aber eine Zahl wird erwartet.

Abbildung 38 – Exception Message

Das Programm stürzt ab, weil die Umwandlung in eine Ganze Zahl

gefordert

ist,

ohne 79

dass

das

möglich

ist.

Das

mögliche

Versagen

des

Programms

kann

jedoch

vorhergesehen werden und der angestrebte Befehl sollte daher besser als ‚Versuch‘ definiert werden. Im Code geschieht das, durch die Befehle ‚try{ }‘ und ‚catch{ }‘ (Zeile 11 und 15 in Abbildung 39). Ersterer (try) wird grundsätzlich ausgeführt. Nur im Falle eines Fehlers kommt es zu der Ausführung des zweiten Codes (catch). Für diese Methode wird eine lokale Variable ‚e‘ der Klasse ‚Exception‘ erzeugt. Die Formulierung ist Teil des objektorientierten Programmierens. Später, wenn die Grundlagen klar sind, wird alles dazu ausführlicher beschrieben.

Abbildung 39 – Exception handled

80

Wichtig ist, dass so für die WriteLine – Methode die Ausgabe der ‚e.Message‘ stattfinden kann (siehe Konsole Zeile 2). Durch die allgemeine Nennung von ‚Expecption‘ werden alle Fehler gleichwertig erkannt. Die Ausgabenachricht ist jedoch genau passend und verhindert, dass das Programm abstürzt. Damit die Fehleingabe nicht nur abgefangen wird, sondern auch die

Möglichkeit

goto – Befehl

einer

innerhalb

Neueingabe der

besteht,

catch - Anweisung

kann

der

verwendet

werden. Damit ist hier ein Sprung von Zeile 19 zu Zeile 9 möglich, direkt vor die Nutzereingabe. Die Bezeichnung des Navigationspunkts, welcher sich in Zeile 9 befindet, ist frei wählbar, woraufhin die Syntaxzeile durch einen Doppelpunkt vervollständigt wird. Mit goto kann genau zu dieser Zeile gesprungen werden. So hat der Benutzer im Falle einer Falscheingabe so oft wie nötig die Möglichkeit zur Korrektur. Innerhalb der catch – Anweisung können weitere unterstützende Hinweise stattfinden. Alles bis hierher kann als Basisgrundlage bezeichnet werden. Es ist nun bekannt, wie die erzeugten Variablen und Arrays verschiedener

Datentypen

miteinander

verrechnet

und

verglichen werden können. Des Weiteren ist die Interaktion mit der Konsole ein zentrales Mittel um diese Grundlagen sinnvoll umzusetzen. Im nächsten Schritt kommen Verzweigungen hinzu. 81

4.7 Verzweigungen Bei einer Spazierrunde durch den Wald ist meist die ungefähre Position

des

Wunschausgangspunkts

bekannt,

z.B.

der

Parkplatz an dem das Auto steht. Dabei sind mögliche Gedanken: „Bei der nächsten Abbiegung sollte ich am ehesten Richtung Osten. Wenn das nicht möglich ist, sollte ich zumindest geradeaus weitergehen können. Ansonsten muss ich dem Weg folgen wie er gebaut wurde. Oder vielleicht sogar: Querfeldein.“

if - Verzweigungen Beim Programmieren geschieht dies durch die Verzweigungen if, else if oder else. Die Verwendung von ‚if‘ ist logischerweise an eine oder mehrere Bedingungen

geknüpft.

Wenn

eine

if – Verzweigung

in

Zusammenhang mit weiteren Bedingungen stehen soll, können im Weiteren else if - Bedingungen angefügt werden. Else deckt dann alle anderen möglichen Fälle ab. Es kann also berücksichtig werden, dass nicht alle Umstände vorhergesehen werden können.

82

Abbildung 40 – Verzweigungen

Allein

die

Information

über

die

Existenz

bestimmter

Programmiermethoden wird Sie nicht weiterbringen. Regelmäßige Beispiele und Übungen hingegen schon. Schreiben Sie dazu am besten den Code ab und überlegen Sie dabei schon was denn voraussichtlich passieren wird. Führen Sie ihn anschließend mit der Entwicklungsumgebung aus. Spätestens nachdem das Ergebnis betrachtet worden ist sollte das Beispiel nachvollziehbar sein.

83

Beispiel 1

// Überprüfen einer ganzen Zahl

Abbildung 41 – Beispiel 1 | Überprüfen einer Zahl

Erklärung: In diesem Beispiel werden Variablen und Verzweigungen verwendet. Gesteuert wird das Programm mit Ein- und Ausgaben. In Zeile 8 wird eine Variable namens ‚x‘ deklariert, sie sei vom Typ int. Mit der Textausgabe in Zeile 9 wird der Nutzer auf eine Eingabeaufforderung vorbereitet. Diese findet in Zeile 11 statt und ordnet dem String ‚Zahl‘ die Nutzereingabe zu. Auch dafür ist in Zeile 7 eine Variable, aber vom Typ string, deklariert worden. Das erzeugen einer gesonderten Variablen ist sehr übersichtlich und es kann dadurch gut nachvollzogen werden, warum die

84

verwendeten Methoden eingesetzt werden. Tatsächlich ist auch eine direktere Vorgehensweise möglich. Zeile 7 bis 12 kann mit folgender Alternative formuliert werden: int x; Console.Write("Geben Sie eine beliebige ganze Zahl ein\t"); Nutzereingabe: try {x = Convert.ToInt32(Console.ReadLine()); }

Im restlichen Programm werden nun drei Bedingungen abgeprüft, woraufhin gegebenenfalls der zutreffende Text ausgeben wird. Dazu wird in den runden Klammern nach der if – Verzweigung ein mathematisches Gesetz formuliert. Beim Zutreffen der Bedingung wird der Befehlskörper geöffnet, welcher durch die geschwungenen Klammern dargestellt wird. Bei nichtzutreffen wird der Befehlskörper missachtet. Es fällt auf, dass das Abprüfen einer Variablen auf Gleichheit (Zeile 16) mit doppelten Gleichzeichen stattfindet. Mit einem einzigen würde ihr Wert verändert werden, das ist in diesem Fall unzulässig! Die else – Verzweigung in Zeile 20 führt zum gleichen Ergebnis wie die else if – Bedingung ( x > 0 ), denn schließlich ist eine ganze Zahl entweder größer oder kleiner oder gleich Null.

85

Abbildung 42 – Beispiel 1 | Konsole

Kopiervorlage: public static void Main() { int x; Console.Write("Geben Sie eine beliebige ganze Zahl ein\t"); Nutzereingabe: try {x = Convert.ToInt32(Console.ReadLine());} catch (Exception e) {

Console.WriteLine(e.Message); Console.Write("Ups. Try again!\t"); goto Nutzereingabe; if (x