Logic-Data-View-Controller-Service-Paradigma: Unterschied zwischen den Versionen

aus GlossarWiki, der Glossar-Datenbank der Fachhochschule Augsburg
Keine Bearbeitungszusammenfassung
 
(113 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
=Definition=
{{MVC:Menü}}
Das [[Logic-Data-View-Controller-Services-Paradigma]] oder [[Logic-Data-View-Controller-Services-Paradigma|-Pattern]], kurz [[LDVCS]],  bezeichnet ein [[Architekturmuster]] zur Trennung einer [[Anwendung]] in drei separate Einheiten:  
==Definition ([[Kowarschick (MMProg)]])==
[[Logic (LDVCS)|Logic]] (Logik), [[Data (ADVCS)|Data]] (Daten), [[View (MVC)|View]] (Darstellung), [[Controller (MVC)|Controller]] (Steuerung) und [[Service (MVCS)|Service]] (Service).
[[Datei:LDVC-Module 01.png|gerahmt|rechts|LDVC-Module]]
[[Datei:LDVCS-Module 01.png|gerahmt|rechts|LDVCS-Module]]


=Konzept=
Als [[Logic-Data-View-Controller-Service-Paradigma]]
[[Medium:LDVCS-Prozess 01.png|gerahmt||rechts|LDVCS-Prozess]]
(engl. [[GlossaryWiki:Logic-data-view-controller-service paradigm|Logic-data-view-controller-service paradigm]]) oder
Dieses Paradigma ist eine Verfeinerung des [[Model-View-Controller-Services-Paradigma]]s.  
[[Logic-Data-View-Controller-Service-Paradigma|-Architektur]]
(engl. [[GlossaryWiki:Logic-data-view-controller-service paradigm|architecture]]),
kurz [[Logic-Data-View-Controller-Service-Paradigma|LDVCS-Paradigma]], [[Logic-Data-View-Controller-Service-Paradigma|LDVCS-Architektur]]
oder auch nur
[[Logic-Data-View-Controller-Service-Paradigma|LDVCS]] bezeichnet man ein [[Architekturmuster]], bei der eine [[Komponente (UML)|Anwendungs-Komponente]] in fünf eigenständige Module unterteilt wird:
[[Logic-Data-View-Controller-Service-Paradigma/View|View]] (Darstellung, Präsentation),
[[Logic-Data-View-Controller-Service-Paradigma/Controller|Controller]] (Steuerung),
[[Logic-Data-View-Controller-Service-Paradigma/Logic|Logic]] (Logik),
[[Logic-Data-View-Controller-Service-Paradigma/Service|Service]] (Service, Zugriff auf externe Daten)
und [[Logic-Data-View-Controller-Service-Paradigma/Data|Data]] (Daten).


Die Modellkomponente des MVCS-Paradigmas übernimmt normalerweise zwei Aufgaben: Die Speicherung der Anwendungsdaten und die Realisierung der Anwendungslogik.
===Datenmodul===
(Manchmal übernimmt auch der Controller die Realisierung der Anwendungslogik.)
Ein [[Logic-Data-View-Controller-Service-Paradigma/Data|Datenmodul]]
Im LDVCS-Paradigma wird die Modellkomponente in zwei Komponenten aufgeteilt: eine Datenkomponente (Data) und eine Logikkomponente (Logic).
(engl. [[GlossaryWiki:Logic-data-view-controller-service paradigm/data|LDVCS data module]])  
Der Controller darf nun nicht mehr direkt schreibend auf die Datenkomponente zugreifen. Dies ist jetzt die Aufgabe der Logikkomponenten (und evtl. der Servicekomponente).
einer [[Logic-Data-View-Controller-Service-Paradigma|LDVCS]]-[[Anwendung]]
dient zur Speicherung bestimmter Daten, {{dh}} zur Speicherung von Teilen des aktuellen Zustands der Anwendung.  


= Der LDVCS-Prozess =
Ein LDVCS-Datenmodul kann weitere Aufgaben übernehmen:


== Beispiel Jump 'n' Run==
* anderen Modulen Zugriff auf die Zustandsdaten gewähren
In einem [[Jump 'n' Run|Jump-'n'-Run]]-Spiel werden Daten ('''Data''') über  
* andere Module über Änderungen informieren (meist mittels des [[Observer-Pattern]]s)
die Spielfigur (Position, Laufrichtiung, Geschwindigkeit ...), die Gegner, die Gegenstände etc. gespeichert.
 
===View (Darstellung, Präsentation)===
[[Logic-Data-View-Controller-Service-Paradigma/View|LDVCS-Views]]
(engl. [[GlossaryWiki:Logic-data-view-controller-service paradigm/view|LDVCS views]])
sind die grafischen, akustischen, haptischen und olfaktorischen Schnittstellen einer
[[Logic-Data-View-Controller-Service-Paradigma|LDVCS]]-[[Anwendung]].
Sie „visualisieren“ Daten, die in [[Logic-Data-View-Controller-Service-Paradigma/Data|Datenmodulen]] der Anwendung enthalten sind.
 
Eine LDVCS-View kann weitere Aufgaben übernehmen:
 
* bei Daten-Änderungen in den zugehörigen [[Logic-Data-View-Controller-Service-Paradigma/Data|Datenmodulen]] der Anwendung die View-Repräsentation dieser Daten automatisch anpassen
* Benutzeraktionen, die über grafische Eingabeelemente – wie Textfelder oder Buttons – erfolgen, an einen [[Logic-Data-View-Controller-Service-Paradigma|Controller]] weiterleiten
 
===Controller (Steuerung)===
[[Logic-Data-View-Controller-Service-Paradigma/Controller|LDVCS-Controller]]
(engl. [[GlossaryWiki:Logic-data-view-controller-service paradigm/controller|LDVCS controllers]]) dienen zur Steuerung einer
[[Logic-Data-View-Controller-Service-Paradigma|LDVCS]]-[[Anwendung]].
Dazu nimmt ein Controller Eingaben aus verschiedensten Quellen entgegen ({{zB}} Sensor-Daten oder Daten, die ein Benutzer über eine beliebige Benutzer-Schnittstelle wie eine Tastatur oder eine Maus eingibt) und leitet diese bereinigt und normalisiert an geeignete [[Logic-Data-View-Controller-Service-Paradigma/Logic|Logikmodule]] weiter.
 
Ein LDVCS-Controller sollte keine weiteren Aufgaben übernehmen.
 
===Logikmodul===
[[Logic-Data-View-Controller-Service-Paradigma/Logic|LDVCS-Logik-Module]]
(engl. [[GlossaryWiki:Logic-data-view-controller-service paradigm/logic|LDVCS logic modules]]) realisieren die
Anwendungslogik einer [[Logic-Data-View-Controller-Service-Paradigma|LDVCS]]-[[Anwendung]].
 
Ein Logikmodul reagiert auf Ereignisse, wie {{zB}} Benutzereingaben, Timer Events oder Ähnliches,
indem es Daten in Datenmodulen entweder indirekt mit Hilfe von
[[Logic-Data-View-Controller-Service-Paradigma/Service|Servicemodulen]] oder direkt manipuliert.
 
Die Aktionen, die ein Logikmodul ausführt, hängen {{iAllg}} vom aktuellen [[Zustand]] der Anwendung ab.
Dieser Zustand kann entweder in Datenmodulen gespeichert werden (so dass auch andere Module darauf zugreifen können)
oder im Logikmodul selbst (so dass ein Zugriff durch andere Module nicht möglich ist).
 
Ein LDVCS-Logik-Modul sollte keine weiteren Aufgaben übernehmen.
 
===Service===
Ein [[Logic-Data-View-Controller-Service-Paradigma/Service|Service]]
(engl. [[GlossaryWiki:Logic-data-view-controller-service paradigm/service|service]])
dient einer [[Logic-Data-View-Controller-Service-Paradigma|LDVCS]]-[[Anwendung]] zur Kommunikation
mit der Außenwelt, {{dh}} mit Dienste-Anbietern wie [[Web-Server]]n, [[Datenbanksystem]]en oder auch [[Dateisystem]]en.
Die Kommunikation kann in beide Richtungen erfolgen: Services können sowohl Daten aus [[Logic-Data-View-Controller-Service/Data|Datenmodulen]] auslesen und in externe
[[Repository|Repositories]] schreiben, als auch Daten aus externen Repositories lesen und in Datenmodule einfügen.
 
Ein LDVCS-Service-Modul sollte keine weiteren Aufgaben übernehmen.
 
===LDVCS-Paradigma: Varianten (Definitionen nach [[Kowarschick (MMProg)]])===
 
<gallery  perrow="2" widths="301px" heights="410px" class="floatright">
  Datei:VCLSD-Schichtenarchitektur 01 301px.png | Beispiel für eine VCLSD-Schichtenarchitektur
  Datei:VCLD-Schichtenarchitektur 01 301px.png | Beispiel für eine VCLD-Schichtenarchitektur
</gallery>
 
====VCLSD-Paradigma====
Ein LDVCS-Paradigma wird '''VCLSD-Paradigma''' genannt, wenn die fünf zugehörigen Module folgende Schichtenarchitektur bilden:
''View'', ''Controller'', ''Logic'', ''Service'', ''Data''.
 
Die fünf Module einer VCLSD-Komponente sind gemäß dem [[Schichtenparadigma]] in Ebenen angeordnet.
Die höheren Ebenen können auf tiefer gelegene Ebenen zugreifen, aber nicht umgekehrt.
 
Die unterste Ebene ist Data. Das zugehörige Modul weiß nichts von den über ihr liegenden Module und kann mit diesen nur mit
indirekt – {{zB}} durch Antworten auf [[Nachricht]]en oder mit Hilfe des [[Observer-Pattern]]s – kommunizieren.
 
Ein Servicemodul kennt nur die darunterliegende Datenmodule und kann nur auf diese  zugreifen
(sowie {{iAllg}} auf externe Datenquellen, sofern es nicht nur Filterfunktionen wahrnimmt).
 
Ein Logikmodul kann entweder direkt auf ein Datenmodul zugreifen oder indirekt mit Hilfe eines Servicemoduls (zum Beispiel
um Daten aus einer externen Quelle zu laden, oder um zu überprüfen,
ob die entsprechenden Zugriffsrechte für eine Datenmanipulation überhaupt gegeben sind).
 
Ein Controller-Modul kann nur auf Logikmodule zugreifen, um Benutzeraktionen an dieses (bereinigt und normalisiert) weiterzuleiten.
Direkte Zugriffe auf Service- und Datenmodule wären zwar möglich, sind aber nicht vorgesehen.
 
Eine View kommuniziert {{iAllg}} direkt nur mit Controller-Modulen, um diesen Benutzeraktionen, die über die View erfolgen, mitzuteilen.
Ein direkter Zugriff auf ein Datenmodul ist nur dann notwendig, wenn die Nachrichten, die von den Datenmodulen verschickt werden,
nicht alle relevanten Informationen enthalten. Zugriffe auf andere Module sind nicht vorgesehen.


Die '''View'''' visualisiert die Elemente des Spiels mit Hilfe von Bildern und Animationen (Walk cyles etc.).
Der Benutzer stellt das „oberste Modul“ dar. Er kommuniziert nur mit View- und Controller-Modulen.
Jede Änderung an den Daten hat, sofern sie sich im für den Spieler sichtbaren Bereich befindet,
eine Anpassung der View zur Folge.


Der Spieler steuert die Spielfigur mit Hilfe der Tastatur. Jeder Tastendruck wird vom Controller analysiert und
====LDVCS-Multicast-Paradigma====
zur Manipulation der Spielfigur an die Logik-Komponente ('''Logic''') weitergeleitet.
Ein LDVCS-Paradigma wird LDVCS-Multicast-Paradigma genannt, wenn alle Module nur indirekt, {{dh}} mit Hilfe
von [[Multicast-Nachricht]]en kommunizieren.
Man beachte, dass die Logik-Komponente i. Allg. aktiv sein kann: Sie kann die Daten selbstständig, d.h. auch ohne Manipultation durch den
Controller verändern. Beispielsweise werden die gegnerischen Figuren, sofern es welche gibt, direkt von der Logik-Komponente gesteuert.


Mit Hilfe einer Service-Komponente ('''Service''') kann das Spiel zu einem Multiuser-Spiel erweitert werden.
===LDVCS-Pattern (Definitionen nach [[Kowarschick (MMProg)]])===
Die Service-Komponente hat dann zwei Aufgaben:
# Die Position des Avatars (d.h. der eigenen Spielfigur) an einen zentralen Server zu übertragen.
# Die Postition anderer Spielfiguren und möglicher Gegner vom zentralen Server zu holen und in die eigene Datenkomponente zu schreiben.


Eine weitere typische Aufgabe der Service-Komponente ist es, die Daten-Komponente bei Programmstart zu initialisieren.
Wenn für ein LDVCS-Paradigma – im Sinne eines [[Entwurfmusters]] – eine konkrete [[Klasse]]n- und [[Objekt]]-Struktur für die
Zu diesem Zweck sollten die Servic-Komponente eine Initialisierungsmethode implementieren, die
fünf Module [[Logic-Data-View-Controller-Service-Paradigma/Data|Data]],  
vom Hauptprogramm direkt aufgerufen wird, nachdem die Daten- und die Service-Komponete erzeugt wurden.
[[Logic-Data-View-Controller-Service-Paradigma/Logic|Logic]],
[[Logic-Data-View-Controller-Service-Paradigma/View|View]],  
[[Logic-Data-View-Controller-Service-Paradigma/Controller|Controller]]
und [[Logic-Data-View-Controller-Service-Paradigma/Service|Service]]
vorgegeben ist, spricht man von einem [[Logic-Data-View-Controller-Service-Pattern|LDVCS-Pattern]].


=== Modularität ===
====VCLSD-Pattern====


Der große Vorteil des LDVCS-Paradigmas ist die Modularität. Das [[Programmierprinzip|Prinzip]] „[[Separation of Concerns]]“
Ein LDVCS-Pattern, das ein VCLSD-Paradigma realisiert, wird auch '''VCLSD-Pattern''' genannt.
wird hierbei bachtet: Jede Aufgabe wird von einer eigenen Komponente bearbeitet.


Ein Jump'n'Run-Spiel beispielsweise, das derartig modular aufgebaut ist, kann sehr leicht an neue Gegebenheiten angepasst werden.
====LDVCS-Multicast-Pattern====
Jede der folgenden Änderungen hat lediglich Auswirkungen auf eine der fünf Komponenten:


# Änderung der Darstellung (d.h. der View): Die View kann jederzeit durch neue [[Skin]]s aktualisiert werden. Es ist auch möglich, die 2D-Ansicht des Spiels durch eine Pseudo-3D-Ansicht zu ersetzen. Bei einem Multiuser-Spiel hat sowieso jeder Spieler seine eigene Sicht auf die Szenerie.
Ein LDVCS-Pattern, das nur auf Multicast-Nachrichten basiert, wird auch '''LDVCS-Multicast-Pattern''' genannt.
# Änderung der Spielsteuerung (d.h. des Controllers): Anstelle einer Steuerung der Spielfigur durch die Tastatur kann beispielsweise eine Steuerung der Spielfigur durch eine WiiMote erfolgen.
# Änderung der Spiellogik (d.h. der Logikkomponente): Die KI-Engine zur Steuerung der Gegener kann beispielsweise durch eine bessere Engine ersetzt werden.
# Änderung der Dateninitialisierung (d.h. der Service-Komponente): Wenn die Dateninitialisierung künfig beispielsweise nicht mehr über XML, sondern über SQL erfolgen soll, muss ledichlich die entsprechende Service-Komponente ausgetauscht werden.
# Änderung des Spielservers (d.h. der Service-Komponente): Es ist jederzeit möglich, ein Multi-User-Spiel über einen anderen Server (mit einer anderen Architektur) laufen zulassen.


Lediglich die Datenkomponente wird im Allgemeinen nicht ausgetauscht, sondern höchstens erweitert. Allerdings ist es denkbar,
==Das VCLSD-Paradigma als Verfeinerung des MVCS-Paradigmas==
Filter vorzuschalten, die einen Zugriff auf bestimmte Daten erst dann erlauben, wenn beispielsweise ein Login-Vorgang erfolgreich abgschlossen wurde.


=Implementierung=
Dieses Pattern ist eine Verfeinerung des [[Model-View-Controller-Service-Paradigma]]s (MVCS-Paradigma).


Folgendes Klassendiagramm zeigt, wie eine Anwendung, die gemäß dem LDVCS-Paradigma implementiert wird, prinzipiell aufgebaut ist.  
Eine VCLSD-Komponente besteht im Gegensatz zum MVCS-Komponenten nicht aus vier, sondern aus fünf Modulen.
Der Grund dafür ist, dass das Modell des MVCS-Paradigmas normalerweise zwei Aufgaben übernimmt: Die Speicherung der Anwendungsdaten und die Realisierung der Anwendungslogik. Häufig übernimmt auch der Controller die Realisierung der Anwendungslogik.


[[Medium:LDVCS 01 Class Diagram.jpg|left|miniatur|977px|'''LDVCS-Klassendiagramm ([http://glossar.hs-augsburg.de/beispiel/tutorium/flex_4/ldvcs/ Umsetzung in Flex 4],
Im VCLSD-Paradigma wird ein Modellmodul daher in zwei Module aufgeteilt: ein Datenmodul (Data) und ein Logikmodul (Logic).
[http://glossar.hs-augsburg.de/webdav/tutorium/flex_4/ldvcs/ SVN-Repository])]]
Der Controller darf nun nicht mehr direkt schreibend auf ein Datenmodul zugreifen. Dies ist jetzt die Aufgabe der Logikmodule (und evtl. der Servicemodule).


== Der VCLSD-Prozess ==
[[Datei:VCLD-Prozess 01.png|gerahmt||rechts|Der VCLD-Prozess]]
[[Datei:VCLSD-Prozess 01.png|gerahmt||rechts|Der VCLSD-Prozess]]


Für jeder der fünf Komponenten (Logic, Data, Model, View. Controller) gibt es ein Interface,
=== Beispiel Jump 'n' Run===
das die Methoden und Attribute deklariert, die diese Komponente unterstützt, sowie eine Klasse,
In einem [[Jump 'n' Run|Jump-'n'-Run]]-Spiel werden Daten ('''Data''') über
die das zugehörige Interface implementiert. Häufig handelt es sich bei derartigen
die Spielfigur (Position, Laufrichtung, Geschwindigkeit ...), die Gegner, die Gegenstände etc. gespeichert.
Komponentenklassen sogar um Singleton-Klassen (vgl. [[Singleton-Pattern]]). Im Allgemeinen
gibt es weitere Komponentenklassen, auf die über die fünf „Haupt-Komponentenklassen“
zugegriffen werden kann.


Darüber hinaus gibt es eine Komponentenklasse <code>DomainComponents</code>, die alle zugehörigen
Die '''View''' visualisiert die Elemente des Spiels mit Hilfe von Bildern und Animationen (Walk cyles etc.).  
Komponenten erzeugt und initialisiert. Auch zu dieser Klasse gibt es im Allgemeinen
Jede Änderung an den Daten hat, sofern sie sich im für den Spieler sichtbaren Bereich befindet,
nur ein Objekt (Singleton-Pattern).
eine Anpassung der View zur Folge.


Durch die Verwendung von Interfaces ist es ganz einfach, eine Kompnentenimplementierung
Der Spieler steuert die Spielfigur mit Hilfe der Tastatur. Jeder Tastendruck wird vom Controller analysiert und
(in der Komponentenklasse <code>DomainComponents</code>) durch eine andere zu ersetzen.  
zur Manipulation der Spielfigur an die Logik-Komponente ('''Logic''') weitergeleitet.
Man beachte, dass die Logik-Komponente {{iAllg}} aktiv sein kann: Sie kann die Daten selbstständig, {{dh}} auch ohne Manipulation durch den
Controller verändern. Beispielsweise werden die gegnerischen Figuren, sofern es welche gibt, direkt von der Logik-Komponente gesteuert.


Man beachte, dass jede Komponente alle anderen Komponenten „kennt“, mit denen sie evtl. kommunizieren muss.
Mit Hilfe einer Service-Komponente ('''Service''') kann das Spiel zu einem Multiuser-Spiel erweitert werden.
Die zugehörigen Part-of-Attribute können als Add-only-Attribute implementiert werden. Das heißt,
Die Service-Komponente hat dann zwei Aufgaben:
es ist nicht notwendig, dass die Werte dieser Attribute nach der Initialisierung durch
# Die Position des Avatars ({{dh}} der eigenen Spielfigur) an einen zentralen Server zu übertragen.
die Komponentenklasse <code>DomainComponents</code> noch einmal von einer anderen Komponente gelesen werden müssten.
# Die Position anderer Spielfiguren und möglicher Gegner vom zentralen Server zu holen und in die eigene Datenkomponente zu schreiben.


Abhängig von ihrer jeweiligen Aufgabe haben die verschiedenen Komponenten
Eine weitere typische Aufgabe der Service-Komponente ist es, die Daten-Komponente bei Programmstart zu initialisieren.
verschiedene Attribute und erweitern (bzw. implementieren) verschiedene Interfaces:
Zu diesem Zweck sollten die Service-Komponente eine Initialisierungsmethode implementieren, die  
vom Hauptprogramm direkt aufgerufen wird, nachdem die Daten- und die Service-Komponente erzeugt wurden.


;<code>IDomainData</code>, <code>DomainData</code>
==== Modularität ====
:Erweitert das <code>IPublischer</code>-Interface (vgl. [[Observer-Pattern]]), d.h. signalisiert Änderungen an andere Komponenten.
:Das Dateninterface definiert eine Reihe von Attributen, die von der Logik- und der Service-Komponente manipuliert und von den anderen Komponenten gelesen werden können.
:Im Sinne des [[Programmierprinzipien#Interface-Segregation-Prinzip.5B10.5D.2C_Interface_segregation_principle|Interface-Segregation-Prinzips]] sollte man sogar zwei Interfaces zur Verfügung stellen: Eines, das nur lesenden Zugriff auf die Attribute zulässt, und eines, dass das erste Interface um einen schreibenden Zugriff auf die Attribute erweitert und nur von der Logic- und der Service-Komponente verwendet wird.
:Es ist durchaus möglich und wiederum wegen des Interface-Segregation-Prinzips auch sinnvoll mehrere (möglichst unabhängige) Datenkomponenten zu implementieren. Der Zugang zu diesen Komponenten würde dann über die „Haupt-Datenkomponente“ <code>DomainData</code> gewährt werden.
:Wegen des von Bertrand Meyer geforderten Prinzips der [[Programmierprinzipien#Modulare_Robustheit.2C_Modular_protection|Modularen Robustheit]] sollte die Datenkomponente nur diejenigen Daten zur Verfügung stellen, auf die der aktuelle Benutzer auch Zugriff hat. Das heißt, die Daten-Komponente filtert selbstständig Daten (abhängig vom Inhalt anderer Attribute), wenn dies notwendig sein sollte.


;<code>IDomainLogic</code>, <code>DomainLogic</code>
Der große Vorteil des VCLSD-Patterns ist die Modularität. Das [[Programmierprinzipien|Prinzip]] „[[Separation of Concerns]]
:Erweitert das <code>IOberserver</code>-Interface (vgl. [[Observer-Pattern]]), um über Änderungen an der Datenkomponente informiert zu werden.
wird hierbei beachtet: Jede Aufgabe wird von einer eigenen Komponente bearbeitet.
:Das Logikinterface definiert einie Reihe von Methoden, die von der Controller-Komponente aufgerufen werden können.
:Auch hier ist es möglich, mehrere Komponenten-Klassen zu definieren, auf deren Objekte über die Hauptkomponente <code>DomainLogic</code> zugegriffen werden kann.
:Die Aufgabe der Logik-Komponente ist es, die Datenkomponente entweder direkt oder indirekt (über die Servicekomponente, i. Allg. asynchron) zu manipulieren.
:Diese Manipulation kann auch aktiv, d.h. unabhängig von Methodenaufrufen durch den Controller erfolgen. Beispielsweise kann eine KI-Komponente eine Spielfigur selbstständig steuern.


;<code>IDomainController</code>, <code>DomainController</code>
Beispielsweise kann ein Jump-'n'-Run-Spiel, das derartig modular aufgebaut ist, sehr leicht an neue Gegebenheiten angepasst werden.
:Könnte das <code>IOberserver</code>-Interface (vgl. [[Observer-Pattern]]) erweitern, um über Änderungen an der Datenkomponente informiert zu werden (zum Beispiel für Force-Feedback-Aktionen). Dies ist i. Allg. jedoch nicht notwendig.
Jede der folgenden Änderungen hat lediglich Auswirkungen auf eines der fünf Module:
:Das Controller-Interface definiert i. Allg. eine Reihe von Methoden, die von der Viewkomponente aufgerufen werden können. Die Komponente kann aber auch Verbindungen zu anderen Eingabemedien herstellen (wie z.B. Tastatur, USB-Controller etc.), um Benutzer-Aktionen abzufangen und geeignet an die Logik-Komponente weiterzuleiten.


;<code>IDomainView</code>, <code>DomainView</code>
# Änderung der Darstellung ({{dh}} der View): Die View kann jederzeit durch neue [[Skin]]s aktualisiert werden. Es ist auch möglich, die 2D-Ansicht des Spiels durch eine Pseudo-3D-Ansicht zu ersetzen. Bei einem Multiuser-Spiel hat sowieso jeder Spieler seine eigene Sicht auf die Szenerie.
:Erweitert das <code>IOberserver</code>-Interface (vgl. [[Observer-Pattern]]), um über Änderungen an der Datenkomponente informiert zu werden.
# Änderung der Spielsteuerung ({{dh}} des Controllers): Anstelle einer Steuerung der Spielfigur durch die Tastatur kann beispielsweise eine Steuerung der Spielfigur durch eine [[WiiMote]] erfolgen. Hier wäre es auch denkbar, dass der WiiMote-Controller bestimmte Datenänderungen (wie {{zB}} Kollisionen) per [[Force Feedback]] an den Benutzer zurückmeldet. Dazu muss sich der Controller ebenfalls über Datenänderungen informieren lassen.
:Die Viewkomponente „visualisert“ den aktuellen Zustand der Datenkomponente geeignet. Dabei ist der Begriff „visualisieren“ sehr weit gefasst: Auch Audio-Ausgaben, Ausgaben an haptische Geräte wie Braille-Zeilen, Steuerung von Lichtorgeln etc. wird darunter verstanden.
# Änderung der Spiellogik ({{dh}} der Logikkomponente): Die KI-Engine zur Steuerung der Gegner kann beispielsweise durch eine bessere Engine ersetzt werden.
:Die Viewkomponente reicht außerdem Benutzereingaben (z.B. Mausklicks auf dem Monitor) an die Controllerkomponente weiter.
# Änderung der Dateninitialisierung ({{dh}} der Service-Komponente): Wenn die Dateninitialisierung künftig beispielsweise nicht mehr über XML, sondern über SQL erfolgen soll, muss lediglich die entsprechende Service-Komponente ausgetauscht werden.
:Im Sinne des [[Programmierprinzipien#Single_responsibility_principle.5B9.5D|Single responsibility principle]]'s sollten die Visualisierung und die Aktivierung des Controllers allerdings von unterschiedlichen Viewobjekten vorgenommen werden.
# Änderung des Spielservers ({{dh}} der Service-Komponente): Es ist jederzeit möglich, ein Multi-User-Spiel über einen anderen Server (mit einer anderen Architektur) laufen zu lassen.


;<code>IDomainService</code>, <code>DomainService</code>
Auch die Datenkomponente kann ausgetauscht werden, wenn {{zB}} andere Datenstrukturen zur Speicherung der Daten eingesetzt werden sollen.
:Erweitert das <code>IOberserver</code>-Interface (vgl. [[Observer-Pattern]]), um über Änderungen an der Datenkomponente informiert zu werden.
Es ist darüber hinaus möglich, einer Datenkomponente {{zB}} mit Hilfe von speziellen Filter-Services Filter vorzuschalten (vgl. [[Aspektorientierte Programmierung]]). Zum Beispiel kann auf diese Weise ein Login-Mechanismus realisiert werden:  
:Diese Erweiterung ist allerdings nur notwendig, wenn die Servicekomponente automatisch Änderungen, die die Datenkomponente signalisiert, an einen Server übertragen soll.
Der Zugriff auf bestimmte Daten wird erst dann erlaubt, wenn ein Login-Vorgang erfolgreich abgeschlossen wurde.
:Falls die Logikkomponente die Services zum Laden von Daten aus dem Netz oder zum Speichern von Daten im Netz aktivieren soll, muss die Servicekomponente dagegen einen Satz geeigneter MEthoden zur Verfügung stelln.


= Verfeinerung des LDVCS-Prozesses=
== Verfeinerung des VCLSD-Prozesses==
Genauso wie der [[Model-View-ControllerProzess|MVC-Prozess]] und der [[Model-View-Controller-Service-Prozess|MVCS-Prozess]] kann auch der LDVCS-Prozess verfeinert werden. Auch hier bietet sich die Aufteilung
Genauso wie der [[Model-View-Controller-Paradigma|MVC-Prozess]] und der [[Model-View-Controller-Service-Paradigma|MVCS-Prozess]] kann auch der VCLSD-Prozess verfeinert werden. Auch hier  
in Kernawendungen (Domains) und eine Rahmenanwendung (Frame) an, die den Zugang zu den Kernanwendungen steuert.
kann eine „äußere VCLSD-Komponente“ eine „innere VCLSD-Komponente“ verwenden:
In diesem Fall gibt es mehrere relativ unabhängige LDVCS-Prozesse: Die Rahmenkomponente darf auf zugehörigen Kernkomponenten zugreifen.
Die Module der äußeren Komponente dürfen auf die Module der inneren Komponente zugreifen.
Der umgekehrte Weg sollte allerdings vermieden werden, damit die Kernanwendungen problemlos in andere Umgebungen integriert werden können.
Der umgekehrte Weg sollte allerdings vermieden werden, damit die innere Komponente problemlos in andere Umgebungen integriert werden können.


[[Medium:LDVCS-Prozess 02.png|gerahmt|links|LDVCS-Prozess 2 (mit Trennung in Frame und Domain)]]
[[Datei:VCLSD-Prozess 02.png|gerahmt|links|Der VCLSD-Prozess mit Trennung in eine äußere und eine innere Komponente]]
&#160;
&#160;
==Beispiel „Spiel mit Highscore-Verwaltung“==
===Beispiel „Spiel mit Highscore-Verwaltung“===
Wenn man ein „Spiel mit Highscore-Verwaltung“ realisieren möchte, sollte man zwei unanhängige Kernanwendungen schreiben.
Wenn man ein „Spiel mit Highscore-Verwaltung“ realisieren möchte, sollte man zwei unabhängige Komponenten implementieren:
Das Spiel selbst und eine spielunabhängige Highscore-Verwaltung. Die Rahmenanwendung verknüpft diese beiden Anwendungen.
Das Spiel selbst und eine spielunabhängige Highscore-Verwaltung.  


Die Rahmenanwendung liest beispielsweise bei
Eine dritte Komponente, die sogenannte Rahmenkomponente verknüpft diese beiden Anwendungen.
Spielende die erreichten Punkte aus dem Spielmodell aus und leitet diese an das Highscore-Modell weiter.
Die Rahmenkomponente liest beispielsweise bei
Eine weitere Möglichkeit wäre, dass die Rahmenanwendung über die Highscore-Anwendung ermittelt,
Spielende die erreichten Punkte aus dem Modell der Spielkomponente aus und leitet diese an das Highscore-Modell weiter.
Eine weitere Möglichkeit wäre, dass die Rahmenkomponente über die Highscore-Anwendung ermittelt,
ob der Spieler schon mindestens fünf Level erfolgreich gespielt hat. Nur in diesem Fall gewährt sie den Zugang zum Trainingsmodus des Spiels.
ob der Spieler schon mindestens fünf Level erfolgreich gespielt hat. Nur in diesem Fall gewährt sie den Zugang zum Trainingsmodus des Spiels.


=Quellen=
==Implementierung==
 
Das VCLSD-Pattern lässt sich auf mehrere Arten implementieren:
* [[View-Controller-Logic-Service-Data-Pattern/Implementierung: Dependency Injection|Initialisierung mittels Dependency Injection]]
* [[View-Controller-Logic-Service-Data-Pattern/Implementierung: Singleton|Initialisierung mittels Singletons]]
* [[View-Controller-Logic-Service-Data-Pattern/Implementierung: Observer|Kommunikation ausschließlich mittels des Observer Patterns]]
<noinclude>
 
===Data Access Object===
{{TBD}}
 
==Quellen==
# {{Quelle|Kowarschick, W.: Multimedia-Programmierung}}
 
==Siehe auch==
*{{Vgl|Model-View-Controller-Paradigma}}
*{{Vgl|Model-View-Controller-Service-Paradigma}}
<noinclude>
<noinclude>
* [[Kowarschick, W.: Multimedia-Programmierung]]</noinclude><noinclude>[[Kategorie:Objektorientierte Programmierung]]
[[Kategorie:MVC]]
[[Kategorie:Glossar]][[Kategorie:MVC]]
[[Kategorie:Objektorientierte Programmierung]]
[[en:LDVCS]]
[[Kategorie:Glossar]]
[[Kategorie:Kapitel:Multimedia-Programmierung]]
[[en:VCLSD]]
{{{{SITENAME}}-konformer Artikel}}</noinclude>
[[Kategorie:Kapitel:Multimedia-Programmierung]]</noinclude>

Aktuelle Version vom 22. September 2017, 16:49 Uhr

Dieser Artikel erfüllt die GlossarWiki-Qualitätsanforderungen nur teilweise:

Korrektheit: 4
(großteils überprüft)
Umfang: 3
(einige wichtige Fakten fehlen)
Quellenangaben: 4
(fast vollständig vorhanden)
Quellenarten: 4
(sehr gut)
Konformität: 4
(sehr gut)

Diese Bewertungen beziehen sich auf alle im nachfolgenden Menü genannten Artikel gleichermaßen.

Definition (Kowarschick (MMProg))

LDVC-Module
LDVCS-Module

Als Logic-Data-View-Controller-Service-Paradigma (engl. Logic-data-view-controller-service paradigm) oder -Architektur (engl. architecture), kurz LDVCS-Paradigma, LDVCS-Architektur oder auch nur LDVCS bezeichnet man ein Architekturmuster, bei der eine Anwendungs-Komponente in fünf eigenständige Module unterteilt wird: View (Darstellung, Präsentation), Controller (Steuerung), Logic (Logik), Service (Service, Zugriff auf externe Daten) und Data (Daten).

Datenmodul

Ein Datenmodul (engl. LDVCS data module) einer LDVCS-Anwendung dient zur Speicherung bestimmter Daten, d. h. zur Speicherung von Teilen des aktuellen Zustands der Anwendung.

Ein LDVCS-Datenmodul kann weitere Aufgaben übernehmen:

  • anderen Modulen Zugriff auf die Zustandsdaten gewähren
  • andere Module über Änderungen informieren (meist mittels des Observer-Patterns)

View (Darstellung, Präsentation)

LDVCS-Views (engl. LDVCS views) sind die grafischen, akustischen, haptischen und olfaktorischen Schnittstellen einer LDVCS-Anwendung. Sie „visualisieren“ Daten, die in Datenmodulen der Anwendung enthalten sind.

Eine LDVCS-View kann weitere Aufgaben übernehmen:

  • bei Daten-Änderungen in den zugehörigen Datenmodulen der Anwendung die View-Repräsentation dieser Daten automatisch anpassen
  • Benutzeraktionen, die über grafische Eingabeelemente – wie Textfelder oder Buttons – erfolgen, an einen Controller weiterleiten

Controller (Steuerung)

LDVCS-Controller (engl. LDVCS controllers) dienen zur Steuerung einer LDVCS-Anwendung. Dazu nimmt ein Controller Eingaben aus verschiedensten Quellen entgegen (z. B. Sensor-Daten oder Daten, die ein Benutzer über eine beliebige Benutzer-Schnittstelle wie eine Tastatur oder eine Maus eingibt) und leitet diese bereinigt und normalisiert an geeignete Logikmodule weiter.

Ein LDVCS-Controller sollte keine weiteren Aufgaben übernehmen.

Logikmodul

LDVCS-Logik-Module (engl. LDVCS logic modules) realisieren die Anwendungslogik einer LDVCS-Anwendung.

Ein Logikmodul reagiert auf Ereignisse, wie z. B. Benutzereingaben, Timer Events oder Ähnliches, indem es Daten in Datenmodulen entweder indirekt mit Hilfe von Servicemodulen oder direkt manipuliert.

Die Aktionen, die ein Logikmodul ausführt, hängen i. Allg. vom aktuellen Zustand der Anwendung ab. Dieser Zustand kann entweder in Datenmodulen gespeichert werden (so dass auch andere Module darauf zugreifen können) oder im Logikmodul selbst (so dass ein Zugriff durch andere Module nicht möglich ist).

Ein LDVCS-Logik-Modul sollte keine weiteren Aufgaben übernehmen.

Service

Ein Service (engl. service) dient einer LDVCS-Anwendung zur Kommunikation mit der Außenwelt, d. h. mit Dienste-Anbietern wie Web-Servern, Datenbanksystemen oder auch Dateisystemen. Die Kommunikation kann in beide Richtungen erfolgen: Services können sowohl Daten aus Datenmodulen auslesen und in externe Repositories schreiben, als auch Daten aus externen Repositories lesen und in Datenmodule einfügen.

Ein LDVCS-Service-Modul sollte keine weiteren Aufgaben übernehmen.

LDVCS-Paradigma: Varianten (Definitionen nach Kowarschick (MMProg))

VCLSD-Paradigma

Ein LDVCS-Paradigma wird VCLSD-Paradigma genannt, wenn die fünf zugehörigen Module folgende Schichtenarchitektur bilden: View, Controller, Logic, Service, Data.

Die fünf Module einer VCLSD-Komponente sind gemäß dem Schichtenparadigma in Ebenen angeordnet. Die höheren Ebenen können auf tiefer gelegene Ebenen zugreifen, aber nicht umgekehrt.

Die unterste Ebene ist Data. Das zugehörige Modul weiß nichts von den über ihr liegenden Module und kann mit diesen nur mit indirekt – z. B. durch Antworten auf Nachrichten oder mit Hilfe des Observer-Patterns – kommunizieren.

Ein Servicemodul kennt nur die darunterliegende Datenmodule und kann nur auf diese zugreifen (sowie i. Allg. auf externe Datenquellen, sofern es nicht nur Filterfunktionen wahrnimmt).

Ein Logikmodul kann entweder direkt auf ein Datenmodul zugreifen oder indirekt mit Hilfe eines Servicemoduls (zum Beispiel um Daten aus einer externen Quelle zu laden, oder um zu überprüfen, ob die entsprechenden Zugriffsrechte für eine Datenmanipulation überhaupt gegeben sind).

Ein Controller-Modul kann nur auf Logikmodule zugreifen, um Benutzeraktionen an dieses (bereinigt und normalisiert) weiterzuleiten. Direkte Zugriffe auf Service- und Datenmodule wären zwar möglich, sind aber nicht vorgesehen.

Eine View kommuniziert i. Allg. direkt nur mit Controller-Modulen, um diesen Benutzeraktionen, die über die View erfolgen, mitzuteilen. Ein direkter Zugriff auf ein Datenmodul ist nur dann notwendig, wenn die Nachrichten, die von den Datenmodulen verschickt werden, nicht alle relevanten Informationen enthalten. Zugriffe auf andere Module sind nicht vorgesehen.

Der Benutzer stellt das „oberste Modul“ dar. Er kommuniziert nur mit View- und Controller-Modulen.

LDVCS-Multicast-Paradigma

Ein LDVCS-Paradigma wird LDVCS-Multicast-Paradigma genannt, wenn alle Module nur indirekt, d. h. mit Hilfe von Multicast-Nachrichten kommunizieren.

LDVCS-Pattern (Definitionen nach Kowarschick (MMProg))

Wenn für ein LDVCS-Paradigma – im Sinne eines Entwurfmusters – eine konkrete Klassen- und Objekt-Struktur für die fünf Module Data, Logic, View, Controller und Service vorgegeben ist, spricht man von einem LDVCS-Pattern.

VCLSD-Pattern

Ein LDVCS-Pattern, das ein VCLSD-Paradigma realisiert, wird auch VCLSD-Pattern genannt.

LDVCS-Multicast-Pattern

Ein LDVCS-Pattern, das nur auf Multicast-Nachrichten basiert, wird auch LDVCS-Multicast-Pattern genannt.

Das VCLSD-Paradigma als Verfeinerung des MVCS-Paradigmas

Dieses Pattern ist eine Verfeinerung des Model-View-Controller-Service-Paradigmas (MVCS-Paradigma).

Eine VCLSD-Komponente besteht im Gegensatz zum MVCS-Komponenten nicht aus vier, sondern aus fünf Modulen. Der Grund dafür ist, dass das Modell des MVCS-Paradigmas normalerweise zwei Aufgaben übernimmt: Die Speicherung der Anwendungsdaten und die Realisierung der Anwendungslogik. Häufig übernimmt auch der Controller die Realisierung der Anwendungslogik.

Im VCLSD-Paradigma wird ein Modellmodul daher in zwei Module aufgeteilt: ein Datenmodul (Data) und ein Logikmodul (Logic). Der Controller darf nun nicht mehr direkt schreibend auf ein Datenmodul zugreifen. Dies ist jetzt die Aufgabe der Logikmodule (und evtl. der Servicemodule).

Der VCLSD-Prozess

Der VCLD-Prozess
Der VCLSD-Prozess

Beispiel Jump 'n' Run

In einem Jump-'n'-Run-Spiel werden Daten (Data) über die Spielfigur (Position, Laufrichtung, Geschwindigkeit ...), die Gegner, die Gegenstände etc. gespeichert.

Die View visualisiert die Elemente des Spiels mit Hilfe von Bildern und Animationen (Walk cyles etc.). Jede Änderung an den Daten hat, sofern sie sich im für den Spieler sichtbaren Bereich befindet, eine Anpassung der View zur Folge.

Der Spieler steuert die Spielfigur mit Hilfe der Tastatur. Jeder Tastendruck wird vom Controller analysiert und zur Manipulation der Spielfigur an die Logik-Komponente (Logic) weitergeleitet.

Man beachte, dass die Logik-Komponente i. Allg. aktiv sein kann: Sie kann die Daten selbstständig, d. h. auch ohne Manipulation durch den Controller verändern. Beispielsweise werden die gegnerischen Figuren, sofern es welche gibt, direkt von der Logik-Komponente gesteuert.

Mit Hilfe einer Service-Komponente (Service) kann das Spiel zu einem Multiuser-Spiel erweitert werden. Die Service-Komponente hat dann zwei Aufgaben:

  1. Die Position des Avatars (d. h. der eigenen Spielfigur) an einen zentralen Server zu übertragen.
  2. Die Position anderer Spielfiguren und möglicher Gegner vom zentralen Server zu holen und in die eigene Datenkomponente zu schreiben.

Eine weitere typische Aufgabe der Service-Komponente ist es, die Daten-Komponente bei Programmstart zu initialisieren. Zu diesem Zweck sollten die Service-Komponente eine Initialisierungsmethode implementieren, die vom Hauptprogramm direkt aufgerufen wird, nachdem die Daten- und die Service-Komponente erzeugt wurden.

Modularität

Der große Vorteil des VCLSD-Patterns ist die Modularität. Das PrinzipSeparation of Concerns“ wird hierbei beachtet: Jede Aufgabe wird von einer eigenen Komponente bearbeitet.

Beispielsweise kann ein Jump-'n'-Run-Spiel, das derartig modular aufgebaut ist, sehr leicht an neue Gegebenheiten angepasst werden. Jede der folgenden Änderungen hat lediglich Auswirkungen auf eines der fünf Module:

  1. Änderung der Darstellung (d. h. der View): Die View kann jederzeit durch neue Skins aktualisiert werden. Es ist auch möglich, die 2D-Ansicht des Spiels durch eine Pseudo-3D-Ansicht zu ersetzen. Bei einem Multiuser-Spiel hat sowieso jeder Spieler seine eigene Sicht auf die Szenerie.
  2. Änderung der Spielsteuerung (d. h. des Controllers): Anstelle einer Steuerung der Spielfigur durch die Tastatur kann beispielsweise eine Steuerung der Spielfigur durch eine WiiMote erfolgen. Hier wäre es auch denkbar, dass der WiiMote-Controller bestimmte Datenänderungen (wie z. B. Kollisionen) per Force Feedback an den Benutzer zurückmeldet. Dazu muss sich der Controller ebenfalls über Datenänderungen informieren lassen.
  3. Änderung der Spiellogik (d. h. der Logikkomponente): Die KI-Engine zur Steuerung der Gegner kann beispielsweise durch eine bessere Engine ersetzt werden.
  4. Änderung der Dateninitialisierung (d. h. der Service-Komponente): Wenn die Dateninitialisierung künftig beispielsweise nicht mehr über XML, sondern über SQL erfolgen soll, muss lediglich die entsprechende Service-Komponente ausgetauscht werden.
  5. Änderung des Spielservers (d. h. der Service-Komponente): Es ist jederzeit möglich, ein Multi-User-Spiel über einen anderen Server (mit einer anderen Architektur) laufen zu lassen.

Auch die Datenkomponente kann ausgetauscht werden, wenn z. B. andere Datenstrukturen zur Speicherung der Daten eingesetzt werden sollen. Es ist darüber hinaus möglich, einer Datenkomponente z. B. mit Hilfe von speziellen Filter-Services Filter vorzuschalten (vgl. Aspektorientierte Programmierung). Zum Beispiel kann auf diese Weise ein Login-Mechanismus realisiert werden: Der Zugriff auf bestimmte Daten wird erst dann erlaubt, wenn ein Login-Vorgang erfolgreich abgeschlossen wurde.

Verfeinerung des VCLSD-Prozesses

Genauso wie der MVC-Prozess und der MVCS-Prozess kann auch der VCLSD-Prozess verfeinert werden. Auch hier kann eine „äußere VCLSD-Komponente“ eine „innere VCLSD-Komponente“ verwenden: Die Module der äußeren Komponente dürfen auf die Module der inneren Komponente zugreifen. Der umgekehrte Weg sollte allerdings vermieden werden, damit die innere Komponente problemlos in andere Umgebungen integriert werden können.

Der VCLSD-Prozess mit Trennung in eine äußere und eine innere Komponente

 

Beispiel „Spiel mit Highscore-Verwaltung“

Wenn man ein „Spiel mit Highscore-Verwaltung“ realisieren möchte, sollte man zwei unabhängige Komponenten implementieren: Das Spiel selbst und eine spielunabhängige Highscore-Verwaltung.

Eine dritte Komponente, die sogenannte Rahmenkomponente verknüpft diese beiden Anwendungen. Die Rahmenkomponente liest beispielsweise bei Spielende die erreichten Punkte aus dem Modell der Spielkomponente aus und leitet diese an das Highscore-Modell weiter. Eine weitere Möglichkeit wäre, dass die Rahmenkomponente über die Highscore-Anwendung ermittelt, ob der Spieler schon mindestens fünf Level erfolgreich gespielt hat. Nur in diesem Fall gewährt sie den Zugang zum Trainingsmodus des Spiels.

Implementierung

Das VCLSD-Pattern lässt sich auf mehrere Arten implementieren:


Data Access Object

TO BE DONE

Quellen

  1. Kowarschick (MMProg): Wolfgang Kowarschick; Vorlesung „Multimedia-Programmierung“; Hochschule: Hochschule Augsburg; Adresse: Augsburg; Web-Link; 2018; Quellengüte: 3 (Vorlesung)

Siehe auch