C-3.0 auto-properties – utile ou non?

Note: Ceci a été posté quand je commençais C #. Avec les connaissances de 2014, je peux vraiment dire que les propriétés automatiques font partie des meilleures choses qui soient arrivées au langage C #.

Je suis habitué à créer mes propriétés en C # en utilisant un champ privé et public:

private ssortingng title; public ssortingng Title { get { return title; } set { title = value; } } 

Maintenant, avec .NET 3.0, nous avons des propriétés automatiques:

 public ssortingng Title { get; set; } 

Je sais que ce sont plus des questions philosophiques / subjectives, mais y a-t-il une raison d’utiliser ces auto-propriétés sauf d’enregistrer cinq lignes de code pour chaque champ? Mon reproche personnel est que ces propriétés me cachent des choses, et je ne suis pas un grand fan de la magie noire.

En fait, le champ privé masqué n’apparaît même pas dans le débogueur, ce qui est correct étant donné que les fonctions get / set ne font rien. Mais quand je veux réellement implémenter une logique getter / setter, je dois quand même utiliser la paire public / privé.

Je vois l’avantage que je sauve beaucoup de code (une à six lignes) sans perdre la possibilité de changer la logique getter / setter plus tard, mais encore une fois je peux déjà le faire en déclarant simplement un champ public “Titre de chaîne publique” sans le besoin du {get; ensemble; } bloquer, économisant ainsi plus de code.

