[Débutant] Ajouter une liste d'objet lors de la création d'un autre objet

Bonjour,

Je me permets de venir poser ma question ici, car je pense que c'est le lieu adéquat.
J'apprends depuis vraiment peu de temps le C# et l'environnement .NET avec ASP.NET MVC.

Après avoir lu pas mal de cours, tutoriel et visionné des vidéos, j'essaye de mettre en application ce que j'ai retenu (pas une mince affaire :mouarf:)
Je me lance dans la création d'un petit projet, mais voilà j'aborde une difficulté que je n'arrive pas à résoudre.

Principe de mon application :

Cette application me permet de gérer les compositions de mon équipe de football pour chaque match.

1) La classe Joueur

Nous avons une classe de modèle : Joueur
Dans cette classe, chaque objet Joueur possède les propriétés suivantes : JoueurID, Firstname, Lastname, Poste et une Image
Globalement cela correspond à renseigner la liste des licenciés de mon club de foot.

Voilà ma classe Joueur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;
 
namespace FCSL.Models.Joueur
{
    public class Joueur
    {
        [Key, Display(Name = "ID")]
        public int JoueurID { get; set; }
 
        [Required, Display(Name = "Nom"), StringLength(30)]
        public string Lastname { get; set; }
 
        [Required, Display(Name = "Prénom"), StringLength(30)]
        public string Firstname { get; set; }
 
        [Required]
        [Display(Name = "Poste")]
        public string Poste { get; set; }
 
        public string Image { get; set; }
    }
}

2) La classe Match

Dans cette classe, je créé un objet à chaque fois qu'un match approche avec les propriétés suivantes : MatchID, MatchDay, MatchTime, Adversaire, Format, Terrain, Tresse, Slug

La classe `Match` donne donc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Web.Mvc;
 
namespace FCSL.Models.Match
{
    public class Match
    {
        [Key]
        public int MatchID { get; set; }
 
        [Required, Display(Name = "Date du match")]
        [DataType(DataType.Date)]
        public DateTime MatchDay { get; set; }
 
        [Required, Display(Name = "Heure du match")]
        [DataType(DataType.Time)]
        [DisplayFormat(ApplyFormatInEditMode = true, DataFormatString = "{0:HH:mm}")]
        public DateTime MatchTime { get; set; }
 
        [Required, Display(Name = "Adversaire")]
        public string Adversaire { get; set; }
 
        [Required, Display(Name = "Type de match")]
        public string Format { get; set; }
 
        [Required, Display(Name = "Terrain")]
        public string Terrain { get; set; }
 
        [Display(Name = "Tresse")]
        public string Tresse { get; set; }
 
        [Required, Display(Name = "Mot-clé")]
        public string Slug
        {
            get { return Format + "_" + Adversaire + "_" + MatchDay.ToString("dd_MM_yyyy"); }
        }
    }
}

3) La partie délicate pour moi

Je voudrais, lors de la création de mon match, pouvoir ajouter tous les joueurs sélectionnés pour ce match.
Donc avoir une ICollection<Joueur.Joueur> ListeJoueurs {get; set;} je suppose dans ma classe Match.
Par exemple avec un menu déroulant et une possibilité de faire une sélection multiple sur ma classe Joueur.

Sauf que voilà, après avoir ajouté cette nouvelle propriété, je ne parviens pas à l'afficher correctement dans ma vue, ni même savoir comment je dois mettre cela en place dans mon controller.

Voici à quoi ressemble ma classe MatchController :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Net;
using System.Web;
using System.Web.Mvc;
using FCSL.Models;
using FCSL.Models.Match;
 
namespace FCSL.Controllers
{
    public class MatchesController : Controller
    {
        private FCSLContext db = new FCSLContext();
 
        // GET: Matches
        public ActionResult Index()
        {
            return View(db.Matches.ToList());
        }
 
        // GET: Matches/Details/5
        public ActionResult Details(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Match match = db.Matches.Find(id);
            if (match == null)
            {
                return HttpNotFound();
            }
            return View(match);
        }
 
        // GET: Matches/Create
        public ActionResult Create()
        {
 
            var listejoueurs = db.Joueurs.Select(c => new
            {
                JoueurName = c.Firstname
            }).ToList();
            ViewBag.Joueur = new MultiSelectList(listejoueurs, "Firstname");
 
            return View();
        }
 
        // POST: Matches/Create
        // Afin de déjouer les attaques par sur-validation, activez les propriétés spécifiques que vous voulez lier. Pour 
        // plus de détails, voir  https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Create([Bind(Include = "MatchID,MatchDay,MatchTime,Adversaire,Format,Terrain,Tresse,Slug,ListeJoueurs")] Match match)
        {
            if (ModelState.IsValid)
            {
                db.Matches.Add(match);
                db.SaveChanges();
                return RedirectToAction("Index");
            }
 
            return View(match);
        }
 
        // GET: Matches/Edit/5
        public ActionResult Edit(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Match match = db.Matches.Find(id);
            if (match == null)
            {
                return HttpNotFound();
            }
            return View(match);
        }
 
        // POST: Matches/Edit/5
        // Afin de déjouer les attaques par sur-validation, activez les propriétés spécifiques que vous voulez lier. Pour 
        // plus de détails, voir  https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Edit([Bind(Include = "MatchID,MatchDay,MatchTime,Adversaire,Format,Terrain,Tresse,Slug,ListeJoueurs")] Match match)
        {
            if (ModelState.IsValid)
            {
                db.Entry(match).State = EntityState.Modified;
                db.SaveChanges();
                return RedirectToAction("Index");
            }
            return View(match);
        }
 
        // GET: Matches/Delete/5
        public ActionResult Delete(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Match match = db.Matches.Find(id);
            if (match == null)
            {
                return HttpNotFound();
            }
            return View(match);
        }
 
        // POST: Matches/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public ActionResult DeleteConfirmed(int id)
        {
            Match match = db.Matches.Find(id);
            db.Matches.Remove(match);
            db.SaveChanges();
            return RedirectToAction("Index");
        }
 
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}

J'ai lu qu'il fallait utiliser les ViewModels (Pourquoi ? Est-ce vrai ?) ?

Voilà à quoi je souhaiterais que mon formulaire ressemble (avec la possibilité de choisir plusieurs joueurs dans la liste) :

Pièce jointe 494520

Merci beaucoup pour votre réponse, je suis vraiment perdu pour le coup