Quelle est la différence entre un champ et une propriété?

Programmation orientée objet principes de dire que, le fonctionnement interne d'une classe doit être caché du monde extérieur. Si vous exposez un champ que vous êtes en essence d'exposer la mise en œuvre interne de la classe. Par conséquent, nous envelopper les champs avec des Propriétés (ou des méthodes en Java cas) pour nous donner la possibilité de changer la mise en œuvre sans casser le code qui dépend de nous. De voir qu'on peut mettre de la logique dans la Propriété nous permet également d'effectuer la validation de la logique, etc si nous en avons besoin.
C# 3 a peut-être déroutant notion de autoproperties. Cela nous permet de définir simplement la Propriété et le C#3 le compilateur va générer le domaine privé pour nous.

public class Person
{
   private string _name;

   public string Name
   {
      get
      {
         return _name;
      }
      set
      {
         _name = value;
      }
   }
   public int Age{get;set;} //AutoProperty generates private field for us
}

OriginalL'auteur

Je vais vous donner quelques exemples d'utilisation de propriétés qui pourraient obtenir les engrenages tournant:

• L'Initialisation Tardive: Si vous avez une propriété d'un objet qui coûte cher à la charge, mais n'est pas accessible à tous beaucoup plus que dans la normale exécute du code, vous pouvez retarder son chargement à l'aide de la propriété. De cette façon, il est juste assis là, mais la première fois un autre module tente d'appeler cette propriété, il vérifie si le champ sous-jacent est null si elle l'est, elle va de l'avant et la charge, inconnu du module appelant. Cela peut grandement accélérer l'initialisation de l'objet.
• Sale de Suivi: que j'ai vraiment appris à propos de mon propre question ici sur StackOverflow. Quand j'ai beaucoup d'objets dont les valeurs ont changé au cours d'une exécution, je peux utiliser la propriété à suivre si elles doivent être enregistrées dans la base de données ou non. Si ce n'est une propriété unique d'un objet a changé, la IsDirty drapeau de ne pas trébucher, et donc l'économie de fonctionnalité de l'ignorer au moment de décider de ce qui doit revenir à la base de données.

OriginalL'auteur

Car beaucoup d'entre eux ont expliqué à l'aide technique, les avantages et les inconvénients de Properties et Field, il est temps d'obtenir en temps réel des exemples.

1. Propriétés permet de définir les accès en lecture seule au niveau

De considérer le cas de dataTable.Rows.Count et dataTable.Columns[i].Caption. Ils viennent de la classe DataTable et les deux sont publics pour nous. La différence dans le niveau d'accès pour eux, c'est qu'on ne peut pas définir la valeur à dataTable.Rows.Count mais nous pouvons lire et écrire à dataTable.Columns[i].Caption. Est-ce possible par le biais de Field? Non!!! Cela peut être fait avec Properties seulement.

public class DataTable
{
    public class Rows
    {       
       private string _count;        

       //This Count will be accessable to us but have used only "get" ie, readonly
       public int Count
       {
           get
           {
              return _count;
           }       
       }
    } 

    public class Columns
    {
        private string _caption;        

        //Used both "get" and "set" ie, readable and writable
        public string Caption
        {
           get
           {
              return _caption;
           }
           set
           {
              _caption = value;
           }
       }       
    } 
}

2. Propriétés dans la grille des propriétés

