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, vous exposez essentiellement l'implémentation interne de la classe. Par conséquent, nous enveloppons les champs avec des propriétés (ou des méthodes dans le cas de Java) pour nous donner la possibilité de changer l'implémentation sans casser le code qui dépend de nous. Voir que nous pouvons mettre la logique dans la propriété nous permet également d'effectuer la logique de validation etc si nous en avons besoin. C# 3 a la notion peut-être confuse d'autopropulseurs. Cela nous permet de définir simplement la propriété et le compilateur C#3 générera le champ 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
}

une différence importante est que les interfaces peuvent avoir des propriétés mais pas des champs. Cela, pour moi, souligne que les propriétés doivent être utilisées pour définir l'interface publique d'une classe alors que les champs sont destinés à être utilisés dans le fonctionnement interne privé d'une classe. En règle générale, je crée rarement des champs publics et de la même manière je crée rarement des propriétés non publiques.

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

• initialisation paresseuse : si vous possédez une propriété d'un objet qui coûte cher à charger, mais qui n'est pas accessible dans les passages normaux du code, vous pouvez retarder son chargement via 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.
• Dirty Tracking: ce que j'ai appris de ma propre question ici sur StackOverflow. Quand j'ai beaucoup d'objets dont les valeurs peuvent avoir changé pendant une course, je peux utiliser la propriété pour suivre s'ils doivent être sauvegardés dans la base de données ou pas. Si pas un seul la propriété d'un objet a changé, le drapeau IsDirty ne se déclenchera pas, et donc la fonctionnalité de sauvegarde sautera dessus au moment de décider ce qui doit revenir à la base de données.

en utilisant des propriétés, Vous pouvez lancer un événement, lorsque la valeur de la propriété est changée (alias. PropertyChangedEvent) ou avant que la valeur est changée pour soutenir l'annulation.

cela n'est pas possible avec les champs (accès direct).

public class Person {
 private string _name;

 public event EventHandler NameChanging;     
 public event EventHandler NameChanged;

 public string Name{
  get
  {
     return _name;
  }
  set
  {
     OnNameChanging();
     _name = value;
     OnNameChanged();
  }
 }

 private void OnNameChanging(){
   EventHandler localEvent = NameChanging;
   if (localEvent != null) {
     localEvent(this,EventArgs.Empty);
   }
 }

 private void OnNameChanged(){
   EventHandler localEvent = NameChanged;
   if (localEvent != null) {
     localEvent(this,EventArgs.Empty);
   }
 }
}

comme beaucoup d'entre eux ont expliqué avec des avantages et des inconvénients techniques de Properties et Field , il est temps d'entrer dans des exemples en temps réel.

1. Propriétés Vous permet de définir le niveau d'accès en lecture seule

prenons le cas de la 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 à eux est que nous ne pouvons pas fixer de valeur à dataTable.Rows.Count mais on peut lire et écrire à dataTable.Columns[i].Caption . Est-ce possible grâce à Field ? Pas de!!! Cela peut être fait avec Properties .

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 de la propriété grid

