Comment puis-je ajouter des lignes à une liste de collection dans mon Modèle?

Après quelques recherches, j'ai trouvé ce blog par Steven Anderson http://blog.stevensanderson.com/2010/01/28/editing-a-variable-length-list-aspnet-mvc-2-style/

Il semble être en train de faire exactement ce que je veux (sauf qu'il est écrit dans MVC2).

OriginalL'auteur Bryan Denny

Je voudrais utiliser une méthode d'extension au lieu que vous pouvez utiliser dans d'autres cas:

Extension:

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
using System.Web.Mvc;
using System.Web.Mvc.Html;
public static class HtmlHelperExtensions
{
///<summary>
///Generates a GUID-based editor template, rather than the index-based template generated by Html.EditorFor()
///</summary>
///<typeparam name="TModel"></typeparam>
///<typeparam name="TValue"></typeparam>
///<param name="html"></param>
///<param name="propertyExpression">An expression which points to the property on the model you wish to generate the editor for</param>
///<param name="indexResolverExpression">An expression which points to the property on the model which holds the GUID index (optional, but required to make Validation* methods to work on post-back)</param>
///<param name="includeIndexField">
///True if you want this helper to render the hidden &lt;input /&gt; for you (default). False if you do not want this behaviour, and are instead going to call Html.EditorForManyIndexField() within the Editor view. 
///The latter behaviour is desired in situations where the Editor is being rendered inside lists or tables, where the &lt;input /&gt; would be invalid.
///</param>
///<returns>Generated HTML</returns>
public static MvcHtmlString EditorForMany<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, IEnumerable<TValue>>> propertyExpression, Expression<Func<TValue, string>> indexResolverExpression = null, bool includeIndexField = true) where TModel : class
{
var items = propertyExpression.Compile()(html.ViewData.Model);
var htmlBuilder = new StringBuilder();
var htmlFieldName = ExpressionHelper.GetExpressionText(propertyExpression);
var htmlFieldNameWithPrefix = html.ViewData.TemplateInfo.GetFullHtmlFieldName(htmlFieldName);
Func<TValue, string> indexResolver = null;
if (indexResolverExpression == null)
{
indexResolver = x => null;
}
else
{
indexResolver = indexResolverExpression.Compile();
}
foreach (var item in items)
{
var dummy = new { Item = item };
var guid = indexResolver(item);
var memberExp = Expression.MakeMemberAccess(Expression.Constant(dummy), dummy.GetType().GetProperty("Item"));
var singleItemExp = Expression.Lambda<Func<TModel, TValue>>(memberExp, propertyExpression.Parameters);
if (String.IsNullOrEmpty(guid))
{
guid = Guid.NewGuid().ToString();
}
else
{
guid = html.AttributeEncode(guid);
}
if (includeIndexField)
{
htmlBuilder.Append(_EditorForManyIndexField<TValue>(htmlFieldNameWithPrefix, guid, indexResolverExpression));
}
htmlBuilder.Append(html.EditorFor(singleItemExp, null, String.Format("{0}[{1}]", htmlFieldName, guid)));
}
return new MvcHtmlString(htmlBuilder.ToString());
}
///<summary>
///Used to manually generate the hidden &lt;input /&gt;. To be used in conjunction with EditorForMany(), when "false" was passed for includeIndexField. 
///</summary>
///<typeparam name="TModel"></typeparam>
///<param name="html"></param>
///<param name="indexResolverExpression">An expression which points to the property on the model which holds the GUID index (optional, but required to make Validation* methods to work on post-back)</param>
///<returns>Generated HTML for hidden &lt;input /&gt;</returns>
public static MvcHtmlString EditorForManyIndexField<TModel>(this HtmlHelper<TModel> html, Expression<Func<TModel, string>> indexResolverExpression = null)
{
var htmlPrefix = html.ViewData.TemplateInfo.HtmlFieldPrefix;
var first = htmlPrefix.LastIndexOf('[');
var last = htmlPrefix.IndexOf(']', first + 1);
if (first == -1 || last == -1)
{
throw new InvalidOperationException("EditorForManyIndexField called when not in a EditorForMany context");
}
var htmlFieldNameWithPrefix = htmlPrefix.Substring(0, first);
var guid = htmlPrefix.Substring(first + 1, last - first - 1);
return _EditorForManyIndexField<TModel>(htmlFieldNameWithPrefix, guid, indexResolverExpression);
}
private static MvcHtmlString _EditorForManyIndexField<TModel>(string htmlFieldNameWithPrefix, string guid, Expression<Func<TModel, string>> indexResolverExpression)
{
var htmlBuilder = new StringBuilder();
htmlBuilder.AppendFormat(@"<input type=""hidden"" name=""{0}.Index"" value=""{1}"" />", htmlFieldNameWithPrefix, guid);
if (indexResolverExpression != null)
{
htmlBuilder.AppendFormat(@"<input type=""hidden"" name=""{0}[{1}].{2}"" value=""{1}"" />", htmlFieldNameWithPrefix, guid, ExpressionHelper.GetExpressionText(indexResolverExpression));
}
return new MvcHtmlString(htmlBuilder.ToString());
}
}

