Einstieg in C# - Software programmieren wie ein Profi

Egal ob Spiele, Web-, Mobile- oder Desktop-Apps - Du brauchst Methodik und die Grundlagen von C#. Beides lernst du hier.
4.5 (103 ratings) Instead of using a simple lifetime average, Udemy calculates a
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
429 students enrolled
$125
Take This Course
  • Lectures 107
  • Length 11.5 hours
  • Skill Level Beginner Level
  • Languages German
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

About This Course

Published 2/2016 German

Course Description

NEU: Lektionen zur Verwendung von GitHub mit Visual Studio

Mache diesen Kurs und du hast in 30 Minuten deine erste C#-Anwendung entwickelt. Viel wichtiger ist jedoch, dass du nicht nur Programmieren lernst, sondern die Arbeitsweise, die professionelle Softwareentwickler verwenden um herausragende Anwendungen zu entwickeln.

Was du lernst

Dieser Kurs vermittelt dir NICHT alle Details der Programmiersprache C#. Er gibt dir einen Einstieg und Überblick der wichtigsten Konzepte, Arbeitsweisen und befähigt dich mehr Details alleine schnell zu lernen.

Damit bist du in der Lage sowohl deine eigenen Softwareprojekte zu starten, wie auch schnell in einem bestehendem Softwareentwicklungsprojekt mitarbeiten zu können. Du hast eine nervige Aufgabe, die sich immer wiederholt? Dann erstelle dir eine Anwendung, die dir die Aufgabe abnimmt oder dich dabei unterstützt sie schneller zu erledigen. Alles was du dafür brauchst, lernst du in diesem Kurs. Die benötigten Werkzeuge und viele weitere Informationen gibt es kostenlos im Internet. Ich zeige dir wo und begleite dich Schritt-für-Schritt bei der Installation, Verwendung und natürlich, wenn du Probleme hast.

Du willst zukünftig Web- oder Mobile-Apps vielleicht sogar für verschiedene Plattformen entwickeln? Dann ist .NET und insbesondere C# eine gute Wahl. Microsoft öffnet .NET immer mehr und es stehen bereits jetzt viele beeindruckende Hilfsmittel und Projekte zur Verfügung um auch unter Linux und OS X mit C# zu entwickeln. Sobald du die Grundlagen verstanden hast, kannst du in das für dich relevante Gebiet eintauchen.

Auch im Bereich der Spieleentwicklung wird C# seit vielen Jahren erfolgreich eingesetzt. Die Entwicklung von Spielen ist NICHT Gegenstand dieses Kurses. Allerdings bringt jedes Spiel ein übliches Problem in der Softwareentwicklung mit sich: Komplexität. Gerade weil du bei der Entwicklung von Spielen dich mit sehr vielen verschiedenen Aspekten beschäftigen musst, hilft dir eine strukturierte Arbeitsweise sehr. Hast du also schon ein Grundverständnis von C# und wie du ein Projekt umsetzen kannst, kannst du dich im nächsten Schritt voll auf deine Idee und Frameworks wie Unity, XNA oder MonoGame konzentrieren.

Wie du mit diesem Kurs lernst ...

... als absoluter Einsteiger: Gerade zu Anfang des Kurses zeige ich dir Alles. Während ich dir im Video zeige wo du die Entwicklungsumgebung Visual Studio 2015 bekommst, wie du sie installierst und das erste mal startest, was du machen musst um dein erstes Projekt zu erstellen und wie du deinen ersten Quellcode schreibst, kannst du diese Schritte direkt nachvollziehen. Zusätzlich gibt es zu jedem Abschnitt eine Übung bei der ich dir eine Aufgabe stelle und dann zeige wie ich sie lösen würde.

... als Umsteiger: Du brauchst nicht mehr soviel Details wie ein absoluter Einsteiger. Daher gibt es zu allen Lektionen eine kurze schriftliche Zusammenfassung. So kannst du die ersten Abschnitte schnell durcharbeiten und hast in Kürze eine produktive Arbeitsumgebung. Anhand der Übungen und Musterlösungen kannst du feststellen welche Bereich du bereits verstanden hast und wo du tiefer eintauchen solltest.

Dir zu vermitteln was professionelle Softwareentwicklung ist und welche genialen Möglichkeiten dir die .NET-Plattform bietet ist mein Ziel. Häufig ist es jedoch so, dass man während der Softwareentwicklung und insbesondere während des Lernens alleine nicht weiter kommt. Die fehlende Interaktion mit dem Dozent hat mich bisher bei Videotutorials immer gestört. Bei diesem Kurs hast du die Möglichkeit deine Probleme und Fragen direkt im Diskussionsforum zu diesem Kurs zu stellen. Dann bekommst du schnell Unterstützung von mir oder einem deiner Mitstudenten.

Da du diesen Kurs zusätzlich zu vielen anderen Aufgaben erledigen wirst, ist er so aufgebaut, dass du nicht mehr als 15-20 Minuten am Tag machen musst. Aus eigener Erfahrung weiß ich, wie anstrengend es ist neben dem Beruf auch noch eine oder gar mehrere Stunden am Tag für Weiterbildung aufzubringen. Häufig ist das der Anfang vom Ende, weil du nach wenigen Tagen einfach keine Motivation mehr hast (egal wie spannend das Thema und der Kurs ist). Du entscheidest natürlich selbst, aber ich empfehle dir jeden Tag wenige Lektionen anzuschauen und etwas zu üben. So wirst du innerhalb weniger Wochen beeindruckende Resultate sehen.

Zum Schluss

Ich bin beeindruckt, dass du bis hier gelesen hast. Du hast auf jeden Fall die Veranlagung ein professioneller Softwareentwickler zu werden. Einer der wichtigsten Aspekte dafür ist der Wille kontinuierlich zu lernen und die Neugierde was es noch alles gibt.

Viel Spaß beim Lernen und dem Kurs

Jan

What are the requirements?

  • Du solltest einen Computer mit Microsoft Windows besitzen und bedienen können: Im Dateisystem navigieren können, ...
  • Du brauchst KEINE Programmierkenntnisse!
  • Du solltest die kostenlose Visual Studio 2015 Community Edition verwenden. In den ersten Lektionen erfährst du, wo du sie bekommst und wie du sie installierst.

What am I going to get from this course?

  • Die Fähigkeit professionell Software zu entwickeln. Vom Aufnehmen der Anforderung bis zum Erstellen einer Installationsroutine.
  • Du hast die Grundlagen um mit Spieleframeworks wie Unity, XNA, MonoGame und anderen zu starten.
  • Du hast die Grundlagen um Web- und Mobile-Apps im .NET Kontext zu entwickeln.
  • Selbstständig die Entwicklung einer eigenen C#-Anwendung zu starten und in kleinen Iterationen voranzutreiben.
  • C# Quellcode mit Klassen und Methoden zu strukturieren.
  • C# Quellcode zu analysieren und zu verändern.
  • C# Syntax und Bibliotheken verwenden zu können.
  • C# Anwendungen testen zu können.
  • Sich in einem Softwareentwicklungsprojekt zurecht zu finden.
  • Eigenständig in einem Softwareentwicklungsprojekt Fehler beheben und Änderungen machen.
  • Du hast einen Überblick über die Kernaktivitäten in einem Softwareentwicklungsprojekt und kannst dich dann in DEINEM Thema spezialisieren.
  • Schnell und nachhaltig mehr C#-Syntax lernen.
  • Praktische Erfahrung in der professionellen Softwareentwicklung mit C# durch viele Übungen und Beispiele die wir gemeinsam machen.
  • Die Möglichkeit den Inhalt des Kurses mit zu bestimmen, weil er kontinuierlich weiter entwickelt wird.

What is the target audience?

  • Einsteiger, die noch keinerlei Erfahrung im Programmieren haben.
  • Umsteiger, die bereits etwas Erfahrung in einer anderen Programmiersprache haben, aber die .NET-Platform noch nicht kennen.
  • C#-Programmierer, die sich eine professionelle Arbeitsweise aneignen wollen.
  • Fach- und Führungskräfte, die ein Grundverständnis für Softwareentwicklung erlangen wollen.

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.

Curriculum

Section 1: Wie du das meiste für dich aus dem Kurs heraus holst
02:35

Willkommen im Kurs!

05:47

Talking Head

  • Es bleibt dir überlassen ob du den Kurs in einem Rutsch durcharbeitest, oder in vielen kleinen Schritten.
  • Kleine Schritte sind optimal, wenn du "nur" nebenbei lernst (Du hast neben deinem Beruf/Studium nur ein bisschen Zeit).
  • Abwechslung zwischen Theorie und Praxis hilft dir, dass du das gelernte auch wirklich abrufst.
  • Mini-Gewohnheiten: Wenigste Motivation bzw. Willenskraft, wenn du viele kleine Schritte machst. Das ist übrigens auch der beste Weg bei der Entwicklung von Sofwtare.
  • Deliberate-Practise: Fokussiere dich auf ein Thema, übe dies in Isolation, hole Dir Feedback und dann übe es immer wieder
  • Wissensabruf hilft gegen vergessen
02:36

