PhilKa: Die Seite wurde neu angelegt: „= Model-View-Controller (MVC) Entwurfsmuster = Das '''Model-View-Controller'''-Muster (kurz: '''MVC''') ist ein grundlegendes '''Architekturmuster''' der Softwareentwicklung, das zur Trennung von Daten, Darstellung und Logik dient. Es sorgt für eine klare Struktur, bessere Wartbarkeit und Wiederverwendbarkeit von Code, insbesondere in GUI- und Webanwendungen. == Grundidee == Das MVC-Muster teilt eine Anwendung in drei klar getrennte Komponenten:…“

2025-11-01T11:41:28Z

Die Seite wurde neu angelegt: „= Model-View-Controller (MVC) Entwurfsmuster = Das '''Model-View-Controller'''-Muster (kurz: '''MVC''') ist ein grundlegendes '''Architekturmuster''' der Softwareentwicklung, das zur **Trennung von Daten, Darstellung und Logik** dient. Es sorgt für eine klare Struktur, bessere Wartbarkeit und Wiederverwendbarkeit von Code, insbesondere in GUI- und Webanwendungen. == Grundidee == Das MVC-Muster teilt eine Anwendung in drei klar getrennte Komponenten:…“

Neue Seite

= Model-View-Controller (MVC) Entwurfsmuster =

Das '''Model-View-Controller'''-Muster (kurz: '''MVC''') ist ein grundlegendes '''Architekturmuster''' der Softwareentwicklung, das zur **Trennung von Daten, Darstellung und Logik** dient.
Es sorgt für eine klare Struktur, bessere Wartbarkeit und Wiederverwendbarkeit von Code, insbesondere in GUI- und Webanwendungen.

== Grundidee ==

Das MVC-Muster teilt eine Anwendung in drei klar getrennte Komponenten:

{| class="wikitable"
! Komponente !! Aufgabe
|-
| '''Model''' || Enthält die Anwendungslogik, Datenstrukturen und Regeln.
Verwaltet den Zustand der Anwendung unabhängig von der Benutzeroberfläche.
|-
| '''View''' || Präsentiert die Daten des Models dem Benutzer (z. B. GUI, Webseite, Konsole).
Reagiert auf Änderungen im Model.
|-
| '''Controller''' || Nimmt Benutzereingaben entgegen, interpretiert sie und ändert Model oder View entsprechend.
|}

<pre>
+--------------+ +--------------+ +--------------+
| View | <----> | Controller | <----> | Model |
| (Anzeige) | | (Steuerung) | | (Daten) |
+--------------+ +--------------+ +--------------+
</pre>

== Ablauf ==
1. **Benutzeraktion:** Der Benutzer interagiert mit der View (z. B. klickt einen Button).
2. **Steuerung:** Der Controller empfängt das Ereignis und ändert den Zustand des Models.
3. **Datenänderung:** Das Model aktualisiert seine Daten und informiert die View.
4. **Anzeige:** Die View aktualisiert die Darstellung gemäß den neuen Modeldaten.

== Beispiel (C++ mit Pseudocode) ==
<syntaxhighlight lang="cpp">
#include <iostream>
#include <string>

// MODEL
class Model {
std::string text = "Hello";
public:
std::string getText() const { return text; }
void setText(const std::string& t) { text = t; }
};

// VIEW
class View {
public:
void display(const std::string& data) {
std::cout << "Anzeige: " << data << std::endl;
}
};

// CONTROLLER
class Controller {
Model& model;
View& view;
public:
Controller(Model& m, View& v) : model(m), view(v) {}
void onUserInput(const std::string& input) {
model.setText(input);
view.display(model.getText());
}
};

int main() {
Model model;
View view;
Controller controller(model, view);

controller.onUserInput("Hallo MVC!");
}
</syntaxhighlight>

**Ergebnis:**
<pre>
Anzeige: Hallo MVC!
</pre>

== Vorteile ==
* **Klare Trennung von Logik, Daten und Darstellung**
* **Einfachere Wartung und Testbarkeit**
* **Mehrfachverwendung des Models mit unterschiedlichen Views**
* **Unabhängige Entwicklung von Frontend und Backend**

== Nachteile ==
* Zusätzlicher Strukturierungsaufwand
* Höhere Komplexität bei kleinen Projekten
* Kommunikation zwischen Komponenten kann aufwendig werden

== Varianten ==
Das MVC-Muster wurde in vielen Frameworks weiterentwickelt oder angepasst:

{| class="wikitable"
! Variante !! Beschreibung
|-
| [[MVP (Model-View-Presenter)]] || Der Presenter übernimmt mehr Logik und kommuniziert direkter mit der View.
|-
| [[MVVM (Model-View-ViewModel)]] || Typisch für GUI-Frameworks (z. B. WPF, MAUI). Datenbindung zwischen View und ViewModel.
|-
| '''HMVC''' || Hierarchisches MVC für modulare Anwendungen mit verschachtelten Controllern.
|}

== MVC in Webanwendungen ==
In modernen Webframeworks wird MVC weit verbreitet eingesetzt:

* **Model:** Daten und Geschäftslogik (z. B. Datenbankmodelle)
* **View:** HTML-/Template-Dateien
* **Controller:** Vermittelt zwischen HTTP-Anfragen und Modellen

Beispiel in Frameworks:
* **Laravel (PHP)**
* **Django (Python)**
* **ASP.NET MVC (C#)**
* **Spring MVC (Java)**
* **Ruby on Rails**

== Beispiel einer Webstruktur ==
<pre>
/app
├── models/
│ └── user.php
├── views/
│ └── userView.html
└── controllers/
└── userController.php
</pre>

== Vergleich mit ähnlichen Mustern ==
{| class="wikitable"
! Muster !! Fokus !! Besonderheit
|-
| [[MVP (Model-View-Presenter)]] || GUI-Architektur || Presenter kontrolliert die View direkt
|-
| [[MVVM (Model-View-ViewModel)]] || Datenbindung || ViewModel abstrahiert View komplett
|-
| [[PAC (Presentation-Abstraction-Control)]] || Interaktive Systeme || Hierarchisch strukturierte Variante von MVC
|}

== Einsatzgebiete ==
* Benutzeroberflächen (Desktop, Web, Mobile)
* GUI-Frameworks (Qt, JavaFX, WPF)
* Webframeworks (Laravel, Django, Spring, Rails)
* Software mit klarer Trennung von Logik und Darstellung

== Siehe auch ==
* [[MVP (Model-View-Presenter)]]
* [[MVVM (Model-View-ViewModel)]]
* [[PAC (Presentation-Abstraction-Control)]]
* [[Entwurfsmuster (Softwareentwicklung)]]
* [[Event-Driven Architecture]]
* [[Observer-Entwurfsmuster]]

== Quellen ==
* Erich Gamma et al.: *Design Patterns – Elements of Reusable Object-Oriented Software*
* Trygve Reenskaug: *MVC Introduction (1979)*
* [https://en.wikipedia.org/wiki/Model–view–controller Wikipedia: Model–View–Controller]
* [https://refactoring.guru/design-patterns/mvc Refactoring.Guru: MVC Pattern]

Model-View-Controller (MVC) - Versionsgeschichte