MVC et Entity Framework Liste de sélection

J'ai un MVC application que je suis en train de mettre ensemble et qui nécessite un certain sélectionner des listes et des listes déroulantes.

Donc, j'ai les modèles suivants....

public class Task
{
    public int ID { get; set; }
    public string Title { get; set; }
    ......
    public virtual ICollection<Monitor> Monitors { get; set; }
    public virtual ICollection<Resource> Resources { get; set; }

}
public class Monitor
{
    public int ID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public IList<Task> Tasks { get; set; }
}
    public class Resource
{
    public int ID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    .....

    public IList<Task> Tasks { get; set; }

La partie intéressante est que lorsque j'affiche une liste de tâches, parmi les autres propriétés d'affichage très bien, j'ai besoin d'afficher une liste de 'les Moniteurs' et une liste de Ressources qui sont affectées à la tâche dans la vue Index illustré ci-dessous.

@model IEnumerable<ResourceManager.Models.Task>
@{
ViewBag.Title = "Index";
}
<h2>Index</h2>
<p>
@Html.ActionLink("Create New", "Create")
</p>
<table>
<tr>
.....
<th>
@Html.DisplayNameFor(model => model.Title)
</th>
.....
<th>
@Html.DisplayNameFor(model => model.Monitors)
</th>
<th>
@Html.DisplayNameFor(model => model.Resources)
</th>
<th></th>
</tr>
@foreach (var item in Model) {
<tr>
.....
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
.....
<td>
@if (item.Monitors == null || item.Monitors.Count == 0) 
{<span>No Monitors Assigned</span>}
else 
{ string.Join(", ", item.Monitors.Select(m => string.Format("{0} {1}", m.FirstName, m.LastName))); }
</td>
<td>
@Html.DisplayFor(modelItem => item.Resources)
</td>
<td>
@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |
@Html.ActionLink("Details", "Details", new { id=item.ID }) |
@Html.ActionLink("Delete", "Delete", new { id=item.ID })
</td>
</tr>
}
</table>

Et ici, c'est le contrôleur....

