Praxiskurs Clean Code mit C#
Du kannst bereits in C# programmieren, willst die Qualität Deines Codes aber verbessern und hochwertigen, sauberen, gut strukturierten und weniger fehleranfälligen Code schreiben? Code, der leicht zu erweitern und leicht zu testen ist? Dann ist dieser C# Clean Code Kurs wie gemacht für Dich. Mit dem erlangten Wissen und den gelernten Best Practice Methoden kannst Du Deinen Code auf das nächste Level bringen und Produktivität und Qualität nachweislich erhöhen. Erfahre mehr über diese C# Clean Code Praxisschulung...
Nutzen
- Clean Code Regeln schnell erlernen und in der Praxis umsetzen
- Code Qualität durch Clean Code Regeln deutlich erhöhen
- Schneller auf neue Anforderungen und Anpassungen reagieren
- Bestehenden C# Code optimieren und besser strukturieren
- Produktivität, Leistung und Qualität erhöhen
Dieser Clean Code Kurs für C# Programmierer bringt Dir bei wie Du hochwertigen Code schreiben kann. Dies bringt vielfältige Vorteile mit sich. Denn wenn Du die Clean Code Regeln gut befolgst, produzierst Du einen klar strukturierten Code, der leicht zu verstehen, zu testen und zu erweitern ist. Clean Code ist weniger fehleranfällig und kann auf Änderungen besser und schneller reagieren. Du oder andere Programmierer können dann den Code leicht erweitern, Debugging und Fehlersuche nehmen bei Clean Code ebenfalls deutlich weniger Zeit in Anspruch. Zusammenfassend lässt sich sagen: wer Clean Code beherrscht ist produktiver, schneller und produziert deutlich besseren Code. Dieses Know-how und die notwendigen Best Practice Methoden sollten zum Werkzeugkasten eines jeden C# Programmierers gehören.
Inhalte
Der Kurs behandelt eine Auswahl folgender Themen:
- Clean Code
- Code Rote
- Risk Management
- Names Rules
- Functions Rules
- Exception Rules
- Comments Rules
- SOLID Principles
- Exkurs: Unit Test
- Test Driven Development
- Refactoring Patterns
- Code Smells
Für weitere Details bitte die untenstehende Agenda ansehen.
Vorkenntnisse
Dieser Clean Code Kurs wurde konzipiert für Softwareentwickler und Programmierer mit soliden und guten C#-Kenntnissen, vergleichbar mit unserem C# Kurs für Einsteiger.
Individuell: wir gehen gezielt auf Dich ein und berücksichtigen Deine Vorkenntnisse, Wunschthemen und Schwerpunkte
Strukturiert und leicht verständlich
Bringe deine Karriere, Studium oder Ausbildung auf die nächste Stufe: mit Zertifikat
Sicher und eigenständig Programme entwickeln (ob privat, beruflich oder für dein Startup)
Viel, viel, viel Praxis: sofort anwendbare Ergebnisse
kleine Gruppen: max. 8 Teilnehmer im 3-Tages-Kurs max. 15 Teilnehmer im Online-Coaching
Von Experten nach der Raed- Methode® entwickelt & auf die Anforderungen von Tech-Unternehmen im Jahr 2020 ausgerichtet
E-Mail-Support auch nach Ende des Kurses
Kursbeschreibung
Das Clean Code Seminar ist auf drei Tage angesetzt und ist ideal für C#-Programmierer, die ihren eigenen oder fremden Code in deutlich besseren Code verwandeln wollen. Besserer Code bedeutet: klar strukturiert, sehr gut lesbar, kompakt und effizient. Ein solcher Code hat eine hohe Qualität und zeichnet sich dadurch aus, dass er leicht zu verstehen und zu erweitern ist. Dieser so genannte saubere Code ist daher sehr flexibel, was es auch großen Entwicklungsteams ermöglicht, schnell auf neue Anforderungen oder Änderungen zu reagieren. Selbst komplexeste Anwendungen können mit Clean Code schneller, sicherer und vor allem für andere nachvollziehbar programmiert werden. Dies ist sehr hilfreich für Deine Kollegen und Mitarbeiter, für Deine Arbeitgeber oder für Deine Auftraggeber und Kunden, die auf Deinem Code aufbauen wollen. Der Clean-Code-Kurs hebt Deinen Code auf die nächste Stufe und steigert nachweislich die Produktivität und Qualität
Was lernst Du am ersten Tag?
Als Motivation für dieses spannende und wichtige Thema befassen wir uns zunächst mit den vier Symptomen von schlechtem Code und schlechter Architektur (Rigidity, Fragility, Inseparability und Opacity) und versetzen uns in die Rolle eines Managers, dessen Projekt sehr langsam voran kommt und ständig Fehler produziert. Deadlines werden nicht eingehalten, Teams sind genervt und Kunden empört und unzufrieden.
Wir eruieren, was er nun tun sollte aus welchen Gründen. Anschließend widmen wir uns dem Begriff "Clean Code": Worum handelt es sich dabei, woran erkennt man guten Code und wie kann man stilsicheren Clean Code schnell erlernen? Um Clean Code zu erzeugen, müssen wir bestimmte Regeln und Techniken an verschiedenen Stellen in unserem C#-Programm einsetzen. C# Programme bestehen in der Regel aus mehreren Klassen und Interfaces. Wir zerlegen nun eine C# Klasse in ihre grundlegenden Bestandteile: Identifier (Klassennamen, Variablennamen, Packagenamen, Methodennamen), Kommentare, Methoden, und ggf. auch eine Ausnahmebehandlung.
Dabei ergeben sich viele interessante Fragen: Wie sollten meine Identifier heißen? Wie lang sollten sie sein? Wie viele Zeilen sollte meine Methode haben? Wie viele Parameter sollte sie idealerweise haben? Wann sollte sie void und wann sollte sie einen Wert aus einem bestimmten Datentypen zurückliefern und warum? Wann sollte ich auf eine Ausnahmebehandlung zurückgreifen, zuerst oder zuletzt? Wie sieht der Abstraktionslevel bei meinen Methoden und meinem Code aus? Mit allen diesen Fragen werden wir uns bei den Clean Code Regeln für Identifier, Kommentare, Methoden und Ausnahmebehandlungen befassen, und zwar anhand von zahlreichen interaktiven Code-Beispielen (Vor/Nach bzw. schlechter Code/guter Code) sowie kleinen Programmieraufgaben.
Was lernst Du am zweiten Tag?
Nach dem ersten Tag beherrschst Du bereits alle wichtigen Regeln zum Erzeugen von Clean Code allerdings nur innerhalb einer Klasse. Am zweiten Tag widmen wir uns den Fragen: Wie sollten unsere Klassen miteinander interagieren, wie sollten wir Klassen so designen, dass neue Anforderungen idealerweise nur durch Erweiterungen und nicht durch Modifizieren und Ändern von vorhandenem Code möglich wird. Wie und wann zerlege ich meine Klasse in mehreren Klassen und warum? Wie kann ich Team A und Team B Module zuweisen, so dass beide Teams unabhängig voneinander entwickeln? Was bedeutet die Regel: "Programm to an interface not implementation", die wir in jedem Fachbuch über Clean Architektur und Code lesen? Wie setzen wir das richtig um? Alle diese Fragen werden wir mit sogenannten SOLID und GRASP Prinzipien beantworten, anhand von spannenden Code-Beispielen und Programmieraufgaben. SOLID steht als Abkürzung für 5 Techniken (Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle und Dependency Inversion Principle).
SOLID zeichnet sich unserer Erfahrung nach dadurch aus, dass es nicht einfach zu planen oder umzusetzen ist. Aber wenn ein Programmier SOLID beherrscht, dann sieht er sofort und auf Anhieb ob sein Programm SOLID verletzt oder nicht. Sollte sein Programm SOLID verletzen, dann kann er sich fragen, warum: Gibt es gute Gründe dafür? Sollte die Antwort Nein lauten, dann kann er jetzt sehr leicht seinen Code derart ändern, dass er die SOLID-Regeln nicht mehr verletzt. Wir finden die Bezeichnung "Principle" allerdings etwas übertrieben: SOLID sind sehr gute Clean Code und Architektur-Regeln, deren Anwendung normalerweise zu einem gut strukturierten und klar definierten Code führt. Dennoch sollte und darf man SOLID nicht immer blind einsetzen. Es gibt ab und an auch gute Gründe, die gegen SOLID sprechen.
Die SOLID-Regeln machen den Code flexibel, bringen aber auch mehr Komplexität mit sich. Man muss fast immer Kompromisse eingehen: Braucht man die Flexibilität, dann muss man auch die Komplexität in Kauf nehmen. Daher sollte sich jeder Programmierer immer die Frage stellen: Warum habe ich SOLID verletzt? Gibt es dafür gute Gründe? Auf jeden Fall sollte jeder gute Programmierer die SOLID-Regeln beherrschen, zu seinem Know-How und Werkzeugkasten hinzufügen und mit gesundem Menschenverstand anwenden. Um das alles nicht zu abstrakt zu behandeln, wirst Du alle SOLID-Regeln mittels kleiner Programmieraufgaben umsetzen und sich selbst ein Bild davon machen, ob und wann sich das für Sie lohnt.
Was lernst Du am dritten Tag?
Wir wollen Clean Code erzeugen, einen Code der nicht nur leicht zu verstehen ist, sondern der vor allem auch richtig funktioniert. Daher gehören auch die Themen Unit Testing und Test Driven Development (TDD) hier zweifellos dazu. Wir unternehmen einen schnellen Exkurs in JUnit 5 und auch in TDD, welches aus 3 Phasen (RED-GREEN-REFACTORING) besteht. Durch einfache Beispiele und Programmieraufgaben wirst Du diese 3 Phasen in Aktion kennen lernen und schnell ein Gefühl dafür bekommen. Wenn Du Dich mehr für Unit Testing und TDD interessieren, Kannst Du auch unseren separaten Kurs C# Unit Testing an der Münchner Coding Akademie besuchen.
Nun kennst Du bereits alle wichtigen Clean Code Regeln für eine und mehrere Klassen und dazu sogar noch Unit Testing. Was jetzt noch fehlt: In großen Projekten musst Du meist mit einem Code arbeiten, den Du nicht selbst geschrieben hast. Du solltest neuen Code aufbauend auf vorhandenem Code schreiben und musst Du daher diesen dafür verstehen und ggf. modifizieren und erweitern. Woran kannst Du nun erkennen, ob die vorhandene Code-Qualität gut genug ist oder nicht? Die Antwort ist relativ einfach: Wenn der vorhandene Code die Clean Code und SOLID-Regeln verletzt und dazu keine oder nur schlechte Tests hat, dann ist die Wahrscheinlichkeit ziemlich hoch, dass es sich um Code mit schlechter Qualität handelt. Genau dafür gibt es einen Katalog für die sogenannten Code Smells.
Als Code Smells bezeichnet man Code, der nach Fehlern und Komplexität riecht. Dies ist sogar noch sehr diplomatisch ausgedrückt. Code Smells ist Code der einfach stinkt, weil er derart schlecht geschrieben ist. Ein solcher schlechter Code bremst die Entwicklung und verringert die Produktivität und Freude am Programmieren. Der erste Schritt um solchen schlechten Code zu beseitigen, ist die sofortige Erkennung desselben; dies ist zunächst eine reine Übungs- und Erfahrungssache. Dennoch gibt es einen Katalog für Code Smells (Names, Functions, Comments und Test Smells) mit über 20 Patterns. Wir sehen uns die wichtigsten Patterns, mit denen man aus schlechtem Code guten Code machen kann, mittels vieler Code-Beispiele und Best Practice Techniken an. Diese Aufgabe: schlechten Code in guten Code zu verwandeln - ist extrem wichtig und sehr anspruchsvoll, denn sie erfordert die Kenntnisse von Refactoring Patterns und kann nur durch intensive Übung und viele Programmieraufgaben erlernt werden. Aus diesem Grund bieten wir dafür zusätzlich einen Kurs "Improve Your Java Code" an, der für das Arbeiten mit Legacy Code der ideale Begleiter ist.
Deine Trainer
Der Clean Code mit C# Kurs wird von einem der folgenden Trainer durchgeführt:

