|
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 :
|
 |
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 : Créer des lecteurs de propriété
|
|
- 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;
}
}
}
|
- 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");
}
}
}
|
- 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 . . .
|
 |
- Fermez la fenêtre DOS
|
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)
|
 |
|
Étude pratique : Créer des propriétés writers
|
|
- 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);
}
}
}
|
- 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);
}
}
}
|
- 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 . . .
|
 |
- Fermez la fenêtre DOS
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.
|
|
