只需要在参数之前添加[FromUri]，看起来像：

GetCategories([FromUri] int[] categoryIds)

并发送请求：

/Categories?categoryids=1&categoryids=2&categoryids=3 

正如 Filip W 指出的那样，您可能不得不求助于这样的自定义模型绑定器(修改为绑定到实际类型的参数(：

public IEnumerable<Category> GetCategories([ModelBinder(typeof(CommaDelimitedArrayModelBinder))]long[] categoryIds) 
{
    // do your thing
}
public class CommaDelimitedArrayModelBinder : IModelBinder
{
    public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
    {
        var key = bindingContext.ModelName;
        var val = bindingContext.ValueProvider.GetValue(key);
        if (val != null)
        {
            var s = val.AttemptedValue;
            if (s != null)
            {
                var elementType = bindingContext.ModelType.GetElementType();
                var converter = TypeDescriptor.GetConverter(elementType);
                var values = Array.ConvertAll(s.Split(new[] { ","},StringSplitOptions.RemoveEmptyEntries),
                    x => { return converter.ConvertFromString(x != null ? x.Trim() : x); });
                var typedValues = Array.CreateInstance(elementType, values.Length);
                values.CopyTo(typedValues, 0);
                bindingContext.Model = typedValues;
            }
            else
            {
                // change this line to null if you prefer nulls to empty arrays 
                bindingContext.Model = Array.CreateInstance(bindingContext.ModelType.GetElementType(), 0);
            }
            return true;
        }
        return false;
    }
}

然后你可以说：

/Categories?categoryids=1,2,3,4和 ASP.NET Web API 将正确绑定categoryIds数组。

我最近自己遇到了这个要求，我决定实现一个ActionFilter来处理这个问题。

public class ArrayInputAttribute : ActionFilterAttribute
{
    private readonly string _parameterName;
    public ArrayInputAttribute(string parameterName)
    {
        _parameterName = parameterName;
        Separator = ',';
    }
    public override void OnActionExecuting(HttpActionContext actionContext)
    {
        if (actionContext.ActionArguments.ContainsKey(_parameterName))
        {
            string parameters = string.Empty;
            if (actionContext.ControllerContext.RouteData.Values.ContainsKey(_parameterName))
                parameters = (string) actionContext.ControllerContext.RouteData.Values[_parameterName];
            else if (actionContext.ControllerContext.Request.RequestUri.ParseQueryString()[_parameterName] != null)
                parameters = actionContext.ControllerContext.Request.RequestUri.ParseQueryString()[_parameterName];
            actionContext.ActionArguments[_parameterName] = parameters.Split(Separator).Select(int.Parse).ToArray();
        }
    }
    public char Separator { get; set; }
}

像这样应用它(请注意，我使用了"id"，而不是"ids"，因为这是我的路由中指定的方式(：

[ArrayInput("id", Separator = ';')]
public IEnumerable<Measure> Get(int[] id)
{
    return id.Select(i => GetData(i));
}

公共网址将是：

/api/Data/1;2;3;4

您可能需要重构它以满足您的特定需求。

如果有人需要 - 通过POST而不是FromUri来实现相同或相似的事情(如删除(，请使用FromBody和客户端(JS/jQuery(格式参数作为$.param({ '': categoryids }, true)

C#：

public IHttpActionResult Remove([FromBody] int[] categoryIds)

j查询：

$.ajax({
        type: 'POST',
        data: $.param({ '': categoryids }, true),
        url: url,
//...
});

$.param({ '': categoryids }, true)的事情是，它 .net 将期望 post body 包含 urlencoding 值，例如没有参数名称和括号的 =1&=2&=3。

将数组参数发送到 Web API 的简单方法

应用程序接口

public IEnumerable<Category> GetCategories([FromUri]int[] categoryIds){
 // code to retrieve categories from database
}

Jquery：将JSON对象作为请求参数发送

$.get('api/categories/GetCategories',{categoryIds:[1,2,3,4]}).done(function(response){
console.log(response);
//success response
});

它将生成您的请求 URL，例如 ../api/categories/GetCategories?categoryIds=1&categoryIds=2&categoryIds=3&categoryIds=4 <</p>

ASP.NET Core 2.0 解决方案(Swagger Ready(

输入

DELETE /api/items/1,2
DELETE /api/items/1

法典

编写提供程序(MVC 如何知道要使用什么绑定程序(

public class CustomBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }
        if (context.Metadata.ModelType == typeof(int[]) || context.Metadata.ModelType == typeof(List<int>))
        {
            return new BinderTypeModelBinder(typeof(CommaDelimitedArrayParameterBinder));
        }
        return null;
    }
}

编写实际的活页夹(访问有关请求，操作，模型，类型等的各种信息(

public class CommaDelimitedArrayParameterBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        var value = bindingContext.ActionContext.RouteData.Values[bindingContext.FieldName] as string;
        // Check if the argument value is null or empty
        if (string.IsNullOrEmpty(value))
        {
            return Task.CompletedTask;
        }
        var ints = value?.Split(',').Select(int.Parse).ToArray();
        bindingContext.Result = ModelBindingResult.Success(ints);
        if(bindingContext.ModelType == typeof(List<int>))
        {
            bindingContext.Result = ModelBindingResult.Success(ints.ToList());
        }
        return Task.CompletedTask;
    }
}

向 MVC 注册

services.AddMvc(options =>
{
    // add custom binder to beginning of collection
    options.ModelBinderProviders.Insert(0, new CustomBinderProvider());
});

使用记录良好的 Swagger 控制器的示例用法

/// <summary>
/// Deletes a list of items.
/// </summary>
/// <param name="itemIds">The list of unique identifiers for the  items.</param>
/// <returns>The deleted item.</returns>
/// <response code="201">The item was successfully deleted.</response>
/// <response code="400">The item is invalid.</response>
[HttpDelete("{itemIds}", Name = ItemControllerRoute.DeleteItems)]
[ProducesResponseType(typeof(void), StatusCodes.Status204NoContent)]
[ProducesResponseType(typeof(void), StatusCodes.Status404NotFound)]
public async Task Delete(List<int> itemIds)
=> await _itemAppService.RemoveRangeAsync(itemIds);

编辑：Microsoft建议通过这种方法为这些操作的孩子使用TypeConverter。因此，请遵循以下海报建议，并使用 SchemaFilter 记录您的自定义类型。

除了使用自定义模型绑定器，您还可以将自定义类型与类型转换器一起使用。

[TypeConverter(typeof(StrListConverter))]
public class StrList : List<string>
{
    public StrList(IEnumerable<string> collection) : base(collection) {}
}
public class StrListConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
    }
    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
    {
        if (value == null)
            return null;
        if (value is string s)
        {
            if (string.IsNullOrEmpty(s))
                return null;
            return new StrList(s.Split(','));
        }
        return base.ConvertFrom(context, culture, value);
    }
}

优点是它使 Web API 方法的参数非常简单。您甚至不需要指定 [FromUri]。

public IEnumerable<Category> GetCategories(StrList categoryIds) {
  // code to retrieve categories from database
}

此示例适用于字符串列表，但您可以执行categoryIds.Select(int.Parse)或直接编写 IntList。

我最初使用了@Mrchief多年的解决方案(效果很好(。但是当我将 Swagger 添加到我的 API 文档项目中时，我的终点没有出现。

我花了一段时间，但这就是我想出的。它适用于 Swagger，并且您的 API 方法签名看起来更干净：

最后，您可以做到：

    // GET: /api/values/1,2,3,4 
    [Route("api/values/{ids}")]
    public IHttpActionResult GetIds(int[] ids)
    {
        return Ok(ids);
    }

WebApiConfig.cs

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        // Allow WebApi to Use a Custom Parameter Binding
        config.ParameterBindingRules.Add(descriptor => descriptor.ParameterType == typeof(int[]) && descriptor.ActionDescriptor.SupportedHttpMethods.Contains(HttpMethod.Get)
                                                           ? new CommaDelimitedArrayParameterBinder(descriptor)
                                                           : null);
        // Allow ApiExplorer to understand this type (Swagger uses ApiExplorer under the hood)
        TypeDescriptor.AddAttributes(typeof(int[]), new TypeConverterAttribute(typeof(StringToIntArrayConverter)));
        // Any existing Code ..
    }
}

创建一个新类：逗号分隔数组参数绑定器.cs

public class CommaDelimitedArrayParameterBinder : HttpParameterBinding, IValueProviderParameterBinding
{
    public CommaDelimitedArrayParameterBinder(HttpParameterDescriptor desc)
        : base(desc)
    {
    }
    /// <summary>
    /// Handles Binding (Converts a comma delimited string into an array of integers)
    /// </summary>
    public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider,
                                             HttpActionContext actionContext,
                                             CancellationToken cancellationToken)
    {
        var queryString = actionContext.ControllerContext.RouteData.Values[Descriptor.ParameterName] as string;
        var ints = queryString?.Split(',').Select(int.Parse).ToArray();
        SetValue(actionContext, ints);
        return Task.CompletedTask;
    }
    public IEnumerable<ValueProviderFactory> ValueProviderFactories { get; } = new[] { new QueryStringValueProviderFactory() };
}

创建一个新类：StringToIntArrayConverter.cs

public class StringToIntArrayConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
    }
}

笔记：

• https://stackoverflow.com/a/47123965/862011 为我指明了正确的方向
• Swagger 仅在使用 [Route] 属性时未能选择逗号分隔的端点

public class ArrayInputAttribute : ActionFilterAttribute
{
    private readonly string[] _ParameterNames;
    /// <summary>
    /// 
    /// </summary>
    public string Separator { get; set; }
    /// <summary>
    /// cons
    /// </summary>
    /// <param name="parameterName"></param>
    public ArrayInputAttribute(params string[] parameterName)
    {
        _ParameterNames = parameterName;
        Separator = ",";
    }
    /// <summary>
    /// 
    /// </summary>
    public void ProcessArrayInput(HttpActionContext actionContext, string parameterName)
    {
        if (actionContext.ActionArguments.ContainsKey(parameterName))
        {
            var parameterDescriptor = actionContext.ActionDescriptor.GetParameters().FirstOrDefault(p => p.ParameterName == parameterName);
            if (parameterDescriptor != null && parameterDescriptor.ParameterType.IsArray)
            {
                var type = parameterDescriptor.ParameterType.GetElementType();
                var parameters = String.Empty;
                if (actionContext.ControllerContext.RouteData.Values.ContainsKey(parameterName))
                {
                    parameters = (string)actionContext.ControllerContext.RouteData.Values[parameterName];
                }
                else
                {
                    var queryString = actionContext.ControllerContext.Request.RequestUri.ParseQueryString();
                    if (queryString[parameterName] != null)
                    {
                        parameters = queryString[parameterName];
                    }
                }
                var values = parameters.Split(new[] { Separator }, StringSplitOptions.RemoveEmptyEntries)
                    .Select(TypeDescriptor.GetConverter(type).ConvertFromString).ToArray();
                var typedValues = Array.CreateInstance(type, values.Length);
                values.CopyTo(typedValues, 0);
                actionContext.ActionArguments[parameterName] = typedValues;
            }
        }
    }
    public override void OnActionExecuting(HttpActionContext actionContext)
    {
        _ParameterNames.ForEach(parameterName => ProcessArrayInput(actionContext, parameterName));
    }
}

用法：

    [HttpDelete]
    [ArrayInput("tagIDs")]
    [Route("api/v1/files/{fileID}/tags/{tagIDs}")]
    public HttpResponseMessage RemoveFileTags(Guid fileID, Guid[] tagIDs)
    {
        _FileRepository.RemoveFileTags(fileID, tagIDs);
        return Request.CreateResponse(HttpStatusCode.OK);
    }

请求 URI

http://localhost/api/v1/files/2a9937c7-8201-59b7-bc8d-11a9178895d0/tags/BBA5CD5D-F07D-47A9-8DEE-D19F5FA65F63,BBA5CD5D-F07D-47A9-8DEE-D19F5FA65F63

如果你想列出/整数数组，最简单的方法是接受逗号(，(分隔的字符串列表并将其转换为整数列表。不要忘记提到[FromUri] attriubte.your url看起来像：

...？ID=71&帐户ID=1,2,3,289,56

public HttpResponseMessage test([FromUri]int ID, [FromUri]string accountID)
{
    List<int> accountIdList = new List<int>();
    string[] arrAccountId = accountId.Split(new char[] { ',' });
    for (var i = 0; i < arrAccountId.Length; i++)
    {
        try
        {
           accountIdList.Add(Int32.Parse(arrAccountId[i]));
        }
        catch (Exception)
        {
        }
    }
}

我创建了一个自定义模型绑定器，它将任何逗号分隔的值(仅原始、十进制、浮点数、字符串(转换为相应的数组。

public class CommaSeparatedToArrayBinder<T> : IModelBinder
    {
        public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            Type type = typeof(T);
            if (type.IsPrimitive || type == typeof(Decimal) || type == typeof(String) || type == typeof(float))
            {
                ValueProviderResult val = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
                if (val == null) return false;
                string key = val.RawValue as string;
                if (key == null) { bindingContext.ModelState.AddModelError(bindingContext.ModelName, "Wrong value type"); return false; }
                string[] values = key.Split(',');
                IEnumerable<T> result = this.ConvertToDesiredList(values).ToArray();
                bindingContext.Model = result;
                return true;
            }
            bindingContext.ModelState.AddModelError(bindingContext.ModelName, "Only primitive, decimal, string and float data types are allowed...");
            return false;
        }
        private IEnumerable<T> ConvertToDesiredArray(string[] values)
        {
            foreach (string value in values)
            {
                var val = (T)Convert.ChangeType(value, typeof(T));
                yield return val;
            }
        }
    }

以及如何在控制器中使用：

 public IHttpActionResult Get([ModelBinder(BinderType = typeof(CommaSeparatedToArrayBinder<int>))] int[] ids)
        {
            return Ok(ids);
        }

我以这种方式解决了这个问题。

我使用向 api 发送的帖子消息将整数列表作为数据发送。

然后，我将数据作为 ienumerable 返回。

发送代码如下：

public override IEnumerable<Contact> Fill(IEnumerable<int> ids)
{
    IEnumerable<Contact> result = null;
    if (ids!=null&&ids.Count()>0)
    {
        try
        {
            using (var client = new HttpClient())
            {
                client.BaseAddress = new Uri("http://localhost:49520/");
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                String _endPoint = "api/" + typeof(Contact).Name + "/ListArray";
                HttpResponseMessage response = client.PostAsJsonAsync<IEnumerable<int>>(_endPoint, ids).Result;
                response.EnsureSuccessStatusCode();
                if (response.IsSuccessStatusCode)
                {
                    result = JsonConvert.DeserializeObject<IEnumerable<Contact>>(response.Content.ReadAsStringAsync().Result);
                }
            }
        }
        catch (Exception)
        {
        }
    }
    return result;
}

接收代码如下：

// POST api/<controller>
[HttpPost]
[ActionName("ListArray")]
public IEnumerable<Contact> Post([FromBody]IEnumerable<int> ids)
{
    IEnumerable<Contact> result = null;
    if (ids != null && ids.Count() > 0)
    {
        return contactRepository.Fill(ids);
    }
    return result;
}

它适用于一条记录或多条记录。 填充是使用 DapperExtensions 的重载方法：

public override IEnumerable<Contact> Fill(IEnumerable<int> ids)
{
    IEnumerable<Contact> result = null;
    if (ids != null && ids.Count() > 0)
    {
        using (IDbConnection dbConnection = ConnectionProvider.OpenConnection())
        {
            dbConnection.Open();
            var predicate = Predicates.Field<Contact>(f => f.id, Operator.Eq, ids);
            result = dbConnection.GetList<Contact>(predicate);
            dbConnection.Close();
        }
    }
    return result;
}

这允许您从复合表(id 列表(中获取数据，然后从目标表中返回您真正感兴趣的记录。

您可以对视图执行相同的操作，但这为您提供了更多的控制和灵活性。

此外，查询字符串中不会显示从数据库中查找的内容的详细信息。 您也不必从csv文件转换。

在使用任何工具(如 Web api 2.x 接口(时，您必须记住，获取、放置、发布、删除、头等函数具有一般用途，但不限于该用途。

因此，虽然 post 通常用于 Web api 界面的创建上下文中，但它不限于该用途。 它是一个常规的 html 调用，可用于 html 实践允许的任何目的。

此外，正在发生的事情的细节隐藏在我们这些天经常听到的那些"窥探者"之外。

api 2.x 界面中命名约定的灵活性和常规 Web 调用的使用意味着您可以向 Web API 发送调用，误导窥探者认为您真的在做其他事情。 例如，您可以使用"POST"来真正检索数据。

创建方法类型 [HttpPost]，创建一个具有一个 int[] 参数的模型，并使用 json 发布：

/* Model */
public class CategoryRequestModel 
{
    public int[] Categories { get; set; }
}
/* WebApi */
[HttpPost]
public HttpResponseMessage GetCategories(CategoryRequestModel model)
{
    HttpResponseMessage resp = null;
    try
    {
        var categories = //your code to get categories
        resp = Request.CreateResponse(HttpStatusCode.OK, categories);
    }
    catch(Exception ex)
    {
        resp = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex);
    }
    return resp;
}
/* jQuery */
var ajaxSettings = {
    type: 'POST',
    url: '/Categories',
    data: JSON.serialize({Categories: [1,2,3,4]}),
    contentType: 'application/json',
    success: function(data, textStatus, jqXHR)
    {
        //get categories from data
    }
};
$.ajax(ajaxSettings);

或者你可以只传递一串分隔的项目，并将其放入接收端的数组或列表中。

我的解决方案是创建一个属性来验证字符串，它执行了一系列额外的常见功能，包括正则表达式验证，您可以仅使用它来检查数字，然后我根据需要转换为整数...

这是您使用的方式：

public class MustBeListAndContainAttribute : ValidationAttribute
{
    private Regex regex = null;
    public bool RemoveDuplicates { get; }
    public string Separator { get; }
    public int MinimumItems { get; }
    public int MaximumItems { get; }
    public MustBeListAndContainAttribute(string regexEachItem,
        int minimumItems = 1,
        int maximumItems = 0,
        string separator = ",",
        bool removeDuplicates = false) : base()
    {
        this.MinimumItems = minimumItems;
        this.MaximumItems = maximumItems;
        this.Separator = separator;
        this.RemoveDuplicates = removeDuplicates;
        if (!string.IsNullOrEmpty(regexEachItem))
            regex = new Regex(regexEachItem, RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase);
    }
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var listOfdValues = (value as List<string>)?[0];
        if (string.IsNullOrWhiteSpace(listOfdValues))
        {
            if (MinimumItems > 0)
                return new ValidationResult(this.ErrorMessage);
            else
                return null;
        };
        var list = new List<string>();
        list.AddRange(listOfdValues.Split(new[] { Separator }, System.StringSplitOptions.RemoveEmptyEntries));
        if (RemoveDuplicates) list = list.Distinct().ToList();
        var prop = validationContext.ObjectType.GetProperty(validationContext.MemberName);
        prop.SetValue(validationContext.ObjectInstance, list);
        value = list;
        if (regex != null)
            if (list.Any(c => string.IsNullOrWhiteSpace(c) || !regex.IsMatch(c)))
                return new ValidationResult(this.ErrorMessage);
        return null;
    }
}

我只是在请求的属性中添加了查询键(Refit lib(。

[Query(CollectionFormat.Multi(]

public class ExampleRequest
{
       
        [FromQuery(Name = "name")]
        public string Name { get; set; }               
       
        [AliasAs("category")]
        [Query(CollectionFormat.Multi)]
        public List<string> Categories { get; set; }
}

所有其他解决方案都需要太多的工作。我试图在HttpGet方法参数中使用IEnumerable<long>或long[]，但我认为仅仅为了使处理程序方法参数的签名long[]而做所有工作是没有意义的。我最终只是将其设置为字符串，然后在处理程序中将其分开。带了我一条线。

public async Task<IActionResult> SomeHandler(string idsString)
{
    var ids = idsString.Split(',').Select(x => long.Parse(x));

现在你可以传递数字，比如

.../SomeHandler?idsString=123,456,789,012