Ohne Quellcode gibt es keine Softwareentwicklung. Daher ist es wichtig, dass du ich damit intensiv beschäftigst. Um dir den Einstieg zu erleichtern biete ich dir verschiedene Möglichkeiten an um den Quellcode zu diesem Kurs zu bekommen bzw. anzuschauen.

Die Details erkläre ich dir in dieser Lektion. Ganz wichtig sind die Ressourcen zu dieser Lektion. Dort findest du nämlich den kompletten Quellcode und viele weitere Links.

03:06

Neben den Übungen hier im Kurs habe ich weitere kostenlose Übungen für dich im Internet. Schau doch mal bei http://www.lernmoment.de/csharp-challenge/ vorbei.

Section 2: In 30 Minuten: Erstelle deine erste C#-Anwendung und lerne Visual Studio kennen
02:22

Installiere die kostenlose Community Edition von Visual Studio 2015. Das ist eine Entwicklungsumgebung. Du verwendest sie um Quellcode zu schreiben, diesen in ein ausführbares Programm zu übersetzen, dein Programm zu testen und (was wir nicht hoffen wollen, aber erfahrungsgemäß immer vor kommt) Fehler zu finden.

Du lernst in dieser Lektion die folgenden Punkte:

  • Was eine Entwicklungsumgebung ist und
  • wie du Visual Studio 2015 installierst.
01:20

Auch wenn du die Funktionen nicht brauchst, die Microsoft dir durch die Registrierung freischaltet, musst du dich registrieren.

04:25

In dieser Lektion wirst du in Visual Studio dein erstes Projekt erstellen. Es gibt viele Arten von Projekten, aber das mit Abstand einfachste ist die Konsolenanwendung. Mit diesem Projekt kannst du eine C#-Anwendung erstellen, die in der Konsole läuft. Das ist zwar nicht so hübsch wie eine tolle Benutzeroberfläche, aber gerade um einfache Aufgaben zu automatisieren absolut ausreichend.

Diese Lektion beinhaltet die folgenden Aktivitäten:

  • Grundeinstellungen für Visual Studio beim ersten Start vornehmen
  • Projekt erstellen mit dem entsprechenden Assistenten in Visual Studio
  • Die wichtigsten Fenster / Bereiche in einem Visual Studio Projekt kennenlernen
  • Das Projekt zum ersten mal ausführen
03:55

Quellcode ist der Weg, wie du deinem Computer sagen kannst, was er für dich tun soll. Das ist schließlich das Ziel einer jeden Softwareentwicklung bzw. des Programmierens. Das Unglaubliche am Programmieren ist, dass du in strukturierter Weise dem Computer sagen kannst was er für dich tun soll. Wenn du das richtig gemacht hast, kann der Computer diese Aufgabe fast unendlich oft wiederholen und für dich ausführen. Es geht also beim Programmieren darum, dass der Computer dir Arbeit abnimmt, die du sonst immer wieder von Hand ausführen müsstest.

Mit jeder Anwendung die du entwickelst, kannst du also richtig Zeit sparen. Grund genug endlich los zulegen!


Hier lernst du folgende Punkte:

  • Was ist Quellcode?
  • Den Unterschied zwischen Syntax und Bibliotheken
09:04

Diese Lektion fokussiert sich ganz auf das Editorfenster in Visual Studio und was du darin siehst. Es geht darum, dass du ein erstes kleines Programm schreibst und erste Elemente im Quellcode kennen lernst. Momentan ist es noch nicht so wichtig, dass du alles verstehst, sondern du sollst ein erstes Gefühl für das Programmieren bekommen.

Als erstes Beispiel wird ein "Hallo Welt!" Programm entwickelt. Dabei handelt es sich um eine der einfachsten Anwendungen überhaupt. Ziel ist es lediglich die Aussage "Hallo Welt!" auf dem Bildschirm zu sehen. Dadurch lernst du die ersten Befehle einer Programmiersprache und siehst die wichtigsten Elemente der Entwicklungsumgebung.

Diese Lektion beinhaltet die folgenden Aktivitäten:

  • Das Editorfenster von Visual Studio kennenlernen
  • Die Blöcke des bereits vorhandenen Quellcodes kennenlernen
  • Deinen ersten Quellcode in C# erstellen
07:40

Nachdem der Quellcode erstellt wurde, muss er nun in eine Form übersetzt werden, welche für den Computer verständlich ist. Der Prozessor als zentraler Befehlsausführer in deinem Computer versteht Quellcode nicht direkt. Es gibt immer irgendein Werkzeug, welches den Quellcode auf bereitet, so dass der Prozessor ihn ausführen kann.


In C# heißt dieser Schritt kompilieren. Dabei wird der von dir erstellt Quellcode durch Werkzeuge wie Compiler, Assembler und Linker in eine ausführbare Datei übersetzt. Erst diese ausführbare Datei kann dann von deinem Computer ausgeführt werden.


In dieser Lektion lernst du, welche Schritte du in der Entwicklungsumgebung ausführen musst, um deinen Quellcode in eine ausführbare Datei umzuwandeln.

06:40

Sowohl das Ausführen wie auch das Testen von Anwendungen hast du bestimmt schon mal gemacht. Es bedeutet nichts anderes, als das du eine Anwendung startest und schaust ob sie die Aufgaben die sie für dich erledigen soll auch richtig macht.


In dieser Lektion verwendest du Visual Studio um die "Hallo Welt" Anwendung auszuführen. Du wirst sehen, dass sie sich noch nicht ganz so verhält, wie das ursprünglich gedacht war. Um den "Fehler" zu finden verwendest du den "Debugger" innerhalb von Visual Studio um die Anwendung in einzelnen Schritt durchzugehen.

05:50

Nachdem du in der vorherigen Lektion gesehen hast, dass die "Hallo Welt" Anwendung noch nicht ganz so läuft wie sie soll, geht es nun darum, diesen Fehler zu beheben indem die 3 Schritte der Programmierung nochmals ausgeführt werden.


Dieses Vorgehen ist für das Programmieren üblich. Es wird sich in kleinen Schritten an das eigentlichen Ziel heran gearbeitet.

3 questions

In diesem Quiz werden die Grundlagen des Programmierens abgefragt. Damit kannst du überprüfen, ob du die Lektionen in diesem Abschnitt verstanden hast, bzw. ob du sie dir überhaupt anschauen musst.

Zusammenfassung - Quellcode schreiben, kompilieren und ausführen
05:06
Section 3: Übung für Anfänger - Habe keine Angst!
02:18

Erstelle eine neues Projekt mit Visual Studio. Es soll wieder ein Konsolenprojekt sein und Ziel ist es, dass du den Satz "Hallo Jan, ich heiße ...!" und anstelle ... deinen Vorname ausgibst. Genau wie bei der "Hallo Welt!" Anwendung, soll sich das Fenster erst schließen, wenn du eine Taste betätigst.

Wenn du die Anwendung erstellt ausgeführt und getestet hast, solltest du sie einmal an einen anderen Ort kopieren und da ausführen. Dabei kann es sich um einen anderen Rechner handeln, oder auch einfach nur ein anderes Verzeichnis.

Ziel dieser Übung ist es, dass du dich mit Visual Studio und der Arbeitsweise vertraut machst und etwaige Berührungsängste abbaust.

Solltest du Probleme mit dieser Übung haben, dann kannst du nochmals in den bisherigen Lektionen nach einer Lösung suchen, oder dein Problem im Diskussionsforum beschreiben. Ich werde dich dann umgehend unterstützen.

03:41

Früher oder später wird es dir passieren, dass du viele Projekte im Versuchsstadium rum liegen hast. Vielleicht hast du mal einen falschen Projekttyp ausgewählt oder hast einfach nur eine Kleinigkeit ausprobiert. Damit du dich nicht immer durch viele Projekte wühlen müsst, zeige ich dir wie du Projekte von Visual Studio löschen kannst.

Visual Studio legt alle wichtigen Informationen in Form von Dateien in das Dateisystem. Sofern du dein Projekt im Pfad erstellst, den Visual Studio vorschlägt, findest du deine Projekte in "Dokumente/Visual Studio 2015/Projects". Darin findest du für jedes von dir angelegte Projekt ein Unterverzeichnis. Wenn du das richtige Unterverzeichnis, also das mit dem Namen des Projektes welches du entfernen willst, gefunden hast, kannst du das Unterverzeichnis einfach löschen.

07:07

Gerade zu Anfang können die Meldungen des Compilers unklar sein. Wenn dein Quellcode einen Fehler hat, dann siehst du das spätestens nach dem "Starten" in der "Fehlerliste". Dort gibt es neben vielen anderen Informationen auch den Fehlercode. Dabei handelt es sich um einen Link, der automatisch im Internet nach diesem Fehler sucht.

Eine gute Quelle für mehr Informationen zu einem Fehler ist http://msdn.microsoft.com Auf dieser Seite von Microsoft gibt es zu jedem Fehler den der Compiler meldet eine detaillierte Beschreibung.

