Warum nur minimaler Benutzer- / handgeschriebener Code und alles in XAML?

Ich bin der Meinung, dass die MVVM-Community wie die OO-Programmierer in den 90er Jahren übereifrig geworden ist. Es handelt sich um eine falsche Bezeichnung. MVVM ist synonym mit keinem Code. Aus meiner geschlossenen StackOverflow-Frage :

Oft stoße ich hier auf Posts über jemanden, der versucht, das Äquivalent in XAML anstelle von Code dahinter zu machen. Ihr einziger Grund ist, dass sie ihren Code hinter "clean" halten wollen. Korrigieren Sie mich, wenn ich falsch liege, aber nicht, dass:

XAML wird ebenfalls kompiliert - in BAML - und muss dann zur Laufzeit ohnehin in Code umgewandelt werden. XAML kann möglicherweise mehr Laufzeitfehler aufweisen, da diese vom Compiler beim Kompilieren nicht erkannt werden - aufgrund falscher Schreibweise - und diese Fehler auch schwerer zu beheben sind. Es ist bereits Code dahinter - wie es oder nicht InitializeComponent (); muss ausgeführt werden und die .gics-Datei enthält eine Menge Code, obwohl sie möglicherweise versteckt ist. Ist es rein psychologisch? Ich vermute, es sind Entwickler, die aus einem Web-Hintergrund kommen und Markup im Gegensatz zu Code mögen.

BEARBEITEN: Ich schlage keinen Code hinter XAML vor - verwende beide - ich ziehe es vor, meine Bindung auch in XAML vorzunehmen - ich bin einfach dagegen, alle Anstrengungen zu unternehmen, um das Schreiben von Code hinter esp in einer WPF-App zu vermeiden - es sollte eine Fusion von sein beides, um das Beste daraus zu machen.

UPDATE: Es ist nicht einmal Microsofts Idee, jedes Beispiel auf MSDN zeigt, wie Sie es in beiden machen können.

Ich habe noch nie von jemandem gehört, der vorschlägt, alles in XAML zu schreiben.

Tatsächlich wäre das eine schreckliche Idee, IMO.

Historisch gesehen stammte das Problem von Winforms-Apps, deren Code Logik enthielt, die nicht dorthin gehörten, weil es Logik war . Daher kommt die Bedeutung von VM. Damit können Sie die Teile isolieren, die die Ansicht mit dem Modell verbinden.

Aus diesem Grund wird in der Ansicht nur das behandelt, was am besten funktioniert, nämlich die Benutzeroberfläche.

Wenn Sie nun Situationen haben, in denen Ihre Benutzeroberfläche Code erfordert, gehen Sie auf jeden Fall danach und fügen Sie ihn in Ihren Code ein. Ich würde jedoch sagen, dass es für 95% der Szenarien wahrscheinlich besser ist, die Benutzeroberfläche in der Markup-Datei zu belassen. Wenn Sie Code benötigen, ist dies wahrscheinlich eine Logik, die Sie ausschreiben möchten das ist zweckmäßigerweise dem Ansichtsmodell überlassen. Ausnahmen hiervon sind Dinge wie Verhalten, aber sie sind völlig getrennte Tiere und erfordern einen besonderen Platz (dh nicht in Ihrem Code dahinter).

Wenn Sie Ihre Frage direkt beantworten und davon ausgehen, dass Sie sich bei "Code" in jedem Fall speziell auf Code-Behind (Code, der sich in einer visuellen Steuerungsklasse befindet) beziehen, liegt dies daran, dass Ihre Benutzeroberfläche vollständig implementiert werden kann und in Blend mit nur einer Technologie manipuliert. Die Annahme ist, dass Ihre UX-Designer keine Entwickler sind und nicht im Code arbeiten möchten und dass sie Layout- und XAML-Experten sind, im Gegensatz zu Programmierexperten. Wenn Sie alles ohne Code-Behind implementieren, können Sie diesen Arten von Designern die Tools geben, die sie benötigen, um vollständig in ihrer Sprache zu arbeiten.

Es bietet eine klare Trennung zwischen imperativer Programmierung und deklarativem Design.

Dies ist der treibende Grund für die Existenz von "Verhaltensweisen" in Silverlight und WPF - anstatt Code in den Code-Behind zu kopieren, sollten Sie ein Verhalten zu einem eigenen kleinen wiederverwendbaren Modul machen. Wenn Sie dies tun, haben Sie mit Blend den Vorteil, dass Sie es buchstäblich auf ein Steuerelement ziehen und dort ablegen können. Anstatt ein einzelnes bewegliches Teil für ein ansonsten in XAML enthaltenes Steuerelement zu haben, haben Sie die beweglichen Teile jetzt in einen schönen Container abstrahiert, der mit Designer-Tools bearbeitet werden kann.

