Vous recherchez un exemple court et simple de getters/setters en C #
J'ai de la difficulté à comprendre le concept de getters et de setters en langage C #. Dans des langages comme Objective-C, ils semblent faire partie intégrante du système, mais pas autant en C # (autant que je sache). J'ai déjà lu des livres et des articles. Ma question s'adresse donc à ceux d'entre vous qui comprennent les getters et les setters en C #, quel exemple utiliseriez-vous personnellement si vous enseigniez le concept à un débutant (cela inclurait aussi peu de lignes de code possible)?
Je pense qu'un peu de code aidera à illustrer ce que sont les setters et les getters:
public class Foo
{
private string bar;
public string GetBar()
{
return bar;
}
public void SetBar(string value)
{
bar = value;
}
}
Dans cet exemple, nous avons un membre privé de la classe appelé bar. Les méthodes GetBar et SetBar font exactement ce qu'elles sont appelées - l'une récupère le membre de la barre et l'autre définit sa valeur.
En c # 1.1 + vous avez des propriétés. La fonctionnalité de base est également la même:
public class Foo
{
private string bar;
public string Bar
{
get { return bar; }
set { bar = value; }
}
}
Le bar des membres privés n'est pas accessible en dehors de la classe. Cependant le public "Bar" est, et il a deux accesseurs - get, qui, comme l'exemple ci-dessus "GetBar ()", renvoie le membre privé, ainsi qu'un ensemble - qui correspond à la méthode SetBar (chaîne de valeur) dans la liste susmentionnée Exemple.
À partir de C 3.0 et supérieur, le compilateur est devenu optimisé au point que de telles propriétés n'ont plus besoin du membre privé comme source. Le compilateur génère automatiquement un membre privé de ce type et l'utilise comme source d'une propriété.
public class Foo
{
public string Bar { get; set; }
}
ce que le code montre est une propriété automatique qui a un membre privé généré par le compilateur. Vous ne voyez pas le député, mais c'est là. Cela a également introduit quelques autres problèmes - principalement avec le contrôle d'accès. En C # 1.1 et 2.0, vous pouvez omettre la partie get ou set d'une propriété:
public class Foo
{
private string bar;
public string Bar
{
get{ return bar; }
}
}
Vous permettant ainsi de restreindre l'interaction des autres objets avec la propriété "Bar" de la classe Foo. À partir de C 3.0 et supérieur - si vous choisissez d'utiliser des propriétés automatiques, vous devez spécifier l'accès à la propriété comme suit:
public class Foo
{
public string Bar { get; private set; }
}
Cela signifie que seule la classe elle-même peut attribuer à Bar une valeur, mais tout le monde peut lire la valeur dans Bar.
En C #, Propriétés représente vos Getters et Setters.
Voici un exemple:
public class PropertyExample
{
private int myIntField = 0;
public int MyInt
{
// This is your getter.
// it uses the accessibility of the property (public)
get
{
return myIntField;
}
// this is your setter
// Note: you can specify different accessibility
// for your getter and setter.
protected set
{
// You can put logic into your getters and setters
// since they actually map to functions behind the scenes
DoSomeValidation(value)
{
// The input of the setter is always called "value"
// and is of the same type as your property definition
myIntField = value;
}
}
}
}
Vous accéderiez à cette propriété comme un champ. Par exemple:
PropertyExample example = new PropertyExample();
example.MyInt = 4; // sets myIntField to 4
Console.WriteLine( example.MyInt ); // prints 4
Quelques autres choses à noter:
- Vous n'avez pas à spécifier à la fois un getter et un setter, vous pouvez omettre l'un ou l'autre.
- Les propriétés ne sont que du "sucre syntaxique" pour votre getter et votre setter traditionnels. Le compilateur construira en réalité les fonctions get_ et set_ en coulisse (dans l'IL compilé) et mappera toutes les références de votre propriété à ces fonctions.
La plupart des langues le font de cette façon, et vous pouvez aussi le faire en C #.
public void setRAM(int RAM)
{
this.RAM = RAM;
}
public int getRAM()
{
return this.RAM;
}
Mais C # donne également une solution plus élégante à ceci:
public class Computer
{
int ram;
public int RAM
{
get
{
return ram;
}
set
{
ram = value; // value is a reserved Word and it is a variable that holds the input that is given to ram ( like in the example below )
}
}
}
Et plus tard y accéder avec.
Computer comp = new Computer();
comp.RAM = 1024;
int var = comp.RAM;
Pour les nouvelles versions de C #, c'est encore mieux:
public class Computer
{
public int RAM { get; set; }
}
et ensuite :
Computer comp = new Computer();
comp.RAM = 1024;
int var = comp.RAM;
Mon explication serait la suivante. (Ce n'est pas si court, mais c'est assez simple.)
Imaginez une classe avec une variable:
class Something
{
int weight;
// and other methods, of course, not shown here
}
Eh bien, il y a un petit problème avec cette classe: personne ne peut voir le weight. Nous pourrions rendre weight public, mais alors tout le monde serait en mesure de changer le weight à tout moment (ce qui n’est peut-être pas ce que nous souhaitons). Alors, bon, on peut faire une fonction:
class Something
{
int weight;
public int GetWeight() { return weight; }
// and other methods
}
C'est déjà mieux, mais maintenant tout le monde au lieu de something.Weight brut doit taper something.GetWeight(), ce qui est bien moche.
Avec les propriétés, on peut faire la même chose, mais le code reste propre:
class Something
{
public int weight { get; private set; }
// and other methods
}
int w = something.weight // works!
something.weight = x; // doesn't even compile
Nice, donc avec les propriétés, nous avons un contrôle plus fin sur l'accès variable.
Un autre problème: d'accord, nous voulons que le code externe puisse définir weight, mais nous souhaitons contrôler sa valeur et ne pas autoriser les poids inférieurs à 100. De plus, il existe une autre variable interne density, qui dépend de weight, nous voudrions donc recalculer la density dès que la weight change.
Ceci est traditionnellement réalisé de la manière suivante:
class Something
{
int weight;
public int SetWeight(int w)
{
if (w < 100)
throw new ArgumentException("weight too small");
weight = w;
RecalculateDensity();
}
// and other methods
}
something.SetWeight(anotherSomething.GetWeight() + 1);
Mais encore une fois, nous ne voulons pas exposer à nos clients que la définition du poids est une opération compliquée, que ce n’est sémantiquement que l’attribution d’un nouveau poids. Donc, le code avec un setter a la même apparence, mais plus joli:
class Something
{
private int _w;
public int Weight
{
get { return _w; }
set
{
if (value < 100)
throw new ArgumentException("weight too small");
_w = value;
RecalculateDensity();
}
}
// and other methods
}
something.Weight = otherSomething.Weight + 1; // much cleaner, right?
Donc, sans aucun doute, les propriétés ne sont "que" un sucre syntaxique. Mais cela améliore le code du client. Il est intéressant de noter que le besoin de choses similaires à la propriété apparaît très souvent, vous pouvez vérifier la fréquence à laquelle vous trouvez les fonctions telles que GetXXX () et SetXXX () dans les autres langues.
C # présente les propriétés qui font le plus gros du travail lourd pour vous ...
c'est à dire
public string Name { get; set; }
est un raccourci C # pour écrire ...
private string _name;
public string getName { return _name; }
public void setName(string value) { _name = value; }
Fondamentalement, les getters et les setters ne sont que des moyens d'aider à l'encapsulation. Lorsque vous créez une classe, vous avez plusieurs variables de classe que vous souhaitez peut-être exposer à d'autres classes afin de leur permettre d'avoir un aperçu de certaines des données que vous stockez. Rendre publique les variables au début peut sembler une solution acceptable, mais à la longue, vous regretterez de laisser les autres classes manipuler directement les variables de membre de votre classe. Si vous les obligez à le faire via un paramètre, vous pouvez ajouter une logique pour vous assurer qu'aucune valeur étrange ne se produit, et vous pouvez toujours modifier cette logique à l'avenir sans modifier la classe.
c'est à dire
private string _name;
public string getName { return _name; }
public void setName(string value)
{
//Don't want things setting my Name to null
if (value == null)
{
throw new InvalidInputException();
}
_name = value;
}
bien voici l'utilisation courante de getter setter dans le cas d'utilisation réel,
public class OrderItem
{
public int Id {get;set;}
public int quantity {get;set;}
public int Price {get;set;}
public int TotalAmount {get {return this.quantity *this.Price;}set;}
}
Exemple simple
public class Simple
{
public int Propery { get; set; }
}
Autant que je sache, les getters et les setters doivent améliorer l'encapsulation ... Il n'y a rien de complexe en C #.
Vous définissez une propriété de l'objet comme ceci:
int m_colorValue = 0;
public int Color
{
set { m_colorValue = value; }
get { return m_colorValue; }
}
C'est l'utilisation la plus simple. En gros, il définit une variable interne ou récupère sa valeur . Vous utilisez une propriété comme celle-ci:
someObject.Color = 222; // sets a color 222
int color = someObject.Color // gets the color of the object
Vous pourriez éventuellement faire un traitement sur la valeur dans les setters ou getters comme ceci:
public int Color
{
set { m_colorValue = value + 5; }
get { return m_colorValue - 30; }
}
si vous ignorez ou récupérez, votre propriété sera en lecture ou en écriture uniquement. C'est comme ça que je comprends les choses.
Ce serait un get/set en C # utilisant la plus petite quantité de code possible. Vous obtenez les propriétés implémentées automatiquement en C # 3.0+ .
public class Contact
{
public string Name { get; set; }
}
Ceci est un exemple de base d'un objet "Article" avec des accesseurs:
public class Article
{
public String title;
public String link;
public String description;
public string getTitle()
{
return title;
}
public void setTitle(string value)
{
title = value;
}
public string getLink()
{
return link;
}
public void setLink(string value)
{
link = value;
}
public string getDescription()
{
return description;
}
public void setDescription(string value)
{
description = value;
}
}
En interne, les getters et les setters ne sont que des méthodes. Lorsque C # est compilé, il génère des méthodes pour vos getters et setters comme ceci, par exemple:
public int get_MyProperty() { ... }
public void set_MyProperty(int value) { ... }
C # vous permet de déclarer ces méthodes en utilisant une syntaxe abrégée. La ligne ci-dessous sera compilée dans les méthodes ci-dessus lors de la création de votre application.
public int MyProperty { get; set; }
ou
private int myProperty;
public int MyProperty
{
get { return myProperty; }
set { myProperty = value; } // value is an implicit parameter containing the value being assigned to the property.
}
Les Getters et les Setters en C # simplifient le code.
private string name = "spots";
public string Name
{
get { return name; }
set { name = value; }
}
Et en l'appelant (supposons que nous avons une personne obj avec une propriété name):
Console.WriteLine(Person.Name); //prints "spots"
Person.Name = "stops";
Console.Writeline(Person.Name); //prints "stops"
Cela simplifie votre code. Où, en Java, vous devrez peut-être avoir deux méthodes, une pour Get () et une pour Set () la propriété, en C #, tout est fait en un seul endroit. Je le fais habituellement au début de mes cours:
public string foobar {get; set;}
Cela crée un getter et un setter pour ma propriété foobar. L'appeler est le même que celui indiqué ci-dessus. Certains points à noter sont que vous n'avez pas à inclure à la fois get et set. Si vous ne voulez pas que la propriété soit modifiée, n'incluez pas set!