MVC 4 - plusieurs-à-Plusieurs de relation et de cases à cocher

Vous commencez avec deux modèles de vue. Le premier, ce qui représente une société choisie...

public class CompanySelectViewModel
{
    public int CompanyId { get; set; }
    public string Name { get; set; }
    public bool IsSelected { get; set; }
}

...et la seconde pour l'abonnement à créer:

public class SubscriptionCreateViewModel
{
    public int Amount { get; set; }
    public IEnumerable<CompanySelectViewModel> Companies { get; set; }
}

Puis dans le SubscriptionControllers OBTENIR une action de charger les entreprises de la base de données à initialiser le modèle de vue:

public ActionResult Create()
{
    var viewModel = new SubscriptionCreateViewModel
    {
        Companies = _context.Companies
            .Select(c => new CompanySelectViewModel
            {
                CompanyId = c.CompanyId,
                Name = c.Name,
                IsSelected = false
            })
            .ToList()
    };

    return View(viewModel);
}

Maintenant, vous avez une vue fortement typée pour cette action:

@model SubscriptionCreateViewModel

@using (Html.BeginForm()) {

    @Html.EditorFor(model => model.Amount)

    @Html.EditorFor(model => model.Companies)

    <input type="submit" value="Create" />
    @Html.ActionLink("Cancel", "Index")
}

À obtenir de la société des cases à cocher au bon rendu d'introduire un éditeur de modèle. Il doit avoir le nom CompanySelectViewModel.cshtml et va dans le dossier Views/Subscription/EditorTemplates (créer un dossier manuellement s'il n'existe pas). Il est fortement typé vue partielle:

@model CompanySelectViewModel

@Html.HiddenFor(model => model.CompanyId)
@Html.HiddenFor(model => model.Name)

@Html.LabelFor(model => model.IsSelected, Model.Name)
@Html.EditorFor(model => model.IsSelected)

Name est ajouté en tant que champ caché pour préserver le nom lors d'un POST.

Vous avez évidemment le style le point de vue un peu plus.

Maintenant, votre POST action pourrait ressembler à ceci:

[HttpPost]
public ActionResult Create(SubscriptionCreateViewModel viewModel)
{
    if (ModelState.IsValid)
    {
        var subscription = new Subscription
        {
            Amount = viewModel.Amount,
            Companies = new List<Company>()
        };

        foreach (var selectedCompany
            in viewModel.Companies.Where(c => c.IsSelected))
        {
            var company = new Company { CompanyId = selectedCompany.CompanyId };
            _context.Companies.Attach(company);

            subscription.Companies.Add(company);
        }

        _context.Subscriptions.Add(subscription);
        _context.SaveChanges();

        return RedirectToAction("Index");
    }

    return View(viewModel);
}

Au lieu d'utiliser Attach vous pouvez également charger la société pour la première fois avec var company = _context.Companies.Find(selectedCompany.CompanyId);. Mais avec Attach vous n'avez pas besoin d'un aller-retour à la base de données pour charger les entreprises à être ajoutés à la collection.

(Edit 2: Dans cette réponse est une continuation de la Edit les actions et les points de vue avec le même exemple de modèle.)

Modifier

Votre modèle n'est pas vraiment un plusieurs-à-plusieurs relations. Vous avez deux un-à-plusieurs relations à la place. Le PublicTransportSubscriptionByCompany entité n'est pas nécessaire normalement. Si vous avez une clé primaire composite dans la table fait de Id_PublicTransportSubscription, Id_PublicTransportCompany et de supprimer la colonne id Id_PublicTransportSubscriptionByCompanyId EF permettrait de détecter ce schéma de la table plusieurs-à-plusieurs relations et de créer une collection dans chacune des entités pour l'abonnement et de l'entreprise et il ne crée pas de l'entité pour le lien de la table. Mon code ci-dessus s'appliquent alors.

