Wat is ViewModel in MVC?

Ik ben nieuw bij ASP.NET MVC. Ik heb een probleem met het begrijpen van het doel van een ViewModel.

Wat is een ViewModel en waarom hebben we een ViewModel nodig voor een ASP.NET MVC-toepassing?

Als ik een goed voorbeeld krijg over de werking en uitleg, zou dat beter zijn.

Antwoord 1, autoriteit 100%

Een view modelvertegenwoordigt de gegevens die u op uw weergave/pagina wilt weergeven, of deze nu worden gebruikt voor statische tekst of voor invoerwaarden (zoals tekstvakken en vervolgkeuzelijsten) die kunnen worden toegevoegd aan de database (of bewerkt). Het is iets anders dan uw domain model. Het is een model voor het uitzicht.

Stel dat u een klasse Employeeheeft die uw domeinmodel voor werknemers vertegenwoordigt en de volgende eigenschappen bevat (unieke identificatie, voornaam, achternaam en aanmaakdatum):

public class Employee : IEntity
{
     public int Id { get; set; }
     public string FirstName { get; set; }
     public string LastName { get; set; }
     public DateTime DateCreated { get; set; }
}

Weergavemodellen verschillen van domeinmodellen doordat weergavemodellen alleen de gegevens bevatten (weergegeven door eigenschappen) die u in uw weergave wilt gebruiken. Stel dat u bijvoorbeeld een nieuw werknemersrecord wilt toevoegen, uw weergavemodel kan er als volgt uitzien:

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

Zoals je kunt zien, bevat het slechts twee van de eigenschappen. Deze twee eigenschappen zitten ook in het werknemersdomeinmodel. Waarom is dit vraag je je misschien af? Idis mogelijk niet ingesteld vanuit de weergave, maar wordt mogelijk automatisch gegenereerd door de tabel Werknemers. En DateCreatedkan ook worden ingesteld in de opgeslagen procedure of in de servicelaag van uw toepassing. Dus Iden DateCreatedzijn niet nodig in het weergavemodel. Misschien wilt u deze twee eigenschappen weergeven als u de gegevens van een werknemer (een werknemer die al is vastgelegd) als statische tekst bekijkt.

Tijdens het laden van de weergave/pagina, zal de actiemethode Aanmaken in uw werknemerscontroller een instantie van dit weergavemodel maken, indien nodig velden vullen en dit weergavemodel vervolgens doorgeven aan de weergave/pagina:

public class EmployeeController : Controller
{
     private readonly IEmployeeService employeeService;
     public EmployeeController(IEmployeeService employeeService)
     {
          this.employeeService = employeeService;
     }
     public ActionResult Create()
     {
          CreateEmployeeViewModel model = new CreateEmployeeViewModel();
          return View(model);
     }
     public ActionResult Create(CreateEmployeeViewModel model)
     {
          // Do what ever needs to be done before adding the employee to the database
     }
}

Uw weergave/pagina kan er als volgt uitzien (ervan uitgaande dat u ASP.NET MVCen de Razorview-engine gebruikt):

@model MyProject.Web.ViewModels.CreateEmployeeViewModel
<table>
     <tr>
          <td><b>First Name:</b></td>
          <td>@Html.TextBoxFor(m => m.FirstName, new { maxlength = "50", size = "50" })
              @Html.ValidationMessageFor(m => m.FirstName)
          </td>
     </tr>
     <tr>
          <td><b>Last Name:</b></td>
          <td>@Html.TextBoxFor(m => m.LastName, new { maxlength = "50", size = "50" })
              @Html.ValidationMessageFor(m => m.LastName)
          </td>
     </tr>
</table>

Validatie zou dus alleen worden gedaan op FirstNameen LastName. Als u FluentValidationgebruikt, heeft u mogelijk een validatie als volgt:

public class CreateEmployeeViewModelValidator : AbstractValidator<CreateEmployeeViewModel>
{
     public CreateEmployeeViewModelValidator()
     {
          RuleFor(m => m.FirstName)
               .NotEmpty()
               .WithMessage("First name required")
               .Length(1, 50)
               .WithMessage("First name must not be greater than 50 characters");
          RuleFor(m => m.LastName)
               .NotEmpty()
               .WithMessage("Last name required")
               .Length(1, 50)
               .WithMessage("Last name must not be greater than 50 characters");
     }
}

En met gegevensannotaties kan het er zo uitzien:

