Die Verwendung von zwei IENumerable-Modelle auf einen Blick

Durchlaufen Modelle kann ein wenig verwirrend zunächst, MVC, nur weil die Vorlagen Helfer (d.h. Html.DisplayFor und Html.EditorFor) können zur Verfügung gestellt werden Vorlagen, die die Helfer rufen automatisch für jedes element in einer Auflistung. Das bedeutet, dass wenn Sie das neue MVC, und Sie erkennen nicht, ein DisplayTemplate oder eine EditorTemplate wurde nicht für die Sammlung schon, es sieht aus, als ob eine einfache:

@Html.DisplayFor(m => m.SomePropertyThatHoldsACollection)

ist alles, was Sie brauchen. Also, wenn Sie gesehen haben so etwas bereits, das könnte sein, warum Sie aus der Annahme, es würde funktionieren. Aber, nehmen wir mal für einen moment, dass ein template nicht zur Verfügung gestellt wurden. Sie haben zwei Optionen.

Erstens-und das ist einfach, wäre die Verwendung foreach über die Sammlung:

@foreach (var post in Model.PostsObject)
{
    @Html.DisplayFor(m => post.PostTitle)
    //display other properties
}

Können Sie auch ein for Schleife, aber mit IEnumerable<T> es ist kein indexer, so wird dies nicht funktionieren:

@for (int i = 0; i < Model.PostsObject.Count(); i++)
{
    //This generates a compile-time error because
    //the index post[i] does not exist.
    //This syntax would work for a List<T> though.
    @Html.DisplayFor(m => post[i].PostTitle)
    //display other properties
}

Wenn Sie nicht wollen, verwenden Sie die for Schleife immer noch, Sie können es verwenden, etwa so:

@for (int i = 0; i < Model.PostsObject.Count(); i++)
{
    //This works correctly
    @Html.DisplayFor(m => post.ElementAt(i).PostTitle)
    //display other properties
}

Also je nachdem, was Sie bevorzugen. Aber irgendwann ist es eine gute Idee wäre, zu sehen in der Bereitstellung von Vorlagen für Ihre Typen. (Hinweis: Obwohl dieser Artikel wurde geschrieben für MVC 2, der Rat, immer noch gilt.) Sie ermöglichen es Ihnen, zu entfernen looping-Logik aus Ihrem Blick auf, halten Sie den Reiniger. In Kombination mit Html.DisplayFor oder Html.EditorFor, Sie generieren auch richtige element Namensgebung für Modell-Bindung (das ist toll). Auch Sie ermöglichen die Wiederverwendung von Präsentation für ein Typ ist.

Eine Letzte Bemerkung, die ich machen würde ist, dass die Benennung Ihrer Eigenschaften ist etwas Ausführlicher:

public class ModelMix
{
    public IEnumerable<Posts> PostsObject { get; set; }
    public IEnumerable<Album> ThreadsObject { get; set; }
}

Wir bereits wissen: Sie sind Objekte, so gibt es keine Notwendigkeit zu fügen, dass am Ende. Das ist besser lesbar:

public class ModelMix
{
    public IEnumerable<Posts> Posts { get; set; }
    public IEnumerable<Album> Threads { get; set; }
}

In der Regel müssen Sie Durchlaufen Sie jedes Element, wenn Sie vorbei sind in jeder Art von IEnumerable<>. Seit Sie gebaut eine semi-komplexe Modell, werden Sie wollen, um anzuzeigen foreach Element in jeder Liste. Hier ist ein Beispiel aus der ASP.NET MVC-tutorials, die ich denke, würde dir ein bisschen weiterhelfen:

@model IEnumerable<ContosoUniversity.Models.Course>

@{
    ViewBag.Title = "Courses";
}

<h2>Courses</h2>

<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <tr>
        <th>
            @Html.DisplayNameFor(model => model.CourseID)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.Title)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.Credits)
        </th>
        <th>
            Department
        </th>
        <th></th>
    </tr>

@foreach (var item in Model) {
    <tr>
        <td>
            @Html.DisplayFor(modelItem => item.CourseID)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.Title)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.Credits)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.Department.Name)
        </td>
        <td>
            @Html.ActionLink("Edit", "Edit", new { id=item.CourseID }) |
            @Html.ActionLink("Details", "Details", new { id=item.CourseID }) |
            @Html.ActionLink("Delete", "Delete", new { id=item.CourseID })
        </td>
    </tr>
}

</table>

In der Regel die meisten Leute benutzen ein ICollection für Ihre Listen, wo so könnten Sie zum Beispiel in einem Objekt:

public virtual ICollection<Post> Posts { get; set; }

Quelle:
http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/reading-related-data-with-the-entity-framework-in-an-asp-net-mvc-application

Ich würde empfehlen, beginnend am Anfang, wie es wird Ihnen helfen zu verstehen, warum Sie benötigen, um dies zu tun:
http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc