Daten an Ansichten übergeben

Eine Ansicht kann ohne ein Modell oder andere Daten aus dem Back-End vorhanden sein. In den meisten Fällen müssen Sie jedoch auf Daten zugreifen, die von einem Controller in Ihrer Ansicht verfügbar gemacht wurden. Da Ihre Ansicht nichts über Ihren Controller wissen muss (gemäß der Regel zur Trennung von Bedenken), ist Ihr Controller dafür verantwortlich, die Daten für die Ansicht verfügbar zu machen. Dies kann auf zwei Arten erfolgen: Entweder definieren Sie ein stark typisiertes Modell und übergeben es dann an die Ansicht, oder Sie können die ViewData/ViewBag-Container verwenden, um Daten für die Ansicht verfügbar zu machen. Lassen Sie uns diese Ansätze jetzt diskutieren.

Beachten Sie, dass sich die Informationen in diesem Artikel und im Schnellstart-Artikel zum Hinzufügen eines Modells zu Ihrem Projekt etwas überschneiden.

Verwenden eines (Ansichts-) Modells

Da diese Technologie als MVC (Model-View-Controller) bezeichnet wird, ist die Verwendung eines (View-) Modells definitiv der sauberste und gebräuchlichste Ansatz, um Daten in eine View zu übertragen. Wir werden später in diesem Tutorial mehr über das Modell sprechen, aber jetzt wissen wir nur, dass es im Grunde genommen nur ein Objekt ist, das normalerweise etwas aus der realen Welt darstellt. Sie werden auch auf das Konzept eines "Ansichtsmodells" stoßen - wir werden später noch genauer darauf eingehen, aber um es kurz zu beschreiben, ein Ansichtsmodell ist nur ein Modell, das an eine Ansicht übergeben wird. Es kann sich also um ein Element handeln, das bereits in Ihrem Projekt vorhanden ist, z.B.: ein Benutzer - oder Produkt -Objekt oder eine Klasse, die Sie speziell definieren, um die Daten darzustellen, auf die Sie zugreifen möchten

Ein Modell muss jedoch keine komplexe Klasse sein - es kann sich theoretisch um eine so einfache Klasse wie eine Zeichenfolge, eine Ganzzahl oder eine Datums- / Uhrzeitangabe handeln. Mit anderen Worten, alles, was sich im .NET Framework befindet, kann als Modell verwendet werden. In der Praxis ist Ihr Modell jedoch normalerweise eine Klasse, die aus mindestens einigen Eigenschaften besteht. So könnte beispielsweise ein Modell, das zur Darstellung eines Produkts verwendet wird, folgendermaßen aussehen:

public class Product
{
    public string Title { get; set; }

    public double Price { get; set; }
}

Die Verbindung zwischen dem Modell und der Ansicht wird vom Controller hergestellt. Er kann Eingaben vom Benutzer entgegennehmen und in relevante Daten für die Ansicht umwandeln, z.B.: so was:

public IActionResult Details(int id)
{
    Product product = new Product()
    {
        Title = "Toilet Paper",
        Price = 1.99
    };
    return View(product);
}

Beachten Sie, wie ich die product -Instanz an die Ansicht (View) übergebe, wenn ich die View() -Methode aufrufe. In der Ansicht "Produkt/Details" kann ich jetzt die Produktklasse als das Modell definieren, das diese Ansicht erwarten kann (und sollte). Verwenden Sie dazu die Direktive @model, die sich oben in Ihrer Ansichtsdatei befindet:

@model HelloMVCWorld.Models.Product

Damit können Sie nun Ihr (Ansichts-) Modell und seine Eigenschaften in Ihrer Ansicht verwenden:

@model HelloMVCWorld.Models.Product

<h1>@Model.Title</h1>
Price: @Model.Price

Dank der Tatsache, dass Sie einen starken Typ als Modell der Ansicht angeben, erhalten Sie Hilfe beim Zugriff auf Mitglieder des Objekts über IntelliSense, und Ihr Code wird während des Erstellungsprozesses überprüft, um sicherzustellen, dass Sie nur die gefundenen Eigenschaften/Methoden auf dem Modellobjekt verwenden.

Dynamische Ansichten

Wenn Sie keinen Modelltyp für Ihre Ansicht deklarieren und die @model-Direktive verwenden, erwartet die Ansicht nicht, dass ein Modell eines bestimmten Typs übergeben wird. Dies hindert Sie jedoch nicht daran, genau das und sogar das zu tun mit dem Objekt. Dies wird häufig als dynamische Ansicht bezeichnet und nur selten verwendet, da Sie die Vorteile der IntelliSense-Unterstützung und die Überprüfung der Eigenschaften während der Kompilierung nicht mehr nutzen können.

