Utilizzo sovraccarico del rendimento restituito

Question

Non ho molta esperienza con l'utilizzo della parola chiave yield. Ho queste estensioni IEnumerableT > per la conversione del tipo.

La mia domanda è: il primo metodo sovraccarico ha lo stesso effetto di rendimento che sto ottenendo dal secondo metodo?

public static IEnumerable<TTo> ConvertFrom<TTo, TFrom>(this IEnumerable<TFrom> toList) 
{ 
    return ConvertFrom<TTo, TFrom>(toList, TypeDescriptor.GetConverter(typeof(TTo))); 
} 

public static IEnumerable<TTo> ConvertFrom<TTo, TFrom>(this IEnumerable<TFrom> toList, TypeConverter converter) 
{ 
    foreach (var t in toList) 
     yield return (TTo)converter.ConvertFrom(t); 
} 

Answer 1

Quando si chiama il primo sovraccarico, chiamerà immediatamente il secondo sovraccarico. Ciò non eseguirà alcun codice nel suo corpo, che sarà stato spostato in una classe nidificata che implementa il blocco iteratore. Quando GetEnumerator() e quindi MoveNext() vengono richiamati per la prima volta sul numero IEnumerable<TTo> restituito, quindi, il codice nel secondo sovraccarico inizierà l'esecuzione.

Ho un tempo abbastanza lungo article on the iterator block implementation, che potresti trovare interessante.

Answer 2

Sì, perché il ritorno resa solo genera una classe IEnumerator sulla compilazione. yield return è solo magia del compilatore.

Answer 3

Per inciso ... la maggior parte dei convertitori di tipo funziona solo per/da stringhe. Un'altra opzione interessante qui potrebbe essere gli operatori di conversione statici definiti rispetto al tipo (s) - Ho qualche codice .NET 3.5 che fa questo in MiscUtil - vedere il metodo Convert citato here.

Re tuo commento:

il modo in cui sto usando questo metodo è quello di tradurre un oggetto EF in un oggetto DataContract per WCF. così List (Alberghi) .ConvertTo (SerializableHotels, Alberghi)()

Suona come si dovrebbe sia utilizzeranno la serializzazione, o se i nomi di proprietà hanno un rapporto diretto, forse qualcosa di simile PropertyCopy<To>.CopyFrom(from) - questo è di nuovo da MiscUtil (ma alcuni dei lavori di Jon questa volta) - vale a dire

public static IEnumerable<TTo> ConvertFrom<TTo, TFrom>(
    this IEnumerable<TFrom> list, TypeConverter converter) 
{ 
    return list.Select(item => PropertyCopy<TTo>.CopyFrom<TFrom>(item); 
} 

oltre a questo, probabilmente stai meglio-off parlando di un Conversion<,> piuttosto che un TypeConverter.