Allaithy Raed
Expert: Java, Python, Clean Code, Clean Software Architektur, Clean Unit Test und TDD, Refactoring Patterns
- Promotion an der LMU im Bereich Programmiersprachen (2022).
Referenzen: 17 Jahre Lehr- und Industrieerfahrung, davon 12 Jahre Dozent an der Ludwig-Maximilians-Universität München für Java, Python, Effiziente Algorithmen, Mehrfach ausgezeichnet für hervorragende Lehre an der LMU, Buchautor für Java & demnächst Python bei den Verlagen Springer und O'Reilly, Entwickler der RAED-Lehrmethode®, Train the Trainer Ausbilder, Team-Schulungen in Java und Python für BMW, VW, BA, SIEMENS, AGFA-Healthcare, TÜV Süd, Schufa AG, ..

Dr. Matthias Hölzl
Expert: Künstliche Intelligenz, Python, C++, Java, JavaScript, Clean Code & Software Architektur
- Promotion an der LMU. Fachbereich: Software Engineering
Referenzen: 30 Jahre Lehr- und Industrieerfahrung. Davon 18 Jahre an der Ludwig-Maximilians-Universität München, zuletzt als Professor für Software and Computational Systems Engineering. Schulung, Technisches Coaching für Maschine Learning, Deep Learning, Prozesse Automatisierung sowie Begutachtung und Verbesserung von Software Architektur bei großen IT Projekten. Python und Java Schulungen für Deutsche Bank, BMW, BA, VKB, etc. Herausgeber und Autor mehrerer Bücher beim Springer-Verlag und Autor zahlreicher wissenschaftlicher Publikationen.