public class CreateEmployeeViewModel : ViewModelBase
{
    [Display(Name = "First Name")]
    [Required(ErrorMessage = "First name required")]
    public string FirstName { get; set; }
    [Display(Name = "Last Name")]
    [Required(ErrorMessage = "Last name required")]
    public string LastName { get; set; }
}

Het belangrijkste om te onthouden is dat het weergavemodel alleen de gegevens vertegenwoordigt die u wilt gebruikenen niets anders. U kunt zich alle onnodige code en validatie voorstellen als u een domeinmodel met 30 eigenschappen heeft en u slechts één waarde wilt bijwerken. In dit scenario zou u alleen deze ene waarde/eigenschap in het weergavemodel hebben en niet alle eigenschappen die zich in het domeinobject bevinden.

Een weergavemodel heeft mogelijk niet alleen gegevens uit één databasetabel. Het kan gegevens uit een andere tabel combineren. Neem mijn voorbeeld hierboven over het toevoegen van een nieuw werknemersrecord. Naast het toevoegen van alleen de voor- en achternaam wil je misschien ook de afdeling van de medewerker toevoegen. Deze lijst met afdelingen komt uit uw tabel Departments. U hebt nu dus gegevens uit de tabellen Employeesen Departmentsin één weergavemodel. U hoeft dan alleen de volgende twee eigenschappen aan uw weergavemodel toe te voegen en het met gegevens te vullen:

public int DepartmentId { get; set; }
public IEnumerable<Department> Departments { get; set; }

Bij het bewerken van werknemersgegevens (een werknemer die al aan de database is toegevoegd) zou het niet veel verschillen van mijn voorbeeld hierboven. Maak een weergavemodel, noem het bijvoorbeeld EditEmployeeViewModel. Heb alleen de gegevens die u in dit weergavemodel wilt bewerken, zoals voornaam en achternaam. Pas de gegevens aan en klik op de verzendknop. Ik zou me niet al te veel zorgen maken over het veld Idomdat de waarde van Idwaarschijnlijk in de URL zal staan, bijvoorbeeld:

http://www.yourwebsite.com/Employee/Edit/3

Neem deze Iden geef deze door aan uw repository-laag, samen met uw voornaam en achternaam.

Bij het verwijderen van een record volg ik normaal gesproken hetzelfde pad als bij het bewerkingsweergavemodel. Ik zou ook een URL hebben, bijvoorbeeld:

http://www.yourwebsite.com/Employee/Delete/3

Als de weergave voor de eerste keer wordt geladen, zou ik de gegevens van de werknemer uit de database halen met de Idvan 3. Ik zou dan gewoon statische tekst op mijn weergave/pagina weergeven zodat de gebruiker kan zien welke medewerker wordt verwijderd. Wanneer de gebruiker op de knop Verwijderen klikt, zou ik gewoon de Idwaarde van 3 gebruiken en deze doorgeven aan mijn repository-laag. Je hebt alleen de Idnodig om een record uit de tabel te verwijderen.

Nog een punt: je hebt niet echt voor elke actie een weergavemodel nodig. Als het eenvoudige gegevens zijn, zou het prima zijn om alleen EmployeeViewModelte gebruiken. Als het complexe weergaven/pagina’s zijn en ze van elkaar verschillen, raad ik je aan voor elk een afzonderlijk weergavemodel te gebruiken.

Ik hoop dat dit alle verwarring wegneemt die u had over weergavemodellen en domeinmodellen.

Antwoord 2, autoriteit 21%

Weergavemodelis een klasse die het gegevensmodel vertegenwoordigt dat in een specifieke weergave wordt gebruikt. We zouden deze klasse kunnen gebruiken als model voor een inlogpagina:

public class LoginPageVM
{
    [Required(ErrorMessage = "Are you really trying to login without entering username?")]
    [DisplayName("Username/e-mail")]
    public string UserName { get; set; }
    [Required(ErrorMessage = "Please enter password:)")]
    [DisplayName("Password")]
    public string Password { get; set; }
    [DisplayName("Stay logged in when browser is closed")]
    public bool RememberMe { get; set; }
}

Met dit weergavemodel kunt u de weergave definiëren (Razor view-engine):

@model CamelTrap.Models.ViewModels.LoginPageVM
@using (Html.BeginForm()) {
    @Html.EditorFor(m => m);
    <input type="submit" value="Save" class="submit" />
}