Auch mit weiteren Details wirst du nicht immer aus den teilweise kryptischen Meldungen des Compilers schlau werden. Daher kannst du jeden Fehler aus der Fehlerliste mit dem entsprechenden Punkt aus seinem Kontextmenü kopieren. Damit kannst du einen Eintrag im Udemy Diskussionsforum zu diesem Kurs erstellen. Ich werde dich dann bestimmt in die richtige Richtung lenken können.

Wie ich die Aufgabe gelöst habe
03:41
Section 4: Intermezzo - Softwareentwicklung ist mehr als nur Programmieren
05:06

Für den Beruf wie auch für die Arbeit in Open Source Projekten ist es wichtig eine Vorstellung von den Arbeitsabläufen zu haben und was eine professionelle Software ausmacht. Dies ist viel wichtiger als die kleinsten Details der Programmiersprache zu verstehen.

Auch für den privaten Bereich ist es extrem hilfreich, wenn du dir einen erprobten und systematischen Arbeitsablauf aneignest. Mit der Entwicklung von Software kannst du enorm viel Zeit verbringen. Um auch irgendwann für dich erfreuliche Resultate zu sehen, ist es wichtig, dass du gerade zu Anfang dir eine systematische Arbeitsweise aneignest.

Bisher im Kurs hast du gelernt, dass die wichtigsten Schritte beim programmieren das Erstellen von Quellcode, das Kompilieren und das Ausführen und Testen sind. Wie bekommst du deine Anwendung nun aber auf einen anderen Rechner, oder vielleicht sogar zu den vielen Leuten, die deine Anwendung auch haben wollen? Wie stellst du sicher, dass du auch das programmierst, was dein Chef oder du selbst haben willst? Bedenke immer, dass deine ersten Programme noch sehr übersichtlich sind. Es passiert aber enorm schnell, dass du tausende Zeile von Quellcode hast.

Wenn du dir nicht von Anfang an eine saubere Arbeitsweise aneignest, dann ist es hinter her viel schwieriger für dich.

01:44

Der Fokus liegt nicht so sehr auf der Syntax, sondern auf den einzelnen Aktivitäten, deren Zusammenhängen und den wichtigsten Konzepten. Anhand der Beispiels in diesem Kurs lernst du wie die Syntax auch ohne einen Kurs lernen kannst.

06:35
  1. Anforderungen aufnehmen
  2. Design erstellen
  3. Programmieren
  4. Testen
  5. Release
Section 5: Iteration #1 - Ein Taschenrechner der nur Addieren kann
04:26

Talking Head:

  • Definiert mit welchem Ziel du eine Software entwickelst
  • Anwender und die Anwendungsumgebung kennenlernen
  • Gewünschte / benötigte Funktionen verstehen
  • Priorisierung / Planung
  • Basis für die Testphase / Abnahme durch den Kunden
  • Methoden & Werkzeuge zum definieren von Anforderungen - Eigene Disziplin innerhalb der Softwareentwicklung
  • Arten von Anforderungen
10:01

Screencast

  • Zeigt wie ich die User Stories in Evernote schreibe
    • Addieren - Um (die Summe zweier Zahlen zu erhalten), möchte ich als (Benutzer) (zwei Zahlen und den + Operator eingeben).
    • Subtrahieren - Um (die Differenz zweier Zahlen zu erhalten), möchte ich als (Benutzer) (zwei Zahlen und den - Operator eingeben). -> Vielleicht noch nicht in dieser Iteration?
    • Starten - Um (den Taschenrechner einfach benutzen zu können), möchte ich als (Benutzer) (die Anwendung mit einem Doppelklick auf jedem Windowsrechner starten können).
  • Vorlage für Stories erklären: Um (den folgenden Nutzen zu erhalten), möchte ich als (Anwendertyp) (diese Funktion).
  • Akzeptanzkriterien (inkl. nicht funktionalen Anforderungen) definieren
07:12

Um bei der Umsetzung der User Story "Addieren" immer unser Ziel vor Augen zu haben, wollen wir die User Story im Quellcode haben. Allerdings ist es so, dass nur Quellcode nach C#-Syntax kompiliert werden kann. Um nun unsere User Story trotzdem im Quellcode anzuzeigen, gibt es einen Kommentar.

Dieser wird durch zwei // eingeleitet und bedeutet, dass der Compiler bis zum Ende der Zeile alles ignorieren kann. Besser gesagt, der ganze Kommentar wird beim kompilieren entfernt. Er dient lediglich für dich und andere die deinen Quellcode sehen zur Dokumentation.

Du bist absolut frei darin, was du in einen Kommentar schreibst. Allerdings ist die eigentliche Intention, dass er anderen Entwicklern hilft deinen Quellcode zu verstehen. Solch ein anderer Entwickler kannst auch du in wenigen Wochen sein. Dann nämlich weißt du vielleicht nicht mehr was genau du mit dem Quellcode gemeint hast. Dann ist es sehr praktisch, wenn du ein paar Hinweise in Form von Kommentaren hinterlassen hast.

07:41

Die Konsole, oder auch das Eingabeaufforderungsfenster wie es von Microsoft in der Übersetzung genannt wird, ist ein Fenster in der Text ein- und ausgegeben werden kann. Bei Konsolenanwendungen wie unserem "Hallo Welt!" und auch jetzt dem "Taschenrechner", ist dies die einzige Möglichkeit zur Interaktion mit dem Benutzer.

Willst du, dass der Benutzer dir etwas mitteilt, wie in diesem Fall den ersten Summanden, musst du ihm als erstes sagen, welche Eingabe du erwartest. Eine Ausgabe machst du mit "Console.WriteLine("Dein Text hier!")".

Danach kannst du auf die Eingabe des Benutzers warten. Dies kannst du beispielsweise mit "Console.ReadLine()" machen. Dann nimmt dein Programm alle eingegebenen Buchstaben bis zum nächsten "Return" entgegen. Wartest du direkt auf eine Eingabe, ohne vorher dem Benutzer mitgeteilt zu haben, was er machen soll, wird deine Anwendung quasi unbedienbar, weil der Benutzer eben nicht weiß, was er tun soll.

06:12

Wenn du dir die beiden Methoden ("ReadLine" und "WriteLine") aus der vorherigen Lektion genau anschaust, wirst du einen wesentlichen Unterschied sehen, "ReadLine" gibt dir Daten zurück und "WriteLine" nimmt welche entgegen. Dies ist verständlich, weil du mit ersterer eine Eingabe vom Benutzer erhalten möchtest, während du mit letzterer eine Ausgabe zum Benutzer machen möchtest.

Nun stellt sich die Frage was mit diesen Daten geschieht. Nehmen wir zum Beispiel die Eingabe. Du kannst in deinem Quellcode die Methode "ReadLine" so häufig verwenden wie du willst. Du könntest zum Beispiel sämtliche Kontaktdaten des Benutzers abfragen.

Allerdings hat der Prozessor nur sehr wenige Möglichkeiten sich diese Daten selber zu merken. Dafür gibt es den Hauptspeicher in dem er die Daten speichert um sie zu einem späteren Zeitpunkt wieder zu verwenden. Um dies zu erreichen, gibt es Variablen. Eine Variable ist nichts anderes als ein Bereich im Hauptspeicher deines Rechners in dem eine Information (z.B. Nachname, Geburtsdatum, ...) liegt. Da der Hauptspeicher ziemlich groß ist, hat jede Variable einen Namen. Wenn du diesen Namen im Quellcode verwendest, weiß der Rechner, dass er die entsprechenden Informationen aus dem Hauptspeicher holen soll und verwenden soll.

Du kannst dir das vorstellen wie deine Küche. In deiner Küche weißt du, wo die verschiedenen Dinge sind und hast Namen dafür. Wenn dir also ein Freund mit dem du in deiner Küche kochst sagt, dass er einen großen Topf braucht, dann weißt du genau in welche Schublade/Schrank du greifen musst. Du hast also den Platz für diesen großen Topf reserviert.

Wenn du also zwei Zahlen vom Benutzer eingeben lassen willst, dann brauchst du für jede eine Variable, in der du diese Zahl speichern kannst. Wenn du einer Variablen eine Zahl bzw. einen Wert zuweist, wird dieser an eine bestimmte Stelle im Hauptspeicher transferiert.

09:13

Ein wichtiger Bestandteil einer Variablen ist ihr Datentyp. In C# muss jede Variable einen Datentyp haben. Dieser gibt an, wie groß der zu reservierende Bereich im Hauptspeicher sein muss und beschreibt welche Art von Daten in einer Variablen gespeichert werden kann.

C# hat unterschiedliche Datentypen für Text (Zeichenketten) und für Zahlen. Dies hat den Vorteil der Typsicherheit. Damit ist gemeint, dass du nicht Äpfel mit Birnen vergleichst, oder im Beispiel der letzten Lektion, dass du nicht Töpfe mit Plastikschüsseln vergleichst.

Warum ist das wichtig? Stell dir einmal vor, dass du eine Plastikschüssel auf eine ganz normale Herdplatte stellst. Auch wenn eine solche Schüssel zwar ein Gefäß ist, ist sie jedoch nicht geeignet erhitzt zu werden. Sie würde schmelzen oder vielleicht sogar brennen.

