使用ASP.NET MVC和3，我如何才能创建隐藏字段，以便使用数组作为列表中的每个项目的值列表正确

2019-07-29 05:41发布

站内文章 / 移动开发
22 0 0

我有需要时另一份声明中需要添加到结束时回发到MVC控制器查询语句的列表。 对于测试我想现在要创建的页面开始用的过滤器列表。 在做这个例子中，该页面将创建过滤器，因为这领域： 

<input id="filters_0__PropertyName" name="filters[0].PropertyName" type="hidden" value="State">
<input id="filters_0__Operator" name="filters[0].Operator" type="hidden" value="=">
<input id="filters_0__Value" name="filters[0].Value" type="hidden" value="CA">

但是，当我看到居然回发到控制器的形式，列表回来为： 

PropertyName = "State"
Operator = "="
Value= "new string[1]" // The value comes back in the first index of the array

我要投的价值参数数组和采取的第一个指数能够获得的价值了。 这是正常的，但不理想。 主要的问题是当该FilterField包含整数或字符串Value属性的数组。 当发生这种情况时，HTML出来的： 

<input id="filters_2__PropertyName" name="filters[3].PropertyName" type="hidden" value="Schedule_Num">
<input id="filters_2__Operator" name="filters[3].Operator" type="hidden" value="IN">
<input id="filters_2__Value" name="filters[3].Value" type="hidden" value="System.Int32[]">

值然后包含对象类型，并在全部没有值。 所以ModelBinder的会很困惑，一切都休息。 是否有扎值列表的视图更简单的方法？

FilterField.cs： 

public class FilterField
{
    public string PropertyName { get; set; }
    public string Operator { get; set; }
    public object Value { get; set; }

    public FilterOutput GetOutput()
    {
        return new FilterOutput(PropertyName, Operator, Value);
    }
}

FilterOutput.cs 

public class FilterOutput
{
    private List<QueryProperty> _properties = new List<QueryProperty>();
    private string _propertyName;
    private string _op;
    private object _value;

    public string Sql { get; set; }
    public QueryProperty[] Properties { get; set; }

    public FilterOutput(string propertyName, string op, object value)
    {
        var sql = "[{0}] {1} {2}";
        Sql = string.Format(sql, propertyName, op, FormatParameter(propertyName, op, value));
        Properties = _properties.ToArray();
    }

    private string FormatParameter(string propertyName, string op, object value)
    {
        _properties.Clear();
        var sb = new StringBuilder();
        switch (op.ToUpper())
        {
            case "IN":
                {
                    var values = value as Array;
                    sb.Append("{");
                    var inCount = 0;
                    foreach (var v in values)
                    {
                        var pName = propertyName + inCount;
                        if (inCount == 0)
                            sb.Append("@" + pName);
                        else
                            sb.Append(",@" + pName);
                        _properties.Add(new QueryProperty { Name = pName, Value = v });
                        inCount++;
                    }
                    sb.Append("}");
                }
                break;
            case "LIKE":
                if (value.ToString().Contains("_"))
                    sb.Append("@" + propertyName);
                else
                    sb.Append("'%' + @" + propertyName + " + '%'");
                _properties.Add(new QueryProperty { Name = propertyName, Value = value });
                break;
            case "BETWEEN":
                var range = value as Array;
                var betweenCount = 0;
                foreach (var r in range)
                {
                    if (betweenCount > 0)
                        sb.Append(" AND ");
                    sb.Append("@" + propertyName + betweenCount);
                    _properties.Add(new QueryProperty { Name = propertyName + betweenCount, Value = r });
                    betweenCount++;
                }
                break;
            default:
                sb.Append("@" + propertyName);
                _properties.Add(new QueryProperty { Name = propertyName, Value = value });
                break;
        }
        return sb.ToString();
    }