En acties:

[HttpGet]
public ActionResult LoginPage()
{
    return View();
}
[HttpPost]
public ActionResult LoginPage(LoginPageVM model)
{
    ...code to login user to application...
    return View(model);
}

Wat dit resultaat oplevert (scherm wordt genomen na het indienen van het formulier, met validatieberichten):

Zoals je kunt zien, heeft een weergavemodel veel rollen:

• Weergavemodellen documenteren een weergave door alleen velden te bevatten die in weergave worden weergegeven.
• Weergavemodellen kunnen specifieke validatieregels bevatten met behulp van gegevensannotaties of IDataErrorInfo.
• Weergavemodel definieert hoe een weergave eruit moet zien (voor LabelFor,EditorFor,DisplayForhelpers).
• Weergavemodellen kunnen waarden uit verschillende database-entiteiten combineren.
• Je kunt eenvoudig weergavesjablonen voor weergavemodellen specificeren en ze op veel plaatsen hergebruiken met behulp van DisplayFor of EditorFor helpers.

Nog een voorbeeld van een weergavemodel en het ophalen ervan: we willen basisgebruikersgegevens, zijn privileges en gebruikersnaam weergeven. We maken een speciaal aanzichtmodel, dat alleen de verplichte velden bevat. We halen gegevens op van verschillende entiteiten uit de database, maar de weergave is alleen op de hoogte van de weergavemodelklasse:

public class UserVM {
    public int ID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public bool IsAdministrator { get; set; }
    public string MothersName { get; set; }
}

Ophalen:

var user = db.userRepository.GetUser(id);
var model = new UserVM() {
   ID = user.ID,
   FirstName = user.FirstName,
   LastName = user.LastName,
   IsAdministrator = user.Proviledges.IsAdministrator,
   MothersName = user.Mother.FirstName + " " + user.Mother.LastName
} 

Antwoord 3, autoriteit 13%

Bewerken: ik heb dit antwoord op mijn blog bijgewerkt:

http://www.samwheat .com/post/The-function-of-ViewModels-in-MVC-web-development

Mijn antwoord is een beetje lang, maar ik denk dat het belangrijk is om weergavemodellen te vergelijken met andere typen veelgebruikte modellen om te begrijpen waarom ze anders zijn en waarom ze nodig zijn.

Om de gestelde vraag samen te vatten en direct te beantwoorden:

Over het algemeen is een weergavemodel een object dat alle eigenschappen en methoden bevat die nodig zijn om een weergave weer te geven. Eigenschappen van View-modellen zijn vaak gerelateerd aan data-objecten zoals klanten en bestellingen en bevatten daarnaast ook eigenschappen die gerelateerd zijn aan de pagina of applicatie zelf, zoals gebruikersnaam, applicatienaam, enz. View-modellen bieden een handig object om door te geven aan een rendering engine om een HTML-pagina te maken. Een van de vele redenen om een weergavemodel te gebruiken, is dat weergavemodellen een manier bieden om bepaalde presentatietaken te testen, zoals het verwerken van gebruikersinvoer, het valideren van gegevens, het ophalen van gegevens voor weergave, enz.

Hier is een vergelijking van entiteitsmodellen (ook bekend als DTO’s of modellen), presentatiemodellen en weergavemodellen.

Gegevensoverdrachtobjecten ook wel “Model” genoemd

Een Data Transfer Object (DTO) is een klasse met eigenschappen die overeenkomen met een tabelschema in een database. DTO’s zijn genoemd naar hun gebruikelijke gebruik voor het pendelen van gegevens van en naar een gegevensopslag.
Kenmerken van DTO’s:

• Zijn bedrijfsobjecten – hun definitie is afhankelijk van applicatiegegevens.
• Bevatten meestal alleen eigenschappen – geen code.
• Voornamelijk gebruikt voor het transporteren van gegevens van en naar een database.
• Eigenschappen komen exact of nauw overeen met velden in een specifieke tabel in een gegevensopslag.

Databasetabellen zijn meestal genormaliseerd, daarom worden DTO’s meestal ook genormaliseerd. Dit maakt ze van beperkt nut voor het presenteren van gegevens. Voor bepaalde eenvoudige gegevensstructuren doen ze het echter vaak best goed.

Hier zijn twee voorbeelden van hoe DTO’s eruit kunnen zien:

public class Customer
{
    public int ID { get; set; }
    public string CustomerName { get; set; }
}
public class Order
{
    public int ID { get; set; }
    public int CustomerID { get; set; }
    public DateTime OrderDate { get; set; }
    public Decimal OrderAmount { get; set; }
}

Presentatiemodellen

Een presentatiemodel is een utility-klasse die wordt gebruikt om gegevens op een scherm of rapport weer te geven. Presentatiemodellen worden doorgaans gebruikt om complexe gegevensstructuren te modelleren die zijn samengesteld uit gegevens van meerdere DTO’s. Presentatiemodellen vertegenwoordigen vaak een gedenormaliseerde weergave van gegevens.

Kenmerken van presentatiemodellen:

• Zijn bedrijfsobjecten – hun definitie is afhankelijk van applicatiegegevens.
• Bevat voornamelijk eigenschappen. Code is doorgaans beperkt tot het formatteren van gegevens of het converteren naar of van een DTO. Presentatiemodellen mogen geen bedrijfslogica bevatten.
• Vaak een gedenormaliseerde weergave van gegevens. Dat wil zeggen, ze combineren vaak eigenschappen van meerdere DTO’s.
• Bevatten vaak eigenschappen van een ander basistype dan een DTO. Bedragen in dollars kunnen bijvoorbeeld worden weergegeven als tekenreeksen, zodat ze komma’s en een valutasymbool kunnen bevatten.
• Vaak gedefinieerd door hoe ze worden gebruikt en door hun objectkenmerken. Met andere woorden, een eenvoudige DTO die wordt gebruikt als backing-model voor het renderen van een grid is in feite ook een presentatiemodel in de context van dat grid.

Presentatiemodellen worden gebruikt “naar behoefte” en “waar nodig” (terwijl DTO’s meestal zijn gekoppeld aan het databaseschema). Een presentatiemodel kan worden gebruikt om gegevens voor een hele pagina, een raster op een pagina of een vervolgkeuzelijst op een raster op een pagina te modelleren. Presentatiemodellen bevatten vaak eigenschappen die andere presentatiemodellen zijn. Presentatiemodellen zijn vaak gemaakt voor eenmalig gebruik, zoals het weergeven van een specifiek raster op een enkele pagina.

Een voorbeeld van een presentatiemodel:

public class PresentationOrder
{
    public int OrderID { get; set; }
    public DateTime OrderDate { get; set; }
    public string PrettyDate { get { return OrderDate.ToShortDateString(); } }
    public string CustomerName { get; set; }
    public Decimal OrderAmount { get; set; }
    public string PrettyAmount { get { return string.Format("{0:C}", OrderAmount); } }
}

Modellen bekijken

Een weergavemodel is vergelijkbaar met een presentatiemodel, omdat het een achtergrondklasse is voor het renderen van een weergave. Het is echter heel anders dan een presentatiemodel of een DTO in hoe het is opgebouwd. View-modellen bevatten vaak dezelfde eigenschappen als presentatiemodellen en DTO’s en daarom worden ze vaak door elkaar gehaald.

Kenmerken van weergavemodellen:

• Zijn de enige gegevensbron die wordt gebruikt om een pagina of scherm weer te geven. Meestal betekent dit dat een weergavemodel elke eigenschap blootlegt die een besturingselement op de pagina nodig heeft om zichzelf correct weer te geven. Door het weergavemodel tot de enige gegevensbron voor de weergave te maken, worden de mogelijkheden en de waarde ervan voor het testen van eenheden aanzienlijk verbeterd.
• Zijn samengestelde objectendie eigenschappen bevatten die bestaan uit applicatiegegevens en eigenschappen die worden gebruikt door applicatiecode. Dit kenmerk is cruciaal bij het ontwerpen van het weergavemodel voor herbruikbaarheid en wordt besproken in de onderstaande voorbeelden.
• Bevat applicatiecode. Weergavemodellen bevatten meestal methoden die worden aangeroepen tijdens het renderen en wanneer de gebruiker interactie heeft met de pagina. Deze code heeft meestal betrekking op gebeurtenisafhandeling, animatie, zichtbaarheid van bedieningselementen, styling, enz.
• Bevat code die zakelijke services aanroept om gegevens op te halen of naar een databaseserver te verzenden. Deze code wordt vaak ten onrechte in een controller geplaatst. Het aanroepen van business services van een controller beperkt meestal de bruikbaarheid van het viewmodel voor unit testing. Voor alle duidelijkheid: view-modellen zelf mogen geen bedrijfslogica bevatten, maar moeten services aanroepen die wel bedrijfslogica bevatten.
• Bevatten vaak eigenschappen die andere weergavemodellen zijn voor andere pagina’s of schermen.
• Worden geschreven “per pagina” of “per scherm”. Voor elke pagina of elk scherm in een toepassing wordt doorgaans een uniek weergavemodel geschreven.
• Meestal afgeleid van een basisklasse, aangezien de meeste pagina’s en schermen gemeenschappelijke eigenschappen hebben.

