Due modelli in una vista in ASP MVC 3

Ho 2 modelli:

public class Person
{
    public int PersonID { get; set; }
    public string PersonName { get; set; }
}
public class Order
{
    public int OrderID { get; set; }
    public int TotalSum { get; set; }
}

Voglio modificare gli oggetti di ENTRAMBE le classi nella vista SINGOLA, quindi ho bisogno di qualcosa come:

@model _try2models.Models.Person
@model _try2models.Models.Order

@using(Html.BeginForm())
{
    @Html.EditorFor(x => x.PersonID)
    @Html.EditorFor(x => x.PersonName)
    @Html.EditorFor(x=>x.OrderID)
    @Html.EditorFor(x => x.TotalSum)
}

Questo, ovviamente, non funziona: è consentita solo un'istruzione "model" in un file .cshtml. Potrebbe esserci qualche soluzione alternativa?

Creare un modello di vista padre che contenga entrambi i modelli.

public class MainPageModel{
    public Model1 Model1{get; set;}
    public Model2 Model2{get; set;}
}

In questo modo puoi aggiungere ulteriori modelli in un secondo momento con il minimo sforzo.

Per utilizzare la tupla è necessario eseguire le seguenti operazioni, nella vista modificare il modello in:

@model Tuple<Person,Order>

per usare i metodi @html devi fare quanto segue, ad esempio:

@Html.DisplayNameFor(tuple => tuple.Item1.PersonId)

o

@Html.ActionLink("Edit", "Edit", new { id=Model.Item1.Id }) |

Item1 indica il primo parametro passato al metodo Tuple ed è possibile utilizzare Item2 per accedere al secondo modello e così via.

nel tuo controller devi creare una variabile di tipo Tuple e poi passarla alla vista:

    public ActionResult Details(int id = 0)
    {
        Person person = db.Persons.Find(id);
        if (person == null)
        {
            return HttpNotFound();
        }
        var tuple = new Tuple<Person, Order>(person,new Order());

        return View(tuple);
    }

Un altro esempio: più modelli in una vista

Un'altra opzione che non ha la necessità di creare un modello personalizzato consiste nell'usare una tupla <> .

@model Tuple<Person,Order>

Non è così pulito come creare una nuova classe che contiene entrambi, come da risposta di Andi, ma è fattibile.

Se sei un fan di avere modelli molto piatti, solo per supportare la vista, dovresti creare un modello specifico per questa particolare vista ...

public class EditViewModel
    public int PersonID { get; set; }
    public string PersonName { get; set; }
    public int OrderID { get; set; }
    public int TotalSum { get; set; }
}

Molte persone usano AutoMapper per mappare dai loro oggetti di dominio alle loro viste semplici.

L'idea del modello di visualizzazione è che supporta solo la visualizzazione, nient'altro. Ne hai uno per vista per assicurarti che contenga solo ciò che è richiesto per quella vista, non carichi di proprietà che desideri per altre viste.

ok, tutti hanno un senso e ho preso tutti i pezzi e li ho messi qui per aiutare i neofiti come me che hanno bisogno di spiegazioni dall'inizio alla fine.

Fai la tua grande classe che contiene 2 classi, come da risposta di @ Andrew.

public class teamBoards{
    public Boards Boards{get; set;}
    public Team Team{get; set;}
}

Quindi nel tuo controller riempi i 2 modelli. A volte devi solo riempirne uno. Quindi nella restituzione, fai riferimento al modello grande e porterà il 2 all'interno con esso alla Vista.

            TeamBoards teamBoards = new TeamBoards();


        teamBoards.Boards = (from b in db.Boards
                               where b.TeamId == id
                               select b).ToList();
        teamBoards.Team = (from t in db.Teams
                              where t.TeamId == id
                          select t).FirstOrDefault();

 return View(teamBoards);

Nella parte superiore della vista

@model yourNamespace.Models.teamBoards

Quindi carica i tuoi input o display facendo riferimento ai contenuti di grandi modelli:

 @Html.EditorFor(m => Model.Board.yourField)
 @Html.ValidationMessageFor(m => Model.Board.yourField, "", new { @class = "text-danger-yellow" })

 @Html.EditorFor(m => Model.Team.yourField)
 @Html.ValidationMessageFor(m => Model.Team.yourField, "", new { @class = "text-danger-yellow" })