    public string ConvertToSql()
    {
        var filterOutput = this;
        var output = filterOutput.Properties.Aggregate(filterOutput.Sql, (current, p) => current.Replace("@" + p.Name, FormatObjectToString(p.Value)));
        output = output
            .Replace("[", "t.").Replace("]", "") // Convert [text] to t.text
            .Replace("{", "(").Replace("}", ")") // Convert {'text1','text2'} to ('text1','text2')
            .Replace("'%' + '", "'%").Replace("' + '%'", "%'"); // Convert '%' + text + '%' to '%text%'
        return " AND " + output;
    }

    public override string ToString()
    {
        var filterOutput = this;
        return filterOutput.Properties.Aggregate(filterOutput.Sql, (current, p) => current.Replace("@" + p.Name, FormatObjectToString(p.Value)).Replace("'%' + '", "'%").Replace("' + '%'", "%'"));
    }

    private string FormatObjectToString(object value)
    {
        if (value is int)
            return value.ToString();
        return String.Format("'{0}'", value);
    }
}

HomeController.cs 

public ActionResult TestQuery(DateTime date)
{
    var builder = new QueryBuilder(_repo, "INFO", date);

    builder.AddFilters(
            new FilterField
                {
                    PropertyName = "State",
                    Operator = "=",
                    Value = "CA"
                },
            new FilterField
                {
                    PropertyName = "Schedule_Num",
                    Operator = "IN",
                    Value = new[] {2, 6}
                });

    var result = builder.Build();
    return View(result);
 }

 [HttpPost]
 public ActionResult TestPost(QueryResult result)
 {
    var builder = new QueryBuilder(_repo, "INFO", date);

    foreach (var f in result.Filters)
    {
        builder.AddFilters(new FilterField
                                   {
                                       PropertyName = f.PropertyName,
                                       Operator = f.Operator,
                                       Value = ((Array)f.Value).GetValue(0)
                                   });
    }

    builder.AddFilters(
            new FilterField
                {
                    PropertyName = "Gender",
                    Operator = "BETWEEN",
                    Value = new[] {"A", "G"}
                });

    var newResult = builder.Build();
    return View("TestQuery", newResult);
 }

TestQuery.cshtml 

@model Models.QueryResult

@using (Html.BeginForm("TestPost", "Home"))
{
    @Html.HiddenFor(m => m.Date)
    for (var i = 0; i < Model.Filters.Count(); i++)
    {
        @Html.Hidden("filters[" + i + "].PropertyName", Model.Filters[i].PropertyName)
        @Html.Hidden("filters[" + i + "].Operator", Model.Filters[i].Operator)
        @Html.Hidden("filters[" + i + "].Value", Model.Filters[i].Value)
    }
    <div class="formArea">
        <p>
            <input type="submit" value="Submit" id="btnSubmit" />
        </p>
    </div>
}

QueryResult.cs 

public class QueryResult
{
    public DateTime Date { get; set; }
    public ObjectQuery<EntityObject> Objects { get; set; }
    public string SqlStatement { get; set; }
    public ObjectParameter[] Parameters { get; set; }
    public AdjustResult AdjustResult { get; set; }
    public IList<FilterField> Filters { get; set; }

    public QueryResult()
    {
        Filters = new List<FilterField>();
    }

    public void AddFilter(FilterField filter)
    {
        Filters.Add(filter);
    }

    public string ParsedSqlStatement()
    {
        var output = Parameters.Aggregate(SqlStatement, (current, p) => current.Replace("@" + p.Name, FormatObjectToString(p.Value)));
        return Filters.Aggregate(output, (current, filter) => current + filter.ConvertToSql());
    }

    private string FormatObjectToString(object value)
    {
        if (value is int)
            return value.ToString();
        return String.Format("'{0}'", value);
    }
}

QueryBuilder.cs 

public class QueryBuilder
{
    public IList<FilterField> Filters { get; set; }

    private IDynamicRepository _repo;
    private string _tablePrefix;
    private DateTime _date;
    private QueryResult _base;

    public QueryBuilder(IDynamicRepository repository, string tablePrefix, DateTime date)
    {
        _repo = repository;
        _tablePrefix = tablePrefix;
        _date = date;
        _base = _repo.GetAll(tablePrefix, date);
        Filters = new List<FilterField>();
    }