Modelsamenstelling bekijken

Zoals eerder vermeld, zijn weergavemodellen samengestelde objecten in die zin dat ze toepassingseigenschappen en bedrijfsgegevenseigenschappen op één object combineren. Voorbeelden van veelgebruikte applicatie-eigenschappen die worden gebruikt op weergavemodellen zijn:

• Eigenschappen die worden gebruikt om de applicatiestatus weer te geven, zoals foutmeldingen, gebruikersnaam, status, enz.
• Eigenschappen die worden gebruikt voor het opmaken, weergeven, stileren of animeren van bedieningselementen.
• Eigenschappen die worden gebruikt voor gegevensbinding, zoals lijstobjecten en eigenschappen die tussenliggende gegevens bevatten die door de gebruiker worden ingevoerd.

De volgende voorbeelden laten zien waarom de samengestelde aard van weergavemodellen belangrijk is en hoe we het beste een weergavemodel kunnen construeren dat efficiënt en herbruikbaar is.

Stel dat we een webtoepassing schrijven. Een van de vereisten van het applicatieontwerp is dat de paginatitel, gebruikersnaam en applicatienaam op elke pagina moeten worden weergegeven. Als we een pagina willen maken om een presentatievolgorde-object weer te geven, kunnen we het presentatiemodel als volgt wijzigen:

public class PresentationOrder
{
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }
    public int OrderID { get; set; }
    public DateTime OrderDate { get; set; }
    public string PrettyDate { get { return OrderDate.ToShortDateString(); } }
    public string CustomerName { get; set; }
    public Decimal OrderAmount { get; set; }
    public string PrettyAmount { get { return string.Format("{0:C}", OrderAmount); } }
}

Dit ontwerp zou kunnen werken… maar wat als we een pagina willen maken die een lijst met bestellingen weergeeft? De eigenschappen PageTitle, UserName en ApplicationName worden herhaald en worden onpraktisch om mee te werken. En wat als we logica op paginaniveau willen definiëren in de constructor van de klasse? We kunnen dat niet langer doen als we een instantie maken voor elke bestelling die wordt weergegeven.

Samenstelling over erfenis

Hier is een manier waarop we het orderpresentatiemodel kunnen herfactoren zodat het een echt weergavemodel wordt en nuttig zal zijn voor het weergeven van een enkel PresentationOrder-object of een verzameling PresentationOrder-objecten:

public class PresentationOrderVM
{
    // Application properties
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }
    // Business properties
    public PresentationOrder Order { get; set; }
}
public class PresentationOrderVM
{
    // Application properties
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }
    // Business properties
    public List<PresentationOrder> Orders { get; set; }
}

Als we naar de bovenstaande twee klassen kijken, kunnen we zien dat een manier om over een weergavemodel na te denken, is dat het een presentatiemodel is dat een ander presentatiemodel als eigenschap bevat. Het presentatiemodel op het hoogste niveau (d.w.z. weergavemodel) bevat eigenschappen die relevant zijn voor de pagina of applicatie, terwijl het presentatiemodel (property) eigenschappen bevat die relevant zijn voor applicatiegegevens.

We kunnen met ons ontwerp een stap verder gaan en een basisweergavemodelklasse maken die niet alleen voor PresentationOrders maar ook voor elke andere klasse kan worden gebruikt:

public class BaseViewModel
{
    // Application properties
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }
}

Nu kunnen we onze PresentationOrderVM als volgt vereenvoudigen:

public class PresentationOrderVM : BaseViewModel
{
    // Business properties
    public PresentationOrder Order { get; set; }
}
public class PresentationOrderVM : BaseViewModel
{
    // Business properties
    public List<PresentationOrder> Orders { get; set; }
}

We kunnen ons BaseViewModel nog meer herbruikbaar maken door het generiek te maken:

public class BaseViewModel<T>
{
    // Application properties
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }
    // Business property
    public T BusinessObject { get; set; }
}

Onze implementaties zijn nu moeiteloos:

public class PresentationOrderVM : BaseViewModel<PresentationOrder>
{
    // done!
}
public class PresentationOrderVM : BaseViewModel<List<PresentationOrder>>
{
    // done!
}

Antwoord 4, autoriteit 3%

Als je eigenschappen hebt die specifiek zijn voor de view en niet gerelateerd zijn aan de DB/Service/Data store, is het een goede gewoonte om ViewModels te gebruiken. Stel dat u een selectievakje geselecteerd wilt laten op basis van een DB-veld (of twee), maar het DB-veld zelf is geen boolean. Hoewel het mogelijk is om deze eigenschappen in het model zelf te maken en het verborgen te houden voor de binding aan gegevens, wilt u het model misschien niet onoverzichtelijk maken, afhankelijk van het aantal van dergelijke velden en transacties.

Als er te weinig weergavespecifieke gegevens en/of transformaties zijn, kunt u het model zelf gebruiken

Antwoord 5, autoriteit 3%

Ik heb niet alle berichten gelezen, maar in elk antwoord lijkt een concept te ontbreken dat me echt heeft geholpen om het te “begrijpen”…

Als een Model verwant is aan een database Tabel, dan is een ViewModel verwant aan een database View– Een weergave retourneert meestal kleine hoeveelheden gegevens uit één tabel of complexe gegevenssets uit meerdere tabellen (joins).

Ik merk dat ik ViewModels gebruik om informatie door te geven aan een weergave/formulier en die gegevens vervolgens over te zetten naar een geldig model wanneer het formulier terug naar de controller wordt gepost – ook erg handig voor het opslaan van lijsten (IEnumerable).

Antwoord 6, autoriteit 2%

MVC heeft geen viewmodel: het heeft een model, view en controller. Een viewmodel is onderdeel van MVVM (Model-View-Viewmodel). MVVM is afgeleid van het presentatiemodel en is populair geworden in WPF. Er zou ook een model in MVVM moeten zijn, maar de meeste mensen missen het punt van dat patroon volledig en ze zullen alleen een weergave en een weergavemodel hebben. Het model in MVC is vergelijkbaar met het model in MVVM.

In MVC is het proces opgesplitst in 3 verschillende verantwoordelijkheden:

• View is verantwoordelijk voor het presenteren van de gegevens aan de gebruiker
• Een controller is verantwoordelijk voor de paginastroom
• Een model is verantwoordelijk voor de bedrijfslogica

MVC is niet erg geschikt voor webapplicaties. Het is een patroon geïntroduceerd door Smalltalk voor het maken van desktop-applicaties. Een webomgeving gedraagt zich heel anders. Het heeft weinig zin om een 40 jaar oud concept uit de desktopontwikkeling te kopiëren en in een webomgeving te plakken. Veel mensen denken echter dat dit oké is, omdat hun applicatie de juiste waarden compileert en retourneert. Dat is naar mijn mening niet genoeg om een bepaalde ontwerpkeuze als ok te verklaren.

Een voorbeeld van een model in een webtoepassing kan zijn:

public class LoginModel
{
    private readonly AuthenticationService authentication;
    public LoginModel(AuthenticationService authentication)
    {
        this.authentication = authentication;
    }
    public bool Login()
    {
        return authentication.Login(Username, Password);
    }
    public string Username { get; set; }
    public string Password { get; set; }
}

De controller kan het als volgt gebruiken:

public class LoginController
{
    [HttpPost]
    public ActionResult Login(LoginModel model)
    {
        bool success = model.Login();
        if (success)
        {
            return new RedirectResult("/dashboard");
        }
        else
        {
            TempData["message"] = "Invalid username and/or password";
            return new RedirectResult("/login");
        }
    }
}

Uw controllermethoden en uw modellen zijn klein, gemakkelijk te testen en to the point.

Antwoord 7, autoriteit 2%

Veel grote voorbeelden, ik zal het op een duidelijke en heldere manier uitleggen.

ViewModel = Model dat is gemaakt om de weergave te dienen.

ASP.NET MVC-weergave kan niet meer dan één model hebben, dus als we eigenschappen van meer dan één modellen in de weergave moeten weergeven, is dit niet mogelijk. ViewModel dient dit doel.

