IEnumerable<T> en C#

Je suis en train d'essayer d'obtenir le code suivant à la compilation, mais je suis d'avoir des erreurs dans VS2008. Quelqu'un peut me dire où je vais mal?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace dummy
{
    public class NaturalNumbersSequence : IEnumerable<int>
    {
        public IEnumerator<int> GetEnumerator()
        {
            for (int i = 1; i <= 1000; i++)
                yield return i;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            for (int i = 1; i <= 1000; i++)
                yield return i;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            foreach (int i in new NaturalNumbersSequence())
                Console.WriteLine(i);
        }
    }
}

Remarque, c'est une bonne idée d'afficher les messages d'erreur que vous obtenez.

OriginalL'auteur fcuk112 | 2009-07-23

c#ienumerable

24

Bien, la première erreur de compilation, j'obtiens, c'est qu'il se plaint que:

En utilisant le générique de type "Système".Les Collections.Génériques.IEnumerator' exige '1' arguments de type

C'est sur la ligne 16, celui-ci:
```
IEnumerator IEnumerable.GetEnumerator()
```
La fixation par l'ajout d'une directive using pour la System.Collections espace de noms (astuce: placez le curseur juste après IEnumerator, sur la r à la fin du mot, et appuyez sur Ctrl+. (ctrl + point-clé), il devrait vous suggérons d'ajouter un "utilisation du Système.Collections;" directive, à le faire).

Puis il compile et s'exécute. Ne qui correspondent à ce que vous attendez?

Aussi, notez que vous devez toujours placer le réel les messages d'erreur que vous obtenez, de cette façon, nous ne sommes pas des aboiements le mauvais arbre si il y a autre chose de mal avec votre code que nous ne sommes pas voir au premier coup d'œil.

En outre, vous pouvez simplifier cette très commune de mise en œuvre de IEnumerable<T> en appelant l'une des méthodes de l'autre, donc je voudrais simplifier la mise en œuvre de la deuxième méthode:
```
IEnumerator IEnumerable.GetEnumerator()
{
    return GetEnumerator(); //this will return the one
                            //available through the object reference
                            //ie. "IEnumerator<int> GetEnumerator"
}
```
cette façon, vous n'en œuvre la réelle énumérateur de code à la fois.

Et voir enfin Earwicker's réponse ainsi, il montre une meilleure (à mon avis du moins) la façon d'écrire tout ce code.

+1. La dernière partie sur la réutilisation d'une mise en œuvre de l'énumérateur sur l'autre, c'est la cerise sur le gâteau.
pourquoi il y a 2 implémentations de l'agent recenseur en premier lieu?

OriginalL'auteur Lasse Vågsæther Karlsen
9

Ne savez pas pourquoi vous obtenez des erreurs, mais ne serait-ce pas plus simple?
```
public static class NumbersSequence
{
    public static IEnumerable<int> Naturals
    {
        get 
        {
            for (int i = 1; i <= 1000; i++)
                yield return i;
        }
    }
}

class Program
{
    public static void Main(string[] args)
    {
        foreach (int i in NumbersSequence.Naturals)
            Console.WriteLine(i);
    }
}
```
Et pourquoi s'arrêter à un mille?!
Tout le monde sait que les nombres au-dessus de 1000 sont anormalement élevé.
Pour moi, la distinction entre "normal" et "grands" nombres est à vingt mille. Je suppose que c'est une "mise en œuvre" de la chose.
Vingt mille est incroyablement élevé. Attendre.... nous parlons développeur salaires ici, hein, les gars?
Il est également intéressant de voir le vieux différend émergents ici, si les nombres naturels commencer à zéro ou à un!

OriginalL'auteur Daniel Earwicker
4

Légèrement hors-sujet, mais peut-être intéressant de voir, c'est cette approche:
```
public static class NumbersSequence
{
    public static IEnumerable<int> Naturals
    {
        get 
        {
            int i = 0;
            while(true)
                yield return i++;
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        foreach (int i in NumbersSequence.Naturals.Take(1000))
            Console.WriteLine(i);
    }
}
```
De C# 3.0, autant que je sache. Attention à l'interminable boucle dans la lecture, et l'appel à Prendre(1000). Avec cette méthode, vous avez maintenant un 'sans fin' de la séquence de nombres naturels (sans fin, jusqu'à la maxvalue d'un int). Il ne sera pas coincé, aussi longtemps que vous dire de prendre une quantité spécifique.

AVERTISSEMENT:
La plupart du code emprunté à Earwicker de réponse.

Alors, quel est i dans Naturals.get?
Toujours agréable de voir des "infini" boucles en action.
Pavel remarqué, vous êtes absent de l'initialisation et de l'incrément de je.
J'aime m'Linq, mais l'homme, je voudrais certainement en oublier .() Dans ce cas. Je préfère avoir Naturals être une méthode acceptant un paramètre de type int.
Ce n'est pas de droite, vous devriez déclarer i à l'intérieur de la get. La façon dont vous l'avez maintenant, une deuxième évaluation de NumbersSequence.Naturals.Take(1000) sera de retour le nombre de 1000 en 1999. Ce qui devrait être la réponse à NumbersSequence.Naturals.Skip(1000).Take(1000)

OriginalL'auteur Erik van Brakel

Lasse a la bonne réponse, et je sais que c'est l'apprentissage du code, mais dans l'intérêt de poursuivre votre apprentissage, je veux parler de deux choses l'une:

Enumerable.Range()
Prendre le temps de réfléchir à propos de cette oeuvre:

public class NaturalNumbersSequence : IEnumerable<int>
{
    public IEnumerator<int> GetEnumerator()
    {
        for (int i=0 i <= int.MaxValue;i++)
            yield return i;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        for (int i=0 i <= int.MaxValue;i++)
            yield return i;
    }
}

class Program
{
    static void Main(string[] args)
    {
        foreach (int i in new NaturalNumbersSequence().TakeWhile(i => i<=1000) )
            Console.WriteLine(i);
    }
}

OriginalL'auteur Joel Coehoorn

Vous devez vous connecter pour publier un commentaire.