Comment puis-je obtenir le premier élément à partir d'un IEnumerable<T> dans .net?

J'ai souvent envie de prendre le premier élément d'un IEnumerable<T> dans .net, et je n'ai pas trouvé une belle façon de le faire. Le meilleur que j'ai trouvé est:

foreach(Elem e in enumerable) {
  //do something with e
  break;
}

Beurk! Alors, est-il un bon moyen de faire cela?

InformationsquelleAutor TimK | 2009-01-30

.net c#

217

Si vous pouvez utiliser LINQ, vous pouvez utiliser:
```
var e = enumerable.First();
```
Cela va lever une exception si énumérable est vide: dans ce cas vous pouvez utiliser:
```
var e = enumerable.FirstOrDefault();
```
FirstOrDefault() sera de retour default(T) si l'énumération est vide, ce qui sera null pour les types référence ou la valeur par défaut "zéro valeur" pour les types de valeur.

Si vous ne pouvez pas utiliser LINQ, votre approche est techniquement correcte et à la création d'un agent recenseur à l'aide de la GetEnumerator et MoveNext méthodes pour récupérer le premier résultat (cet exemple suppose énumérable est un IEnumerable<Elem>):
```
Elem e = myDefault;
using (IEnumerator<Elem> enumer = enumerable.GetEnumerator()) {
    if (enumer.MoveNext()) e = enumer.Current;
}
```
Joel Coehoorn mentionné .Single() dans les commentaires; il travaillera aussi, si vous attendez votre énumérable pour contenir exactement un élément, cependant, il va lever une exception si elle est vide ou ayant plus d'un élément. Il y a un correspondant SingleOrDefault() méthode qui couvre ce scénario d'une manière similaire à FirstOrDefault(). Cependant, David B explique que SingleOrDefault() peut encore lever une exception dans le cas où l'énumération contient plus d'un élément.

Edit: Merci Marc Gravel pour préciser que j'ai besoin de disposer de ma IEnumerator objet après utilisation - j'ai édité le non-LINQ exemple pour afficher les using mot-clé pour mettre en œuvre ce modèle.
- Vous devez être using enumer - mais d'autres que cela, bon ;-p
- Merci Marc - édité. =)
- Intéressant de souligner que SingleOrDefault sera de retour 1) Le seul élément s'il n'existe qu'un seul élément. 2) la valeur null si il n'y a pas d'éléments. 3) lancer une exception si il n'y a plus d'un élément.
- Bon appel de David B - ajout d'une note.
- using System.Linq; ok maintenant ça fonctionne!
InformationsquelleAutor Erik Forbes
34

Juste au cas où vous êtes en utilisant .NET 2.0 et n'ont pas accès à LINQ:
```
 static T First<T>(IEnumerable<T> items)
 {
     using(IEnumerator<T> iter = items.GetEnumerator())
     {
         iter.MoveNext();
         return iter.Current;
     }
 }
```
Cela devrait faire ce que vous cherchez...il utilise des génériques, de sorte que vous obtenez le premier élément sur n'importe quel type IEnumerable.

L'appeler de la sorte:
```
List<string> items = new List<string>() { "A", "B", "C", "D", "E" };
string firstItem = First<string>(items);
```
Ou
```
int[] items = new int[] { 1, 2, 3, 4, 5 };
int firstItem = First<int>(items);
```
Vous pouvez modifier facilement assez pour imiter .NET 3.5 de l'interface IEnumerable.ElementAt() la méthode d'extension:
```
static T ElementAt<T>(IEnumerable<T> items, int index)
{
    using(IEnumerator<T> iter = items.GetEnumerator())
    {
        for (int i = 0; i <= index; i++, iter.MoveNext()) ;
        return iter.Current;
    }
} 
```
De l'appeler comme ceci:
```
int[] items = { 1, 2, 3, 4, 5 };
int elemIdx = 3;
int item = ElementAt<int>(items, elemIdx);
```
Bien sûr, si vous ne avoir accès à LINQ, puis il ya beaucoup de bonnes réponses posté déjà...
- Vous devez être using iter
- Oups, bien sûr, vous avez raison, merci. J'ai corrigé mes exemples.
- Les itérateurs sont jetables? Ne savais pas...
- Si vous êtes sur la 2.0, vous n'avez pas la var soit.
- Eh bien, je suppose que si vous voulez obtenir capricieux, je vais déclarer correctement 😛
- Comme quelqu'un qui est coincé à l'aide .NET 2.0, ce fut très apprécié! Bravo.
InformationsquelleAutor BenAlabaster
24

Bien, vous n'avez pas à spécifier la version de .Net vous utilisez.

En supposant que vous avez 3.5, une autre voie est la ElementAt méthode:
```
var e = enumerable.ElementAt(0);
```
- ElementAt(0), simple et sympathique.
InformationsquelleAutor Adam Lassek

FirstOrDefault ?

Elem e = enumerable.FirstOrDefault();
//do something with e

InformationsquelleAutor Amy B

0

Utilisation FirstOrDefault ou une boucle foreach, comme déjà mentionné. Manuellement extraction d'un agent recenseur et de l'appel de Courant doit être évitée. foreach va disposer de votre agent recenseur pour vous si elle met en œuvre IDisposable. Lors de l'appel de la méthode MoveNext et Actuelle, vous devez éliminer manuellement (si applicable).
- Comment peut-on prouver que l'agent recenseur doit être évitée? Les tests de performances sur ma machine indiquer qu'il a environ 10% de gain de performance sur foreach.
- Cela dépend de ce que vous êtes l'énumération sur. Un Erumerator pourrait fermer la connexion à la Base de données, quinte et fermer le handle de fichier, la libération de certains des objets verrouillés, etc. Ne pas supprimer un énumérateur de certains de liste d'entiers ne sera pas nocif, je suppose.
InformationsquelleAutor Mouk

Si votre IEnumerable ne pas exposer c'est <T> et Linq échoue, vous pouvez écrire une méthode à l'aide de la réflexion:

public static T GetEnumeratedItem<T>(Object items, int index) where T : class
{
  T item = null;
  if (items != null)
  {
    System.Reflection.MethodInfo mi = items.GetType()
      .GetMethod("GetEnumerator");
    if (mi != null)
    {
      object o = mi.Invoke(items, null);
      if (o != null)
      {
        System.Reflection.MethodInfo mn = o.GetType()
          .GetMethod("MoveNext");
        if (mn != null)
        {
          object next = mn.Invoke(o, null);
          while (next != null && next.ToString() == "True")
          {
            if (index < 1)
            {
              System.Reflection.PropertyInfo pi = o
                .GetType().GetProperty("Current");
              if (pi != null) item = pi
                .GetValue(o, null) as T;
              break;
            }
            index--;
          }
        }
      }
    }
  }
  return item;
}

InformationsquelleAutor CZahrobsky

essayer cette

IEnumberable<string> aa;
string a = (from t in aa where t.Equals("") select t.Value).ToArray()[0];

InformationsquelleAutor daodao

0

vous pouvez également essayer le plus générique de la version qui vous donne le i-ème élément

énumérable.ElementAtOrDefault(i));

espère que cela aide

InformationsquelleAutor random person on the internet

Vous devez vous connecter pour publier un commentaire.