Einstieg in C# - Software programmieren wie ein Profi
4.9 (156 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.
528 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Einstieg in C# - Software programmieren wie ein Profi to your Wishlist.

Add to Wishlist

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.9 (156 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.
528 students enrolled
Created by Jan Suchotzki
Last updated 8/2017
German
Current price: $110 Original price: $125 Discount: 12% off
30-Day Money-Back Guarantee
Includes:
  • 14 hours on-demand video
  • 3 Articles
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • 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.
View Curriculum
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.
Description

NEU: Installation und Verwendung von Visual Studio 2017!

Mache diesen Kurs und du hast in einer Stunde 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 2017 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.

Um diesen Kurs noch individueller auf deine Bedürfnisse anzupassen, beantworte ich jede Woche eine Frage eines Kursteilnehmers mit einem neuen Video. So kann ich dir "fast" ganz persönlich bei deinen Herausforderungen helfen.

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

Who 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.
Curriculum For This Course
122 Lectures
13:51:44
+
Wie du das meiste für dich aus dem Kurs heraus holst
4 Lectures 14:04

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
Wie der Kurs dir beim Lernen hilft.
05:47

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.

Preview 02:36

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.

Softwareentwicklung braucht viel Praxis!
03:06
+
NEU: Visual Studio 2017 - Erstelle deine erste C# Anwendung
9 Lectures 59:33

Installiere die kostenlose Community Edition von Visual Studio 2017. 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 2017 installierst.
NEU: Visual Studio 2017 Community (kostenlos) installieren
05:19

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
Preview 08:00

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
NEU: Quellcode - Was ist das überhaupt?
07:21

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
NEU: Es wird ernst - Lass deinen Computer "Hallo Welt" schreiben.
11:26

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.

NEU: Kompilieren - Vom Quellcode zur Anwendung
07:50

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.

NEU: Ausführen & Testen - Tut es was es soll?
09:58

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.

NEU: Iteration - Entwickle mit den 3 Grundschritten
03:06

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.

Kennst du die Basics?
3 questions

Zusammenfassung - Quellcode schreiben, kompilieren und ausführen
05:06
+
Übung für Anfänger - Habe keine Angst!
4 Lectures 16:47

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.

Jetzt bist du dran
02:18

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.

Wie du Fehlversuche (Visual Studio Projekte) löschen kannst
03:41

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.

Was wenn es nicht klappt?
07:07

Wie ich die Aufgabe gelöst habe
03:41
+
Intermezzo - Softwareentwicklung ist mehr als nur Programmieren
3 Lectures 13:25

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.

Preview 05:06

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.

Preview 01:44

  1. Anforderungen aufnehmen
  2. Design erstellen
  3. Programmieren
  4. Testen
  5. Release
Preview 06:35
+
Iteration #1 - Ein Taschenrechner der nur Addieren kann
11 Lectures 01:12:11

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
Grundlagen: Anforderungen - Die Basis eines Softwareentwicklungsprojektes.
04:26

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
Was soll der Taschenrechner können? - In 10 Minuten zu den ersten User Stories.
10:01

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.

C# Syntax: Kommentare - User Story im Quellcode
07:12

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.

C# Bibliothek: Console - Erst die Ausgabe, dann die Eingabe
07:41

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.

C# Syntax: Variablen - Merke dir den ersten Summanden
06:12

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.

C# Syntax: Datentypen - Text ist nicht gleich Zahl
09:13

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.

C# Bibliothek: Convert - Text in Ganzzahl wandeln
07:12

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.

Die User Story fertig stellen und testen
05:22

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

Versionskontrolle (Git) - Das Sicherheitsnetz für deinen Taschenrechner
05:29

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.

Preview 04:55

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

Zusammenfassung - Definiere Anforderungen, dann kannst du sie auch testen
04:28
+
Übung - Addiere Zahlen mit unterschiedlichen Datentypen
3 Lectures 24:52

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.

Datentypen float, double und decimal - Auf die Position des Kommas kommt es an
14:00

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.

Jetzt bist du dran - Addieren mit Gleitkommazahlen
01:13

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

Übung Gleitkommazahlen - Was ich heraus gefunden habe
09:39
+
Intermezzo - Kontrolle über Versionen und Änderungen
8 Lectures 53:29

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
Versionskontrolle - Das Sicherheitsnetz für die tägliche Arbeit
05:31

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.

Ältere Version wiederherstellen - Fehler korrigieren ganz einfach!
06:03

Ü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.

Die Versionshistorie anschauen mit Visual Studio & Git
05:51

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.

Inhalt - JA zu Dokumenten und Quellcode, aber NEIN zu Binaries
09:20

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.

Verwende keine Versionsbezeichnung im Namen
09:47

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.

AssemblyInfo - Versionsinformationen in den Meta-Daten
04:49

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.

Tag - unser erstes Mini-Release
11:14

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.

Versionsverwaltung - Abschlussplädoyer ;-)
00:54
+
Iteration #2 - Taschenrechner mit allen Grundrechenarten
17 Lectures 02:06:39
  • 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.
Was ist eigentlich Softwaredesign?
08:43

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.

Anforderungen für diese Iteration
04:50

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.

Feinentwurf - Achtung! Wir drehen uns im Kreis.
05:10

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.

Einführung in Methoden - Wir haben schon welche erstellt und verwendet
09:04

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.

Single Level of Abstraction - Eine separate Methode für das Addieren.
09:31

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.

Zwischenfrage - Benutzt du noch die Versionsverwaltung?
02:30

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.

Erstellen einer Methode - Wir verlagern die Eingabe
15:19

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.

Verwenden einer Methode - Wir benutzen die neue Methode
04:17

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.

Methoden ausführen - Lerne den Debugger kennen
11:58

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.

Zwischenschritt - "Softwarestruktur" User Story abschließen
09:59

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.

Mini-Übung - Erstelle eine Methode die zwei Zahlen subtrahiert
01:08

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.

Benutzerinteraktion - eine Methode für alles
08:15

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 -): ".