E. . . . torna al ranch, quando arriva il Post, fai riferimento alla Big Class:

 public ActionResult ContactNewspaper(teamBoards teamboards)

e utilizzare ciò che i modelli hanno restituito:

string yourVariable = teamboards.Team.yourField;

Probabilmente hanno alcune cose di DataAnnotation Validation nella classe e probabilmente mettono if (ModelState.IsValid) all'inizio del blocco di salvataggio / modifica. . .

In effetti c'è un modo per utilizzare due o più modelli in una vista senza racchiuderli in una classe che li contenga entrambi.

Utilizzo di Employee come modello di esempio:

@model Employee

Viene effettivamente trattato come.

@{ var Model = ViewBag.model as Employee; }

Quindi il metodo View (dipendente) sta impostando il tuo modello su ViewBag e quindi ViewEngine lo sta eseguendo.

Ciò significa che,

ViewBag.departments = GetListOfDepartments();
    return View(employee);

Può essere usato come,

            @model  Employee
        @{
                var DepartmentModel = ViewBag.departments as List<Department>;
        }

In sostanza, puoi usare tutto ciò che è nel tuo ViewBag come un "Modello" perché è così che funziona comunque. Non sto dicendo che questo sia architettonicamente ideale, ma è possibile.

Basta creare un singolo modello di vista con tutte le informazioni necessarie, normalmente quello che faccio è creare un modello per ogni vista in modo da poter essere specifico su ogni vista, o creare un modello principale ed ereditarlo. OPPURE creare un modello che includa entrambe le viste.

Personalmente li aggiungerei semplicemente in un modello, ma è così che lo faccio:

public class xViewModel
{
    public int PersonID { get; set; }
    public string PersonName { get; set; }
    public int OrderID { get; set; }
    public int TotalSum { get; set; }
}

@model project.Models.Home.xViewModel

@using(Html.BeginForm())
{
    @Html.EditorFor(x => x.PersonID)
    @Html.EditorFor(x => x.PersonName)
    @Html.EditorFor(x => x.OrderID)
    @Html.EditorFor(x => x.TotalSum)
}

È possibile utilizzare il modello di presentazione http://martinfowler.com/eaaDev/PresentationModel.html

Questo modello "Visualizza" di presentazione può contenere sia Persona che Ordine, questa nuova
classe può essere il modello a cui fa riferimento la vista.

Un altro modo di cui non si parla mai è creare una vista in MSSQL con tutti i dati che si desidera presentare. Quindi utilizzare LINQ to SQL o qualsiasi altra cosa per mapparlo. Nel tuo controller torna alla visualizzazione. Fatto.

non puoi dichiarare due modelli su una vista, prova a usare Html.Action("Person", "[YourController]")& Html.Action("Order", "[YourController]").

In bocca al lupo.

Oltre a un modello di visualizzazione in asp.net, puoi anche creare più visualizzazioni parziali e assegnare diverse visualizzazioni del modello a ciascuna visualizzazione, ad esempio:

   @{
        Layout = null;
    }

    @model Person;

    <input type="text" asp-for="PersonID" />
    <input type="text" asp-for="PersonName" />

quindi un altro modello di visualizzazione parziale per il modello di ordine

    @{
        Layout = null;
     }

    @model Order;

    <input type="text" asp-for="OrderID" />
    <input type="text" asp-for="TotalSum" />

quindi nella tua vista principale carica entrambe le viste parziali di

<partial name="PersonPartialView" />
<partial name="OrderPartialView" />

Spero che lo trovi utile !!

uso ViewBag per Project e Model per l'attività, quindi in questo modo sto usando due modelli in una vista singola e nel controller ho definito il valore oi dati della viewbag

List<tblproject> Plist = new List<tblproject>();
            Plist = ps.getmanagerproject(c, id);

            ViewBag.projectList = Plist.Select(x => new SelectListItem
            {
                Value = x.ProjectId.ToString(),
                Text = x.Title
            });

e in vista tbltask e projectlist sono i miei due modelli di diff

@ {

IEnumerable<SelectListItem> plist = ViewBag.projectList;

} @model List