    public ActionResult Index()
{
var tasks = from t in db.Tasks where t.IsActive == true select t;
return View(tasks);
}

J'aimerais que la liste de Moniteurs et de la liste de Ressources pour afficher une chaîne de caractères sur l'Index, les Supprimer et les Détails de Vues c'est à dire "Moniteur 1, le Moniteur 2, 3 de Moniteur" et "Ressource 1, Ressource 2 Ressource 3'.

Cependant sur les autres vues (Créer et Modifier), je veux qu'ils apparaissent comme un choix de la liste.

Où voulez-vous stocker le Moniteur sélectionné ou une Ressource?
J'ai une table pour les Moniteurs, les Tâches et les Ressources avec la croix-lien de tables pour TaskMonitor et TaskResources

InformationsquelleAutor Jay Davis | 2013-07-30

6

Abord Créer la liste de sélection dans votre contrôleur,
```
 
var surveille = //de Votre requête linq 
ViewData["ddlList"] = moniteurs .Sélectionnez(x => nouvelle SelectListItem { 
Texte = x.Prénom, 
Valeur = x.Id.ToString() 
}).ToList(); 
```
Et puis vous pouvez les utiliser à votre point de vue comme suit,
```
<%=Html.DropDownList("myList") %>
```
- Je vais essayer ce pour les listes. Je vais vous laisser savoir comment ça fonctionne.
- Ok, donc var allMonitors est de retour tous les moniteurs de la db, mais j'obtiens une erreur lorsqu'il tente de créer le ViewData, en disant: "LINQ to entities ne reconnaît pas la méthode" du Système.String ToString ()', et cette méthode ne peut pas être traduit dans un magasin d'expression".
InformationsquelleAutor Jatin patil
4

Pour l'affichage des Moniteurs/Ressources (et puisque vous voulez les afficher comme une liste séparée par des virgules), vous pouvez simplement utiliser string.Join:
```
<td>
@string.Join(",", Model.Monitors.Select(m => string.Format("{0} {1}", m.FirstName, m.LastName)))
</td>
```
Pour être en mesure d'utiliser effectivement Html.DisplayFor, vous devez créer un affichage personnalisé de modèle afin de Rasoir de savoir réellement comment réagir. Pour ce faire, dans votre point de Vue dossier, créer un nouveau dossier appelé "DisplayTemplates", et en cela, créer une nouvelle vue partielle appelée "Moniteurs.cshtml" et "Ressources.cshtml", fortement typés pour IEnumerable<Monitor> et IEnumerable<Resource>, respectivement. Puis à l'intérieur de ce fichier, il vous suffit de l'ajouter à peu près le même code que ci-dessus:
```
@model IEnumerable<Monitor>
@string.Join(",", Model.Select(m => string.Format("{0} {1}", m.FirstName, m.LastName)))
```
Alors à votre avis, vous pouvez appeler le:
```
@Html.DisplayFor(m => m.Monitors, "Monitors")
```
Malheureusement, dans cet exemple, vous avez à nourrir le nom du modèle, parce que le comportement par défaut de DisplayFor pour une liste, est de rendre le modèle d'affichage à plusieurs reprises, une fois pour chaque membre de la liste. Vous pourrait faire quelque chose comme:
```
# Monitor.cshtml
@model Monitor
@Model.FirstName @Model.LastName,
```
Et puis:
```
@Html.DisplayFor(m => m.Monitors)
```
Mais votre dernier élément aurait une virgule à la fin.

Pour l'édition de listes, tout ce que vous avez à faire est de passer les listes de sélection à votre vue. De façon optimale, vous devrez faire cela avec un modèle de vue, mais pour des raisons de simplicité, je vais juste utiliser ViewBag ici. Dans votre action de contrôleur:
```
ViewBag.MonitorChoices = db.Monitors.Select(m => new SelectListItem
{
Value = m.ID.ToString(),
Text = string.Format("{0} {1}", m.FirstName, m.LastName)
});
```
Puis, dans votre créer/modifier l'affichage:
```
@Html.ListBoxFor(m => m.Monitors, ViewBag.MonitorChoices)
```
- Détail sympa dans votre réponse! Des acclamations.
- Je vais essayer cela et vous laisser savoir comment il fonctionne. Réponse fantastique!
- cela a fonctionné très bien pour l'Index et l'affichage des Détails. J'ai un problème avec le paresseux liaison si. Mes écrans sont de retour null même si ils sont dans la DB.
- votre navigation propriétés doivent être virtual ICollections, c'est à dire public virtual ICollection<Monitor> Monitors { get; set; }
- Ok, qui fixe les paresseux de liaison, mais maintenant un autre problème avec l'affichage...je vois que la chaîne est d'arriver à créer (dans ce cas, j'ai 2 moniteurs affectés), mais il ne montre. J'ai fait mettre à jour le code ci-dessus
- Parce que string.Join retourne une chaîne de caractères, il n'a pas d'écrire sur la sortie standard, ou autrement rendre quelque chose à l'écran. Lorsque vous êtes à l'extérieur d'un codeblock et vous préfixe des choses comme ça avec @, Rasoir comprend ce que vous voulez et sorties de la valeur de retour, mais que le Rasoir est un comportement, pas la valeur par défaut. Vous avez besoin de faire un littéral de chaîne avec la @: la syntaxe Razor (c'est à dire @:@string.Join...) ou de le mettre à l'intérieur du HTML (c'est à dire <span>@string.Join...</span>).
InformationsquelleAutor Chris Pratt

Essayer comme suit,

var surveille = //de Votre requête linq 
Liste monitorList = new Liste(); 
foreach (var moniteur moniteurs ){ 
SelectListItem item = new SelectListItem(); 
de l'élément.Texte = moniteur.Prénom; 
de l'élément.Valeur = moniteur.Id.ToString(); 
monitorList .Add(item); 
} 
ViewData["ddlList"] = monitorList;

InformationsquelleAutor Jatin patil

Vous devez vous connecter pour publier un commentaire.