Binden des Models

Die Kommunikation zwischen einem Client (normalerweise einem Browser) und dem Webserver ist sehr einfach - Zeichenfolgen werden hin und her übertragen, da der Client keine Kenntnisse über Ihre ausgefallenen .NET-Objekte hat. In früheren Zeiten von ASP Classic und ASP.NET WebForms, bevor das MVC-Framework in .NET Framework eingeführt wurde, war das Aktualisieren eines Modells etwas umständlich. Zunächst mussten Sie ein FORMULAR mit allen Feldern erstellen, die der Benutzer ändern könnte. Wenn dieses FORMULAR auf den Server zurückgesendet wurde, müssen Sie jedes der FORMULAR-Felder lesen und Ihrem Modell zuweisen. Wenn wir diesen Ansatz wählen und ihn mit ASP.NET MVC verwenden würden, würde er ungefähr so aussehen:

<form method="post" action="/ModelBinding/UpdateFromOldSchoolForm">
    <input type="text" name="txtFirstName" value="@Model.FirstName" />
    <input type="text" name="txtLastName" value="@Model.LastName" />
    <input type="submit" value="Update" />
</form>

public IActionResult UpdateFromOldSchoolForm()
{
    WebUser webUser = LoadUserFromDatabase();

    webUser.FirstName = Request.Form["txtFirstName"];
    webUser.LastName = Request.Form["txtLastName"];

    UpdateUserInDatabase(webUser);

    return Content("User updated!");
}

Ein manuell erstelltes FORMULAR, das die Werte einer Methode POSTET, die dann die Werte liest und sie einem Objekt zuweist. Alles sehr einfach und oldschool. Mit ASP.NET MVC wurde jedoch das Konzept der Modellbindung eingeführt. Es ermöglicht Ihren Ansichten, Informationen aus dem Modell zu verwenden, um z.B.: Ein FORMULAR zum Bearbeiten des Modells, das jedoch noch hilfreicher ist, wenn die Empfangsmethode auf dem Controller die gesendeten Werte als Objekt des Typs "Models" behandelt, anstatt Sie zu zwingen, Zeichenfolgen aus dem FORMULAR zu lesen. Mit anderen Worten, dank der Magie der Modellbindung können Sie jetzt während der gesamten Kommunikation zwischen Client und Server mit Objekten arbeiten. Mal sehen, wie es funktioniert!

Model Binding verwenden

Zuerst brauchen wir ein Modell. Wenn Sie nicht wissen, um welches Modell es sich handelt, sollten Sie einige Artikel zurückspringen und sich darüber informieren. Wir erstellen ein einfaches Modell (eine Klasse) für den Umgang mit Informationen über einen Benutzer:

public class WebUser
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

In unserem Controller können wir jetzt eine Instanz dieser Klasse an die Ansicht übergeben. In einer realen Anwendung würden wir das WebUser-Objekt wahrscheinlich aus einer Datenbank abrufen, aber um die Dinge einfach zu halten, generieren wir für diese Demonstration einfach eine neue:

[HttpGet]
public IActionResult SimpleBinding()  
{  
    return View(new WebUser() { FirstName = "John", LastName = "Doe" });  
}

Indem wir unserer Ansicht mitteilen, welche Art von Modell sie mit der @model-Direktive erwarten, können wir jetzt verschiedene Hilfsmethoden (mehr dazu später) verwenden, um bei der Erzeugung eines FORMULARS zu helfen:

@using(var form = Html.BeginForm())
{
    <div>
    @Html.LabelFor(m => m.FirstName)
    @Html.TextBoxFor(m => m.FirstName)
    </div>

    <div>
    @Html.LabelFor(m => m.LastName)
    @Html.TextBoxFor(m => m.LastName)
    </div>

    <input type="submit" value="Submit" />
}

Das Ergebnis ist ein sehr allgemein wirkendes FORMULAR, das jedoch Beschriftungen und Textfelder enthält, in denen die Eigenschaften Ihres Modells gespeichert werden:

Standardmäßig wird das FORMULAR an dieselbe URL zurückgesendet, von der es übermittelt wurde. Daher benötigen wir eine POST-akzeptierende Controller-Methode, um die FORMULAR-Übermittlung zu verarbeiten:

[HttpPost]
public IActionResult SimpleBinding(WebUser webUser)
{
    //TODO: Update in DB here...
    return Content($"User {webUser.FirstName} updated!");
}

Beachten Sie, dass unsere Controller-Aktion nur einen Parameter vom selben Typ wie das Modell akzeptiert, das wir ursprünglich an die View übergeben haben: Die WebUser-Klasse. Hinter den Kulissen verarbeitet ASP.NET MVC nun das FORMULAR und weist den Eigenschaften der WebUser-Klasse die Werte zu, die in den bearbeitbaren Steuerelementen enthalten sind. Das ist die Magie der Modellbindung!

Zusammenfassung

Dank der Modellbindung können Sie die Beziehungen zwischen Ihren Modellen und Ihren Ansichten viel einfacher pflegen. In diesem Artikel haben wir nur die Oberfläche angekratzt - es gibt viel mehr Möglichkeiten mit Model Binding, wie Sie in einigen der kommenden Artikel entdecken werden.