Comportamento previsto quando una richiesta per una raccolta avrà zero elementi

Diciamo che ti viene dato il seguente ...

List<Thing> theThings = fubar.Things.All();

Se non ci fosse nulla da restituire, cosa ti aspetteresti da restituire fubar.Things.All ()?

Modifica: grazie per le opinioni. Aspetterò un po 'e accetterò l'ingresso con il maggior numero di up.

Sono d'accordo con le risposte finora, in particolare quelle che suggeriscono una raccolta vuota. Un fornitore ha fornito a un'API diverse chiamate simili all'esempio precedente. Un fornitore che ha realizzato entrate per $ 4,6 milioni l'anno scorso tramite le loro API, BTW. Fanno qualcosa che fondamentalmente non sono d'accordo - lanciano un'eccezione.

Delle due possibilità (cioè restituire una nullo restituire una raccolta vuota) sceglierei di restituire una raccolta vuota, perché consente al chiamante di saltare un controllo del valore restituito. Invece di scrivere questo

List<Thing> theThings = fubar.Things.All();
if (theThings != null) {
    for (Thing t : theThings) {
        t.doSomething();
    }
}

sarebbero in grado di scrivere questo:

List<Thing> theThings = fubar.Things.All();
for (Thing t : theThings) {
    t.doSomething();
}

Questo secondo frammento di codice è più breve e più facile da leggere, poiché il livello di annidamento è inferiore di uno.

Mi aspetterei un elenco vuoto. theThingssarebbe ancora un oggetto, ma theThings.Counto theThings.size()ritornerebbe 0.

Problemi di progettazione del genere vengono risolti dal modello Null Object

... Invece di utilizzare un riferimento null per comunicare l'assenza di un oggetto (ad esempio un cliente inesistente), si utilizza un oggetto che implementa l'interfaccia prevista, ma il cui corpo del metodo è vuoto. Il vantaggio di questo approccio rispetto a un'implementazione predefinita funzionante è che un oggetto null è molto prevedibile e non ha effetti collaterali: non fa nulla.

Ad esempio, una funzione può recuperare un elenco di file in una directory ed eseguire alcune azioni su ciascuno di essi. Nel caso di una directory vuota, una risposta potrebbe essere quella di generare un'eccezione o restituire un riferimento null anziché un elenco. Pertanto, il codice che prevede un elenco deve verificare che in realtà ne abbia uno prima di continuare, il che può complicare la progettazione ...

Suggerimento particolarmente applicabile nel tuo caso (che ritorna Listquando non ci sono Thing) è:

... Restituendo invece un oggetto null (cioè un elenco vuoto ), non è necessario verificare che il valore restituito sia in realtà un elenco. La funzione di chiamata può semplicemente iterare l'elenco normalmente, senza fare nulla. Tuttavia, è ancora possibile verificare se il valore restituito è un oggetto null (ad esempio un elenco vuoto) e reagire in modo diverso se lo si desidera.

Dovresti, IMHO, restituire un valore VUOTO. Non so di C #, ma in Java abbiamo questo:

  List list = Collections.EMPTY_LIST;
  Set set = Collections.EMPTY_SET;
  Map map = Collections.EMPTY_MAP;

  // For the type-safe 
  List<String> s = Collections.emptyList();
  Set<Long> l = Collections.emptySet();
  Map<Date> d = Collections.emptyMap();

http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Collections.html

Vorrei restituire una raccolta vuota rispetto alla restituzione di un valore null perché in questo modo è possibile evitare di scrivere una verifica null nel codice chiamante.

Le due soluzioni significano cose diverse.

Se ci sono solo zero delle cose che stai restituendo, restituisci SEMPRE una raccolta vuota! Prendi il caso di un elenco di directory. Se non ci sono file nella directory, si restituisce una raccolta vuota di file.

D'altra parte, se la directory non esiste, non è proprio appropriato. "Non posso restituire nulla" significa qualcosa di completamente diverso. In tal caso, è necessario restituire null o generare un'eccezione a seconda della situazione, non restituire una raccolta vuota come se nulla fosse sbagliato.