Page d'Accueil

Types de propriétés

 

Lecteurs de propriété

Une propriété est dite read si son rôle est uniquement de rendre disponible la valeur de la variable membre qu'elle représente. Pour créer une propriété read, dans le corps de la propriété, dactylographiez le mot-clé get et créer un corps pour le mot-clé, à l'aide des accolades traditionnelles qui délimitent une section du code. Voici un exemple :

using System;

namespace Example
{
    public class Square
    {
	private double _side;

        // This is a new property
        public double Side
        {
            get
            {
            }
        }
    }
}

Dans le corps de la clause get, vous pouvez mettre en application le comportement qui serait utilisé pour rendre la valeur du champ disponible à l'extérieur. La manière la plus simple consiste à retourner juste le champ correspondant. Voici un exemple :

using System;

namespace Example
{
    public class Square
    {
	private double _side;

        // This is a new property
        public double Side
        {
            get
            {
                return _side;
            }
        }
    }
}

Une propriété read désigné également sous le nom de propriété read-only parce que les clients de la classe peuvent seulement recouvrer la valeur de la propriété mais ne peuvent pas la changer. Par conséquent, si vous créez (seulement) une propriété read, vous devriez procurer aux utilisateurs la possibilité d'indiquer principalement la valeur de la variable membre. Pour ce faire, vous pouvez créer une méthode accessoire ou un constructeur pour la classe. Voici un exemple d'un tel constructeur :

using System;

namespace Example
{
    public class Square
    {
	private double _side;

        // This is a new property
        public double Side
        {
            get
            {
                return _side;
            }
        }

        public Square(double s)
        {
            _side = s;
        }
    }
}

Une fois qu'une propriété read a été créée, d'autres classes peuvent lui accéder, par exemple ils peuvent lire sa valeur comme suit :

using System;

namespace Example
{
    public class Square
    {
	private double _side;

        // This is a new property
        public double Side
        {
            get
            {
                return _side;
            }
        }

        public Square(double s)
        {
            _side = s;
        }
    }

    class Exercise
    {
	static void Main()
	{
            Square sq = new Square(-25.55);

            Console.WriteLine("Square Side: {0}", sq.Side);

	}
    }
}

Ceci produirait :

Square Side: -25.55

Press any key to continue...

Nous avons décrit une propriété comme servant de porte à son champ extérieur correspondant, empêchant ces classes extérieures de le salir avec la variable membre. Notez que la classe Square avait donnée une valeur négative pour la variable membre, qui est habituellement peu réaliste pour le côté d'un carrée (Square). Dans ce cas-ci et d'autres, tout en protégeant toujours le champ comme privé, vous pouvez utiliser la propriété read pour remettre à zéro la valeur du champ ou même pour la rejeter. Pour fournir cette fonctionnalité, vous pouvez créer un rapport conditionnel dans la propriété read pour effectuer un processus de vérification. Voici un exemple :

The Properties of a Class
using System;

namespace Example
{
    public class Square
    {
	private double _side;

        // This is a new property
        public double Side
        {
            get
            {
		// If the value given to the side is negative,
		// then set it to 0
		if( _side < 0 )
	    	    return 0;
                else
	            return _side;
            }
        }

        public Square(double s)
        {
            _side = s;
        }
    }

    class Exercise
    {
	static void Main()
	{
            Square sq1 = new Square(-12.48);
            Square sq2 = new Square(25.55);

	    Console.WriteLine("First Square Characteristics");
            Console.WriteLine("Side:      {0}\n", sq1.Side);			

            Console.WriteLine("Second Square Characteristics");
	    Console.WriteLine("Side:      {0}\n", sq2.Side);
	}
    }
}

Ceci produirait :

First Square Characteristics
Side:      0

Second Square Characteristics
Side:      25.55