Ähnlich ist es mit Variablen. Was sollte deiner Meinung nach passieren, wenn der Rechner eine Zahl mit einem Buchstaben addieren soll? Wir haben darauf keine Antwort und dann kann dein Rechner das erst nicht. Variablen werden also mit einem Datentypen versehen, damit für sie ausreichend Platz im Hauptspeicher reserviert werden kann und damit klar ist welchen Regeln sie folgen.

07:12

Von der Konsole bekommen wir grundsätzlich nur Zeichenketten. Dies ist, wie du in der letzten Lektion gesehen hast, etwas unpraktisch. Insbesondere, wenn wir addieren wollen. Dazu gibt es für C# die Klasse "Convert". Mit ihr kannst du, sofern die Regeln eingehalten werden, Datentypen in einander konvertieren.

05:22

In diesem Abschnitt haben wir bisher folgende User Story bearbeitet:

Titel: Addieren

Story: Als Benutzer möchte ich zwei Zahlen eingeben, um deren Summe berechnen zu lassen

Akzeptanzkriterien:

  • Zahlen zwischen 0 und 10 können addiert werden


Nachdem nun die Zeichenkette in Ganzzahlen konvertiert sind, brauchen wir nur noch die eigentliche Addition ausführen und testen ob die Anwendung auch tatsächlich die Anforderungen aus der User Story erfüllt.

Um auch später noch zu wissen welche Aufgaben wir erledigt haben, werden wir an unserer User Story kenntlich machen, dass wir sie getestet haben und als erledigt ansehen.

05:29

Hier eine praktische Anleitung und dann im nächsten Abschnitt eine theoretische Einheit dazu?

04:55

Wo der Quellcode zu diesem Kurs liegt habe ich dir bereits gezeigt. In dieser Lektion zeige ich dir, wie du ihn sehr einfach in Visual Studio importieren kannst. So kannst du einfach ein Projekt mit dem ganzen Quellcode erstellen und immer wieder als Referenz verwenden, wenn bei deiner eigenen Entwicklung etwas nicht ganz so klappt, wie es sollte.

04:28

In dieser Iteration hast du nicht nur C#-Syntax gelernt, sondern du hast Konzepte gelernt die du in jeder anderen Programmiersprache wieder findest.

Section 6: Übung - Addiere Zahlen mit unterschiedlichen Datentypen
14:00

Bisher kann unser Taschenrechner lediglich Ganzzahlen verarbeiten. Wenn wir also eine Kommazahl wie beispielsweise einen Geldbetrag (inkl. Cent) addieren wollen, geht das momentan nicht. Daher geht es in dieser Lektion um einen weiteren Datentypen.

In C# gibt es die Datentypen "float", "double" und "decimal". Sie alle können sogenannte Gleitkommazahlen darstellen. Die Idee dabei ist, dass du eine Ganzzahl nimmst und über einen Zusatz definierst wo das Komma ist. In einigen Anzeigen von Visual Studio siehst du dementsprechend Zahlen wie "314e2" was ausgeschrieben "3,14" entspricht.

Wichtig ist, dass sich float, double und decimal in ihrer Genauigkeit und Größe unterscheiden. Dies kannst du im Detail hier: https://msdn.microsoft.com/de-de/library/b1e65aza.aspx und hier https://de.wikipedia.org/wiki/Gleitkommazahl nachlesen.

Du solltest du also merken, dass obwohl ein float eine große Zahl darstellen kann, fehlt es teilweise an Genauigkeit. Wenn du große Zahlen mit großer Genauigkeit darstellen willst, musst du entweder double oder decimal verwenden.

01:13

Der Taschenrechner unterstützt bisher nur Ganzzahlen. In dieser Übung geht es darum, dass du eine Version erstellst, die nur Gleitkommazahlen addieren kann. Du kannst also eine komplett neue Version erstellen, die keine Ganzzahlen (int) unterstützt, sondern nur Gleitkommazahlen (float).

Wie immer führe bitte alle wichtigen Aktivitäten der Softwareentwicklung und der Programmierung aus. Du solltest also auch die Anforderungen (User Stories) entsprechend erweitern.

09:39

Hier zeige ich dir wie ich die Übung lösen würde

Section 7: Intermezzo - Kontrolle über Versionen und Änderungen
05:31

Talking Head -> Vielleicht Screencast und GitHub zeigen?

  • Lokal Änderungen verwalten
    • Dein Spickzettel für später
    • Ohne Furcht Änderungen machen
  • Gemeinsam mit anderen an einem Projekt arbeiten
    • Erkläre anderen was du gemacht hast
  • Es geht aber auch um ausgelieferte Versionen
    • Nächste Version mit neuen Funktionalitäten
    • Behebung von Fehlern in älteren Versionen
06:03

Du kannst die Versionsverwaltung unter anderem dafür benutzen, dass du Ideen oder Lösungswege ausprobierst. Jede Datei, die in der Versionsverwaltung gespeichert ist, kann auf einen vorherigen ihres Inhaltes zurück gesetzt werden. Dazu gehst du im Projektmappenexplorer auf die entsprechende Datei und öffnest deren Kontextmenü.

Sobald du Änderungen an einer Datei machst, die unter der Versionsverwaltung steht, wird diese Datei im Projektmappenexplorer mit einem roten Haken versehen. Dies zeigt an, dass es Änderungen an ihr gibt. Möchtest du die Änderungen wieder rückgängig machen, kannst du einfach die entsprechende Funktion aus dem Kontextmenü wählen. Du kannst dir auch sämtliche Änderungen die du seit dem letzten "commit" gemacht hast über die Funktion "Mit ungehinderten vergleichen..." anschauen.

Im Video zeige ich dir die anhand eines praktischen Beispiels.

05:51

Über die Versionshistorie kannst du dir sämtliche Änderungen anschauen die du an den Dateien gemacht hast. Die Funktion "Verlauf anzeigen...", die du ebenfalls über das Kontextmenü öffnen kannst, bekommst du sämtliche Änderungen die an der jeweiligen Datei vorgenommen wurden.

Die komplette Historie aller Änderungen (unabhängig von der Datei) findest du im Team-Explorer. Dort gibt es das Menü "Verzweigungen". Der Zweig (bzw. Branch) "master" ist hier momentan der richtige Anlaufpunkt für dich. Auch dort gibt es im Kontextmenü den Eintrag "Verlauf anzeigen...".

In der sich öffnenden Übersicht siehst du alle Commits. Wenn du einen einzelnen auswählst, siehst du sowohl deine Nachricht, wie auch alle von diesem Commit betroffenen Dateien.

09:20

Es gehören nicht alle Arten von Dokumenten und Dateien in die Versionsverwaltung. Alles was du selbst erstellst und nicht aus anderen Dateien erzeugt werden kann, ist wahrscheinlich in der Versionsverwaltung gut aufgehoben.

Visual Studio trifft bereits eine Vorauswahl von Dateien, die in die Versionsverwaltung gehen. So werden beispielsweise die erzeugte ausführbare Datei, also dein eigentliches Programm, welches du starten kannst, nicht mit in die Versionsverwaltung genommen. Das liegt daran, dass du es jederzeit wieder erzeugen kannst, wenn du den Quellcode und das Visual Studio Projekt hast.

Neben dem eigentlichen Quellcode und den dazugehörigen Dateien von Visual Studio solltest du allerdings auch andere Dokumente wie beispielsweise die Anforderungen bzw. in unserem Fall die User Stories versionieren. Je nachdem, welches Werkzeug du für die Erstellung und Verwaltung der Anforderungen benutzt, ist die Versionierung bereits enthalten, oder du kannst ebenfalls die Versionsverwaltung des Quellcodes dafür verwenden.

Um einen zentralen Zugriff und Verwaltung zu haben, werden wir die User Stories nun auch in unser Git-Verzeichnis legen. Somit haben wir den Quellcode und die Anforderungen immer synchron.

09:47

Wenn du eine Versionsverwaltung verwendest ist es keine gute Idee eine Information über die Version in den Namen einer Datei zu integrieren. Denn alles was für die Versionierung wichtig ist, sollte mit der Versionsverwaltung erledigt werden.

Daher werden wir nun auch unser Visual Studio Projekt umbenennen. Denn es trägt "Iteration_1" im Namen und im nächsten Abschnitt wollen wir mit Iteration 2 beginnen. Natürlich wollen wir auf dem bisherigen aufsetzen und daher steht uns "Iteration_1" im Weg.

Während der Umbenennung zeige ich dir auch gleich ein paar Einstellungen in Visual Studio wo der Name des Projektes verwendet wird. In den Einstellungen des Visual Studio Projektes kannst du beispielsweise den Namen der ausführbaren Datei, also die Datei die du startest um dein Programm zu starten, verändern. In der Datei AssemblyInfo machst du Einstellungen, die später in Windows sichtbar sind.

04:49

Die AssemblyInfo enthält Informationen, die später als Metadaten an deine ausführbare Datei gehängt werden. So kannst du beispielsweise den Namen deiner Firma, ein Copyright und ähnliches dort eintragen.

