Warum wird es als Best Practice angesehen, den Programmcode und den Code der grafischen Benutzeroberfläche in verschiedene Klassen zu packen?

Deshalb sagt mir mein Lehrer, dass es sehr wichtig ist, den Programmcode und den Code der grafischen Benutzeroberfläche nicht in denselben Klassen zu kapseln, sondern sie vollständig unabhängig zu halten. Ich schreibe gerade ein iPhone-Spiel mit einem Gitter darin. Für mich ist es viel sinnvoller, sowohl das grafische Raster als auch den technischen Code in derselben "Raster" -Klasse zu erstellen. Werden andere Programmierer dies missbilligen? Ist es in der Tat sehr wichtig, die grafische Oberfläche und den Code unabhängig zu halten? Welche Probleme treten auf, wenn ich es nicht tue?

Vielen Dank!

EDIT: danke Jungs! Wäre es in Ordnung, wenn ich zuerst das Projekt aufschreibe und dann den Code kopiere, um die Trennung des Anliegenentwurfs zu bilden. Ich weiß, dass dies den Zweck völlig zunichte machen kann, aber nur als Übung ... Damit ich dieses Entwurfsmuster das nächste Mal von Anfang an anwenden kann?

Das Konzept, auf das sich Ihr Lehrer bezieht, wird als Trennung von Bedenken bezeichnet.

Um es in Ihrem Kontext zu veranschaulichen, wenn Sie Ihr Programm vervollständigen und dann entscheiden, dass Sie es auf Android portieren möchten; Sie müssen viel mehr Code neu schreiben, als wenn Sie die Rasterlogik getrennt hätten.

Ein Interface-Control sollte sich nur mit dem Zeichnen befassen, was ihm gesagt wird. Die Grid-Logik sollte sich nur mit dem befassen, was sich im Grid befindet, und nicht mit dem Zeichnen.

Hilft das ?

Um es einfacher zu machen, Ihren Code zu ändern . Was ist, wenn Sie morgen kein Raster, sondern eine Liste verwenden möchten? Wenn Ihre GUI von Ihrer Logik getrennt ist, ist es einfach zu tun.

Außerdem schreiben Sie Code, der wiederverwendbarer ist . Wenn Ihre GUI Ihren technischen Code nicht enthält, können Sie ihn auch wiederverwenden. Erstellen Sie ein ausgefallenes Raster mit allen Optionen, und verwenden Sie es in anderen Projekten. Wenn Sie GUI und technischen Code mischen, können Sie dies nicht tun.

Es gibt Ihnen auch Code, der einfacher zu lesen ist. Wenn Ihr Grid nur GUI-Funktionen unterstützt, ist es einfacher, Ihren Code zu verstehen oder zu ändern.

Der allgemeine Ansatz der objektorientierten Programmierung zur Trennung von Belangen , wobei Code in logische Aufgaben aufgeteilt wird. Dies scheint zunächst mehr Arbeit. Wenn Ihr Projekt jedoch wächst, ist es einfacher, Ihren Code zu verfolgen und zu verwalten.

Aus diesem Grund ist es wahrscheinlich besser, Code, der für die Anzeige eines Rasters verantwortlich ist, und Code, der sich mit Daten befasst, die möglicherweise in diesem Raster angezeigt werden, zu trennen.

Wenn Aufteilung von Bedenken auf eine Anwendungsstruktur angewendet wird, ist das Ergebnis eine mehrschichtige Architektur (oder N-Tier-Architektur) http://en.wikipedia.org/wiki/Multitier_architecture .

Um auf den anderen Antworten aufzubauen und Ihnen ein Beispiel zu geben, sollten Sie sich irgendwie erlauben, Ihre Logik / Daten in Ihr Gitter einzuspeisen oder umgekehrt.

Ihr Rastersteuerelement kann entweder eine RenderMethode oder eine DataBindMethode verfügbar machen.

class GridControl
{
    public Render(GridData data) { ... }
}

oder

class GridControl
{
    public DataBind(GridData data) { ... }
}

