d'Accueil de page

Introduction aux indexeurs :
Une propriété peut être indexée

 

Introduction

Dans les sections précédentes, nous avons appris comment créer une rangée, comment assigner des valeurs à ses éléments, et comment obtenir la valeur de chaque élément. Voici un exemple :

using System;

public class Program
{
    static int Main()
    {
        double[] Numbers = new double[5];

        Numbers[0] = 927.93;
        Numbers[1] = 45.155;
        Numbers[2] = 2.37094;
        Numbers[3] = 73475.25;
        Numbers[4] = 186.72;

        for (int i = 0; i < Numbers.Length; i++)
            Console.WriteLine("Number {0}: {1}", i+1, Numbers[i]);

        Console.WriteLine();
        return 0;
    }
}

Ceci produirait :

Number 1: 927,93
Number 2: 45,155
Number 3: 2,37094
Number 4: 73475,25
Number 5: 186,72

Press any key to continue . . .

De la même manière, si nous déclarions une rangée comme variable membre d'une classe, pour accéder aux éléments de ce membre, nous avons dû utiliser une instance de la classe, suivi de l'opérateur point, suivi de la variable membre appliquée avec les crochets. Au lieu d'accéder à chaque élément par sa variable membre, vous pouvez créer un type de propriété désigné sous le nom d'indexeur.

