Passando array funzione che prende sia oggetto params [] o IEnumerable <T>

Question

voglio passare un array di oggetti personalizzati per una funzione come String.Join che ha le seguenti firme:

• public static string Join(string separator, params Object[] values)
• public static string Join(string separator, IEnumerable<T> values)

Se io chiamo la funzione come questa:

var arr = new MyClass[]{ new MyClass(), new MyClass() }; 
string text = string.Join("\n", arr); 

ottengo un errore di compilazione:

The call is ambiguous between the following methods or properties: 'string.Join(string, params object[])' and 'string.Join(string, System.Collections.Generic.IEnumerable)'

posso risolvere l'ambiguità utilizzando la funzione IEnumerable<T>:

var arr = new MyClass[]{ new MyClass(), new MyClass() }; 
string text = string.Join<MyClass>("\n", arr); 

Ma posso chiamare la funzione params object[]? In uno scenario di prestazioni critiche, sarebbe preferibile accedere direttamente alla matrice piuttosto che tramite un enumeratore.

Sto usando C# 4.0, se questo fa alcuna differenza.

Answer 1

Se si passa un object[] come secondo parametro, il compilatore deve scegliere il sovraccarico object[] poiché corrisponde esattamente. Nel caso in cui si dispone di un array diverso digitato (MyClass[] in questo caso) solo lanciare l'array object[]:

string.Join("\n", (object[])arr); 

non sono in realtà cambiando il tipo di oggetti o eseguire alcuna conversione in fase di esecuzione, è' sto solo dando al compilatore un suggerimento su quale sovraccarico usare.

E per quanto riguarda il commento sulle prestazioni, non dimenticare di confrontare entrambe le opzioni se le prestazioni sono così importanti. Non dare per scontato che uno sia più veloce dell'altro. (E sempre il profilo l'intera applicazione - è probabile che eventuali colli di bottiglia stanno per essere altrove.)

Answer 2

Se si cambia il tipo di variabile arr-object[] si chiamerà l'altro di sovraccarico:

object[] arr = new MyClass[] { new MyClass(), new MyClass() }; 
string text = string.Join("\n", arr); 

Puoi anche scriverlo esplicitamente su object[]: string.Join ("\ n", (oggetto []) arr);

Answer 3

È possibile chiamare l'altro di sovraccarico come questo (che è quello che param vengono utilizzati per) -

string text = string.Join("\n", new MyClass(), new MyClass()); 

Answer 4

Il cambiamento più semplice per il codice sarebbe quello di andare da:

var arr = new MyClass[]{ new MyClass(), new MyClass() }; 
    string text = string.Join("\n", arr); 

A:

var arr = new object[]{ new MyClass(), new MyClass() }; 
    string text = string.Join("\n", arr); 

Come detto prima, il casting funziona anche:

var arr = new MyClass[]{ new MyClass(), new MyClass() }; 
    string text = string.Join("\n", (object[])arr); 

Per ulteriori informazioni su questo argomento, ricerca C# overload resolution.

La risoluzione del sovraccarico è un argomento interessante di per sé, ma non ho ancora trovato il collo di bottiglia per un problema di prestazioni.

Answer 5

Se usate IEnumerable è possibile utilizzare il <object> overload generica del metodo ToArray():

var allFoos = foo.GetAllFoos().ToArray<object>(); 
string s = string.Join(", ", allFoos); 

sembra meno gonfio e più leggibile per me.