Dr. Max Meier
Expert: .NET/C#, Software Architektur, Microservice, API-Design, Unit Test und TDD, SQL-Datenbanken
- Promotion an der LMU im Fachbereich Softwaretechnik
Referenzen: 15 Jahre Berufserfahrung als Softwareentwickler, Softwarearchitekt und Berater in den Branchen Systemgastronomie, E-Commerce, Versicherungen, Interaktive Medien. Konzeption, Entwurf, Durchführung und Leitung von großen Softwareprojekten als der führende Architekt. Diverse Schulungen in C#, Microservices, Unit Test und Datenbanken für VW und verschiedene IT-Firmen.

Prof. Dr. Peer Kröger
Expert: Künstliche Intelligenz, Data Science, Big Data, SQL/NoSQL Datenbank, Python, Java
- Promotion an der LMU. Im Fachbereich Data Science
Referenzen: Jahrelange Erfahrung in der Umsetzung von Data Science Projekten sowie in der Beratung und in Schulungen u.a. in der Automobil-Industrie, bei Finanzdienstleistern und im Mittelstand. Ca. 150 wissenschaftlich begutachtete Publikationen (über 8000 mal zitiert) zum Thema Data Science, Data Mining, Maschinelles Lernen. KI Mitglied des KI-Kompetenzzentrums Munich Center for Machine Learning (MCML) an der LMU München sowie Professor für Informationssysteme und Data Mining an der CAU zu Kiel (Lehrstuhlinhaber).

