Page d'Accueil

 Fondamentaux du soutien de .NET pour les collections

 

Énumération des membres d'une collection

 

Introduction aux collections de système

En étudiant les rangées, nous avons vu que vous pourriez utiliserla boucle for  pour visiter chaque membre d'une rangée. Ceci a été également fait avec l'aide de l'opérateur []. Dans la leçon précédente, nous avons vu que, en créant une collection, vous devriez fournir une méthode qui vous permet de rechercher un membre de la collection. Dans les deux cas, vous pouvez énumérer les membres d'une rangée ou d'une collection par une technique appelée une énumération. L'énumération d'une collection consiste à visiter chaque membre de la liste, pour n'importe quelle raison jugée nécessaire. Par exemple, vous pouvez énumérer une collection pour qfficher une liste de ses membres. Vous pouvez énumérer une collection en recherchant un membre qui répond à un certain critère.

En outre, ou au lieu de la boucle for, .NET Framework fournit des autres et mieux l'appui pour l'énumération. Dans la langue de C#, vous pouvez énumérer une collection en utilisant l'opérateur de foreach, mais la collection doit être préparée pour elle : vous ne pouvez pas simplement n'employer le foreach pour aucune collection. Cet appui est fourni par deux interfaces principales : IEnumerator et IEnumerable. Ces deux interfaces sont définies dans le namespace de System.Collection. Par conséquent, si vous avez l'intention de les employer, vous pouvez inclure ce namespace dans votre fichier source.

 

Étude pratique Étude pratique : Présentation des collections intégrées

  1. Commencer Microsoft Visual C# et créer une nouvelle application de console appelée FlowerShop5
  2. Pour créer un nouveau dossier, sur le menu principal, projet de clic - > ajouter le nouvel article…
  3. Dans les calibres énumérer, cliquer le dossier de code
  4. Placer le nom à FlowerAccessories et le clic s'ajoutent
  5. Le dossier vide, introduire au clavier ce qui suit :
     
    public enum FlowerType
    {
         Roses      = 1,
         Lilies     = 102,
         Daisies    = 104,
         Carnations = 112,
         LivePlant  = 220,
         Orchids    = 234,
         Tulips     = 242,
         Iris       = 250,
         Mixed      = 462,
         Other      = 464
    }
    
    public enum FlowerColor
    {
        Red = 1,
        White,
        Yellow,
        Pink,
        Orange,
        Blue,
        Lavender,
        Mixed
    }
    
    public enum FlowerArrangement
    {
        Bouquet = 1,
        Balloon,
        Vase,
        Basket,
        Bundle,
        Any
    }
  6. Créer une nouvelle classe, dans l'explorateur de solution, droit-cliquent FlowerShop5 - > ajouter - > classe…
  7. Placer le nom pour fleurir et la pression entrent
  8. Changer le dossier comme suit :
     
    using System;
    
    namespace FlowerShop5
    {
        public class Flower
        {
            private decimal pc;
            public Flower Next;
            public FlowerType Type;
            public FlowerColor Color;
            public FlowerArrangement Arrangement;
    
            public Flower()
            {
                Type = FlowerType.Mixed;
                Color = FlowerColor.Mixed;
                Arrangement = FlowerArrangement.Vase;
                pc = 0.00M;
            }
    
            public Flower(FlowerType type, FlowerColor color,
                    FlowerArrangement argn, decimal price)
            {
                Type = type;
                Color = color;
                Arrangement = argn;
                pc = price;
            }
    
            public decimal UnitPrice
            {
                get { return pc; }
                set { pc = value; }
            }
        }
    }
  9. Créer une nouvelle classe, dans la vue de classe, droit-cliquent FlowerShop5 - > ajouter - > classe…
  10. Placer le nom à FlowerInventory et le clic s'ajoutent
  11. Changer la classe comme suit :
     
    using System;
    
    namespace FlowerShop5
    {
        public abstract class AFlower
        {
            protected int items;
    
            public AFlower()
            {
                items = 0;
            }
    
            public int Count
            {
                get { return items; }
            }
    
            public abstract int Add(Flower obj);
            public abstract Flower Get(int index);
            public abstract bool Delete();
        }
    
        public class FlowerInventory : AFlower
        {
            public Flower Head;
            public Flower Inventory;
    
            public FlowerInventory()
            {
                Head = null;
            }
    
            public override int Add(Flower NewFlower)
            {
                Flower Sample = new Flower();
    
                Sample = NewFlower;
                Sample.Next = Head;
                Head = Sample;
                return items++;
            }
    
            public override Flower Get(int index)
            {
                Flower Current = Head;
    
                for(int i = Count - 1;
                    i > index && Current != null;
                    i--)
                    Current = Current.Next;
                return Current;
            }
    
            public override bool Delete()
            {
                if (Head == null)
                {
                    Console.WriteLine("The inventory is empty");
                    return false;
                }
    
                Flower Current;
    
                Current = Head.Next;
                Head.Next = Current.Next;
                items--;
                return true;
            }
        }
    }
  12. Économiser tous  

