Est-il prudent d'exposer un iNeumable dans une propriété?

L'utilisateur peut être capable de renvoyer à la classe de collecte, alors exposez.

collection.Select(x => x)

Je ne suggérerais pas d'envelopper un itératif dans un itérateur pour empêcher les destinataires de monkeying avec la connexion sous-jacente. Mon inclination serait d'utiliser un wrapper quelque chose comme: xxx pré>

si le type de retour des propriétés est ienumerable code>, la coercition de type enracinable code> à iEnumerable code> enregistrerait la structure et rendrait le comportement et la performance correspondent à ceux d'une classe. Si, toutefois, les propriétés, ont été définies comme type de retournement enveloppé code>, il serait alors possible d'enregistrer une étape de boxe dans les cas où le code d'appel attribue soit le retour à une propriété de type enveloppé (très probablement à la suite de quelque chose comme var mykeys = mycollection.keys; code>) ou utilise simplement la propriété directement dans une boucle "foreach". Notez que si l'énumérateur renvoyé par getenumerator () code> serait une structure, qui devra toujours être encadré dans tout cas. P>

L'avantage de la performance d'utilisation d'une structure plutôt que de la classe serait généralement assez légère; Cependant, l'utilisation d'une structure correspondrait à la recommandation générale que les propriétés ne créent pas de nouvelles instances d'objet de tas. Construire une nouvelle instance de struct qui ne contient que une référence à un objet de tas existant est très bon marché. Le plus gros inconvénient d'utiliser une structure telle que définie ici serait qu'il serait verrouillé dans le comportement de la chose renvoyée au code d'appel, alors que simplement renvoyer ienumerable code> permettrait d'autres approches. P >

Notez également que cela peut dans certains cas être possible d'éliminer l'exigence de tout boxe et d'exploiter les optimisations de typage de canard en C # et VB.net foreach code> en boucle si l'on utilise un type comme: P>

public struct FancyWrappedEnumerable<TItems,TEnumerator,TDataSource> : IEnumerable<TItems> where TEnumerator : IEnumerator<TItems>
{
    TDataSource _dataSource;
    Func<TDataSource,TEnumerator> _convertor;
    public FancyWrappedEnumerable(TDataSource dataSource, Func<TDataSource, TEnumerator> convertor)
    {
        _dataSource = dataSource;
        _convertor = convertor;
    }
    public TEnumerator GetEnumerator()
    {
        return _convertor(_dataSource);
    }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return _convertor(_dataSource);
    }
}