Étude pratique Étude pratique : Créer des lecteurs de propriété

  1. Pour créer les propriétés read, changez le contenu du fichier ShoppingStore.cs comme suit :
     
    using System;
    
    namespace DepartmentStore2
    {
        class ShoppingItem
        {
            private long itemNo;
            private string nm;
            private string sz;
            private decimal price;
    
            // A property for the stock number of an item
            public long ItemNumber
            {
                get
                {
                    return itemNo;
                }
            }
    
            // A property for the name of an item
            public string Name
            {
                get
                {
                    return nm;
                }
            }
    
            // A property for size of a merchandise
            public string Size
            {
                get
                {
                    if( sz == "0" )
                        return "Unknown Size or Fits All";
                    else
                        return sz;
                }
            }
    
            // A property for the marked price of an item
            public decimal UnitPrice
            {
                get
                {
                    return price;
                }
            }
    
            // A constructor used to initialize an item
            public ShoppingItem(long  nbr,
                                   string  nme,
                                   string  siz,
                                   decimal prc)
            {
                itemNo = nbr;
                nm     = nme;
                sz     = siz;
                price  = prc;
            }
        }
    }
  2. Accédez au fichier Program.cs et changez le comme suit :
     
    using System;
    
    namespace DepartmentStore2
    {
        class Program
        {
            static void Main()
            {
                long number;
                string name;
                string size;
                decimal price;
    
                Console.WriteLine("/-/Arrington Department Store/-/");
                Console.Write("Enter the Item #:     ");
                number = long.Parse(Console.ReadLine());
                Console.Write("Enter the Item Name:  ");
                name = Console.ReadLine();
                Console.Write("Enter the Item Size:  ");
                size = Console.ReadLine();
                Console.Write("Enter the Unit Price: ");
                price = decimal.Parse(Console.ReadLine());
    
                ShoppingItem store = new ShoppingItem(number, name, size, price);
    
                Console.WriteLine("\n================================");
                Console.WriteLine("/-/Arrington Department Store/-/");
                Console.WriteLine("--------------------------------");
                Console.WriteLine("Customer Invoice");
                Console.WriteLine("Item #:      {0}", store.ItemNumber);
                Console.WriteLine("Description: {0}", store.Name);
                Console.WriteLine("Item Size:   {0}", store.Size);
                Console.WriteLine("Unit Price:  {0:C}", store.UnitPrice);
                Console.WriteLine("================================\n");
            }
        }
    }
  3. Exécutez le programme :
     
    /-/Arrington Department Store/-/
    Enter the Item #:     622805
    Enter the Item Name:  Black Leather Hand Bag
    Enter the Item Size:  Medium
    Enter the Unit Price: 85.95
    
    ================================
    /-/Arrington Department Store/-/
    --------------------------------
    Customer Invoice
    Item #:      622805
    Description: Black Leather Hand Bag
    Item Size:   Medium
    Unit Price:  $85.95
    ================================
    
    Press any key to continue . . .
    Black Leather Hand Bag
  4. Fermez la fenêtre DOS

La propriété writer

Dans notre classe Square jusqu'ici, nous avions utilisé un constructeur pour créer une valeur pour chacune des variables membre nécessaires. Ceci  signifie que nous avons dû toujours nous assurer que nous avons su la valeur du champ quand nous avons déclaré une instance de la classe. Parfois, ce n'est pas efficace. Par exemple, vous ne pouvez pas simplement appeler un constructeur au milieu du programme, qui plus est, après que l'objet ait été déclaré, pour assigner une nouvelle valeur au champ. Pour résoudre ce genre de problème, vous devez fournir  d'autres moyens d'accéder au champ n'importe quand pour changer sa valeur.

En outre, ou au lieu de, recherchant la valeur d'un champ d'une classe, vous pouvez vouloir que les classes externes puissent changer la valeur de ce membre. Continuant notre politique pour cacher un champ comme privé, vous pouvez créer un autre type de propriété. Une propriété est mentionnée comme écrivent si elle peut changer (ou écrire) la valeur de son champ correspondant.

Pour créer une propriété write, dactylographiez le mot-clé set suivi des des accolades délimiteurs. Voici un exemple :

using System;

namespace Example
{
    public class Square
    {
        private double _side;

        // This is a new property
        public double Side
        {
	    set
	    {
	    }
        }
    }
}

La tâche minimum que vous pouvez effectuer avec une propriété write est de lui assigner une valeur qui serait fournie par le monde extérieur. Pour soutenir ceci, C# fournit le mot-clé contextuel value. Voici un exemple :

using System;

namespace Example
{
    public class Square
    {
	private double _side;

        // This is a new property
        public double Side
        {
	    set
	    {
                 _side = value
	    }
        }
    }
}

Comme vous voyez, les clients d'une classe peuvent changer le champ correspondant d'une variable membre à travers la propriété writer. Basé sur ce rapport, il n'est pas peu commun pour un client d'une classe d'essayer « de salir » avec un champ. Par exemple, un objet externe peut assigner une valeur inadmissible à une variable membre. Considérer le programme suivant :

using System;

namespace Example
{
    public class Square
    {
	public double _side;

        // This is a new property
        public double Side
        {
            set
            {
                _side = value;
            }
        }

        public Square(double s)
        {
            _side = s;
        }

        public double Perimeter()
        {
            return Side * 4;
        }

        public double Area()
        {
            return Side * Side;
        }
    }

    class Exercise
    {
        static void Main()
        {
            Square sq1 = new Square();
            Square sq2 = new Square();
			
            sq1._side = -12.48;
            sq2._side = 25.55;

            Console.WriteLine("First Square Characteristics");
            Console.WriteLine("Side:      {0}", sq1._side);
            Console.WriteLine("Perimeter: {0}", sq1.Perimeter());
            Console.WriteLine("Area:      {0}\n", sq1.Area());

            Console.WriteLine("Second Square Characteristics");
            Console.WriteLine("Side:      {0}", sq2._side);
            Console.WriteLine("Perimeter: {0}", sq2.Perimeter());
            Console.WriteLine("Area:      {0}", sq2.Area());
        }
    }
}

Ceci produirait :

First Square Characteristics
Side:      -12.48
Perimeter: -49.92
Area:      155.7504