vous auriez pu travailler avec Button dans Visual Studio. Ses propriétés sont indiquées dans le PropertyGrid comme Text , Name etc. Quand nous faisons glisser et déposons un bouton, et quand nous cliquons sur les propriétés, il sera trouver automatiquement la classe Button et les filtres Properties et montrer que dans PropertyGrid (où PropertyGrid ne montrera pas 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 indiquées, mais pas SomeProperty . Pourquoi??? Parce que les propriétés peuvent accepter attributs . Il n'apparaît pas dans le cas où [Browsable(false)] est faux.

3. Peut exécuter des instructions à L'intérieur des 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ées dans le liant Source

Binding Source nous aide à diminuer le nombre de lignes de code. Fields ne sont pas acceptés par BindingSource . On devrait utiliser Properties pour ça.

5. Mode de débogage

Considérons que nous sommes à l'aide de Field pour contenir une valeur. À un moment donné, nous devons déboguer et vérifier où la valeur est nulle 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 définir le mode de débogage dans Property .

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

différences-utilisations (quand et pourquoi)

Un champ est une variable qui est déclarée directement dans une classe ou structure. Une classe ou structure peut avoir des champs d'instance ou de champs statiques ou les deux. En général, vous devez utiliser les champs seulement pour les variables qui ont une accessibilité privée ou protégée . Les données que votre classe expose au code client doivent être fournies par les méthodes, les propriétés et les indexeurs. Par en utilisant ces constructions pour l'accès indirect aux champs internes, vous pouvez vous prémunir contre des valeurs d'entrée invalides.

Un propriété est un membre qui fournit un mécanisme souple pour lire, écrire ou calculer la valeur d'un champ privé. Les propriétés peuvent être utilisées comme s'il s'agissait de données publiques, mais ce sont en fait des méthodes spéciales appelées accesseurs . Cela permet d'accéder facilement aux données et contribue encore à promouvoir le sécurité et flexibilité des méthodes . Les propriétés permettent à une classe d'exposer une façon publique d'obtenir et de définir des valeurs, tout en cachant le code d'implémentation ou de vérification. Un accesseur get property est utilisé pour retourner la valeur de la propriété, et un accesseur set est utilisé pour attribuer une nouvelle valeur.

propriétés ont l'avantage principal de vous permettre de changer la façon dont les données sur un objet est accédé sans briser 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 exposez un champ directement, alors vous devrez changer l'interface publique de votre classe pour ajouter la nouvelle fonctionnalité. Ce changement briserait les clients existants, en exigeant qu'ils soient recompilés avant qu'ils puissent utiliser la nouvelle version de votre code.

si vous écrivez une bibliothèque de classe conçue pour une large consommation (comme le .net Framework, qui est utilisé par des millions de personnes), cela peut être un problème. Cependant, si vous écrivez une classe utilisée en interne à l'intérieur d'une petite base de code (disons <= 50 lignes K), ce n'est vraiment pas une grosse affaire, parce que personne ne serait affecté négativement par vos changements. Dans ce cas il vraiment juste personnelles préférence.

dans le fond une propriété est compilée en méthodes. Ainsi, une propriété Name est compilée en get_Name() et set_Name(string value) . Vous pouvez voir si vous étudiez le code compilé. Il y a donc une (très) petite performance aérienne 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.

supportent l'accès asymétrique, c'est-à-dire que vous pouvez avoir soit un getter et un setter, soit un seul des deux. De même, les propriétés prennent en charge l'accessibilité individuelle pour getter/setter. Les champs sont toujours symétriques, c'est à dire que vous pouvez toujours obtenir et définir la valeur. Une Exception à cela est les champs readonly qui ne peuvent évidemment pas être définis après l'initialisation.

propriétés peuvent fonctionner pendant une très longue période, ont des effets secondaires, et peut même jeter exceptions. Les champs sont rapides, sans effets secondaires, et ne fera jamais d'exception. En raison d'effets secondaires, une propriété peut retourner une valeur différente pour chaque appel (comme cela peut être le cas pour DateTime).Maintenant, C'est-à-dire DateTime.Now n'est pas toujours égal à DateTime.Maintenant.) Champs retourne toujours la même valeur.

peuvent être utilisés pour les paramètres out / ref, les propriétés peuvent ne pas l'être. Les propriétés supportent une logique supplémentaire – cela pourrait être utilisé pour mettre en œuvre le chargement paresseux entre autres choses.

propriétés soutenir un niveau d'abstraction en encapsulant ce que cela signifie pour obtenir/définir la valeur.

Utiliser les propriétés dans la plupart des cas, mais essayez d'éviter les effets secondaires.

lorsque vous voulez que votre variable privée(champ) soit accessible à l'objet de votre classe à partir d'autres classes, vous devez créer des propriétés pour ces variables.

par exemple si j'ai des variables nommées "id" et "nom" qui est privé mais il peut y avoir des situations où cette variable doit être utilisée en lecture/écriture en dehors de la classe. Dans cette situation, la propriété peut m'aider à obtenir cette variable à lire / écrire en fonction de l'get / set défini pour le propriété. Une propriété peut être readonly / writeonly / readwrite both.

voici la démo

class Employee
{
    // Private Fields for Employee
    private int id;
    private string name;