Introduction à l'interface d'IEnumerator

L'interface d'IEnumerator fournit les moyens d'identifier la classe qui tient un échantillon de l'article qui sera énuméré. Cette interface est équipée d'une propriété et de deux méthodes. Pour employer les fonctionnalités fournies par l'IEnumerator connecter, vous doit créer une classe qui des instruments il. Vous pouvez commencer la classe comme suit :

public class Enumerator : IEnumerator
{
}
Collections

Si votre collection est une liste ranger-basée, vous pouvez commencer par déclarer la rangée basse dans la classe : Voici un exemple :

public class Enumerator : IEnumerator
{
    private double[] numbers;
}

Si la collection ranger-n'est pas basée, vous pouvez déclarer une variable pour la classe qui serait énumérée.

Le rôle de l'agent recenseur est d'agir sur une collection. Pour cette raison, la classe devrait être préparée pour recevoir une collection externe. Ceci peut être fait en la passant à un constructeur de l'agent recenseur. Voici un exemple :

public class Enumerator : IEnumerator
{
    private double[] numbers;

    public Enumerator(double[] list)
    {
    }
}

La collection interne serait employée dans la classe d'agent recenseur. La collection externe serait la source des valeurs de la liste qui serait agent recenseur. Pour ces raisons, vous pouvez devriez initialiser la collection interne avec les valeurs de la liste externe. Ceci peut être fait comme suit :

public class Enumerator : IEnumerator
{
    private double[] numbers;

    public Enumerator(double[] list)
    {
        this.numbers = list;
    }
}

Étude pratique Étude pratique : Présentation des énumérations

  1. Créer une nouvelle classe, dans la vue de classe, droit-cliquent FlowerShop5 - > ajouter - > classe…
  2. Placer le nom de la classe à FlowerIdentifier et le clic s'ajoutent
  3. Changer le dossier comme suit :
     
    using System;
    using System.Collections;
    
    namespace FlowerShop5
    {
        public class FlowerIdentifier : IEnumerator
        {
            public FlowerInventory counts;
    
            public void Identify(FlowerInventory list)
            {
                this.counts = list;
            }
        }
    }
  4. Économiser le dossier

L'article courant d'une énumération

Dans la leçon précédente, en présentant quelques techniques de créer une liste, nous avons vu que vous devriez avoir un type d'étiquette, comme champ, qui te permet de surveiller l'article qui est actuellement accédé ou employé dans la liste. C'est particulièrement valable en rendant visite aux membres de la collection. L'interface d'IEnumerator fournit une propriété qui est employée pour identifier le membre courant de la liste. Cette propriété s'appelle Current. Puisque l'article courant est censé pour être regardé seulement, la propriété courante est inaltérable. Basé sur les règles de la classe abstraite, se rappeler que vous devez mettre en application tous les membres d'une interface dans la classe qui est basée sur elle.

Pour mettre en application la propriété courante, vous pouvez mettre en application le son obligez l'accédant à renvoyer l'article à la position actuelle. Ceci peut être fait comme suit :

public class Enumerator : IEnumerator
{
    private double[] numbers;
    private int cur;

    public Enumerator(double[] list)
    {
        this.numbers = list;
    }

    public Object Current
    {
        get { return numbers[cur]; }
    }
}

Étude pratique Étude pratique : Obtenir à l'article courant

  1. Dans le dossier de FlowerIdentifier.cs, mettre en application la propriété d'IEnumerator.Current comme suit :
     
    using System;
    using System.Collections;
    
    namespace FlowerShop5
    {
        public class FlowerIdentifier : IEnumerator
        {
            private int curPosition = -1;
            public FlowerInventory counts;
    
            public void Identify(FlowerInventory list)
            {
                this.counts = list;
            }
    
            public Object Current
            {
                get
                {
                    try
                    {
                        return this.counts.Get(this.curPosition);
                    }
                    catch (IndexOutOfRangeException)
                    {
                        Console.WriteLine("The current item must be accessed " +
                                          "within the range of available items");
                    }
                }
            }
        }
    }
  2. Économiser le dossier

Rajustement de l'étiquette de l'article courant

Bien que vous devriez pouvoir identifier l'article courant à tout moment, quand l'application commence, avant que la collection puisse être énumérée, l'étiquette qui est employée pour surveiller l'article courant devrait être placée à avant le commencement du compte. Ceci peut être fait en plaçant l'étiquette à -1. Voici un exemple :