Sie könnten also das obige Beispiel nehmen und die @model-Direktive oben in der Ansicht entfernen, und es würde immer noch funktionieren. In dieser Situation wird die Model-Eigenschaft als dynamisches Objekt betrachtet, bei dem Sie auf Eigenschaften zugreifen können, ohne dass der Compiler überprüft, ob sie vorhanden sind. Dies bedeutet natürlich auch, dass beim Versuch, auf eine nicht vorhandene Eigenschaft zuzugreifen, die Seitengenerierung zur Laufzeit fehlschlägt, was zu einer unangenehmen Ausnahme führt. Daher werden dynamische Ansichten nicht häufig verwendet.

Verwenden der ViewData/ViewBag-Container

Alternativ zu der stark typisierten Methode zum Übergeben von Daten an eine Ansicht können Sie die sogenannten ViewData/ViewBag-Container verwenden. Sie können ihnen vom Controller aus Daten hinzufügen und dann automatisch auf die in Ihren Ansichten gespeicherten Daten zugreifen. Es ist eigentlich ganz einfach und Sie können fast das Gleiche erreichen, als hätten Sie ein stark typisiertes Modell verwendet. Hier ist ein Beispiel:

public IActionResult DetailsViewData(int id)
{
    ViewBag.ProductTitle = "Toilet Paper";
    ViewBag.ProductPrice = 1.99;
    return View();
}

Dank der immer verfügbaren Eigenschaft ViewBag können Sie jetzt in Ihrer Ansicht genauso einfach auf diese Daten zugreifen:

<h1>@ViewBag.ProducTtitle</h1>
Price: @ViewBag.ProductPrice

Der Hauptunterschied besteht darin, dass diese Eigenschaften beim Kompilieren nicht überprüft werden und IntelliSense beim Schreiben keine Hilfe bietet. Mit anderen Worten, Sie könnten einen Eigenschaftsnamen leicht falsch schreiben und würden es erst bemerken, wenn Sie die Ansicht verwenden. Daher sollten Sie den ViewData/ViewBag nur für sehr kleine Datenmengen verwenden. Beachten Sie jedoch, dass Sie die Verwendung von ViewData/ViewBag mit einer herkömmlichen, stark typisierten Ansicht kombinieren können .

Was ist der Unterschied zwischen ViewData und ViewBag?

Sie werden bemerkt haben, dass ich zwei Begriffe für den Umgang mit dynamischen Ansichtsdaten verwendet habe: Die Eigenschaften ViewData und ViewBag. Diese beziehen sich beide auf dasselbe, nämlich ein Wörterbuch der Schlüssel und Werte (der Objekte). Der ViewBag ist jedoch eine DynamicObject-Darstellung des Wörterbuchs, sodass Sie auf die Daten zugreifen können, als wären es Eigenschaften des ViewBag-Objekts, anstatt auf Einträge in einem Wörterbuch. Es steht Ihnen frei, beide Eigenschaften austauschbar zu verwenden, da sie sich immer auf dieselben Daten beziehen. Zum Vergleich sehen Sie hier ein Beispiel, wie es aussehen würde, wenn Sie beide Ansätze verwenden:

Controller:

public IActionResult DetailsViewData(int id)
{
    ViewData["ProductTitle"] = "Toilet Paper";
    ViewBag.ProductPrice = 1.99;
    return View();
}

Ansicht:

<h1>@ViewData["ProducTtitle"]</h1>
Price: @ViewBag.ProductPrice

Beachten Sie, wie ich ViewData und damit einen wörterbuchbasierten Ansatz zum Lesen und Schreiben des ProductTitle verwende, während ich die objektbasierte Punktnotation verwende, um auf ProductPrice zuzugreifen. Das lässt Sie mit ein paar kleineren Unterschieden zurück, z.B.: die Möglichkeit, das Vorhandensein eines bestimmten Schlüssels/Werts in der ViewData-Auflistung zu überprüfen (mithilfe der ContainsKey() -Methode). Am Ende des Tages sollten Sie den Ansatz verwenden, den Sie am attraktivsten finden, und sich dann an ihn halten, um die Konsistenz zu gewährleisten.

Zusammenfassung

Sie können Daten von einem Controller auf verschiedene Weise an eine Ansicht übergeben. Die empfohlene Methode ist jedoch fast immer die stark typisierte Ansicht, in der Sie den Modelltyp definieren, den Ihre Ansicht erwarten kann. Auf diese Weise erhalten Sie IntelliSense-Unterstützung und können die Eigenschaften und Methoden, die Sie verwenden möchten, während der Kompilierung überprüfen.