循环（可选）方法参数

Question

I'm writing a simple library, which provides access to a REST Webservice which has multiple optional parameters.

Sample URL:
http://localhost/doSomething?a=a&b=b&c=c

So my starting point is a method with optional parameters. Something like this:

public byte[] DoSomething(string a = null, string b = null, string c = null)
{
    string query = "doSomething";
    //Get Parameters
    if (a != null)
    {
        //Handle first ?
        query = String.Format("{0}&{1}={2}", query, "a", a);
    }
    [...]
}

You can imagine, this leads to a long method, IF you have a lot of parameters. One way to reduce the code size would be to add every parameter to a collection:

public byte[] DoSomething(string a = null, string b = null, string c = null)
{
    string query = "doSomething";
    var parameters = new Dictionary<string, string> {{"a", a}, {"b", b}, {"c", c}};
    foreach (var parameter in parameters)
    {
        if (!String.IsNullOrEmpty(parameterPair.Value))
        {
            //Handle first ?
            query = String.Format("{0}&{1}={2}", query, parameter.Key, parameter.Value);
        }
    }
    [...] 
}

This is a bit more suiteable, but I'm curious if there's a better method to solve such a problem without creating long if statements or manually creating a collection.

Answer 1

This is an option:

public byte[] DoSomething(Tuple<string,string>[] kvp)
{
 ...
}

Answer 2

One way is to use an anonymous type and reflection, like this:

public byte[] DoSomething(string a = null, string b = null, string c = null)
{
    var p = new { a, b, c };
    var parts = from property in p.GetType().GetProperties()
                let value = property.GetValue(p) as string
                where !string.IsNullOrEmpty(value)
                select string.Format("{0}={1}", property.Name, value);

    var query = "?" + string.Join("&", parts);

    [...]
}

Answer 3

Here's an example using params :

byte[] DoSomething(params KeyValuePair<string, string>[] parameters)
{
    var builder = new StringBuilder();
    for (int i = 0; i < parameters.Length; i++)
    {
        builder.AppendFormat("{0}={1}", parameters[i].Key, parameters[i].Value);
        if (i != parameters.Length - 1)
        {
            builder.Append("&");
        }
    }
    string urlParams = builder.ToString(); // contains "param1=value1&param2=value2"
    ...
}

And here's how to use it:

DoSomething(new[] { 
                    new KeyValuePair<string, string>("param1", "value1"), 
                    new KeyValuePair<string, string>("param2", "value2"), 
                    });

Answer 4

Based on the answers of T McKeown, Nasreddine and John Gibb I came up with a "ParameterModel". There are WebService Methods, which have basicly the same parameters + some additional ones, so I came up this way to use inheritance.

public class BaseABCModel
{
    public string A { get; set; }
    public string B { get; set; }
    public string C { get; set; }

    public BaseABCModel(string a = null, string b = null, string c = null)
    {
        A = a;
        B = b;
        C = c;
    }

    public Dictionary<string, string> GetParameters()
    {
        return GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)
       .ToDictionary(propertyInfo => propertyInfo.Name, propertyInfo => 
       (String) propertyInfo.GetValue(this));
    }
}


//Methods:
public byte[] DoSomething(BaseABCModel model)
{
    string query = GetQuery("doSomething", model.GetParameters())
}


public string GetQuery(string methodName, Dictionary<string, string> parameters)
{
    string parameterString = parameters.Where(parameter => !String.IsNullOrEmpty(parameter.Value))
    .Aggregate(String.Empty, (current, parameter) => String.Format(
    String.IsNullOrEmpty(current) ? "{0}?{1}={2}" : "{0}&{1}={2}",
    current, parameter.Key, parameter.Value));

    return methodName + parameterString;
}

Answer 5

Here is what I came up with. I was messing around with the idea of not doing the a = null, b = null params.

        public byte[] mainoutput(string text)
    {

        byte[] retval = null;

        char[] delimeterChars = { '?' };

        string[] newparsm = text.Split(delimeterChars);
        string query = "";
        int count = 0;

        foreach (string s in newparsm)
        {
            count += 1;

            if (s.Length > 2)
            {
                if (count == 1)
                {
                    query = query + "?" + s;
                }
                else
                {
                    query = query + "&" + s;
                }
            }

        }
        Console.WriteLine(query);

        return retval;

    }