19

I have a function which returns a variable number of elements, should I return an array or a List? The "collection's" size does not change once returned, ie for all purposes the collection is immutable. I would think to just return an array, but some people have said to not return variable sized arrays from a function as it is "poor form". Not sure why?

Does it matter that this needs to be .NET 2.0 compliant?

Improve this question
3
  • Why are arrays in C# evil? I know that in C/C++ they are evil, cause an array and a pointer are the same Commented Aug 13, 2009 at 22:17
  • 2
    have you seen this? stackoverflow.com/questions/434761/… Commented Aug 13, 2009 at 22:17
  • 2
    I hate the term "X programming construct is evil", it used far too often. Arrays are not preferred because they can be error prone to work with and they provide less abstraction between you and the implementation. Honestly, in C# many of the problems inherent in C++ arrays disappear, but a IList<T> ( or some other collection) is a nicer, higher level interface. Commented Aug 13, 2009 at 22:19

7 Answers 7

Reset to default
26

It's bad form to return arrays if not needed, and especially to return List<T>.

Usually, you'll want to return IEnumerable<T> or IList<T>.

If your user is going to just need to run through each element, IEnumerable<T> will provide this capability. It also allows you to potentially implement the routine (now or later) using deferred execution.

If your user needs to access elements by index, return IList<T>. This provides all of the benefits of arrays, but gives you more flexibility in your implementation. You can implement it as an array, a list, or some other collection that implements IList<T>, and you don't have to convert/copy to an array.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

I went with List<T> because the ConvertAll function was really handy in this case.
Can I get the length of an IEnumerable type?
List<T> is against the design guidelines. LINQ provides means of getting counts and casting, for IEnumerable<T> and IList<T>.
The problem with List<T> being returned is that List<T> should be an implementation detail, not a concrete part of your interface itself. IList<T> provides all of the API-level functionality of a list, but is much cleaner to return.
9

One opinion I see pretty often a suggestion to return either IList<T> or ReadOnlyCollection<T>. It's OK to return these if you have one of these available - both can be assigned directly to an IEnumerable<T> (they work directly with any LINQ methods). One thing to note is ReadOnlyCollection<T> is a very lightweight type that can wrap any IList<T>.

Improve this answer

Comments

5

Expanding on Reed's answer.

Eric Lippert did a great blog post on this very subject. It's got probably the most detailed answer available

Improve this answer

1 Comment

Link dead, available at https://learn.microsoft.com/en-us/archive/blogs/ericlippert/arrays-considered-somewhat-harmful
3

Return IEnumerable unless you need:

  1. access Count - then return IReadOnlyCollection.
  2. modify elements and Count is less the ArrayList.Capacity - then return array.
  3. add new elements - then return list.
  4. some microoptimizations - do benchmark. E.g. foreach over array is quicker then over the list

BenchmarkDotNet=v0.10.8, OS=Windows 10 Redstone 1 (10.0.14393) Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4 Frequency=3233538 Hz, Resolution=309.2588 ns, Timer=TSC [Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0 Clr : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0 Core : .NET Core 4.6.25211.01, 64bit RyuJIT

 Method | Job | Runtime | Mean | Error | StdDev | Min | Max | Median | Rank | Allocated | ---------- |----- |-------- |-----------:|-----------:|----------:|-----------:|-----------:|-----------:|-----:|----------:| TestList | Clr | Clr | 5,153.3 ns | 34.002 ns | 31.806 ns | 5,119.2 ns | 5,213.4 ns | 5,135.9 ns | 3 | 0 B | TestArray | Clr | Clr | 730.1 ns | 6.962 ns | 6.512 ns | 722.4 ns | 743.9 ns | 729.5 ns | 2 | 0 B | TestList | Core | Core | 5,188.4 ns | 102.816 ns | 96.174 ns | 5,070.3 ns | 5,342.6 ns | 5,185.6 ns | 3 | 0 B | TestArray | Core | Core | 709.0 ns | 6.126 ns | 5.730 ns | 700.8 ns | 718.6 ns | 708.1 ns | 1 | 0 B |

Code: 

[RankColumn, MinColumn, MaxColumn, StdDevColumn, MedianColumn] [ClrJob, CoreJob] [HtmlExporter, MarkdownExporter] [MemoryDiagnoser] public class BenchmarkForEach { List<string> testData = new List<string>(); string[] testArray; public BenchmarkForEach() { for(int i=0;i<1000;i++) { testData.Add(i.ToString()); } testArray = testData.ToArray(); } [Benchmark] public int TestList() { var x = 0; foreach(var i in testData) { x += i.Length; } return x; } [Benchmark] public int TestArray() { var x = 0; foreach (var i in testArray) { x += i.Length; } return x; } }
Improve this answer

Comments

1

As you've undoubtedly seen from the answers in this thread, opinions on this subject range wide.

In general, my thoughts are the following:

If I am returning a list whose size is constant and I don't want the caller to be able to modify my data (which is 99% of the time), I'll return a ReadOnlyCollection<T>. This gives me immutability on the client side without having to double (or triple, or whatever) the memory footprint of my data in creating a new list or an array.

I hesitate to say that "you should always return IEnumerable or IEnumerable<T>". While this is certainly appropriate in some cases (and these cases aren't few), the lightweight nature of the IEnumerable interface greatly limits your functionality (no index-based retrieval being the biggest), and in many cases the underlying source of data is going to be an array anyway, even if it's a List<T>.

An additional danger of returning IEnumerable comes from the lazy practice of simply returning the inner list in the context of that interface. Doing that exposes you to the calling method abusing this shortcut by casting it back to the more robust collection type. A good, defensive programmer won't do this.

The lowest memory footprint comes from using a ReadOnlyCollection built from a List. A ReadOnlyCollection does still expose you to danger through reflection-based abuse and capturing a reference to the mutable list, but that's a bit of a fringe case.

Improve this answer

3 Comments

"...exposes you to the calling method abusing this shortcut by casting it back to the more robust collection type. A good, defensive programmer won't do this." Hogwash. The library's responsibility is to create a clear interface for the client. The library's reponsibility isn't to anticipate the client basing his code on the library's internals. By using IEnumerable<T>, you're telling the client that all you guarantee is that he'll get a list of items that he can go through. If he casts back to your internal type, it's his fault, not yours, if his code breaks with a future version.
@Kyralessa: Defensive programming is writing code that's designed in such a way as to eliminate (or, more realistically, limit) the potential for abuse by a caller. Casting is a common, necessary aspect of development, and downplaying this danger is foolhardy. The situation that I describe is a very large part of why ReadOnlyCollection<T> exists, as it's a NEW instance that points to the same object, rather than viewing the same object through a different interface.
Well, you can always get the best of both worlds: Return a ReadOnlyCollection<T>, but have your method actually typed as an IEnumerable<T>. Then you're only guaranteeing the enumerability, but if they cast it to an IList<T> or something, it still won't let them modify it due to the way IList<T> is implemented in ReadOnlyCollection<T>.
0

If the size of the collection is not to change after being returned IEnumerable<T> would be my choice, since the caller could then use LINQ extension methods with the list immediately.

Improve this answer

Comments

0

It is easy to get an array from an IList if an array is what you need, but the reverse is not true. So returning an IList is preferable.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.