    //Property for id variable/field
    public int EmployeeId
    {
       get
       {
          return id;
       }
       set
       {
          id = value;
       }
    }

    //Property for name variable/field
    public string EmployeeName
    {
       get
       {
          return name;
       }
       set
       {
          name = value;
       }
   }
}

class MyMain
{
    public static void Main(string [] args)
    {
       Employee aEmployee = new Employee();
       aEmployee.EmployeeId = 101;
       aEmployee.EmployeeName = "Sundaran S";
    }
}

La deuxième question ici, "quand un champ être utilisé au lieu d'une propriété?", n'est que brièvement évoqué dans cette autre réponse et un peu trop , 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érer les propriétés d'exposition plutôt que les champs d'exposition. Alors que vous ne serez probablement pas régulièrement se retrouver à dire " wow, imaginez combien pire, les choses seraient 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 sur les propriétés, et c'est leur capacité à être utilisé comme paramètres" ref " / "out". Supposons que vous ayez une méthode avec 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 pour le faire, depuis X et Y sont des 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 ça va être pas mal! Sauf si vous avez des mesures qui prouvent le contraire, il n'y a aucune raison de jeter une puanteur. Mais je crois que ce n'est pas techniquement garanti d'ê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 certains 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). Plus la méthode TransformPoint est coûteuse, moins la différence est prononcée. Le répéter à vous-même, courir avec la première ligne commenté et, avec elle, pas commenté.

même s'il n'y avait pas d'avantage lié au rendement pour ce qui est de ce qui précède, il existe d'autres endroits où le fait de pouvoir utiliser des paramètres ref et out pourrait être bénéfique, comme lorsqu'on appelle la famille de méthodes Entrelockée ou Volatile . Note: dans le cas où cela est nouveau pour vous, Volatile est fondamentalement un moyen d'obtenir le même comportement fourni par le mot-clé volatile . En tant que tel, comme volatile , il ne résout pas par magie tous les problèmes de sécurité du fil comme son nom suggère qu'il pourrait.

Je ne veux vraiment pas avoir l'air de préconiser que vous alliez "oh, je devrais commencer à exposer des champs au lieu de propriétés."Le point est que si vous avez besoin d'utiliser régulièrement ces membres dans les appels qui prennent des paramètres" ref "ou" out", en particulier sur quelque chose qui pourrait être un type de valeur simple qui est peu probable d'avoir jamais besoin de l'un des éléments de valeur ajoutée des propriétés, un argument peut être fait.

en outre, les propriétés Vous permettent d'utiliser la logique lors de la définition des valeurs.

ainsi vous pouvez dire que vous voulez seulement mettre une valeur à un champ entier, si la valeur est supérieure à x, sinon jeter une exception.

fonction vraiment utile.

si vous allez utiliser des primitives thread, vous êtes forcé d'utiliser des champs. Les propriétés peuvent casser votre code fileté. En dehors de cela, ce que cory a dit est correct.

(Ce doit vraiment être un commentaire, mais je ne peux pas poster un commentaire, s'il vous plaît excuser si il n'est pas approprié comme un post).

j'ai déjà travaillé à un endroit où la pratique recommandée était d'utiliser des champs publics au lieu de propriétés alors que la propriété équivalente def aurait simplement été d'accéder à un champ, comme dans:

get { return _afield; }
set { _afield = value; }

Leur raisonnement était que le champ public pourrait être converti en une propriété plus tard dans l'avenir si nécessaire. Il semblait un peu étrange pour moi à l'époque. À en juger par ces messages, il semble que peu ici seraient d'accord non plus. Qu'auriez-vous pu dire pour essayer de changer les choses ?

Edit: je devrais ajouter que toute la base de code à cet endroit a été compilée en même temps, de sorte qu'ils ont pu penser que changer l'interface publique des classes (en changeant un champ public en propriété) n'était pas un problème.

cette page sur MSDN a une comparaison et des conseils sur lequel utiliser quand:

https://msdn.microsoft.com/en-us/library/9d65as2e (v=vs 90).aspx