Alors, qu’est-ce qui me manque ici? Pourquoi quelqu’un voudrait-il réellement utiliser les propriétés automatiques?

    Nous les utilisons tout le temps dans Stack Overflow.

    Vous pourriez également être intéressé par une discussion sur les propriétés et les variables publiques . À mon humble avis, c’est vraiment une réaction à cela, et pour cela, c’est génial.

    Oui, il suffit de sauvegarder le code. Il est plus facile de lire des miles lorsque vous en avez beaucoup. Ils sont plus rapides à écrire et plus faciles à entretenir. Le code de sauvegarde est toujours un bon objective.

    Vous pouvez définir différentes scopes:

     public ssortingng PropertyName { get; private set; } 

    Pour que la propriété ne puisse être modifiée que dans la classe. Ce n’est pas vraiment immuable car vous pouvez toujours accéder au setter privé par la reflection.

    A partir de C # 6, vous pouvez également créer de vraies propriétés en readonly , c’est-à-dire des propriétés immuables qui ne peuvent pas être modifiées en dehors du constructeur:

     public ssortingng PropertyName { get; } public MyClass() { this.PropertyName = "whatever"; } 

    Au moment de la compilation cela deviendra:

     readonly ssortingng pName; public ssortingng PropertyName { get { return this.pName; } } public MyClass() { this.pName = "whatever"; } 

    Dans les classes immuables avec beaucoup de membres, cela permet d’économiser beaucoup de code.

    Les trois gros inconvénients de l’utilisation des champs au lieu des propriétés sont les suivants:

    1. Vous ne pouvez pas vous connecter à un champ alors que vous pouvez accéder à une propriété
    2. Si vous commencez à utiliser un champ, vous ne pourrez plus les changer ultérieurement (facilement) en propriété
    3. Certains atsortingbuts peuvent être ajoutés à une propriété que vous ne pouvez pas append à un champ

    Personnellement, j’aime les auto-propriétés. Quel est le problème avec la sauvegarde des lignes de code? Si vous voulez faire des choses dans les getters ou les setters, il n’y a pas de problème pour les convertir ultérieurement en propriétés normales.

    Comme vous l’avez dit, vous pouvez utiliser des champs et si vous voulez leur append de la logique, vous devez les convertir en propriétés. Mais cela pourrait présenter des problèmes d’utilisation de la reflection (et peut-être ailleurs?).

    Les propriétés vous permettent également de définir différents niveaux d’access pour le getter et le setter que vous ne pouvez pas faire avec un champ.

    Je suppose que c’est la même chose que le mot-clé var. Une question de préférence personnelle.

    De Bjarne Stroustrup, créateur de C ++:

    Je n’aime pas particulièrement les cours avec beaucoup de fonctions get et set. C’est souvent une indication que cela n’aurait pas dû être une classe en premier lieu. C’est juste une structure de données. Et si c’est vraiment une structure de données, faites-en une structure de données.

    Un tu sais quoi? Il a raison. À quelle fréquence placez-vous simplement les champs privés dans un get et un set, sans rien faire dans get / set, simplement parce que c’est la chose à faire avec les objects. C’est la solution de Microsoft au problème. Ce sont essentiellement des champs publics auxquels vous pouvez vous connecter.

    Une chose que personne ne semble avoir mentionnée est la façon dont les propriétés automatiques ne sont malheureusement pas utiles pour les objects immuables (généralement des structures immuables). Parce que pour cela vous devriez vraiment faire:

     private readonly ssortingng title; public ssortingng Title { get { return this.title; } } 

    (où le champ est initialisé dans le constructeur via un paramètre passé, puis est en lecture seule.)

    Cela présente donc des avantages par rapport à un simple autoproperty private set / get private set .

    Je crée toujours des propriétés au lieu de champs publics car vous pouvez utiliser des propriétés dans une définition d’interface, vous ne pouvez pas utiliser de champs publics dans une définition d’interface.

    Les propriétés automatiques sont autant une magie noire que toute autre chose en C #. Une fois que vous y réfléchissez en termes de compilation en IL plutôt que de l’étendre à une propriété C # normale, c’est beaucoup moins de magie noire que beaucoup d’autres constructions de langage.

    J’utilise les auto-propriétés tout le temps. Avant C # 3, je ne pouvais pas être dérangé par la saisie et je me suis contenté d’utiliser des variables publiques.

    La seule chose qui me manque, c’est de pouvoir faire ça:

     public ssortingng Name = "DefaultName"; 

    Vous devez déplacer les valeurs par défaut dans vos constructeurs avec des propriétés. fastidieux 🙁

    Je pense que toute construction intuitive ET réduisant les lignes de code est un gros plus.

    Ce sont ces types de fonctionnalités qui rendent les langages tels que Ruby si puissants (cela et les fonctions dynamics, qui aident également à réduire les excès de code).

    Ruby a toujours eu comme:

     attr_accessor :my_property attr_reader :my_getter attr_writer :my_setter 

    Le seul problème que j’ai avec eux, c’est qu’ils ne vont pas assez loin. La même version du compilateur qui a ajouté des propriétés automatiques, ajouté des méthodes partielles. Pourquoi ils n’ont pas mis les deux ensemble est au-delà de moi. Un simple “partiel sur Changed” aurait rendu ces choses vraiment très utiles.

    C’est simple, c’est court et si vous voulez créer une véritable implémentation dans le corps de la propriété, cela ne cassera pas l’interface externe de votre type.

    Aussi simple que cela.

    Une chose à noter ici est que, à ma connaissance, il s’agit simplement de sucre syntaxique au niveau C # 3.0, ce qui signifie que l’IL généré par le compilateur est le même. Je suis d’accord pour éviter la magie noire, mais quand même, moins de lignes pour la même chose est une bonne chose.

    À mon avis, vous devez toujours utiliser les propriétés automatiques au lieu des champs publics. Cela dit, voici un compromis:

    Commencez avec un champ interne en utilisant la convention de dénomination que vous utiliseriez pour une propriété. Quand vous avez d’abord soit

    • besoin d’accéder au terrain depuis l’extérieur de son assemblage, ou
    • besoin d’attacher une logique à un getter / setter

    Faites ceci:

    1. renommer le champ
    2. le rendre privé
    3. append une propriété publique

    Votre code client n’aura pas besoin de changer.

    Un jour, cependant, votre système se développera et vous le décomposerez en assemblages séparés et en solutions multiples. Lorsque cela se produit, tous les champs exposés reviendront vous hanter, car, comme Jeff l’a mentionné, changer un champ public en propriété publique est un changement révolutionnaire de l’API .

    J’utilise CodeRush, c’est plus rapide que les propriétés automatiques.

    Pour faire ça:

      private ssortingng title; public ssortingng Title { get { return title; } set { title = value; } } 

    Nécessite huit frappes au total.

    Eh bien, avec des extraits de code, une auto-propriété du même nom serait sept frappes au total;)

    @Domenic: Je ne comprends pas .. vous ne pouvez pas faire cela avec les propriétés auto?

     public ssortingng Title { get; } 

    ou

     public ssortingng Title { get; private set; } 

    Est-ce ce dont vous parlez?

    Mon plus grand reproche avec les propriétés automatiques est qu’elles sont conçues pour gagner du temps, mais je trouve souvent que je dois les développer plus tard avec des propriétés complètes.

    Ce qui manque à VS2008, c’est un refactore Auto-propriété éclaté.

    Le fait que nous ayons un refactor de champ encapsulé rend la façon dont je travaille plus rapidement d’utiliser des champs publics.