Luca Morelli
Software Engineer und Analyst
Teamleiter

.NET-Softwareentwicklung: Definition der Architektur oder Arbeit innerhalb einer bestehenden.

Ich habe die Architektur von Projekten definiert, für die ich die technische Verantwortung trug, etwa C-06 und C-07, langjährige Projekte, die ich als alleiniger Entwickler betreut habe. Die übrigen aktuellen Projektbeispiele beschreiben Beratungsaufträge, bei denen ich bestehenden Teams und Produkten beigetreten bin. Mein Entscheidungsspielraum unterscheidet sich stark zwischen diesen Situationen, ebenso wie die Art und Weise, wie ich Methoden und Muster anwende.

Wenn ich das System entwerfewähle ich seine Struktur und Technologien basierend auf dem Problem, den Einschränkungen und den Personen, die es warten werden.
Wenn ich einem Produktteam beitreteverstehe ich die bestehenden Entscheidungen, folge den Teamkonventionen und trage innerhalb meines zugewiesenen Rahmens bei.

Zwei Arbeitsweisen

01

Wenn ich die Architektur definiere

Wenn ich für die Gestaltung eines Projekts verantwortlich bin, treffe ich die Architekturentscheidungen und trage die Verantwortung dafür.

Ich beginne mit Anforderungen und Einschränkungen, lege dann Modulgrenzen fest, wähle den Technologie-Stack und entscheide, wie die Teile kommunizieren. Von Anfang an berücksichtige ich, wer das System bauen, testen und warten wird. Ich führe ein Muster ein, wenn es ein echtes Problem löst oder die Anwendung leichter weiterentwickelbar macht.

Entscheidungen, die ich bewerte

  • Modulverantwortlichkeiten und -grenzen
  • Domain-Regeln und Use Cases
  • Persistenz und externe Integrationen
  • Testbarkeit, Releases und Wartung
02

Wenn ich einem bestehenden Produkt beitrete

Bei Beratungsaufträgen sind die Architektur und Richtlinien oft bereits vorhanden.

Meine erste Aufgabe besteht darin, das System zu verstehen: Konventionen, Abhängigkeiten, Flüsse zwischen Diensten und die Gründe für frühere Entscheidungen. Ich analysiere, entwickle und teste die mir zugewiesenen Aufgaben in Abstimmung mit dem Team. Wenn ich ein strukturelles Problem finde, schlage ich eine Änderung vor, die zum Projekt und zu den Verantwortlichkeiten derjenigen passt, die die Architektur besitzen.

Diese Situation spiegelt sich in den meisten Projektbeispielen auf dieser Website wider. Die Seite Arbeitsweise erläutert meine verschiedenen Rollen ausführlicher.

Mein Beitrag

  • Analyse jeder Aufgabe innerhalb des größeren Systems
  • Entwicklung nach den Standards des Teams
  • Testen und Verhindern von Regressionen
  • Vorschlagen technischer Verbesserungen, wenn ein Teil des Systems verbessert werden kann

Ein Beispiel: eine Anwendung wachsen lassen, ohne sie zu zersplittern

In C-06 habe ich die Architektur definiert und entwickle sie seit 2013 als alleiniger Entwickler weiter.

Es gibt zwei Arten von Daten: die Daten in der Datenbank und die Projektdaten, die in Dateien gespeichert und über eine eigene Bibliothek verwaltet werden. Anfangs war die gesamte Anwendungslogik in einem einzigen Block konzentriert; mit wachsender Last wurde das zum Problem.

Ich habe das System weder neu geschrieben noch in viele Dienste aufgeteilt. Gemeinsam mit dem Kunden und seinen Mitarbeitern haben wir die Abläufe analysiert und die Engpässe ermittelt; anschließend habe ich nur das abgetrennt, was es rechtfertigte:

  1. die Verwaltung der Projektdaten, auf einen eigenen Server verlagert;
  2. lang laufende Prozesse, an eine RabbitMQ-Warteschlange und an Programme übergeben, die die Anfragen abarbeiten;
  3. das Haupt-Backend, das weiterhin die datenbanknahen APIs bedient und zum zentralen Einstiegspunkt für die übrigen Anfragen wurde (API-Gateway);
  4. die schrittweise Migration des Backend-Codes von .NET Framework zu .NET;
  5. ein Redis-Cache in der Projektverwaltung, damit Vorgänge, die innerhalb kurzer Zeit dasselbe Ergebnis liefern, nicht wiederholt werden.

Im Lauf der Zeit kam eine Android-App hinzu, mit der sich die Tätigkeiten im Außendienst verfolgen lassen: Dafür waren eine Web-API, die die Rohdaten der Geräte entgegennimmt, und ein Dienst nötig, der sie verarbeitet und für spätere Analysen aufbereitet.

Die Last auf dem Kern ist gesunken und die Leistung gestiegen, bei nur wenigen zusätzlichen Komponenten. Jede abgetrennte Komponente erhöht Komplexität und Betriebskosten: Ich habe sie nur dort eingeführt, wo der Nutzen eindeutig war.

Die Migration zu .NET macht auch das Monitoring vollständiger: Neben dem eigenen Anwendungscode liefern die .NET-Bibliotheken bereits Traces und Metriken, die sich mit wenig Konfiguration erfassen lassen. Als nächsten Schritt erwäge ich, diese Abdeckung mit OpenTelemetry auszubauen, um das Monitoring auf Standardwerkzeuge statt auf Eigenentwicklungen zu stützen.