Weergavemodel is een modelklasse die alleen die eigenschappen kan bevatten die nodig zijn voor een weergave. Het kan ook eigenschappen van meer dan één entiteit (tabellen) van de database bevatten. Zoals de naam al doet vermoeden, is dit model specifiek gemaakt voor de View-vereisten.

Enkele voorbeelden van weergavemodellen staan hieronder

• Om gegevens van meer dan entiteiten op een weergavepagina weer te geven, kunnen we een
  Bekijk het model en heb eigenschappen van alle entiteiten waarvoor we willen
  om gegevens te vermelden. Word lid van die database-entiteiten en stel View-model in
  eigenschappen en keer terug naar de weergave om gegevens van verschillende
  entiteiten in één tabelvorm
• Het weergavemodel kan alleen specifieke velden van een enkele entiteit definiëren die:
  vereist voor de weergave.

ViewModel kan ook worden gebruikt om records in meer dan één entiteit in te voegen, bij te werken, maar het belangrijkste gebruik van ViewModel is om kolommen van meerdere entiteiten (model) in één weergave weer te geven.

De manier om ViewModel te maken is hetzelfde als het maken van een Model, de manier om een view te creëren voor het Viewmodel is hetzelfde als het creëren van een view voor Model.

Hier is een klein voorbeeld van Gegevens weergeven met ViewModel.

Ik hoop dat dit nuttig zal zijn.

Antwoord 8, autoriteit 2%

Bekijk model a is een eenvoudige klasse die meer dan één klasse-eigenschap kan bevatten. We gebruiken het om alle vereiste eigenschappen te erven, b.v. Ik heb twee klassen Student en Vak

Public class Student
{
public int Id {get; set;}
public string Name {get; set;}
}  
Public class Subject
{
public int SubjectID {get; set;}
public string SubjectName {get; set;}
}

Nu willen we de naam van de student en de naam van het onderwerp weergeven in de weergave (in MVC), maar het is niet mogelijk om meer dan één klas toe te voegen, zoals:

@model ProjectName.Model.Student  
 @model ProjectName.Model.Subject

de bovenstaande code geeft een foutmelding…

We maken nu één klasse en kunnen deze elke naam geven, maar dit formaat “XyzViewModel” maakt het gemakkelijker te begrijpen. Het is een erfenisconcept.
Nu maken we een derde klasse aan met de volgende naam:

public class StudentViewModel:Subject
{
public int ID {get; set;}
public string Name {get; set;}
}

Nu gebruiken we dit ViewModel in View

@model ProjectName.Model.StudentViewModel

We hebben nu toegang tot alle eigenschappen van StudentViewModel en overgenomen klasse in View.

Antwoord 9

ViewModel is een tijdelijke oplossing die de conceptuele onhandigheid van het MVC-framework herstelt. Het vertegenwoordigt de 4e laag in de 3-laags Model-View-Controller-architectuur. wanneer Model (domeinmodel) niet geschikt is, te groot (groter dan 2-3 velden) voor de View, maken we een kleiner ViewModel om het door te geven aan de View.

Antwoord 10

View Model is een klasse die we kunnen gebruiken voor het weergeven van gegevens op View. Stel dat je twee entiteiten Place en PlaceCategory hebt en je wilt toegang krijgen tot gegevens van beide entiteiten met behulp van een enkel model, dan gebruiken we ViewModel.

 public class Place
    {
       public int PlaceId { get; set; }
        public string PlaceName { get; set; }
        public string Latitude { get; set; }
        public string Longitude { get; set; }
        public string BestTime { get; set; }
    }
    public class Category
    {
        public int ID { get; set; }
        public int? PlaceId { get; set; }
        public string PlaceCategoryName { get; set; }
        public string PlaceCategoryType { get; set; }
    }
    public class PlaceCategoryviewModel
    {
        public string PlaceName { get; set; }
        public string BestTime { get; set; }
        public string PlaceCategoryName { get; set; }
        public string PlaceCategoryType { get; set; }
    }

Dus in het bovenstaande voorbeeld zijn Place en Category de twee verschillende entiteiten en PlaceCategory viewmodel is ViewModel dat we kunnen gebruiken in View.

Antwoord 11

Een weergavemodel is een conceptueel model van gegevens. Het gebruik ervan is om bijvoorbeeld een subset te krijgen of gegevens uit verschillende tabellen te combineren.