Mini-Übung - Verwende eine Methode um den Operator einzulesen
01:12

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.


If-Anweisung - Der Taschenrechner lernt Minus
16:28

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.

Vergleichsoperatoren und der Datentyp bool (Boolean)
06:34

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.

Switch-Case-Anweisung - Eine Alternative zur if-Anweisung
07:55

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.

Zusammenfassung - Softwaredesign erstellen mit Methode(n)
03:46
+
Übung - Vervollständige die Grundrechenarten
3 Lectures 12:15

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.

Jetzt bist du dran - Multiplizieren und Dividieren
01:42

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?

Zusatzaufgabe: Aufräumen in Main - Berechnung bekommt eine eigene Methode
02:01

Übung Methoden & Kontrollfluss - Was ich heraus gefunden habe
08:32
+
Intermezzo - Objektorientierung und UML ein Weg für das Softwaredesign
12 Lectures 01:24:32

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.

Preview 06:27

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.

Preview 10:28

  • 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?
Objektorientierung in der Praxis - Klassen definieren
10:31

  • 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!
Objektorientierung in der Praxis - Objekt anlegen und verändern
11:39

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.
Mini-Übung - Erweitere die Klasse Auto
02:01

Meine Lösung zur Übung
01:22

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.

Datenkapselung - Verstecke Attribute für eine höhere Evolvierbarkeit
03:34

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.

Konstruktor - Wie Objekte erzeugt werden
08:57

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.

Eigenschaften - Kein direkter Zugriff auf Attribute bitte!
12:22

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.

UML Klassendiagramm - Eine Klasse zeichnen
05:31

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.

UML Klassendiagramm - Beziehungen visualisieren
06:24

Model View Controller - Design nach Mustern
05:16
8 More Sections
About the Instructor
Jan Suchotzki
4.6 Average rating
311 Reviews
2,584 Students
3 Courses
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.