Vous pourriez avoir travaillé avec Button dans Visual Studio. Ses propriétés sont affichées dans la PropertyGrid comme Text,Name etc. Lorsque nous faites glisser et déposez un bouton, et quand on clique sur les propriétés, il va automatiquement trouver la classe Button et filtres Properties et de montrer que dans PropertyGrid (où PropertyGrid de ne pas s'afficher Field même si elles sont publiques).

public class Button
{
    private string _text;        
    private string _name;
    private string _someProperty;

    public string Text
    {
        get
        {
           return _text;
        }
        set
        {
           _text = value;
        }
   } 

   public string Name
   {
        get
        {
           return _name;
        }
        set
        {
           _name = value;
        }
   } 

   [Browsable(false)]
   public string SomeProperty
   {
        get
        {
           return _someProperty;
        }
        set
        {
           _someProperty= value;
        }
   } 

Dans PropertyGrid, les propriétés Name et Text seront affichés, mais pas SomeProperty. Pourquoi??? Parce que les Propriétés peuvent accepter Attributs. Il ne s'affiche pas dans le cas où [Browsable(false)] est faux.

3. Peut exécuter des instructions à l'intérieur de Propriétés

public class Rows
{       
    private string _count;        


    public int Count
    {
        get
        {
           return CalculateNoOfRows();
        }  
    } 

    public int CalculateNoOfRows()
    {
         //Calculation here and finally set the value to _count
         return _count;
    }
}

4. Seules les Propriétés peuvent être utilisés dans la Source de Liaison

La Source De Liaison nous aide à réduire le nombre de lignes de code. Fields ne sont pas acceptés par BindingSource. Nous devrions utiliser Properties.

5. Mode de débogage

Considérons que nous sommes à l'aide de Field pour contenir une valeur. À un certain moment, nous avons besoin de déboguer et de vérifier si la valeur null pour ce champ. Il sera difficile de le faire lorsque le nombre de lignes de code sont plus de 1000. Dans de telles situations, nous pouvons utiliser Property et permet de définir le mode de débogage à l'intérieur de Property.

   public string Name
   {
        //Can set debug mode inside get or set
        get
        {
           return _name;
        }
        set
        {
           _name = value;
        }
   }

OriginalL'auteur

Propriétés ont pour principal avantage de vous permettre de changer la façon dont les données sur un objet est accessible sans casser son interface publique. Par exemple, si vous avez besoin d'ajouter une validation supplémentaire, ou pour modifier un champ stocké dans un calcul, vous pouvez le faire facilement si vous avez initialement exposé le champ en tant que propriété. Si vous venez exposés à un champ directement, alors que vous auriez à changer l'interface publique de la classe pour ajouter la nouvelle fonctionnalité. Cette modification aurait une pause de clients existants, les obligeant à être recompilé avant de pouvoir utiliser la nouvelle version de votre code.

Si vous écrivez une bibliothèque de classe conçu pour la consommation (comme le .NET Framework, qui est utilisé par des millions de personnes), qui peut être un problème. Toutefois, si vous écrivez une classe utilisée en interne au sein d'une petite base de code (dire <= 50 K lignes), c'est vraiment pas une grosse affaire, parce que personne ne serait en être défavorablement affectés par les changements. Dans ce cas, il a vraiment tout se résume à la préférence personnelle.

OriginalL'auteur

Dans le fond d'une propriété est compilé dans les méthodes. Ainsi, un Name propriété est compilé dans get_Name() et set_Name(string value). Vous pouvez voir si vous étudiez le code compilé.
Donc, il y a une (très) petite surcharge de performance lors de leur utilisation. Normalement, vous utilisez toujours une Propriété, si vous exposez un champ à l'extérieur, et vous aurez souvent l'utiliser en interne si vous avez besoin de faire de la validation de la valeur.

OriginalL'auteur

La deuxième question ici, "quand un champ être utilisé au lieu d'une propriété?", n'est que brièvement abordé dans cette autre réponse et un peu celle-ci aussi, mais pas vraiment beaucoup de détails.

En général, toutes les autres réponses sont spot-on sur la bonne conception: préférez exposer les propriétés de trop exposer les champs. Alors que vous ne sera probablement pas régulièrement trouver vous-même en disant "wow, imaginez combien pire des choses serait si j'avais fait ce un champ au lieu d'une propriété", c'est tellement plus rare de penser à une situation où l'on pouvait dire "wow, Dieu merci, j'ai utilisé un champ ici, au lieu d'une propriété."

Mais il y a un avantage que les champs ont plus de propriétés, et c'est leur capacité à être utilisés comme "ref" /"out" paramètres". Supposons que vous avez une méthode ayant la signature suivante:

public void TransformPoint(ref double x, ref double y);

et supposons que vous souhaitez utiliser cette méthode pour transformer un tableau créé comme ceci:

System.Windows.Point[] points = new Point[1000000];
Initialize(points);

Voici je pense que le moyen le plus rapide de le faire, depuis X et Y sont propriétés:

for (int i = 0; i < points.Length; i++)
{
    double x = points[i].X;
    double y = points[i].Y;
    TransformPoint(ref x, ref y);
    points[i].X = x;
    points[i].Y = y;
}

Et qui va être très bon! Sauf si vous avez les mesures de prouver le contraire, il n'y a aucune raison de lancer une odeur. Mais je crois que c'est techniquement pas garantis pour être aussi rapide que cela:

internal struct MyPoint
{
    internal double X;
    internal double Y;
}

//...

MyPoint[] points = new MyPoint[1000000];
Initialize(points);

//...

for (int i = 0; i < points.Length; i++)
{
    TransformPoint(ref points[i].X, ref points[i].Y);
}

Faire quelques les mesures moi-même, la version avec des champs prend environ 61% du temps que la version avec les propriétés (.NET de 4,6, Windows 7 x64, mode de libération, pas de débogueur). Le plus cher de la TransformPoint méthode vieillit, moins prononcée que la différence devient. Le répéter à vous-même, courir avec la première ligne commenté et, avec elle, pas commenté.

Même si il n'y avait pas d'avantages de performance pour le haut, il y a d'autres endroits où le fait d'être en mesure d'utiliser ref et les paramètres de sortie peuvent être utiles, comme lors de l'appel de la Interloqué ou Volatile famille de méthodes. Remarque: Dans le cas où cela est nouveau pour vous, la Volatilité est essentiellement un moyen d'obtenir le même comportement fournis par le volatile mot-clé. En tant que tel, comme volatile, il n'a pas comme par magie résoudre tous les thread-safety malheurs comme son nom suggère qu'il pourrait.

Je certainement ne voulez pas ressembler à je défends que vous allez vous dire "oh, je dois commencer à exposer les champs plutôt que des propriétés." Le point est que si vous avez besoin d'utiliser régulièrement ces membres dans les appels que prendre "ref" ou "out" paramètres, en particulier sur quelque chose qui pourrait être un simple type de la valeur qui est peu probable qu'on ait besoin de l'un des éléments à valeur ajoutée de propriétés, un argument peut être faite.

OriginalL'auteur

Si vous allez utiliser le thread primitives, vous êtes obligé d'utiliser des champs. Les propriétés peuvent briser votre fileté code. En dehors de cela, ce que cory est correct.

OriginalL'auteur

Techniquement, je ne pense pas qu'il y a une différence, parce que les propriétés sont juste des wrappers autour des champs créés par l'utilisateur ou automatiquement par le compilateur.Le but de propriétés est de faire respecter les encapsuation et à offrir un léger méthode-comme caractéristique.
C'est juste une mauvaise pratique de déclarer des champs en tant que public, mais il n'a pas de problèmes.

OriginalL'auteur

Champs sont membre ordinaire variables ou membre des instances d'une classe. Les propriétés sont un abstraction d'obtenir et de définir leurs valeurs. Les propriétés sont également appelées accesseurs, car ils offrent un moyen de changer et récupérer un champ si vous exposez un champ dans la classe en tant que privé. En général, vous devez déclarer vos variables de membre privé, puis de déclarer ou de définir des propriétés pour eux.

  class SomeClass
  {
     int numbera; //Field

     //Property 
    public static int numbera { get; set;}

  }

OriginalL'auteur

Propriétés encapsuler les champs, vous permettant ainsi d'effectuer un traitement supplémentaire sur la valeur de définir ou de récupérer. Typiquement, il est exagéré d'utiliser les propriétés si vous ne serez pas faire des pré - ou post-traitement sur la valeur du champ.

OriginalL'auteur

Traditionnellement champs privés sont définies par getter et setter. Par souci de moins de code, vous pouvez utiliser les propriétés pour définir les champs à la place.

OriginalL'auteur

De Wikipédia -- La programmation orientée objet:

La programmation orientée objet (POO) est un paradigme de programmation basé sur le concept d ' "objets", qui sont des structures de données qui contiennent des de données, sous la forme de champs, souvent connu sous le nom des attributs; et code, sous la forme de procédures, souvent connu sous le nom de méthodes de. (italiques ajoutés)

Propriétés sont en fait une partie d'un objet de comportement, mais ils sont conçus pour donner aux consommateurs de l'objet de l'illusion/abstraction de travailler avec les données de l'objet.

OriginalL'auteur

Propriétés sont utilisées pour exposer le terrain. Ils utilisent des accesseurs(set, get) à travers lequel les valeurs des champs privés peuvent être lues, écrites ou de les manipuler.

Propriétés ne nommez pas les emplacements de stockage. Au lieu de cela, ils ont accesseurs que lire, écrire ou calculer leurs valeurs.

À l'aide de propriétés, nous pouvons définir la validation sur le type de données est défini sur un champ.

Par exemple, nous avons privé champ entier de l'âge sur que nous devrions permettre à des valeurs positives depuis l'âge ne peut pas être négative.

Nous pouvons le faire de deux façons en utilisant des accesseurs et des mutateurs et en utilisant la propriété.

 Using Getter and Setter

    //field
    private int _age;

    //setter
    public void set(int age){
      if (age <=0)
       throw new Exception();

      this._age = age;
    }

    //getter
    public int get (){
      return this._age;
    }

 Now using property we can do the same thing. In the value is a key word

    private int _age;

    public int Age{
    get{
        return this._age;
    }

    set{
       if (value <= 0)
         throw new Exception()
       }
    }

Automatique de mise en œuvre de la propriété si nous n'avons pas de logique dans les accesseurs get et set, nous pouvons utiliser l'auto mise en œuvre de la propriété.

Quand use auto-mise en œuvre de la propriété compile crée un privé, anonyme champ qui ne peuvent être accessibles par le biais de accesseurs get et set.

public int Age{get;set;}

Résumé Des Propriétés
Une classe abstraite peut avoir un résumé de la propriété, qui doit être mis en œuvre dans la classe dérivée

public abstract class Person
   {
      public abstract string Name
      {
         get;
         set;
      }
      public abstract int Age
      {
         get;
         set;
      }
   }

//overriden something like this
//Declare a Name property of type string:
  public override string Name
  {
     get
     {
        return name;
     }
     set
     {
        name = value;
     }
  }

Nous pouvons définir une propriété privée
Dans ce que nous pouvons en privé, définissez la propriété automatique(définie dans la classe)

public int MyProperty
{
    get; private set;
}

Vous pouvez obtenir même avec ce code. Dans ce jeu de propriétés fonctionnalité n'est pas disponible, nous avons la valeur de domaine directement en.

private int myProperty;
public int MyProperty
{
    get { return myProperty; }
}

OriginalL'auteur

La grande majorité des cas ça va être un nom de propriété que vous avez accès, par opposition à un nom de variable (champ) La raison en est que c'est considéré comme une bonne pratique .NET et C#, en particulier, pour protéger chaque morceau de données au sein d'une classe, si c'est une variable d'instance ou d'une variable statique (variable de classe), car il est associé à une classe.

Protéger l'ensemble de ces variables avec des propriétés qui vous permettent de définir, définir et obtenir les accesseurs et faire des choses comme la validation lorsque vous êtes à la manipulation de ces éléments de données.

Mais dans d'autres cas, comme La classe de mathématiques (espace de noms System), il ya un couple de propriétés statiques qui sont intégrés dans la classe. dont l'un est le calcul de la constante PI

par exemple. Les mathématiques.PI

et parce que PI est un morceau de données qui est bien défini, nous n'avons pas besoin d'avoir plusieurs copies de PI, il va toujours être la même valeur. Donc, les variables statiques sont parfois utilisés pour partager des données entre un objet d'une classe, mais le sont également couramment utilisés pour la constante de l'information où vous avez seulement besoin d'une copie de l'élément de données.

OriginalL'auteur

Infos supplémentaires:
Par défaut, les accesseurs get et set sont aussi accessible que la propriété elle-même.
Vous pouvez contrôler ou limiter l'accesseur de l'accessibilité individuelles (get et set) par l'application plus restrictive des modificateurs d'accès.

Exemple:

public string Name
{
    get
    {
        return name;
    }
    protected set
    {
        name = value;
    }
}

Ici obtenir est toujours accessible par le public (comme la propriété est publique), mais l'ensemble est protégé (l'accès est plus limité prescripteur).

OriginalL'auteur