In dieser Lektion zeige ich dir, wie du automatisch die Versionsnummer generieren lässt. Dies ist hilfreich, wenn du dein Programm an andere Personen verteilst und von denen dann Rückmeldung über Fehler, Funktionen, ... bekommst. Wenn sie dir die Versionsnummer sagen, weißt du sofort mit welchem Stand sie arbeiten. Vielleicht hast du den Fehler oder die gewünschte Funktion schon in einer neuen Version eingebaut.

11:14

Bevor wir die Iteration 1 endgültig abschließen, erstellen wir in dieser Lektion gemeinsam ein kleines Release. Dazu fügen wir unserem Projekt eine Release Note und eine zip-Datei (mit den wichtigsten Artefakten aus Iteration 1) hinzu.

Außerdem werden wir in der Versionsverwaltung einen Tag erstellen. Damit können wir immer direkt sehen bis zu welchem Punkt wir für Iteration 1 gearbeitet haben. Auch ist es damit möglich genau diesen Stand wiederherzustellen, wenn wir später einmal noch daran arbeiten müssen.

00:54

Die Versionsverwaltung ist eines der wichtigsten Werkzeuge für jeden Softwareentwickler. Es gibt allerdings immer noch Entwickler die sich damit nicht auskennen, oder es nicht benutzen. Nach dieser Ansprache gehörst du sicherlich nicht dazu.

Section 8: Iteration #2 - Taschenrechner mit allen Grundrechenarten
08:43
  • Warum
    • Ziel: Eine Lösung finden die allen Anforderungen gerecht wird.
    • Damit du und andere sich einfacher zu recht finden können
    • Wiederverwendung
    • Wartbarkeit
    • Planbarkeit -> Aufgaben identifizieren und verteilen
    • Um Risiken zu identifizieren und vermeiden zu können
  • Was
    • Grundlegende Entscheidungen Treffen
    • Beschreibung der Struktur einer Software (ähnlich wie ein Bauplan)
    • Beschreibung des Verhaltens (Was machen die Bewohner in einem Haus?) - Erst damit kann eine Struktur validiert werden.
  • Wie
    • Architektur - Das große Ganze
    • Feindesign - Details für die Implementierung
  • Verschiedenste Arten der Modellierung
    • Eine Skizze auf einem Blatt Papier oder auf einer Tafel reicht häufig schon aus.
    • Komplexere Software wird häufig mit UML modelliert
    • Bei einigen Technologien bekommst du ein Grobdesign gleich mit dazu (Beispiel WPF)

    Das Softwaredesign beschäftig sich damit die grundlegende Struktur für eine Lösung zu modellieren. Die Anforderungen beschreiben den Problemraum. Während des Softwaredesigns (oder auch Entwurf genannt) wird der mögliche Lösungsraum erarbeitet und gleichzeitig auch eingeschränkt. Beim Entwurf werden viele wichtige Entscheidungen getroffen wie beispielsweise welche Technologien verwendet wird, welche Prinzipien und Muster verwendet werden, aber auch welche Teile der zukünftigen Software vielleicht gekauft werden können/sollen, wie anfallende Entwicklungsaufgaben auf das Team verteilt werden können und noch viele weitere. Dabei spielen ganz unterschiedliche Faktoren aus Bereichen wie Technik, Organisation und Projekt eine Rolle.
04:50

Bisher kann unser Taschenrechner lediglich Addieren. Nun sollten wir ein wenig Gas geben und wenigstens das Subtrahieren hinzufügen.

Auch wenn es in diesem Abschnitt um das Softwaredesign geht, wollen wir doch die wesentlichen Schritt der Softwareentwicklung in jeder Iteration ausführen. Daher werden wir in dieser Lektion gemeinsam die User Story "Subtrahieren" erstellen.

Da das Thema Softwaredesign ist, werden wir zusätzlich eine "User Story" einfügen, die sich mit der Umgestaltung beschäftigt. Wir erstellen also die User Story "Softwarestruktur". Daran veranschauliche ich, dass einer der zentralen Aspekte bei der Softwareentwicklung das schaffen von Werten für den Kunden ist. Wenn du Änderungen an deiner Software machst, die du nicht mit einem Vorteil für den Kunden begründen kannst, solltest du wenigstens nochmals überlegen ob du sie wirklich jetzt machen solltest. Andererseits ist es für die "Entscheider" im Projekt wichtig zu verstehen, wer gerade was macht. Es sollte also eine gute Transparent geben.

Der Kunde sollte immer im Fokus deiner Arbeit stehen! In der Softwareentwicklung mit all ihren Möglichkeiten und Komplexität ist es sehr leicht sich in Kleinigkeiten und Nichtigkeiten zu verlaufen. Um dieses möglichst früh zu erkennen, bzw. dieses zu vermeiden, solltest du immer wieder die Kundenbrille aufsetzen. Entweder du versuchst aus deiner Erfahrung heraus zu erahnen, was dein Kunde braucht, oder, was wesentlich besser ist, du involvierst deinen Kunden direkt.

05:10

Diese Aktivität führst du mindestens in jeder Iteration aus. Häufig wirst du den Feinentwurf sogar mehrfach während einer Iteration überarbeiten. Bei vielen Entwicklern ist es dabei so, dass diese Aktivität implizit gemacht wird. Sie denken also gar nicht darüber nach, sondern fällen Entscheidungen während sie Quellcode schreiben.

Ich bin der Ansicht, dass der Feinentwurf auf keinen Fall unnötig aufgebläht werden sollte oder etwas ist in das viel Zeit investiert werden sollte. Es hilft jedoch, wenn man sich ein paar Minuten zurück lehnt und explizit über die nächsten Schritte nachdenkt.

Viele der allgemeinen Prinzipien die für den Grobentwurf relevant sind, können und sollten auch für den Feinentwurf angewendet werden. In den folgenden Lektionen und Abschnitten wirst du einige dieser Prinzipien kennenlernen. Dabei sollte dir genau dies bewusst sein. Egal ob ich Prinzipien wie "Single Level of Abstraction" oder "Separation of Concerns" anhand eines kleinen oder großen Stück Quellcodes einführe. Du solltest immer beachten, dass sie im Feinentwurf wie auch im Grobentwurf angewendet werden können und sollten.

09:04

Methoden sind Container für Quellcode. Der größte Teil von Quellcode in C# wird innerhalb einer Methode geschrieben. Gleichzeitig sind sie die kleinste Einheit zur Strukturierung von deinem Quellcode.

Eines der Hauptziele von Methoden ist die Abstrahierung von Details. Du kannst logisch zusammenhängenden Quellcode in eine Methode packen und ihr dann einen aussagekräftigen Namen geben. Dieser Schritt wird als die Definition und die Implementierung einer Methode bezeichnet.

Das alles hat zum Ziel, dass Methoden in anderen Methoden verwendet bzw. aufgerufen werden können. So ergibt sich eine Hierarchie von Methodenaufrufen. Dabei sollte es bestenfalls so sein, dass je tiefer eine Methode in dieser Hierarchie liegt, sie um so mehr Details hat. Die letzte Methode in einer Hierarchie hat nur noch einfache Operationen (wie Berechnungen) und ruft keine weitere Methode mehr auf.

In dieser Lektion zeige ich dir, wie du eine einfach Methode definierst und verwendest. Wir sehen auch, dass wir bisher bereits einige Methoden verwendet haben und auch schon eine geschrieben haben.

09:31

Ein wichtiger Aspekt für die Implementierung, aber auch für das Design, ist die passende Abstraktionsebene. Es gibt ein Prinzip welches sich "Single Level of Abstraction" nennt. Dabei geht es darum, dass Quellcode in einer Methode möglichst immer auf dem gleichen Abstraktionsniveau liegen sollte. Wenn du beispielsweise in deiner Methode eine Methode aufrufst die eine komplexe 3D-Zeichnung ausgibt und gleichzeitig eine einfache Addition machst, dann sind das sehr unterschiedliche Abstraktionsniveaus.

Dies macht es schwer für andere Entwickler (inkl. dir selbst in einigen Wochen) deinen Quellcode zu verstehen. Du kannst das mit einem Zeitungsartikel vergleichen. Wenn du plötzlich eine sehr detaillierte Kleinigkeit als Überschrift hast, können die Leser mit dem Artikel nichts anfangen. Es wird einfach erwartet, dass alle Überschriften in einer Zeitung ein ähnliches Niveau haben.

Da Abstraktionsniveau immer etwas abstrakt ist ;-), finde ich den Begriff Symmetrie nicht schlecht. Der Quellcode in deiner Methode sollte eine gewisse Symmetrie haben. Wenn du also Berechnungen und Benutzereingaben auf der Konsole vermischst, dann hast du eher eine unsymmetrische Methode.

Genau das ist momentan der Fall bei unserer Main-Methode. Daher werden wir in dieser Lektion eine Methode für das Addieren schreiben. Damit wird dieses Detail aus der Main-Methode in eine eigene Methode verlagert. Das gibt der Main-Methode wenigstens etwas Symmetrie.

02:30

Auch wenn ich in den letzten Lektionen nicht immer explizit gesagt habe, dass wir die Versionsverwaltung verwenden, ist es sicherlich für dich schon selbstverständlich, oder?