Dann kann Ihre logische Einheit entweder das GridControl nehmen und ein Datenobjekt daran binden oder das Rendern mit dem Datenobjekt jedes Mal manuell aufrufen, wenn sich etwas ändert.

Ihre GridLogic sollte auch einen Verweis auf das GridControl enthalten, damit es an alle Eingaben / Ereignisse gebunden werden kann, die auftreten.

Die Idee hinter der Datenbindung ist, dass Ihr Grid-Steuerelement die Daten auf Änderungen überwacht und sich selbst neu rendert. Wenn Sie eine Render-Funktion verfügbar machen, rendert Ihre Logikeinheit das Steuerelement manuell neu.

In beiden Fällen können Sie die Logik und das Raster so aufteilen, dass Sie leichter voneinander abweichen können, ohne etwas zu beschädigen. Sie können auch ein neues Steuerelement wie a schreiben ListControl, um Ihre Daten als Liste anstelle eines Rasters anzuzeigen, ohne Ihre gesamte Logik neu schreiben zu müssen.

Ich empfehle Ihnen dringend, einen Blick auf die MVC-Architektur zu werfen .

Es ist eine Weiterentwicklung des von Ihnen erwähnten Konzepts (Trennung von Programmcode und grafischer Oberfläche). MVC steht für Model-View-Controller. Hier sind das Modell die Daten, View der Code der grafischen Benutzeroberfläche und COntroller der Code, der die Daten verarbeitet.

Auf diese Weise haben Sie drei Teile Ihres Programms erstellt. Jedes Teil kann ausgetauscht werden, ohne dass Änderungen an den anderen beiden Teilen erforderlich sind.

Dies hängt von den zukünftigen Änderungen ab, die zu erwarten sind. Was Sie minimieren möchten, ist die Anzahl der manuellen Codeänderungen, die erforderlich sind, um jede einzelne Funktionsänderung korrekt zu implementieren.

MVC gewinnt, wenn Änderungen auf den V-Teil oder "Ansicht" beschränkt sind.

Nach meiner Erfahrung ist es viel wahrscheinlicher, dass sich Änderungen auf alle drei Teile auswirken. Daher ist es besser, wenn sie nicht getrennt werden. Um zu zeigen, was ich meine, habe ich lange Zeit eine von mir entwickelte Technik namens Dynamische Dialoge verwendet , bei der eine neue Anforderung, z Text:

if(deTextEdit(&sName)){
  // do XYZ
}

Anstelle mehrerer getrennter Bearbeitungen, um anzugeben, dass das Bearbeitungsfeld vorhanden ist, um einen eindeutigen Bezeichner dafür zu erstellen, um es an die Modellvariable zu binden und um es mit der Ereignisbehandlungsroutine für verlorenen Fokus zu verknüpfen.

Wenn Sie zu diesem Link gehen, sehen Sie ein komplexeres Beispiel.

Grundsätzlich besteht die Idee darin, den Code in eine domänenspezifische Sprache umzuwandeln, um die Anzahl der zur Erreichung des Zwecks erforderlichen Änderungen zu minimieren. Der Grund, warum Sie dies tun möchten, besteht nicht nur darin, den Aufwand zu verringern, sondern auch die Möglichkeit, Fehler einzuführen, indem Sie eine oder mehrere Änderungen vergessen oder falsch codieren. Es reduziert auch die Größe des Quellcodes um ungefähr eine Größenordnung.

Es ist nicht frei. Es führt eine einmalige Lernkurve für den Programmierer ein.

Die grafische Oberfläche ist systemabhängig, während der Spielkern ein Algorithmus ist, der völlig unabhängig von dem System ist, auf dem er ausgeführt wird. Das Beibehalten der beiden Teile erleichtert das Verwalten, Testen und Debuggen des Programms, da die Änderungen in einem Subsystem die Funktionsweise des anderen nicht beeinflussen. Auch wenn Sie sich nicht für die Portabilität interessieren, ist Ihnen die Robustheit und Wartbarkeit Ihres Programms wichtig.