How To Pass An Array As A Parameter While Calling an ASP.NET Web API

Through this blog, I would like to share how to pass an array as a parameter, while calling an ASP.NET Web API.

Thus, let's begin by creating the same. This blog is strictly to comprehend how to pass an array as parameter while calling ASP.NET Web API.

Consider that you want to perform some basic operation like Addition, Multiplication etc. by passing two or more parameters. However, the number of parameters is not specific.

We will create a method, which will accept three parameters. An input is mandatory for performing the operation while another would be an optional array. 

public class BasicOperationPerform : BasicOperationBase
    {


        public override double PerformOperation(string operation, double n1, double n2, params double[] nn)
        {
            double result = 0;
            if (operation == "ADD")
            {
                Addition add = new Addition();
                double totaladdition = add.GetAddition(n1, n2, nn);
                result = totaladdition;
            }
            else if (operation == "SUB")
            {
                Subtraction add = new Subtraction();
                double totalsubtraction = add.GetSubtraction(n1, n2, nn);
                result = totalsubtraction;
            }
            else if (operation == "MUL")
            {
                Multiplication add = new Multiplication();
                double totalMultiplication = add.GetMultiplication(n1, n2, nn);
                result = totalMultiplication;
            }
            else if (operation == "DIV")
            {
                Division add = new Division();
                double totaladdition = add.GetDivision(n1, n2, nn);
                result = totaladdition;
            }


            return result;
        }

Now, let us create an APIController and observe whether the implemented stuff is sufficient for the requirement or not.

public class BasicOperationController : ApiController
   {
       [HttpGet]
       [Route("api/GetBasicOperationResult/{operation}/{n1}/{n2}/{nn}")]
       public IHttpActionResult GetBasicOperationResult(string operation, double n1, double n2, [FromUri]double[] nn = null)
       {
           BasicOperationPerform bop = new BasicOperationPerform();
           double result = bop.PerformOperation(operation, n1, n2, nn);

           return Ok(result);
       }
   }

There are two things which need to be implemented in this code block.

1. The nn parameter is optional. Thus, we need to add ? behind the nn in route as {nn?} to make it optional.
   
   
2. How will we pass an array in the URL and the same would be accepted by the method. The best option to deal with it is create a Custom Action Filter attribute, which will filter the URL by a specific separator, as shown below. 

Thus, we will create an ArrayInputAttribute and override OnActionExecuting method for processing the input URL.

 

public class ArrayInputAttribute : ActionFilterAttribute
    {
        private readonly string[] _parameternames;

        public string Separator { get; set; }


        public ArrayInputAttribute(params string[] parameternames)
        {
            _parameternames = parameternames;
            Separator = "-";
        }



        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)
        {

            foreach (var parameterName in _parameternames)
            {
                ProcessArrayInput(actionContext, parameterName);
            }
        }
    }

Note

We have used "-" as a separator.

Now, we are having the filter, which can be applied to the URL input and can transform to an array.

Thus, our method can be updated, as shown.

[HttpGet]
        [ArrayInput("nn")]
        [Route("api/GetBasicOperationResult/{operation}/{n1}/{n2}/{nn?}")]
        public IHttpActionResult GetBasicOperationResult(string operation, double n1, double n2, [FromUri]double[] nn = null)
        {
            BasicOperationPerform bop = new BasicOperationPerform();
            double result = bop.PerformOperation(operation, n1, n2, nn);

            return Ok(result);
        }

Note

We have updated the method with the following.

1. [ArrayInput("nn")]
2. [Route("api/GetBasicOperationResult/{operation}/{n1}/{n2}/{nn?}")]

Now, we can call the Web API by passing the URL, as shown below.

"/api/GetBasicOperationResult/ADD/10/10/10-10-10".

Finally, there can be some other method also for dealing with it