C# function parameter Array vs List

Question

I'm writing a simple C# class that handle SQL queries in a specific contest. Most of the queries will be SELECT statement with 3-4 parameters that should be escaped properly, so the function will be something like this

public DataTable Select(string query, string[] parameters) {
    # some code
}

Should parameters be an Array or a List<>? Is there some best practice when choosing between these two types as function parameter or is it just a matter of preferences?

P.S. I usually prefer List<> because of the flexibility but here the possibility to create an Array on the fly is a good point.

If there is any manipulation of the parameters I would go with a List as resizing arrays is expensive. If no resizing is necessary i would stick with an array. — Chris Hawkes, Apr 27 '15 at 12:41
my advice : dont write this kind of generic data access stuff. its a waste of time. etiher make a db specifc repository which returns your objects or use the system.data generic data stuff — Ewan, Apr 27 '15 at 13:04

Sayse · Accepted Answer · 2015-04-27T12:54:54.627

14

You should use IEnumerable, then it can be either since both list and array implement this

public DataTable Select(string query, IEnumerable<string> parameters)

They also both implement IList and ICollection, which may offer other useful properties as shown by Tim Schmelter in the comments

edited Apr 27 '15 at 12:54

answered Apr 27 '15 at 12:41

Sayse

42,633
14
77
146

4

IEnumerable you mean – Rodrigo López Apr 27 '15 at 12:42
Hmm, possibly it depends on what the OP wants to restrict to, Possibly `IEnumerable` too, Thanks – Sayse Apr 27 '15 at 12:43
3

If he wants to include only arrays or lists as mentioned he should use `IList`. Then you can still access them by index without casting and use the `Count` property(yes, array has). – Tim Schmelter Apr 27 '15 at 12:44
@TimSchmelter - Thanks, I've updated my answer to reflect your comment. – Sayse Apr 27 '15 at 12:55
Warning: Using IEnumerable can result in unexpected behaviour. See: https://www.jetbrains.com/help/resharper/PossibleMultipleEnumeration.html – Marc van Nieuwenhuijzen Oct 28 '21 at 13:50

dcastro · Answer 2 · 2015-04-27T13:01:39.793

According to the Robustness principle, or Postel's law (emphasis mine):

Be conservative in what you do, be liberal in what you accept from others

In other words, use the "broadest" type possible, the one higher up in the inheritance hierarchy, so as to:

demand as little as possible from the user,
and give the user as many choices as possible.

In this case:

if all you need to do is iterate through the collection of parameters, then you should demand from the user an instance of a type that can be iterated: which, in this case, is IEnumerable<T>.
If you needed to add/remove items, then ICollection<T> would be the most liberal option
If, for some reason, you need to access items by index, then you should demand a IList<T>.

score 2 · Answer 3 · answered Apr 27 '15 at 12:52

On top of what nvoig said, I would:

public DataTable Select(string query, params string[] parameters)
{
    return Select(query, (IEnumerable<string>)parameters);
}

public DataTable Select(string query, IEnumerable<string> parameters)
{
    return null;
}

so that if you have a "static" query, you can use the first overload (because you know at compile time the number of parameters), while if you have a "dynamic" query you can use the second overload with a string[] or a List<string> or the result of a LINQ expression.

score 1 · Answer 4 · answered Apr 27 '15 at 12:47

Personally, I would expect at least one overload that grants me the ability to pass a params array:

public DataTable Select(string query, params string[] parameters);

That would allow me to call it with parameters like this:

Select("SELECT FROM WHERE", "3", "17", "Joe");

Anyone having an IEnumerable<> could pass it in easily, too:

Select("SELECT FROM WHERE", myData.ToArray());

Better would be an overload doing this for me.

score 0 · Answer 5 · answered Apr 27 '15 at 12:45

In general I would use IEnumerable<T> if you only read from the sequence.

In this particular context however I'd simply use a params string[] or even params object[] type since then you can use it like String.Format, i.e.

var dt = Select("select A from Table where X=? and Y=?", value1, value2);

score 0 · Answer 6 · answered Apr 27 '15 at 12:46

0

If your parameters have all the same type (here string) you can use params keyword with string array.

public DataTable Select(string query, params string[] parameters)

Thus you can call it like below

Select(myQuery, param1, param2, ...);

answered Apr 27 '15 at 12:46

csblo

1,571
13
20

C# function parameter Array vs List

6 Answers6