    public void AddFilters(params FilterField[] filters)
    {
        foreach (var f in filters)
        {
           Filters.Add(f);
        }
    }

    public void RemoveFilter(FilterField filter)
    {
        Filters.Remove(filter);
    }

    public QueryResult Build()
    {
        return _base.Where(Filters.ToArray());
    }
}

Extensions.cs 

public static QueryResult Where(this QueryResult result, string predicate, params QueryProperty[] properties)
{
    result.Objects = result.Objects.Where(predicate.ReplaceIdentifier(), properties.Select(p => new ObjectParameter(p.Name, p.Value)).ToArray());
    return result;
}

public static QueryResult Where(this QueryResult result, FilterField filter)
{
    var filterOutput = filter.GetOutput();
    result.Objects = result.Objects.Where(filterOutput.Sql.ReplaceIdentifier(), filterOutput.Properties.Select(p => new ObjectParameter(p.Name, p.Value)).ToArray());
    result.AddFilter(filter);
    return result;
}

public static QueryResult Where(this QueryResult result, params FilterField[] filters)
{
    return filters.Aggregate(result, Where);
}

由于一些你想了解更多的信息，这里的一切是如何联系的一些细节在一起。 基本上，控制器获取来自归结为WHERE之后的SQL语句的UI过滤器列表。 这样一个过滤器会变成FIELD =值或字段IN（值1，值）。 该QueryBuilder的创建使用Entity.CreateQuery的SQL语句的基础（“SELECT * FROM表”）。 上一旦该方法生成（）的QueryBuilder是跑步，它创建了具有查询转身日期和所有查询的EntityObjects与连接过滤器到一个QueryResult中模型，其中用于查看使用说明。 我继续并增加了一些更多的类来展示如何将这些结合在一起。

Answer 1:

在你看来，你就不需要设置名字那样，你可以使用HiddenFor来为你做的。 改变你的for循环在你的视图是： 

for (var i = 0; i < Model.Filters.Count(); i++)
{
    @Html.HiddenFor(m => m.Filters[i].PropertyName)
    @Html.HiddenFor(m => m.Filters[i].Operator)
    @Html.HiddenFor(m => m.Filters[i].Value)
}

这应该给你正确的标记，这反过来将有助于默认的模型绑定发送过滤器到你的QueryResult的HttpPost方法:)。

**编辑：由于要绑定多个值或单一数值（ int或string ，或者可以是Array ），你最好改变的Value在属性FilterField类是一个List<string> 。

所以，在FilterField类替换此： 

public object Value { get; set; }

有了这个： 

public List<string> Values { get; set; }

然后改变你的标记是： 

for (var i = 0; i < Model.Filters.Count(); i++)
{
    @Html.HiddenFor(m => m.Filters[i].PropertyName)
    @Html.HiddenFor(m => m.Filters[i].Operator)
    for (var j = 0; j < Model.Filters[i].Values.Count; j++)
    {
        @Html.HiddenFor(m => m.Filters[i].Values[j])
    }
}

这样一来，虽然它可能不像在世界上最美丽的一段代码，它可以节省您不必在模型绑定工作，你怎么想的那样，它只会默认绑定到谬以千里的头痛。



Answer 2:

我觉得你能适应这个想法从这篇文章 。

在你的情况下，每个项目将是FilterItems代替GiftItems ...



Answer 3:

默认情况下，具有相同名称的多个输入将结合到阵列。 因此，你需要每个值离散迭代并将其添加为一个隐藏的输入（名称相同）。 当回发，它会结合为一个数组。

迭代的每个值也应消除与该对象类型被设置为的值的问题。



文章来源: Using ASP.NET and MVC 3, how can I create hidden fields so that a List with an array as a value of each item in the list binds correctly?
标签： c# asp.net-mvc asp.net-mvc-3 linq razor
举报

收藏的人(0)

Ta的文章 更多文章
登录 后发表评论
0条评论
还没有人评论过~