Étude pratique : Présentation des propriétés indexées

  1. Commencez une nouvelle application de console appelée PropertyRental1
  2. Pour créer une nouvelle classe, sur le menu principal, cliquez projet - > Ajouter la classe…
  3. Placez le nom Property  et appuyez Enter
  4. Changez le fichier comme suit :
     
    using System;
    
    namespace PropertyRental1
    {
        public enum Condition
        {
            Excellent,
            Good,
            NeedsRepair,
            Unknown
        }
    
        public class Property
        {
            private long propCode;
            private Condition cond;
            private short beds;
            private float baths;
            private decimal val;
    
            public long PropertyCode
            {
                get { return propCode; }
                set { propCode = value; }
            }
    
            public Condition PropertyCondition
            {
                get { return cond; }
                set { cond = value; }
            }
    
            public short Bedrooms
            {
                get { return beds; }
                set { beds = value; }
            }
    
            public float Bathrooms
            {
                get { return (baths <= 0) ? 0.00f : baths; }
                set { baths = value; }
            }
    
            public decimal MonthlyRent
            {
                get { return (val <= 0) ? 0.00M : val; }
                set { val = value; }
            }
    
            public Property()
            {
                Random rnd = new Random();
                propCode = rnd.Next(100000, 999999);
                cond = Condition.Unknown;
                beds = 0;
                baths = 0.0f;
                val = 0.00M;
            }
        }
    }
  5. Pour créer une nouvelle classe, sur le menu principal, cliquez projet - > Ajouter la classe…
  6. Placez le nom PropertyListing et appuyez Enter
  7. Changez le fichier comme suit :
     
    using System;
    
    namespace PropertyRental1
    {
        public class PropertyListing
        {
            public Property[] props;
    
            public PropertyListing()
            {
                Random rnd = new Random();
                prop = new Property[40];
    
                // Create a few properties ready to be rented
                props[0] = new Property();
                props[0].PropertyCode = rnd.Next(100000, 999999);
                props[0].PropertyCondition = Condition.Excellent;
                props[0].Bedrooms = 5;
                props[0].Bathrooms = 3.5f;
                props[0].MonthlyRent = 2650;
    
                props[1] = new Property();
                props[1].PropertyCode = rnd.Next(100000, 999999);
                props[1].PropertyCondition = Condition.Excellent;
                props[1].Bedrooms = 3;
                props[1].Bathrooms = 2.5f;
                props[1].MonthlyRent = 1750;
    
                props[2] = new Property();
                props[2].PropertyCode = rnd.Next(100000, 999999);
                props[2].PropertyCondition = Condition.Good;
                props[2].Bedrooms = 4;
                props[2].Bathrooms = 2.5f;
                props[2].MonthlyRent = 2450;
    
                props[3] = new Property();
                props[3].PropertyCode = rnd.Next(100000, 999999);
                props[3].PropertyCondition = Condition.Excellent;
                props[3].Bedrooms = 1;
                props[3].Bathrooms = 1.0f;
                props[3].MonthlyRent = 880;
    
                props[4] = new Property();
                props[4].PropertyCode = rnd.Next(100000, 999999);
                props[4].PropertyCondition = Condition.Excellent;
                props[4].Bedrooms = 3;
                props[4].Bathrooms = 2.5f;
                props[4].MonthlyRent = 1880;
    
                props[5] = new Property();
                props[5].PropertyCode = rnd.Next(100000, 999999);
                props[5].PropertyCondition = Condition.Good;
                props[5].Bedrooms = 2;
                props[5].Bathrooms = 1.0f;
                props[5].MonthlyRent = 1050;
    
                // Since we don't yet have a complete list of properties
                // Create some empty ones
                for (int i = 6; i < 40; i++)
                {
                    props[i] = new Property();
                }
            }
        }
    }
  8. Accédez au fichier Program.cs et changez le comme suit :
     
    using System;
    
    namespace PropertyRental1
    {
        public class Program
        {
            static int Main()
            {
                PropertyListing properties = new PropertyListing();
                Property prop = new Property();
    
                for (int i = 0; i < 6; i++)
                {
                    Console.WriteLine("{0}.----------------------------------",
    			i + 1);
                    Console.WriteLine("Property #:   {0}",
    				  properties .props[i].PropertyCode);
                    Console.WriteLine("Condition:    {0}",
    				  properties .props[i].PropertyCondition);
                    Console.WriteLine("Bedrooms:     {0}",
    				  properties .props[i].Bedrooms);
                    Console.WriteLine("Bathrooms:    {0}",
    				  properties .props[i].Bathrooms);
                    Console.WriteLine("Market Value: {0}\n",
    			properties .props[i].MonthlyRent.ToString("C"));
                }
                Console.WriteLine("======================================");
    
                return 0;
            }
        }
    }
  9. Appuyez Ctrl + F5 pour exécuter l'application. Ceci produirait :
     
    1.----------------------------------
    Property #:   920119
    Condition:    Excellent
    Bedrooms:     5
    Bathrooms:    3.5
    Market Value: $2,650.00
    
    2.----------------------------------
    Property #:   587917
    Condition:    Excellent
    Bedrooms:     3
    Bathrooms:    2.5
    Market Value: $1,750.00
    
    3.----------------------------------
    Property #:   904376
    Condition:    Good
    Bedrooms:     4
    Bathrooms:    2.5
    Market Value: $2,450.00
    
    4.----------------------------------
    Property #:   421662
    Condition:    Excellent
    Bedrooms:     1
    Bathrooms:    1
    Market Value: $880.00
    
    5.----------------------------------
    Property #:   305196
    Condition:    Excellent
    Bedrooms:     3
    Bathrooms:    2.5
    Market Value: $1,880.00
    
    6.----------------------------------
    Property #:   503836
    Condition:    Good
    Bedrooms:     2
    Bathrooms:    1
    Market Value: $1,050.00
    
    ======================================
    Press any key to continue . . .
  10. Fermez la fenêtre DOS

L'indexeur

Un indexeur, également appelé une propriété indexée, est la propriété d'une classe qui vous permet d'accéder à une variable  membre d'une classe en utilisant les dispositifs d'une rangée. Pour créer une propriété indexée, commencez la classe comme toute autre. Dans le corps de la classe, créer un champ qui est une rangée. Voici un exemple :

public class Number
{
    double[] Numbers = new double[5];
}

Puis, dans le corps de la classe, créez une propriété appelée this avec ses accessoires. La propriété this doit être le même type que le champ auquel elle se rapportera. La propriété doit prendre un paramètre comme une rangée. Ceci signifie qu'elle doit avoir des crochets. À l'intérieur des parenthèses, inclure le paramètre que vous utiliserez comme index pour accéder aux membres de la rangée.