Ajouter une propriété de le modèle, ce qui le EditorForMany helper va stocker l'index généré. Sans cela, le Html.Validation* méthodes ne fonctionnent pas (voir ici pour une plongée dans le “pourquoi” pour les curieux).

public class UserModel
{
public string UserName { get; set; }
public List<Email> Emails = new List<Email>();      
}
public class Email
{
public string Address { get; set; }
public string Index { get; set; }
}

Substitut @Html.EditorFor(modelItem => e-mail.L'adresse):

@Html.EditorForMany(x => x.Emails, x => x.Index, false);
@Html.EditorForManyIndexField(x => x.Index)

(Note: Si vous n'êtes pas dans un <tr>, <tbody> or <ul> ou similaire le code de @Html.EditorForMany(x => x.E-mails, x => x.L'indice) et vous n'aurait pas besoin d' @Html.EditorForManyIndexField(x => x.E-mails, x => x.Index) ou @Html.EditorForManyIndexField(x => x.L'indice). Sans paramètre Indexfield vous-même votre table serait mal formaté et donc on fait comme ceci.)

Désormais, tous nos problèmes sont résolus! Vous verrez que Html.EditorForMany() utilise le Guid plutôt que des numéros d'index. Cela supprime la nécessité pour nous de dire à nos AJAX d'extrémité index qui a été utilisé, comme notre AJAX point de terminaison au lieu de cela il vous suffit de créer un nouveau GUID. Html.EditorForMany() prend également soin de façon transparente la production de la .Champ d'Index pour nous.

Tout ce qui reste à faire est d'obtenir notre AJAX d'extrémité et en cours d'exécution. Pour ce faire, j'définir une nouvelle action dans mon Contrôleur.

[OutputCache(NoStore = true, Duration = 0, VaryByParam = "*")]
public ActionResult AddEmail()
{
var user = new UserModel();
user.Emails.Add(new Email()); 
return View(user);
}

Créer une nouvelle vue Vues\Shared\AddEmail.cshml;

@model DynamicListBinding.Models.UserModel
@{
Layout = null;
}
@Html.EditorForMany(x => x.Emails, x => x.Index, false);

Bravo à Matt pour origine l'article

OriginalL'auteur Ogglas

Avez-vous songé à l'aide d'un tiers des outils pour cela?

J'ai trouvé ceci sur CodeProject et semble répondre à vos exigences. Oui il va me falloir un peu de peaufinage, mais il devrait faire le travail

http://www.codeproject.com/Articles/277576/AJAX-based-CRUD-tables-using-ASP-NET-MVC-3-and-jTa

Sinon, vous pouvez passer des heures sur la mise en œuvre des fonctionnalités similaires en JavaScript/jQuery.

OriginalL'auteur