public class Enumerator : IEnumerator
{
    private double[] numbers;
    private int cur;

    public Enumerator(double[] list)
    {
        this.numbers = list;
        cur = -1;
    }

    public Object Current
    {
        get { return numbers[cur]; }
    }
}

Tandis que la collection est, à un moment vous pouvez vouloir remettre à zéro l'étiquette de l'article courant dans sa position originale. Pour soutenir cette opération, l'IEnumerator est équipé d'une méthode appelée Reset. Sa syntaxe est :

void Reset() ;

En appliquant cette méthode, assigner simplement une valeur non-existante, qui est habituellement -1, à l'étiquette de surveillance de l'article courant. Ceci peut être fait comme suit :

public class Enumerator : IEnumerator
{
    private double[] numbers;
    private int cur;

    public Enumerator(double[] list)
    {
        this.numbers = list;
        cur = -1;
    }

    public Object Current
    {
        get { return numbers[cur]; }
    }

    public void Reset()
    {
        cur = -1;
    }
}

En utilisant l'applicateur de l'interface d'IEnumerator, si vous essayez d'accéder à un article au delà du nombre maximum des articles, le compilateur jetterait une exception d'IndexOutOfRangeException. Pour cette raison, en prévoyant un mauvais comportement, vous devriez attraper cette exception quand mettant en application la propriété courante.

Étude pratique Étude pratique : Rajustement de l'étiquette de l'article courant

  1. Dans le dossier de FlowerIdentifier.cs, appliquer la méthode d'IEnumerator.Reset () comme suit :
     
    using System;
    using System.Collections;
    
    namespace FlowerShop5
    {
        public class FlowerIdentifier : IEnumerator
        {
            private int curPosition = -1;
            public FlowerInventory counts;
    
            public void Identify(FlowerInventory list)
            {
                this.counts = list;
            }
    
            public Object Current
            {
                get
                {
                    try
                    {
                        return this.counts.Get(this.curPosition);
                    }
                    catch (IndexOutOfRangeException)
                    {
                        Console.WriteLine("The current item must be accessed " +
                                          "within the range of available items");
                    }
                }
            }
    
            public void Reset()
            {
                this.curPosition = -1;
            }
        }
    }
  2. Économiser le dossier

Se déplacer au prochain article dans l'agent recenseur

Dans la leçon précédente, nous avons vu que, en utilisant les articles d'une collection, one-way que vous pouvez localiser un article des autres est de pouvoir sauter d'un article au prochain. Cette opération est également très importante en énumérant une collection. Pour soutenir cette opération, l'IEnumerator est raillé avec la méthode de MoveNext (). Sa syntaxe est:

bool MoveNext () ;

En appliquant cette méthode, incrémenter d'abord l'étiquette qui surveille l'article courant de la collection. Après incrémentation de l'étiquette, contrôle s'il est inférieur que tout le nombre d'articles. S'il est, renvoyer vrai. Autrement, renvoyer faux. Ceci peut être fait comme suit :

public class Enumerator : IEnumerator
{
    private double[] numbers;
    private int cur;

    public Enumerator(double[] list)
    {
        this.numbers = list;
        cur = -1;
    }

    public Object Current
    {
        get { return numbers[cur]; }
    }

    public void Reset()
    {
        cur = -1;
    }

    public bool MoveNext()
    {
        cur++;
        if (cur < numbers.Length)
            return true;
        else
            return false;
    }
}

Étude pratique Étude pratique : Se déplacer au prochain article dans l'agent recenseur

  1. Appliquer la méthode d'IEnumerator.MoveNext () comme suit :
     
    using System;
    using System.Collections;
    
    namespace FlowerShop5
    {
        public class FlowerIdentifier : IEnumerator
        {
            private int curPosition = -1;
            public FlowerInventory counts;
    
            public void Identify(FlowerInventory list)
            {
                this.counts = list;
            }
    
            public Object Current
            {
                get
                {
                    try
                    {
                        return this.counts.Get(this.curPosition);
                    }
                    catch (IndexOutOfRangeException)
                    {
                        Console.WriteLine("The current item must be accessed " +
                                          "within the range of available items");
                    }
    
    		return null;
                }
            }
    
            public void Reset()
            {
                this.curPosition = -1;
            }
    
            public bool MoveNext()
            {
                this.curPosition++;
    
                if (this.curPosition < counts.Count)
                    return true;
                else
                    return false;
            }
        }
    }
  2. Économiser le dossier
 

Précédent Copyright © 2007, Yevol Suivant