Traditionnellement, et comme nous avons vu jusqu'ici, vous accédez habituellement aux membres d'une rangée en utilisant un index basé sur un nombre. Par conséquent, vous pouvez utiliser un type int comme index de la rangée. Naturellement, le paramètre l'index doit avoir un nom, tel que i. Ceci serait fait comme suit :

public class Number
{
    double[] Numbers = new double[5];

    public double this[int i]
    {
    }
}

Si vous voulez que la propriété soit en lecture seulement (Read only), inclure seulement un accessoire get. Dans l'accessoire get, vous devriez renvoyer un élément du champ de la rangée auquel la propriété se rapporte, en utilisant le paramètre de la propriété. Ceci serait fait comme suit :

public class Number
{
    double[] Numbers = new double[5];

    public double this[int i]
    {
        get { return Numbers[i]; }
    }
}

Une fois que vous avez créé la propriété indexée, la classe peut être utilisée. Pour commencer, vous pouvez déclarer une variable de la classe. Pour accéder à son champ rangé, vous pouvez lui appliquer directement les crochets. Voici un exemple :

using System;

public class Number
{
    double[] Numbers;

    public double this[int i]
    {
        get { return Numbers[i]; }
    }

    public Number()
    {
        Numbers = new double[5];
        Numbers[0] = 927.93;
        Numbers[1] = 45.155;
        Numbers[2] = 2.37094;
        Numbers[3] = 73475.25;
        Numbers[4] = 186.72;
    }
}

public class Program
{
    static int Main()
    {
        Number nbr = new Number();

        for (int i = 0; i < 5; i++)
            Console.WriteLine("Number {0}: {1}", i + 1, nbr[i]);

        Console.WriteLine();
        return 0;
    }
}

Basé sur ceci, un type de formule  pour créer et utiliser une propriété basée sur un index est :

class ClassName
{
    DataType[] ArrayName = new DataType[Index];

    public DataType this[int i]
    {
        get { return ArrayName[i]; }
    }
}

Propriétés indexées d'autres types primitifs

Dans l'exemple ci-dessus, nous avons créé une propriété qui a produit des valeurs à double précision. En créant une propriété indexée, vous déciderez quel type de valeur la propriété doit produire ou le type qu'il peut avoir. Par opposition à un int ou à un double, vous pouvez également créer une propriété qui prend ou produit une chaîne de caractères (string). Pour ce faire, vous pouvez utiliser le modèle de classe ci-dessus  avec le type de données désiré, tel que string. Voici un exemple d'une propriété indexée basée sur une chaîne de caractères (string) :

using System;

public class Philosopher
{
    string[] phil = new string[8];

    public string this[int i]
    {
        get { return phil[i]; }
    }

    public Philosopher()
    {
        phil[0] = "Aristotle";
        phil[1] = "Emmanuel Kant";
        phil[2] = "Tom Huffman";
        phil[3] = "Judith Jarvis Thompson";
        phil[4] = "Thomas Hobbes";
        phil[5] = "Cornell West";
        phil[6] = "Jane English";
        phil[7] = "James Rachels";
    }
}

public class Program
{
    static int Main()
    {
        Philosopher thinker = new Philosopher();

        for (int i = 0; i < 8; i++)
            Console.WriteLine("Philosopher: {0}", thinker[i]);

        Console.WriteLine();
        return 0;
    }
}

Ceci produirait :

Philosopher: Aristotle
Philosopher: Emmanuel Kant
Philosopher: Tom Huffman
Philosopher: Judith Jarvis Thompson
Philosopher: Thomas Hobbes
Philosopher: Cornell West
Philosopher: Jane English
Philosopher: James Rachels

Press any key to continue . . .

De la même manière, vous pouvez créer une propriété indexée basée sur une valeur Booléenne en lui faisant simplement retourner un type bool. Voici un exemple :

using System;

public class DrivingWhileIntoxicated
{
    bool[] dwi = new bool[7];

    public bool this[int i]
    {
        get { return dwi[i]; }
    }

