Question: Suppose I have a method that returns an array or list or some other collection. If something goes wrong inside or when there is simply no data to return, what is better - to return null or to return array (list, etc.) that has length (count) equal to 0?

In fact is it important, or it is just a matter of developer's preferences?

Answer: 
It's better to return an empty collection. This way when someone calls the function like so:

```
foreach(var i in items)
{

}

```

it doesn't throw a null reference exception on them.

Technically, you could argue empty vs. `null` means, but in reality a lot of people (myself included at times) forget to be defensive and don't check to see if the object is null before using it. It's playing into what other people assume is going to happen, which means less bugs and less angry users.
Although I'd say it's mostly a matter of developer's preference, to return an empty collection might be a better approach.

Let's say you have an object which contains a collection member.

```
public class Customer {
    private IList<Order> _orders;

    public Customer() {
        _orders = new List<Order>();
    }

    public IList<Order> Orders {
        get {
            return _orders;
        } 
    }
}

```

One generally will prefer to have this member as a readonly property so that its customer's orders don't get lost without any apparent reason. So, returning `null` is not an option. You would likely work better with an empty collection than a null reference. As such, instantiating the collection within the class constructor is a better approach.

And most importantly, when using DataBinding, for instance, you might get strange behaviour when returning null collection reference, as it will best work with an empty collection instead.

Another example, when iterating through a collection such as:

```
foreach (Order o in c.Orders) {
    // Do something here...
}

```

This `foreach` loop will simply not get executed when the collection is empty, without you having to check whether it is a null reference first. It simplifies the code and minimizes its complexity.

This depends on the scenario you're wokring in.