Übergabe eines Arrays von Ganzzahlen an ASP.NET Web API?

Question

Ich habe einen ASP.NET Web API (Version 4) REST-Dienst, wo ich ein Array von Ganzzahlen übergeben müssen.

Hier ist meine Aktionsmethode:

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

Und dies ist die URL, die ich ausprobiert habe:

/Categories?categoryids=1,2,3,4

Answer 1

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));
    }
}

Verwendung:

    [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);
    }

Anfrage uri

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

Answer 2

Wenn Sie wollen, Liste / Array von Integer einfachste Weg, dies zu tun ist, akzeptieren Sie die Komma(,) getrennte Liste von String und konvertieren Sie es in eine Liste von integers.do nicht vergessen zu erwähnen, [FromUri] attriubte.your url aussehen wie:

...?ID=71&accountID=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)
        {
        }
    }
}

Answer 3

Machen Sie die Methode Typ [HttpPost], erstellen Sie ein Modell, das einen int[]-Parameter hat, und post mit 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);

Answer 4

Oder Sie können einfach eine Zeichenkette mit abgegrenzten Elementen übergeben und diese in ein Array oder eine Liste auf der Empfängerseite einfügen.

Answer 5

Ich habe dieses Thema auf diese Weise angesprochen.

Ich habe eine Postnachricht an die API verwendet, um die Liste der Ganzzahlen als Daten zu senden.

Dann habe ich die Daten als ienumerable zurückgegeben.

Der Sendecode lautet wie folgt:

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;
}

Der Empfangscode lautet wie folgt:

// 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;
}

Es funktioniert sowohl für einen als auch für mehrere Datensätze. Das Füllen ist eine überladene Methode mit 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;
}

Auf diese Weise können Sie Daten aus einer zusammengesetzten Tabelle (der id-Liste) abrufen und dann die Datensätze, an denen Sie wirklich interessiert sind, aus der Zieltabelle zurückgeben.

Sie könnten dasselbe mit einer Ansicht tun, aber das gibt Ihnen ein wenig mehr Kontrolle und Flexibilität.

Außerdem werden die Einzelheiten der Abfrage aus der Datenbank nicht im Abfragetext angezeigt. Sie müssen auch nicht aus einer csv-Datei konvertieren.

Bei der Verwendung von Werkzeugen wie der Web-Api 2.x-Schnittstelle ist zu beachten, dass die Funktionen get, put, post, delete, head usw. einen allgemeinen Zweck haben, aber nicht auf diesen beschränkt sind.

Obwohl post im Allgemeinen in einem Erstellungskontext in der Web-Api-Schnittstelle verwendet wird, ist es nicht auf diese Verwendung beschränkt. Es ist ein regelmäßig html-Aufruf, der für jeden nach der html-Praxis zulässigen Zweck verwendet werden kann.

Außerdem werden die Einzelheiten der Vorgänge vor den "neugierigen Augen" verborgen, von denen man heutzutage so viel hört.

Die Flexibilität der Namenskonventionen in der Web-Api-2.x-Schnittstelle und die Verwendung regulärer Webaufrufe bedeutet, dass Sie einen Aufruf an die Web-Api senden, der Schnüfflern vorgaukelt, Sie würden in Wirklichkeit etwas anderes tun. Sie können z. B. "POST" verwenden, um wirklich Daten abzurufen.