Second Square Characteristics
Side:      25.55
Perimeter: 102.2
Area:      652.8025

Press any key to continue...

Pour cette raison, et puisque c'est par writer que les objets externes changeraient la valeur de la variable membre, vous pouvez utiliser la propriété write, plutôt que lread, pour valider ou rejeter une nouvelle valeur assignée au champ. Rappelez vous que les objets client de la classe peuvent seulement lire la valeur du champ par la propriété read. Par conséquent, il peut y avoir peu de souci seulement de ce côté.

Propriétés lecture/écriture

Si vous créez une propriété qui a seulement une section set, la propriété est désigné sous le nom de write-only parce que les autres classes peuvent seulement lui assigner une valeur (ou lui écrire une valeur). Si vous créez une propriété qui a les deux sections get  et set, sa variable membre correspondante peut recevoir de nouvelles valeurs de l'extérieur de la classe et la variable membre peut fournir ses valeurs aux clients de la classe. Une telle propriété est désigné sous le nom de lecture/écriture (read/write)

Read/Write Properties

Étude pratique Étude pratique : Créer  des propriétés writers

  1. Pour créer des propriétés writers et compléter le programme, changez la teneur du fichier ShoppingItem.cs comme suit :
     
    using System;
    
    namespace DepartmentStore2
    {
        class ShoppingItem
        {
            private long itemNo;
            private string nm;
            private string sz;
            private decimal price;
    
            // A property for the stock number of an item
            public long ItemNumber
            {
                get
                {
                    return itemNo;
                }
    
                set
                {
                    if (itemNo <= 0)
                        itemNo = 0;
                    else
                        itemNo = value;
                }
            }
    
            // A property for the name of an item
            public string Name
            {
                get
                {
                    return nm;
                }
    
                set
                {
                    if (nm == "")
                        nm = "Item no Description";
                    else
                        nm = value;
                }
            }
    
            // A property for size of a merchandise
            public string Size
            {
                get
                {
                    if( sz == "0" )
                        return "Unknown Size or Fits All";
                    else
                        return sz;
                }
    
                set
                {
                    sz = value;
                }
            }
    
            // A property for the marked price of an item
            public decimal UnitPrice
            {
                get
                {
                    return price;
                }
    
                set
                {
                    if (price < 0)
                        price = 0.00M;
                    else
                        price = value;
                }
            }
    
            public static ShoppingItem Read()
            {
                ShoppingItem shop = new ShoppingItem();
    
                Console.Write("Item #:     ");
                shop.itemNo = long.Parse(Console.ReadLine());
                Console.Write("Item Name:  ");
                shop.Name = Console.ReadLine();
                Console.Write("Item Size (Enter 0 if unknown):  ");
                shop.Size = Console.ReadLine();
                Console.Write("Unit Price: ");
                shop.UnitPrice = decimal.Parse(Console.ReadLine());
    
                return shop;
            }
    
            public static void Write(ShoppingItem item)
            {
                Console.WriteLine("Item #:      {0}", item.ItemNumber);
                Console.WriteLine("Description: {0}", item.Name);
                Console.WriteLine("Item Size:   {0}", item.Size);
                Console.WriteLine("Unit Price:  {0:C}", item.UnitPrice);
            }
        }
    }
  2. Accédez au fichier Program.cs et changez le comme suit :
     
    using System;
    
    namespace DepartmentStore2
    {
        class Program
        {
            static void Main()
            {
                Console.WriteLine("/-/Arrington Department Store/-/");
                Console.Write("Enter the following pieces of ");
                Console.WriteLine("information about the sale item");
                ShoppingItem saleItem = ShoppingItem.Read();
    
                Console.WriteLine("\n================================");
                Console.WriteLine("/-/Arrington Department Store/-/");
                Console.WriteLine("--------------------------------");
                ShoppingItem.Write(saleItem);
            }
        }
    }
  3. Exécutez le programme. Voici un exemple :
     
    /-/Arrington Department Store/-/
    Enter the following pieces of
    information about the sale item
    Item #:     114888
    Item Name:  North Hook Alpine Jacket
    Item Size (Enter 0 if unknown):  Large
    Unit Price: 275.95
    
    ================================
    /-/Arrington Department Store/-/
    --------------------------------
    Item #:      114888
    Description: North Hook Alpine Jacket
    Item Size:   Large
    Unit Price:  $275.95
    Press any key to continue . . .
  4. Fermez la fenêtre DOS

Une propriété booléenne

Vous pouvez créer une propriété de type booléen. Pour ce faire, indiquer d'abord son type de données comme bool. En traitant la propriété, veillez à ce que son accessoire get retourne un type booléen. Une propriété booléenne n'est pas comme les autres propriétés régulières. Elle doit indiquer sa valeur comme vraie ou fausse. Comme fait pour des méthodes booléennes, une propriété booléenne doit produire seulement une valeur vraie ou fausse.

 

Précédent Copyright © 2007-2008, Yevol Suivant