Backend und Frontend

Ich arbeite seit fast dreißig Jahren in der Softwareentwicklung. Das Microsoft-Ökosystem ist mein Hauptreferenzpunkt, neben den Webtechnologien, die jedes Projekt benötigt.

Auf der Backend-Seite arbeite ich hauptsächlich mit .NET und ASP.NET Core: APIs, Anwendungsregeln, Daten und Integrationen. Ich bin der Plattform von .NET Framework bis zu den aktuellen .NET-Versionen gefolgt und habe für kleine und mittelständische Unternehmen sowie in Unternehmensumgebungen gearbeitet.

Auf der Frontend-Seite habe ich umfangreiche Erfahrung mit Angular: zunächst AngularJS, dann Angular ab seinen frühesten Versionen. Ich habe auch React in großen Projekten eingesetzt. Das Produkt und das Team bestimmen die Wahl des Tools; in jedem Fall strebe ich an, Schnittstellen zu erstellen, die auch bei wachsender Funktionalität und Teamgröße überschaubar bleiben.

Organisation von Code, wenn ich die Wahl habe

Ich beginne nicht mit dem Namen einer Architektur. Ich beginne mit den Regeln, die der Code ausdrücken muss, und den Änderungen, die er unterstützen muss.

Wo die Geschäftslogik eine wesentliche Rolle spielt, halte ich die Geschäftsregeln des Kunden von den technischen Details (Datenbanken, Nachrichtenübermittlung, externe APIs) getrennt, nach den Prinzipien der Clean Architecture. Oft organisiere ich den Code nach Funktionen, mit einem Vertical Slice-Ansatz: Wer eine Funktion ändert, kann ihrem Weg folgen, ohne entfernte Ordner durchsuchen zu müssen.

Ich setze Dependency Injection ein, um Abhängigkeiten explizit darzustellen, und trenne Befehle, Abfragen und ihre Handler, wenn dies die Anwendungsfälle klarer macht. Diese Werkzeuge erfordern Maßhalten: zusätzliche Schichten und Abstraktionen können eine einfache Funktion schwerer nachvollziehbar machen.

Microservices und ereignisgesteuerte Kommunikation

Die Trennung von Modulen innerhalb einer Anwendung und der Einsatz unabhängiger Dienste sind unterschiedliche Entscheidungen.

Ich erwäge Microservices, wenn die funktionalen Grenzen klar sind und ein echter Vorteil darin besteht, die Teile unabhängig weiterzuentwickeln oder zu veröffentlichen. Diese Autonomie hat ihren Preis: Netzwerkkommunikation, Fehlerbehandlung, Überwachung und Release-Koordination. In anderen Kontexten kann eine Anwendung mit gut definierten Modulen geeigneter sein.

Ich habe an Projekten gearbeitet, die Azure Service Bus oder RabbitMQ für die asynchrone Kommunikation genutzt haben; in bestehenden Produkten habe ich bei Integrationen geholfen und Abläufe diagnostiziert. Die Entkopplung erfordert Sorgfalt bei Verzögerungen, doppelten Nachrichten, Fehlern und Nachverfolgbarkeit.

Fachdomäne und Tests

Wichtige Regeln sollten für Personen, die das Produkt kennen, verständlich sein und im Laufe der Zeit testbar bleiben.

Ich wende Domain-Driven Design-Ideen in dem Umfang an, den das Problem erfordert: eine gemeinsame Sprache mit Produktexperten, Grenzen zwischen funktionalen Bereichen und Geschäftsregeln, die dort platziert werden können, wo sie verstanden und getestet werden können. Nicht jede Anwendung benötigt jedes DDD-Muster.

Automatisierte Tests überprüfen das Verhalten und schützen zukünftige Änderungen. Ich wende TDD an, wenn das Schreiben eines Tests zuerst eine Regel oder einen Sonderfall eingrenzt; in anderen Situationen füge ich Tests während der Entwicklung hinzu oder reproduziere einen Fehler mit einem Test, bevor ich ihn behebe. Tests ermöglichen es auch, eine API zu überprüfen, bevor der Client bereit ist. Wo Tests für die Genehmigung eines Pull Requests erforderlich sind, folge ich den Anforderungen des Teams. Eine hohe Abdeckung garantiert jedoch allein keine guten Tests.

Komplexität im Verhältnis zum Problem

Die Architektur sollte einem Projekt helfen zu wachsen, anstatt ein Selbstzweck zu werden.

Ein System, das Ereignisse austauscht, benötigt nicht unbedingt Event Sourcing: Dieses bringt zusätzliche Arbeit bei Versionierung und langfristigem Management mit sich, und ich würde es nur für einen konkreten Bedarf in Betracht ziehen.

Ich wende das gleiche Kriterium auf Schichten, Muster und verteilte Dienste an: Beginnen Sie mit einer angemessenen Struktur und entwickeln Sie sie weiter, wenn Regeln, Grenzen oder Lasten eine elaboriertere Lösung rechtfertigen. In Projekten, die ich leite, übernehme ich die Verantwortung für diese Entscheidungen; wenn ich an jemandes Produkt arbeite, helfe ich, es innerhalb der Verantwortlichkeiten und Einschränkungen des Teams zu verbessern.

Softwarearchitekten und Solution Architects in der Cloud

Möchten Sie eine Anwendung entwerfen oder ein bestehendes Produkt weiterentwickeln?

Ausführlicher Lebenslauf und Referenzen auf Anfrage verfügbar.