Dr. Stefan Behnel
Expert: Python, Pytest, Unit Test und TDD, Clean Code, Clean Software Architektur, Fast Python, Cython
- Promotion an der TU Darmstadt zum Dr. Ing. in Softwarearchitektur
Referenzen: 15 Jahre Erfahrung als Consultant, Software-Entwickler und Software-Architekt in den Branchen Finanzdienstleistung, Autoindustrie, Verlag und Touristik im Bereich High-Performance Python und Open-Source, Hauptentwickler von Cython, auf Cython basiert die Data Sience Bibliothek PANDA. Python Schulungen für Dräger, Apple, Sky Deutschland, IT-Firmen, ...
ZERTIFIKAT
Selbstverständlich erhältst Du als Teilnehmer am Clean Code mit C# Kurs ein Zertifikat. Voraussetzung dafür ist die komplette Teilnahme an allen Kurseinheiten und Programmier-Aufgaben und die erfolgreiche Programmierung eines kleinen Abschlussprojektes. Das allerdings wird Ihnen nach diesem intensiven C# Clean Code Schulung mehr Freude als Stress bereiten.
Agenda
Die Agenda ist aufgrund der zahlreichen Fachbegriffe in englischer Sprache verfasst. Beschreibungen sowie Kursmaterial erhalten Sie auf Deutsch. Den Kurs kannst Du wahlweise in deutscher oder englischer Sprache buchen.
Alle Seminarinhalte werden individuell an die Wünsche unserer Teilnehmer angepasst. Sie können je nach Wissensstand variieren und werden gemeinsam mit dem Seminarleiter an Tag 1 definiert. Bei diesem Clean Code mit C# Seminar hast Du die Wahl aus folgenden Themen:
C# Clean Code Kurs Tag 1
Code Rote
- Bad Code
- Productivity Problem
- Manager Reaction
- Code Rote
- Rigidity
- Fragility
- Inseparability
- Opacity
Clean Code
- Definition: Boosch
- Definition: Stroustrup
- Definition: Cunningham
- Definition: Feathers
Names Rules
- Good Name
- Bad Name
- Ottinger's Rules
- Intention-Revealing
- Pronounceable
- Searchable
- Describe the Problem
- Avoid Desinformation
- Meaningful Distinctions
- Avoid Hungarian notation
- Parts of Speech
- Scrope Length Rules
Functions
- Function Grammar
- Big Function
- Extract Rule
- Step-Down Rule
- Command-Query
- Parameter List Rules
- Maximal three Arguments
- No Boolean Argument
- No output Argument
- No null Argument
- Statement Rules
- Do One Thing Rule
- Small Function Rule
- Hidden Classes Rule
- Minimize Side-Effect
- Avoid Switch
Error Handling Rules
- Error Handling First
- Prefer Exception over Values
- Exception Classes
Comments Rules
- Good Comments
- Legal Comments
- Informative Comments
- Explanation of Intent
- Clarification
- TODO Comments
- Javadocs in APIs
- Bad Comments
- Mumbling Comments
- Redundant Comments
- Misleading Comments
- Mandated Comments
- Journal Comments
- Noise Comments
- Scary Noise Comments
C# Clean Code Kurs Tag 2
Object-Oriented
- What is object-oriented
- Dependency Management
- Dependency Inversion
- Switch Statements
- Fan-Out Problem
SOLID Principles
- Single Responsibility
- Open Close
- Liskov Substitution
- Interface Segregation
- Dependency Inversion
C# Clean Code Kurs Tag 3
xUnit Test
- Life Cycle and AAA Rules
- xUnit Annotations
- xUnit Asserstions
- Parameterized Tests
Test Driven Development
- What is TDD?
- RED Phase
- GREEN Phase
- REFACTORING Phase
Code Smells: Names
- Bad names
- Unambiguous Names
- Encodings Names
- ...
Code Smells: Function
- Too Many Arguments
- Output Arguments
- Flag Arguments
- Dead Function
Code Smells: Comments
- Inappropriate Information
- Obsolete Comment
- Redundant Comment
- Commented-Out Code
Code Smells: Test
- Insufficient Tests
- Test Ambiguity
- Exhaustively Test
- Slow Tests