sont les variables de membre ordinaire ou les instances de membre d'une classe. Les propriétés sont une abstraction pour obtenir et définir leurs valeurs . Les propriétés sont aussi appelées accesseurs parce qu'elles offrent un moyen de changer et de récupérer un champ si vous exposez un champ dans la classe comme privé. En général, vous devez déclarer vos variables membres privées, puis déclarer ou définir des propriétés pour elles.

  class SomeClass
  {
     int numbera; //Field

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

  }

encapsulent les champs, vous permettant ainsi d'effectuer un traitement supplémentaire sur la valeur à définir ou à récupérer. Il est généralement exagéré d'utiliser des propriétés si vous ne faites pas de pré - ou post-traitement sur la valeur du champ.

techniquement, Je ne pense pas qu'il y ait de différence, parce que les propriétés sont simplement des enveloppements autour des champs créés par l'utilisateur ou automatiquement créés par le compilateur.Le but de properties est d'imposer l'encapsulation et d'offrir une fonctionnalité de méthode légère. C'est une mauvaise pratique de déclarer les champs publics, mais ça n'a aucun problème.

de l'OMI, les Propriétés ne sont que la "SetXXX()" "GetXXX()" fonctions/méthodes/interfaces paires, nous avons utilisé avant, mais ils sont plus concise et élégante.

traditionnellement, les champs privés sont définis par les méthodes getter et setter. Pour le plaisir de moins de code vous pouvez utiliser des propriétés pour définir des champs à la place.

quand vous avez une classe qui est "Voiture". Les propriétés sont la couleur,la forme..

où les champs as sont des variables définies dans le champ d'application d'une classe.

De Wikipédia -- programmation orientée Objet :

Object-oriented programming (OOP) est un paradigme de programmation basé sur le concept d ' "objets", qui sont des structures de données qui contiennent des données , sous la forme de champs , souvent appelés attributs; et code, sous la forme de procédures, souvent connues sous le nom de méthodes . (non souligné dans l'original)

les propriétés font en fait partie du comportement d'un objet, mais sont conçues pour donner aux consommateurs de l'objet l'illusion/l'abstraction de travailler avec les données de l'objet.

propriétés sont un type spécial de membre de classe, dans les propriétés, nous utilisons un ensemble prédéfini ou obtenir la méthode.Ils utilisent des accesseurs par lesquels nous pouvons lire, écrire ou changer les valeurs des champs privés.

par exemple , prenons une classe appelée Employee , avec des champs privés pour le nom, l'âge et Employee_Id. Nous ne pouvons pas accéder à ces champs depuis l'extérieur de la classe , mais nous pouvons accéder à ces champs privés par le biais de propriétés.

Pourquoi utilisons-nous propriétés?

pour comprendre cela clairement avec un exemple permet de prendre une classe d'étudiant qui ont ID, passmark, nom. Maintenant dans cet exemple quelque problème avec le champ public

• ID ne doit pas être -cinq.
• nom ne peut pas être défini à null
• la note de passage devrait être en lecture seule.
• si le nom de l'étudiant est manquant, aucun nom ne doit être retourné.

pour supprimer ce problème, nous utilisons la méthode Get and set.

// A simple example
public class student
{
    public int ID;
    public int passmark;
    public string name;
}

public class Program
{
    public static void Main(string[] args)
    {
       student s1 = new student();
       s1.ID = -101; // here ID can't be -ve
       s1.Name = null ; // here Name can't be null
    }
}

Maintenant, nous prenons un exemple de méthodes get et set

public class student
{
    private int _ID;
    private int _passmark;
    private string_name ;
    // for id property
    public void SetID(int ID)
    {
        if(ID<=0)
        {
            throw new exception("student ID should be greater then 0");
        }
        this._ID = ID;
    }
    public int getID()
    {
        return_ID;
    }
}
public class programme
{
    public static void main()
    {
        student s1 = new student ();
        s1.SetID(101);
    }
    // Like this we also can use for Name property
    public void SetName(string Name)
    {
        if(string.IsNullOrEmpty(Name))
        {
            throw new exeception("name can not be null");
        }
        this._Name = Name;
    }
    public string GetName()
    {
        if( string.IsNullOrEmpty(This.Name))
        {
            return "No Name";
        }
        else
        {
            return this._name;
        }
    }
        // Like this we also can use for Passmark property
    public int Getpassmark()
    {
        return this._passmark;
    }
}