Jede Lektion ist so aufgebaut, dass sie in sich abgeschlossen ist und somit sollte auch nach jeder Lektion ein "commit" in die Versionsverwaltung erfolgen. Hier zeige ich dir noch einmal wie das geht. Ab nun solltest du selber dran denken und es vor allem bei deinen eigenen Projekten auch so umsetzen.

15:19

In dieser Lektion erstellen wir gemeinsam eine Methode. Ich erläutere dir anhand dieses Beispiels, welche Bestandteile eine Methode hat und wie und wo du eine Methode anlegen kannst.

Ein Teil von unserem Quellcode ist die Interaktion mit dem Benutzer für die Eingabe von Informationen. In dieser Lektion erstellen wir eine Methode die genau eine Information vom Benutzer abfragt. Daran erkennst du das grundlegende Konzept hinter Methoden und kannst danach deine eigenen Methoden erstellen.

04:17

In den wenigen Zeilen Quellcode die wir bisher geschrieben haben, haben wir schon einige Methoden verwendet. Dies ist dir vielleicht nicht so bewusst. In dieser Lektion zeige ich dir ganz explizit wie du die Methode die du in der letzten Lektion angelegt hast verwenden kannst.

11:58

Methoden werden, wenn du dein Programm startest, von deinem Rechner ausgeführt. Um jedoch zu verstehen, was genau im Hintergrund passiert, lernst du in dieser Lektion den Debugger kennen. Mit ihm hast du zur Entwicklungszeit die Möglichkeit dein Programm bei der Ausführung zu beobachten. Du kannst also Schritt für Schritt durch deinen Quellcode gehen und ganz konkret sehen was passiert, wenn dieser ausgeführt wird. Das ist so, als würdest dein Programm vom Rechner in Zeitlupe ausgeführt und du kannst jederzeit auf Pause oder Weiter drücken.

Dabei erfährst du gleich einiges über den Kontrollfluss des Programmes. Neben dem eigentlichen Verwenden der Methode werden wir den Debugger in Visual Studio benutzen um zusehen, was im Rechner passiert, wenn Methoden aufgerufen werden.

09:59

Der Fokus dieser Lektion liegt auf dem Softwaredesign. Ein sehr wichtiger Aspekt davon ist die Einteilung des Quellcodes in verschiedene Module. In den letzten Lektionen haben wir die Methode als das kleinstmögliche Modul zur Strukturierung von Quellcode kennen gelernt.

Nachdem wir nun einige Änderungen im Quellcoe gemacht haben, ist es wichtig, dass wir einmal aus den Tiefen des Projekts auftauchen und überlegen wo wir stehen. Dazu schauen wir uns die User Stories an und entscheiden ob wir eine der für diesen Abschnitt / Iteration relevanten User Stories bereits erfüllt haben.

Anhand dieser User Story siehst du auch gleich warum viele Entwickler ein Problem damit haben, wenn eine technische Aufgabe als User Story verpackt wird. Die Idee der User Story ist, dass Entwickler mit Benutzern oder mit ihren Repräsentanten (z.B. Product Owner / Manager) diese diskutieren können und das die User Stories aus Benutzersicht priorisiert werden. Das ist bei technischen Aufgaben wie der User Story "Softwarestruktur" nicht wirklich möglich, weil ein Benutzer oder ein Product Manager nicht unbedingt das Wissen hat um den Inhalt zu beurteilen. Obwohl es einen klaren Nutzen für den Auftraggeber gibt, er bekommt eine evolvierbare Software, handelt es sich nicht um eine wirkliche Funktionalität.

Andererseits steht diese User Story zusammen mit den anderen im Dokument und wird so von allen gesehen. Dementsprechend kann der Product Manager auch sehen, dass an etwas gearbeitet wird, was nicht direkt eine Funktionalität erzeugt. Meiner Meinung nach ist diese Transparenz sehr wichtig und auch der Grund warum eine User Story für solche technischen Aufgaben missbraucht werden darf.

01:08

Verwende den 7-Schritte-Plan um eine Methode zu definieren, die zwei Zahlen subtrahieren kann. Du brauchst sie noch nicht verwenden. Das machen wir in der nächsten Lektion gemeinsam.

08:15

Vielleicht ist dir beim Erstellen der Methode "Subtrahiere" schon aufgefallen, dass einiges in unserer Main-Methode nicht so ganz passt, wenn wir nun auch die Subtraktion unterstützen wollen. Bisher steht in unserem Quellcode immer etwas von Summand. So haben wir zum Beispiel eine Methode die heißt "HoleSummanden". Diese Methode ändert sich für die Subtraktion zwar nicht, aber es ist verwirrend, wenn wir von Summanden sprechen und diesen dann in eine Methode "Subtrahiere" stecken.

Bevor wir also die Methode "Subtrahiere" in unserer Main-Methode verwenden, werden wir etwas aufräumen und die verwendeten Namen für Methoden und Variablen allgemeiner fassen.

Außerdem wirst du sehen, dass wir beim Auslagern von Quellcode in separate Methoden etwas über das Ziel hinaus geschossen sind. Wir haben zwei Methoden die eigentlich exakt das Gleiche machen. Diese werden wir nun zusammen führen und somit weniger Quellcode haben.

01:12

Nachdem wir nun eine einheitliche Methode haben mit der wir Eingaben vom Benutzer holen können, ist es an der Zeit, dass wir den Benutzer fragen welche Operation er mit den Zahlen ausführen möchte. Es ist nun deine Aufgabe die Main-Methode so zu erweitern, dass du eine Variable mit dem Namen "operation" anlegst und darin die Antwort des Benutzers speicherst auf die Frage "Bitte gib die auszuführende Operation an (+ oder -): ".

16:28

Methoden sind nur ein wichtiger Aspekt für den Kontrollfluss in Programmen. Neben Methoden gibt es allerdings dedizierte Befehle die den Kontrollfluss eines Programmes beeinflussen. Bisher haben wir immer nur einen sequentiellen Ablauf in unserem Programm gehabt.

Das wollen wir nun ändern. Denn mit 2 Zahlen kannst du immer nur entweder Plus oder Minus machen. Daher gibt es mit der if-Anweisung die Möglichkeit im Quellcode eine Entscheidung zu treffen.

Eine if-Anweisung erlaubt dir den Kontrollfluss zu beeinflussen. Dies ist die erste Anweisung, die es uns ermöglicht eine Methode nicht mehr sequentiell von oben nach untern abzuarbeiten. Denn mit einem if machst du eine Fallunterscheidung. Die Anweisungen im if-Zweig (das zwischen den geschweiften Klammern) werden nur ausgeführt, wenn die Bedingung der if-Anweisung (das zwischen den runden Klammern) "wahr" bzw. "true" ergibt.

Du verwendest zwei Gleichheitszeichen (also "==") um zu überprüfen ob zwei Werte gleich sind. So kannst du also überprüfen ob der Wert in einer Variablen mit einer Konstanten übereinstimmt. Natürlich kannst du damit auch den Wert zweier Variablen vergleichen.

Wenn du Variablen in einem bestimmten Kontext definierst, dann ist sie auch nur dort verfügbar. Definierst du also beispielsweise eine Variable (z.B. "double Resultat = 0;") in einer if-Anweisung (zwischen den geschweiften Klammern), dann ist diese Variable nur in diesem Kontext (den geschweiften Klammern) verfügbar. Du kannst sie also nicht später innerhalb des else-Zweigs oder in der restlichen Methode verwenden.


06:34

Den Gleichheitsoperator "==" hast du bereits kennen gelernt. Im Kontext der if- und switch-Anweisungen musst du jedoch häufig auch andere Bedingungen überprüfen. Dazu stelle ich dir in dieser Lektion noch weitere Vergleichsoperatoren vor und zeige dir, wie du einfach heraus findest was das Resultat der Vergleiche ist.

07:55

Auch bei der switch-case-Anweisung geht es darum, dass unterschiedliche Anweisungen abhängig von einer Entscheidung ausgeführt werden. Die switch-case-Anweisung wird insbesondere dann verwendet, wenn es einige Alternativen gibt.

03:46

Dieser Abschnitt war sehr geprägt vom Thema "Methoden". Das liegt daran, dass es der kleinste und vielleicht auch wichtigste Baustein für Quellcode ist. Im folgenden wirst du weitere Bausteine aus dem Bereich der ObjektOrientierung kennen lernen. Methoden, oder Funktionen wie sie auch genannt werden, sind jedoch allgemein gültig. Es ist ganz egal in welcher Programmiersprache und mit welchen Basis Technologien du arbeitest. Es wird immer eine Art von Funktion geben.

Daher war es mir besonders wichtig dir dieses Thema im Detail zu vermitteln. Es ist wichtig dieses Konzept zu verstehen, wenn du mit C# entwickeln willst. Es ist wahrscheinlich für die Softwareentwicklung allgemein eines der Kernkonstrukte überhaupt.