Nach meiner Erfahrung kommt es häufig darauf an, zu versuchen, komplizierte Logik in XAML-Triggern zu verwenden, um sie aus dem Code-Behind herauszuhalten, wenn der bessere, einfachere Ansatz darin besteht, diese Logik in keiner der beiden zu platzieren - sie gehört in die Ansicht -Modell.

Einer der größten Vorteile, wenn Sie in xaml alles tun, was Sie können, ist, dass das gesamte Verhalten an einem Ort bleibt. Jedes Mal, wenn der Entwickler zwischen dem XAML und dem Code wechseln muss, wird es schwieriger, ihn zu verstehen.

Ich war in einem WPF-Team, das die Reduzierung des Code-Behind nicht zu einer Priorität gemacht hat. Es gab mehr als ein paar Male, in denen das Debuggen viel schwieriger war, weil ein Ereignishandler das Steuerelement manipulierte, und es war nicht sofort ersichtlich, weil das Verhalten auf zwei Dateien verteilt war.

Trotzdem glaube ich, dass Sie zu Recht denken, dass es manchmal besser ist, beim Designprinzip Kompromisse einzugehen. Einige Dinge sind in xaml sehr schwierig zu tun. Ich habe Stunden oder sogar Tage damit verbracht, zu versuchen, ein Verhalten in xaml zum Laufen zu bringen, das ich mit Code-Behind in viel kürzerer Zeit hätte machen können. Ich bin gekommen, um Code-Behind als letzten Ausweg zu behandeln, aber ich würde niemals jemandem sagen, dass er es niemals verwenden sollte. Es ist nur ein weiterer Kompromiss, den ein guter Ingenieur verstehen muss.

edit: Aus den Kommentaren geht hervor, dass mein Post als Argument gegen xaml interpretiert wird. Ich wollte das Gegenteil argumentieren. Reines XAML ist immer vorzuziehen, da es das gesamte Verhalten an einem Ort behält. Eine Mischung aus XAML und CodeBehind kann sich verwickeln, daher ist die Minimierung des CodeBehind ideal. Xaml ist aus vielen Gründen einem reinen Code-Behind vorzuziehen. WPF und Silverlight sind so konzipiert, dass sie in xaml geschrieben sind.

Ich habe nur sehr oberflächliches Wissen über XAML, aber es verwirrt mich, dass der Compiler keine Tippfehler erkennt.

Der grundlegende Unterschied besteht darin, dass XAML deklarativ ist , während beispielsweise C # ein Imperativ ist.

Einfach gesagt:

Pane p = new Pane(200, 100);
Button foo = new Button("foo");
Button bar = new Button("bar");
p.addChild(foo);
p.addChild(bar);

gegen

<Pane width="200" height="100">
    <Button label="foo"/>
    <Button label="bar"/>
<Pane>

Der obere Code erzeugt wirklich eine Hierarchie durch Nebeneffekte, während der untere einfach deklariert. Es ist auch erwähnenswert, dass, während zum Beispiel die addChildMethode umbenannt werden könnte, die Kind-Eltern-Beziehung den Kern des semantischen Modells bildet und genauso im deklarativen Snippet dargestellt wird. Es ist sehr weit von der Implementierung entfernt, was viele darunter liegende Optimierungen wie die verzögerte Instanziierung völlig transparent macht.
Die deklarative Programmierung bietet eine Reihe von Vorteilen. Es ist prägnanter, ausdrucksvoller und Ihrem Modell sehr nahe. Ich würde so weit gehen, wie es vorzuziehen ist.

Dies bedeutet jedoch nicht, dass Sie versuchen sollten, alles in XAML zu schreiben. C # verfügt über viele Konstrukte auf hoher Ebene, die einen deklarativen Stil ermöglichen.

Am Ende soll Ihr Code kurz und einfach zu lesen sein. Wenn Sie also in C # dasselbe mit weniger Code als in XAML erreichen können, ist die Verwendung von C # logisch. Beachten Sie jedoch, dass XAML-Code in dem Sinne "portabler" ist, dass er weitaus weniger anfällig für Änderungen in den verwendeten Komponenten ist und das .NET-Framework abstrahiert (z. B. die Details zur Implementierung von Bindungen).