Ma conception d'un champ est un champ doit être modifié uniquement par sa mère, d'où la classe. Résultat la variable devient privée, puis d'être en mesure de donner le droit de lire les classes / méthodes en dehors de je passe par le système de la propriété avec seulement L'Get. Le champ est alors récupéré par la propriété en lecture seule et! Si vous voulez la modifier vous devez passer par des méthodes (par exemple le constructeur) et je trouve que grâce à cette façon de vous rendre sûr, nous avons un meilleur contrôle sur notre code parce que nous"bouchons". On pourrait très bien toujours tout mettre en public donc tous les cas possibles, la notion de variables / méthodes / classes etc... à mon avis c'est juste une aide pour le développement, la maintenance du code. Par exemple, si une personne reprend un code avec des champs publics, elle peut faire n'importe quoi et donc des choses "illogiques" en relation avec l'objectif, la logique de pourquoi le code a été écrit. C'est mon point de vue.

quand j'utilise un modèle classique domaine privé / public readonly propriétés,pour 10 soldats champs je devrais écrire 10 publics propriétés! Le code peut être beaucoup plus rapide. Je découvre le setter privé et maintenant j'utilise seulement les propriétés publiques avec un setter privé. Le setter crée en arrière plan un champ privé.

C'est pourquoi mon vieux style de programmation classique était:

public class MyClass
{
 private int _id;
 public int ID { get { return _id; } }
 public MyClass(int id)
 {
  _id = id;
 }
}

mon nouveau style de programmation:

public class MyClass
{
 public int ID { get; private set; }
 public MyClass(int id)
 {
  ID = id;
 }
}

la grande majorité des cas, il va être un nom de propriété que vous accédez par opposition à un nom de variable ( champ ) la raison en est qu'il est considéré comme une bonne pratique en .NET et en C# en particulier pour protéger chaque morceau de données au sein d'une classe, que ce soit une variable d'instance ou une variable statique (variable de classe) parce qu'il est associé à une classe.

protège toutes ces variables avec des propriétés correspondantes qui permettent vous devez définir, définir et obtenir accesseurs et faire des choses comme la validation lorsque vous manipulez ces morceaux de données.

mais dans d'autres cas comme classe de mathématiques (Espace-nom du système), Il ya un couple de propriétés statiques qui sont intégrés dans la classe. l'un d'eux est la constante mathématique PI

par exemple. Mathématique.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. Ainsi les variables statiques sont parfois utilisées pour partager des données parmi l'objet d'une classe, mais elles sont aussi couramment utilisées pour des informations constantes où vous n'avez besoin que d'une copie d'un morceau de données.

informations supplémentaires: Par défaut, les accesseurs get et set sont aussi accessibles que la propriété elle-même. Vous pouvez contrôler / restreindre l'accessibilité ou l'accessibilité individuellement (pour get et set) en appliquant des modificateurs d'accès plus restrictifs.

exemple:

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

ici get est toujours accessible au public (puisque la propriété est publique), mais set est protégé (un spécificateur d'accès plus restreint).

sont utilisées pour exposer le champ. Ils utilisent des accesseurs (set, get) par lesquels les valeurs des champs privés peuvent être lues, écrites ou manipulées.

ne désignent pas les emplacements de stockage. Au lieu de cela, ils ont des accesseurs qui lisent, écrivent, ou calculent leurs valeurs.

en utilisant les propriétés nous pouvons définir la validation sur le type de données qui est défini sur un champ.

par exemple, nous avons l'âge de champ entier privé sur que nous devrions permettre des valeurs positives car l'âge ne peut pas être négatif.

nous pouvons le faire de deux façons en utilisant getter et setters 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()
       }
    }

Auto 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 u se auto-mise en œuvre de la propriété compile crée un privé, anonyme champ qui ne peuvent être accessibles par le biais de get et set accesseur.

public int Age{get;set;}

Abstrait "Propriétés De La 1519190920" Une classe abstraite peut avoir une propriété abstraite, qui doit être implémentée 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;
     }
  }

public int MyProperty
{
    get; private set;
}

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