Si vous ne voulez pas modifier le schéma pour une raison quelconque, vous devez modifier le POST d'action comme:

[HttpPost]
public ActionResult Create(SubscriptionCreateViewModel viewModel)
{
    if (ModelState.IsValid)
    {
        var subscription = new Subscription
        {
            Amount = viewModel.Amount,
            SubscriptionByCompanies = new List<SubscriptionByCompany>()
        };

        foreach (var selectedCompany
            in viewModel.Companies.Where(c => c.IsSelected))
        {
            var company = new Company { CompanyId = selectedCompany.CompanyId };
            _context.Companies.Attach(company);

            var subscriptionByCompany = new SubscriptionByCompany
            {
                Company = company
            };

            subscription.SubscriptionByCompanies.Add(subscriptionByCompany);
        }

        _context.Subscriptions.Add(subscription);
        _context.SaveChanges();

        return RedirectToAction("Index");
    }

    return View(viewModel);
}

OriginalL'auteur Slauma

Juste une extension de Slauma de réponse. Dans mon cas, j'ai eu à représenter plusieurs-à-plusieurs comme une table entre les Produits et les Rôles, la première colonne représente les Produits, l'en-tête représentant les Rôles et le tableau à remplir avec des cases à cocher pour sélectionner les rôles pour le produit.
Pour réaliser cela, j'ai utilisé ViewModel comme Slauma décrit, mais il a ajouté un autre modèle contenant les deux dernières, comme suit:

public class UserViewModel
{
    public int Id { get; set; }
    public string Name { get; set; }
    public IEnumerable<ProductViewModel> Products { get; set; }
}

public class ProductViewModel
{
    public int Id { get; set; }
    public string Name { get; set; }
    public IEnumerable<RoleViewModel> Roles { get; set; } 
}
public class RoleViewModel
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsSelected { get; set; }
}

Prochain, dans le Contrôleur, nous avons besoin de remplir de données:

UserViewModel user = new UserViewModel();
user.Name = "Me";
user.Products = new List<ProductViewModel>
                {
                    new ProductViewModel
                    {
                        Id = 1,
                        Name = "Prod1",
                        Roles = new List<RoleViewModel>
                        {
                            new RoleViewModel
                            {
                                Id = 1,
                                Name = "Role1",
                                IsSelected = false
                            }
                            //add more roles
                        }
                    }
                    //add more products with the same roles as Prod1 has
                 };

Prochain, en Vue:

@model UserViewModel@using (Ajax.BeginForm("Create", "User",
new AjaxOptions
{
    HttpMethod = "POST",
    InsertionMode = InsertionMode.Replace,
    UpdateTargetId = "divContainer"
}))
{
<table>
    <thead>
        <tr>
            <th>
            </th>
            @foreach (RoleViewModel role in Model.Products.First().Roles.ToList())
            {
                <th>
                    @role.Name
                </th>
            }
        </tr>
    </thead>
    <tbody>
        @Html.EditorFor(model => model.Products)
    </tbody>
</table>
<input type="submit" name="Create" value="Create"/>
}

Comme vous le voyez, EditorFor est à l'aide de modèle pour les Produits:

@model Insurance.Admin.Models.ProductViewModel
@Html.HiddenFor(model => model.Id)
<tr>
    <th class="col-md-2 row-header">
        @Model.Name
    </th>
    @Html.EditorFor(model => model.Roles)
</tr>

Ce modèle utilise un autre modèle pour les Rôles de:

@model Insurance.Admin.Models.RoleViewModel
@Html.HiddenFor(model => model.Id)
<td>
    @Html.EditorFor(model => model.IsSelected)
</td>

Et voila, nous avons un tableau contenant première colonne des Produits, l'en-tête contient des Rôles et le tableau est rempli avec des cases à cocher. Nous publions UserViewModel et vous verrez que toutes les données sont affichées.

OriginalL'auteur Nicolae