Methoden sind im Bereich des Softwaredesign sowohl für die Struktur wie auch das Verhalten relevant. Sie nehmen Quellcode auf und sind somit für die Struktur einer Software sehr wichtig. Sie bilden aber auch Teile des Verhaltens ab. Nimm beispielsweise die User Story "Addieren von zwei Zahlen". Die hat beschreibt ein gewisses Verhalten. Teile dieses Verhaltens wie zum Beispiel "Eingabe einer Zahl", "Validieren des zulässigen Bereichs der Zahlen", "Addieren", ... wirst du in der ein oder anderen Weise als Methoden später im Quellcode wieder finden.

Section 9: Übung - Vervollständige die Grundrechenarten
01:42

Unser Taschenrechner kann bereits Plus und Minus. Deine Aufgabe ist es nun die Grundrechenarten zu vervollständigen. Du sollst also Multiplizieren und Dividieren hinzufügen. Dabei ist deine Aufgabe sowohl die entsprechenden Methoden zu definieren (die 7 Schritte können dir helfen), wie auch sie in der Main-Methode zu verwenden.

Dabei ist natürlich darauf zu achten, dass du die Anforderungen überarbeitest wie auch den Quellcode.

02:01

Als weitere Aufgabe möchte ich, dass du die ganze Berechnung in eine separate Methode auslagerst. Mittlerweile ist unsere Main-Methode schon wieder ganz schön umfangreich geworden. Daher ist es nun an der Zeit eine eigene Methode "Berechnung" zu erstellen. Kleiner Hinweis: Inhaltlich brauchst du eigentlich nichts ändern. Du brauchst lediglich eine Methode mit den passenden Parametern definieren und kopierst dann die komplette switch-case-Anweisung rein.

Bitte überlege dir dann, welche weiteren Gründe es gibt, die Berechnung in eine separate Methode auszulagern.

Zusatz zum Zusatz: Wenn du noch immer nicht genug von Methoden hast, kannst du noch die Berechnung und die Ausgabe des Resultat separieren. Ziel ist es also eine Methode zu haben, die die Berechnung macht und eine Methode die die Ausgabe macht. Welche Argumente findest du für diese Änderung und welche dagegen?

Übung Methoden & Kontrollfluss - Was ich heraus gefunden habe
08:32
Section 10: Intermezzo - Objektorientierung und UML ein Weg für das Softwaredesign
06:27

Es gibt eigentlich nur zwei Gründe weshalb eine Software geändert werden muss: Beseitigung eines Fehlers oder Hinzufügen einer neuen Funktionalität. Aufgabe des Softwaredesigns ist nun, dem Quellcode eine innere Struktur zu geben, der genau solche Änderungen erlaubt.

Würde eine Software einmalig erstellt und dann nie wieder geändert, wäre der Großteil des Softwaredesigns überflüssig. Da es jedoch fast unmöglich ist eine Software ohne Fehler und/oder mit allen für den Kunden relevanten Funktionen zu entwickeln, selbst, wenn es nur eine sehr einfache Anwendung ist, sind Änderungen das täglich Brot eines Softwareentwicklers.

Unter Evolvierbarkeit verstehen wir, dass alle anfallenden Änderungen möglichst einfach umgesetzt werden können. Eine Anwendung wird häufig über einige Jahre verwendet. In dieser Zeit ändern sich Rahmenbedingungen und der Quellcode. Je länger eine Software existiert, desto schwieriger ist es jedoch eine Änderung umzusetzen. In manchen Fällen ist es nach einiger Zeit sogar gar nicht mehr möglich Änderungen umzusetzen, weil keiner der aktuellen Entwickler ein Verständnis für den Quellcode hat.

Wenn du also später Fehler beheben musst, oder neue Funktionalitäten hinzufügen musst, solltest du deinen Quellcode so strukturieren und aufbauen, dass du ihn später einfach ändern kannst. Dann hat dein Quellcode eine hohe Evolvierbarkeit.

10:28

Klassen werden sehr ähnlich wie Datentypen verwendet. Bei einer Klasse handelt es sich um einen zusammengesetzten Datentyp. D.h. eine Klasse besteht aus Daten, also Variablen die in diesem Kontext als Attribute oder Felder bezeichnet werden, und Verhalten, also Funktionen die in diesem Kontext als Methoden bezeichnet werden.

Die Idee dahinter ist, dass wir Gegenstände, auch als Objekte bezeichnet ;-), aus unserer realen Welt in unserer Software modellieren. Das wird gemacht, weil uns Objekte aus unserem Alltag sehr bekannt sind und wir üblicherweise in Objekten mit ihren Eigenschaften und ihrem Verhalten denken. Wenn wir beide uns beispielsweise über ein Auto unterhalten, dann wissen wir, dass es üblicherweise einen Hersteller und eine Farbe hat. Wir wissen auch, dass es Verhalten wie Beschleunigung, Bremsen, ... besitzt. Durch diese Denkmuster fällt es uns leichter in unserer Umwelt zurecht zu kommen.

Genau diesen Gedanken hat die Objektorientierung aufgenommen und versucht mit Hilfe von Klassen und Objekten zu lösen. Dabei kannst du dir eine Klasse als eine Art Bauplan für Objekte vorstellen. Die Klasse ist Quellcode mit dem du definierst welche Attribute und Methoden für eine bestimmte Art von Objekten in deiner Anwendung wichtig sind. Wenn du beispielsweise Software für eine Autovermietung entwickelst, könnte es eine Klasse Auto geben, die viele Attribute und Methoden hat. Das kommt daher, weil viele Details eines Autos in diesem Kontext wichtig sind.

In einem anderen Kontext, zum Beispiel Entwicklung einer Software die zur Personalplanung eingesetzt wird (u.a. auch in einer Autovermietung), haben andere Klassen wie Mitarbeiter viel mehr Details. Auch in diesem Kontext kann es eine Klasse Auto geben, weil vielleicht ab einer gewissen Position die Mitarbeiter einen Firmenwagen bekommen, aber die Klasse Auto wird weniger und andere Attribute und Methoden haben.

Klassen geben dir also die Möglichkeit eine Lösung für dein konkretes Problem zu modellieren. Dabei sind sie ähnlich wie Methoden ein Element zur Strukturierung von Quellcode. Im Unterschied zu Methoden beinhalten Klassen jedoch nicht nur Verhalten, sondern auch Daten. Dabei ist die grundlegende Idee, dass über die in der Klasse enthaltenen Daten ein Zustand definiert wird, welcher über die in der Klasse enthaltenen Methoden geändert werden kann. So fasst eine Klasse Quellcode zusammen der in sich eine starke Abhängigkeit hat.

Wenn wir sagen eine Klasse ist ein Datentypen, dann kannst du dir ein Objekt als eine Variable vorstellen. Ein Objekt wird auch als Instanz einer Klasse bezeichnet. Solch ein Objekt hat alle die Variablen, die in der Klasse definiert sind, von der es instanziert wurde. Die Klasse definiert allerdings nur welche Daten Variablen es überhaupt gibt und kann deren Wertebereich einschränken. Ein Objekt hingegen hat für all diese Variablen nun ganz konkrete Werte.

Wenn wir bei dem Beispiel Auto bleiben und sagen, dass unsere Klasse Auto vielleicht die Attribute Hersteller und Baujahr hat, dann hätte ein Objekt welches mein Auto repräsentiert die Werte Audi und 2003.

10:31
  • Wo werden sie definiert?
  • Wie werden sie definiert?
  • Was machen die Zugriffsmodifizierer public und private?
  • Wie lege ich ein Attribut an?
  • Wie lege ich eine Methode an?
  • Wie kann ich einer Methode auf andere Methoden der Klasse zugreifen?
11:39
  • Wie lege ich ein Objekt an?
  • Wie verändere ich ein Objekt?
  • Objekte können von der selben Klasse kommen, aber sie sind autark! -> zeigen im Debugger!
02:01

Bisher haben wir die Daten in der Klasse "Auto" nur verwendet. Objektorientierung versucht allerdings starke Abhängigkeiten in einer Klasse zu bündeln. Daher ist es nun deine Aufgabe die Klasse so zu erweitern, dass

  • die aktuelle Geschwindigkeit gespeichert wird,
  • die Geschwindigkeit innerhalb der Methode "BeschleunigeAuf100KmH" entsprechend gesetzt wird,
  • und es eine Möglichkeit gibt die aktuelle Geschwindigkeit auf der Konsole auszugeben.
Meine Lösung zur Übung
01:22
03:34

Bisher haben wir die Daten in unserer Klasse "Auto" direkt über die Attribute gesetzt. Das ist allerdings eine nicht so gute Idee. Erinnere dich daran, dass die Objektorientierung eine gute Evolvierbarkeit zum Ziel hat.

08:57

Ein Konstruktor ist eine Art spezielle Methode die immer dann aufgerufen wird, wenn du ein Objekt von einer Klasse anlegst (Instantiierung). In dieser Lektion erfährst du, warum du das verwenden solltest und wie ein Konstruktor aussieht und verwendet wird.

12:22

C# bietet mit Eigenschaften ein weiteres Mittel um zu verhindern, dass Attribute direkt von außen verändert werden können. In dieser Lektion erfährst du wie du eine Eigenschaft definierst und wie du sie verwendest.

05:31