    public DrivingWhileIntoxicated()
    {
        dwi[0] = false;
        dwi[1] = true;
        dwi[2] = true;
        dwi[3] = false;
        dwi[5] = false;
        dwi[6] = false;
    }
}

public class Program
{
    static int Main()
    {
        DrivingWhileIntoxicated driving = new DrivingWhileIntoxicated();

        Console.WriteLine("Police Report");
        Console.WriteLine("-------------------------------");
        for(int i = 0; i < 7; i++)
            Console.WriteLine("Driver Was Intoxicated: {0}", driving[i]);

        Console.WriteLine();
        return 0;
    }
}

Ceci produirait :

Police Report
-------------------------------
Driver Was Intoxicated: False
Driver Was Intoxicated: True
Driver Was Intoxicated: True
Driver Was Intoxicated: False
Driver Was Intoxicated: False
Driver Was Intoxicated: False
Driver Was Intoxicated: False

Press any key to continue . . .

Utiliser un Index Non Basé sur un Nombre Entier

Dans les leçons précédentes, nous avons vu comment créer différentes rangées qui sont numériques ou basées sur une chaîne de caractères. Voici un exemple d'une rangée flottante (float) :

using System;

public class Program
{
    static int Main()
    {
        float[] ages = new float[5];

        ages[0] = 14.50f;
        ages[1] = 12.00f;
        ages[2] = 16.50f;
        ages[3] = 14.00f;
        ages[4] = 15.50f;

        Console.WriteLine("Student Age: {0}", ages[2]);
        Console.WriteLine();
        return 0;
    }
}

Quand nous pensons aux rangées, nous considérons habituellement passer un paramètre basé sur un nombre dans les crochets de la variable, comme fait pour la rangée ages (âges) ci-dessus :

float[] ages = new float[5];

En utilisant une propriété indexée, vous pouvez utiliser presque n'importe quel type d'index, tel qu'une valeur réelle ou une chaîne. Pour ce faire, dans les crochets de la propriété this, passez le type désiré comme index. Voici un exemple :

public class StudentAge
{
    public float this[string name]
    {
    }
}

En définissant la propriété indexée, il y a deux règles que vous devez suivre et vous en êtes déjà averti parce qu'une propriété indexée est comme une méthode qui prend un paramètre et ne renvoie pas un void. Par conséquent, en mettant en application une propriété indexée, assurez vous qu'elle retourne le bon type de valeur et assurez vous de passer l'index approprié à la valeur de retour de la propriété this. Voici un exemple :

public class StudentAge
{
    public float this[string name]
    {
        get
        {
            if(  name == "Ernestine Jonas" )
                return 14.50f;
            else if( name == "Paul Bertrand Yamaguchi" )
                return 12.50f;
            else if( name == "Helene Jonas" )
                return 16.00f;
            else if( name == "Chrissie Hanson" )
                return 14.00f;
            else if( name == "Bernard Hallo" )
                return 15.50f;
            else
                return 12.00f;
        }
    }
}

Une fois que vous avez défini la propriété, vous pouvez l'utiliser. Pour accéder à n'importe lequel de ses éléments, vous devez passer le type approprié d'index. Dans ce cas-ci, l'index doit être passé comme chaîne de caractères (string) et pas comme un nombre entier. Vous pouvez alors faire ce que vous voulez avec la valeur produite par la propriété. Par exemple, vous pouvez l'afficher à l'utilisateur. Voici un exemple :

using System;

public class StudentAge
{
    public float this[string name]
    {
        get
        {
            if(  name == "Ernestine Jonas" )
                return 14.50f;
            else if( name == "Paul Bertrand Yamaguchi" )
                return 12.50f;
            else if( name == "Helene Jonas" )
                return 16.00f;
            else if( name == "Chrissie Hanson" )
                return 14.00f;
            else if( name == "Bernard Hallo" )
                return 15.50f;
            else
                return 12.00f;
        }
    }
}

public class Program
{
    static int Main()
    {
        StudentAge sa = new StudentAge();
        float age = sa["Paul Bertrand Yamaguchi"];

        Console.WriteLine("Student Age: {0}", age);

        Console.WriteLine();
        return 0;
    }
}