Misschien wilt u alleen specifieke eigenschappen, zodat u alleen die en geen extra onnodige eigenschappen kunt laden

Antwoord 12

• ViewModel bevatten velden die worden weergegeven in de weergave (voor
  LabelFor,EditorFor,DisplayFor helpers)
• ViewModel kan specifieke validatieregels hebben met behulp van gegevensannotaties
  of IDataErrorInfo.
• ViewModel kan meerdere entiteiten of objecten uit verschillende gegevens hebben
  modellen of gegevensbron.

ViewModel ontwerpen

public class UserLoginViewModel 
{ 
[Required(ErrorMessage = "Please enter your username")] 
[Display(Name = "User Name")]
[MaxLength(50)]
public string UserName { get; set; }
 [Required(ErrorMessage = "Please enter your password")]
 [Display(Name = "Password")]
 [MaxLength(50)]
 public string Password { get; set; } 
} 

Het weergavemodel in de weergave presenteren

@model MyModels.UserLoginViewModel 
@{
 ViewBag.Title = "User Login";
 Layout = "~/Views/Shared/_Layout.cshtml";
}
@using (Html.BeginForm())
{
<div class="editor-label">
 @Html.LabelFor(m => m.UserName)
</div>
<div class="editor-field">
 @Html.TextBoxFor(m => m.UserName)
 @Html.ValidationMessageFor(m => m.UserName)
</div>
<div class="editor-label">
 @Html.LabelFor(m => m.Password)
</div>
<div class="editor-field">
 @Html.PasswordFor(m => m.Password)
 @Html.ValidationMessageFor(m => m.Password)
</div>
<p>
 <input type="submit" value="Log In" />
</p>
</div>
}

Werken met actie

public ActionResult Login()
{ 
return View();
}
[HttpPost]
public ActionResult Login(UserLoginViewModel user)
{
// To acces data using LINQ
DataClassesDataContext mobjentity = new DataClassesDataContext();
 if (ModelState.IsValid) 
{ 
try
 {
 var q = mobjentity.tblUsers.Where(m => m.UserName == user.UserName && m.Password == user.Password).ToList(); 
 if (q.Count > 0) 
 { 
 return RedirectToAction("MyAccount");
 }
 else
 {
 ModelState.AddModelError("", "The user name or password provided is incorrect.");
 }
 }
 catch (Exception ex)
 {
 } 
 } 
 return View(user);
} 

1. Plaats in ViewModel alleen die velden/gegevens die u wilt weergeven
   de weergave/pagina.
2. Aangezien view de eigenschappen van het ViewModel vertegenwoordigt, is het dus:
   gemakkelijk voor weergave en onderhoud.
3. Gebruik een mapper wanneer ViewModel complexer wordt.

Antwoord 13

Als je code wilt bestuderen voor het opzetten van een “Baseline” webapplicatie met ViewModels, kan ik je aanraden deze code op GitHub te downloaden: https://github.com/ajsaulsberry/BlipAjax. Ik ontwikkelde applicaties voor grote ondernemingen. Wanneer u dit doet, is het problematisch om een goede architectuur op te zetten die al deze “ViewModel” -functionaliteit afhandelt. Ik denk dat je met BlipAjax een zeer goede “baseline” zult hebben om mee te beginnen. Het is gewoon een eenvoudige website, maar geweldig in zijn eenvoud. Ik hou van de manier waarop ze de Engelse taal gebruikten om te wijzen op wat echt nodig is in de applicatie.

Antwoord 14

ViewModel is het model met velden voor gebruik in mvc View. Het gebruik van ViewModel voor de weergave heeft de volgende voordelen:

• Omdat het databasemodel (Entiteitsklasse) de gegevens van een enkele tabel bevat. Indien gegevens uit meerdere tabellen vereist zijn, kan één Viewmodel velden van meerdere tabellen hebben.
• Gebruiker kan niet rechtstreeks communiceren met databasemodel, dus databaselaag of -model is beveiligd.
• Het wordt gebruikt om gegevens uit het databasemodel te halen via de repository en door te geven om te bekijken. Evenzo wordt het gebruikt voor het posten van gegevens naar het databasemodel om databaserecords bij te werken.

Antwoord 15

Het weergavemodel is hetzelfde als uw gegevensmodel, maar u kunt er 2 of meer gegevensmodelklassen aan toevoegen. Volgens dat moet je je controller veranderen om 2 modellen tegelijk te gebruiken