UML steht für Unified Modelling Language. Es ist eine Sprache mit der du sowohl die Struktur wie auch das Verhalten der Klassen / Objekte in deiner objektorientierten Anwendung visualisieren kannst. Die UML hat verschiedene Diagrammtypen und Elemente zur Modellierung von Struktur und Verhalten. In diesem Kurs lernst du nur das Klassendiagramm kennen, weil es aus meiner Sicht das wichtigste ist, solange du nicht eine große Anzahl an Klassen und Funktionalitäten hast.

Eine Klasse wird im UML-Klassendiagramm als eine Box dargestellt. Dabei kann diese Box in drei weitere Kästen unterteilt sein. Jeder Kasten wird Compartment genannt. Dabei steht im obersten Compartment der Klassennamen, dann kommen die Attribute und ganz unten stehen die Methoden.

Viele der Details, die du nach der UML-Spezifikation verwenden kannst, wirst du momentan erstmal nicht brauchen. Wichtig ist nur, dass du die ein paar Punkte merkst. Dann hast du nämlich die Möglichkeit sehr einfach auf einem Whiteboard, Flipchart, weißen Blatt Papier, ... deine Ideen zur Struktur deiner Anwendung aufzeichnen. So ist es häufig einfacherer mit anderen Entwicklern über deine Ideen und Probleme zu sprechen.

06:24

Der für dich momentan wichtigste Anwendungsfall der UML ist die Visualisierung der Struktur. Dazu brauchst du neben den Klassen noch deren Beziehung. Diese wird in der UML Assoziation genannt.

Model View Controller - Design nach Mustern
05:16
Section 11: Iteration #3 - Verbessern der Bedienung
Anforderungen für diese Iteration
05:15
07:58

In dieser Lektion zeige ich dir, welche Auswirkungen die Anforderungen für diese Iteration auf das Design haben. Du siehst ganz konkret wie die Klassenstruktur (nach dem Model-View-Controller Muster) für den Taschenrechner angepasst wird.

Model - Die Kernlogik des Taschenrechners in einer Klasse
08:43
Mini-Übung - Erstelle die Klasse ConsoleView
00:45
View - Eine Klasse für die Benutzerinteraktion
10:36
Controller - Klebstoff zwischen die anderen Klassen
10:50
04:33

Der Ablauf der Eingabe und Ausgabe wird nicht mehr im Controller realisiert, sondern im View selber. Dabei wird auch gleich das Modell vom View mit Daten aus der Eingabe gefüttert. Der Controller sucht dann wirklich nur noch den View Eingabe oder Ausgabe aus und führt das Modell nach der Eingabe aus.

Als Erweiterung könnten wir den Rechner insgesamt noch komplexer machen. So das beispielsweise immer die letzte Berechnung angezeigt wird oder das die ganze Aufgabe seid dem letzten Reset angezeigt wird.

02:08

In den letzten Lektionen haben wir uns sehr auf die User Story "ObjektOrientierung" fokussiert und können diese nun erstmal als erledigt ansehen.

Nun geht es darum, dass wir ein paar weitere Syntaxelemente lernen und die beiden noch offenen Stories bearbeiten.

11:31

Bevor wir die "Fortlaufende Berechnung" im Taschenrechner implementieren, benötigen wir ein weiteres Element (bzw. Elemente) aus der Syntax. Daher zeige ich dir in dieser Lektion was Schleifen sind und wie du sie verwendest. Dazu werden wir zwei ganz einfache Beispiele realisieren.

Ähnlich wie bei der if-Anweisung wird bei Schleifen eine Bedingung getestet. Solange diese erfüllt ist, wird alles was innerhalb des Schleifenrumpfes definiert ist wiederholt. Dabei wird die Bedingung bei jedem Durchlauf neu ausgewertet. Sobald die Bedingung nicht mehr erfüllt ist, werden die Anweisungen nach dem Schleifenrumpf ausgeführt.

07:31

Bisher müssen wir für jede Berechnung unseren Taschenrechner neu starten. Das ist ziemlich lästig. Daher werden wir in dieser Letktion eine while-Schleife im Anwendungskontroller implementieren.

02:33

Um solche kleinen Verbesserungen im Quellcode geht es beim Refactoring. Gerade bei Softwareentwicklung in vielen kleinen Iterationen, wirst du deinen bisher geschriebenen Quellcode immer wieder anpassen müssen. Schließlich wollen wir ja, dass unser Quellcode evolvierbar und leicht verständlich ist.

Bei unserem Ansatz Softwaredesign zu machen geht es darum, dass wir nicht erst einige Wochen planen welche Methoden wir brauchen, sondern einmal grundsätzlich überlegen welche Prinzipien wir umsetzen wollen und wie die Grobstruktur aussieht. Welche Methoden es gibt, wie diese heißen und welche Parameter wir verwenden wird allerdings während der Implementierung, also beim Schreiben des Quellcodes, definiert.

Somit haben wir sehr schnell ein laufendes Programm, welches wir dann kontinuierlich erweitern können. Dabei kommt es allerdings häufig vor, dass wir etwas was wir gerade gemacht haben wieder überarbeiten müssen. Wir müssen vielleicht eine Methode umbenennen, oder stellen fest, dass wenn wir eine weitere Funktionalität hinzufügen, eine gerade erstellt Methode überflüssig wird.

Section 12: Iteration #4 - Fehlerbehandlung und Fehlerbehebung
07:25

Grundsätzlich:

  • Haben wir das richtige Produkt entwickelt? bzw. Kann der Benutzer mit dem Produkt seine Ziele erfüllen? -> Validierung
  • Haben wir gemäß unserer Spezifikationen entwickelt? bzw. Wurde das Produkt richtig erstellt? - Verifizierung

Dabei umfasst das Testen eine Vielzahl von Aktivitäten um eine Software zu validieren und zu verifizieren.

Wichtige Punkte:

  • Alle Schritte der Entwicklung (Anforderungen, Design und Implementierung) können getestet werden.
  • Neben dem Ausführen der Anwendung mit speziellen Testdaten, können auch Reviews gemacht werden.
  • Es gibt unterschiedliche Ebenen beim Testen. Wir benutzen hier Systemtests und Unittests.
  • Es gibt unterschiedliche Arten von Tests. Wir verwenden in diesem Kurs exploratives Testen und Funktionstests in Form von automatischen Unittests.
  • Blackbox versus Whitebox
  • Was bedeutet Testen für dich als Entwickler? -> Du solltest deinen Quellcode getestet haben.


HINWEIS: Wie in den anderen Abschnitten und Iterationen auch, gibt es hier nur einen ersten Überblick und Einführung in das Thema "Testen". Das Thema ist so umfangreich, dass es einen eigenen Kurs dafür geben kann. Wenn du daran Interesse hast, dann informiere mich im Diskussionsforum.

Article

Hier geht es erstmal darum, dass du dir Überlegst was du testen möchtest und wie du es testen möchtest. In dieser Lektion werden wir für unser Taschenrechnerprojekt ein kleines Dokument erstellen, welches die wichtigsten Punkte bezüglich der Teststrategie zusammen fasst.

Es ist nicht zwingend notwendig, dass du ein solches Dokument erstellst, aber es hilft dir später um dich und deinen Entwicklungsprozess zu verbessern.

Für unseren Taschenrechner werden wir "exploratives Testen" auf der Systemtestebene anwenden und formelles Testen auf der Unittestebene. Dabei kannst du dir immer überlegen, welche Teile die wichtigsten oder fehleranfälligsten sind und konzentrierst deine Bemühungen bezüglichen Testen auf diesen Bereich. Für das formelle Testen machen wir das auch. Obwohl auch der AnwendungsController und der ConsoleView wichtige Bestandteile sind, ist doch die Kernlogik im RechnerModel. Daher werden wir auch dieses und nicht die anderen beiden Klassen mit automatischen Unittests versehen.

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Jan Suchotzki, Software & Technologie Geek

Die Leidenschaft meine Softwareentwicklung zu verbessern und neue Technologien zu lernen treiben mich jeden Morgen aus dem Bett! Seit über 15 Jahren entwickele ich Software im Kontext von intelligenten technischen Systemen. Dabei liegt mein Fokus auf der Entwicklung von Desktopanwendung im .NET-Umfeld und der Programmierung von Mikrokontrollern in C. Neben der eigentlichen Programmierung ist mir ein ganzheitlicher Blick auf das Thema Softwareentwicklung sehr wichtig. So habe ich bereits als Tester, Entwickler, Softwarearchitekt, Projektleiter und Berater für Entwicklungsprozesse in verschieden großen Entwicklungsprojekten gearbeitet.

Seit einigen Jahren beschäftige ich mich mit dem Thema Lernen im Beruf. Die Teilnahme an Fortbildungen und das Lernen mit Büchern und Lerngruppen haben mich nicht zufriedengestellt. Ich bin der Ansicht, dass es sowohl für berufstätige Entwickler, wie auch Neulinge in der Softwareentwicklung einen besseren Weg zum Lernen geben muss. Daher entwickle ich nun Konzepte und Kurse um das nebenberufliche Lernen effektiver zu machen.

Ready to start learning?
Take This Course