Ceci produirait :

Student Age: 12.5

Press any key to continue . . .

Vous pouvez également passer une énumération comme index. Pour ce faire, après avoir défini l'agent recenseur l'énumérateur), dactylographiez son nom et un nom de paramètre dans les crochets du membre this, puis définissez la propriété comme vous voulez. Pour accéder à la propriété en dehors, appliquez un membre énumération aux crochets sur une instance de la classe. Voici un exemple :

using System;

public enum CategoryFee
{
    Children,
    Adult,
    Senior,
    Unknown
}

public class GolfClubMembership
{
    double[] fee = new double[4];

    public GolfClubMembership()
    {
        fee[0] = 150.95d;
        fee[1] = 250.75d;
        fee[2] = 85.65d;
        fee[3] = 350.00d;
    }

    public double this[CategoryFee cat]
    {
        get
        {
            if (cat == CategoryFee.Children)
                return fee[0];
            else if (cat == CategoryFee.Adult)
                return fee[1];
            else if (cat == CategoryFee.Senior)
                return fee[2];
            else
                return fee[3];
        }
    }
}

public class Program
{
    static int Main()
    {
        GolfClubMembership mbr= new GolfClubMembership();

        Console.WriteLine("Membership Fee: {0}", mbr[CategoryFee.Senior]);

        Console.WriteLine();
        return 0;
    }
}

Ceci produirait :

Membership Fee: 85.65

Press any key to continue . . .

Étude pratique : Créer un indexeur

  1. Pour créer un indexeur, accéde au fichier PropertyListing.cs et changez le comme suit :
     
    using System;
    
    namespace PropertyRental1
    {
        public class PropertyListing
        {
            public Property[] props;
    
            public string this[long code]
            {
                get {
                    for(int i = 0; i < props.Length; i++)
                        if( code == props[i].PropertyCode )
                            return "Property #:   " + props[i].PropertyCode + 
                                "\nCondition:    " + props[i].PropertyCondition +
                                   "\nBedrooms:     " + props[i].Bedrooms + 
                                   "\nBathrooms:    " + props[i].Bathrooms +
                         "\nMonthly Rent: " + props[i].MonthlyRent.ToString("C");
                    return "Unidentifiable Property";
                }
            }
    
            public PropertyListing()
            {
                . . . No Change
            }
        }
    }
  2. Accédez au fichier Program.cs et changez le comme suit :
     
    using System;
    
    namespace PropertyRental1
    {
        public class Program
        {
            static int Main()
            {
                PropertyListing properties = new PropertyListing();
                long lngCode;
    
                Console.WriteLine("Here is a list of our properties by code");
                for (int i = 0; i < 6; i++)
                    Console.WriteLine("Property Code: {0}",
    			properties.props[i].PropertyCode);
    
                try
                {
                    Console.Write("Enter Property Code: ");
                    lngCode = long.Parse(Console.ReadLine());
    
                    Console.WriteLine("======================================");
                    Console.WriteLine("Property Information");
                    Console.WriteLine("--------------------------------------");
                    Console.WriteLine(properties[lngCode]);
                    Console.WriteLine("======================================");
    
                }
                catch (FormatException)
                {
                    Console.WriteLine("=- Invalid Property Code -=");
                }
    
                return 0;
            }
        }
    }
  3. Appuyez Ctrl + F5 pour exécuter l'application. Voici un exemple :
     
    Here is a list of our properties by code
    Property Code: 355443
    Property Code: 653004
    Property Code: 800118
    Property Code: 839375
    Property Code: 148561
    Property Code: 697001
    Enter Property Code: 697001
    ======================================
    Property Information
    --------------------------------------
    Property #:   697001
    Condition:    Good
    Bedrooms:     2
    Bathrooms:    1
    Monthly Rent: $1,050.00
    ======================================
    Press any key to continue . . .
  4. Fermez la fenêtre DOS
 

Page d'Accueil Copyright © 2007-2008, Yevol Suivant