Wat is het verschil tussen een veld en een eigenschap?

Wat maakt een veld in C# anders dan een eigenschap, en wanneer moet een veld worden gebruikt in plaats van een eigenschap?

Antwoord 1, autoriteit 100%

Eigenschappen stellen velden bloot. Velden moeten (bijna altijd) privé blijven voor een klasse en toegankelijk zijn via get en set-eigenschappen. Eigenschappen bieden een abstractieniveau waarmee u de velden kunt wijzigen zonder dat dit invloed heeft op de externe manier waarop ze worden benaderd door de dingen die uw klasse gebruiken.

public class MyClass
{
    // this is a field.  It is private to your class and stores the actual data.
    private string _myField;
    // this is a property. When accessed it uses the underlying field,
    // but only exposes the contract, which will not be affected by the underlying field
    public string MyProperty
    {
        get
        {
            return _myField;
        }
        set
        {
            _myField = value;
        }
    }
    // This is an AutoProperty (C# 3.0 and higher) - which is a shorthand syntax
    // used to generate a private field for you
    public int AnotherProperty { get; set; } 
}

@Kent wijst erop dat eigenschappen niet verplicht zijn om velden in te kapselen, ze zouden een berekening op andere velden kunnen doen of andere doeleinden kunnen dienen.

@GSS wijst erop dat je ook andere logica kunt doen, zoals valideren, wanneer een eigenschap wordt geopend, een andere handige functie.

Antwoord 2, autoriteit 25%

Objectgeoriënteerde programmeerprincipes zeggen dat de interne werking van een klasse verborgen moet blijven voor de buitenwereld. Als je een veld blootlegt, leg je in wezen de interne implementatie van de klasse bloot. Daarom wikkelen we velden in met Eigenschappen (of methoden in het geval van Java) om ons de mogelijkheid te geven de implementatie te wijzigen zonder de code te breken, afhankelijk van ons. Aangezien we logica in de eigenschap kunnen plaatsen, kunnen we ook validatielogica enz. uitvoeren als we die nodig hebben.
C# 3 heeft het mogelijk verwarrende begrip autoproperties. Dit stelt ons in staat om eenvoudig de eigenschap te definiëren en de C#3-compiler zal het privéveld voor ons genereren.

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
}

Antwoord 3, autoriteit 16%

Een belangrijk verschil is dat interfaces eigenschappen kunnen hebben, maar geen velden. Dit onderstreept voor mij dat eigenschappen moeten worden gebruikt om de openbare interface van een klasse te definiëren, terwijl velden bedoeld zijn om te worden gebruikt in de privé, interne werking van een klasse. In de regel maak ik zelden openbare velden en evenzo maak ik zelden niet-openbare eigenschappen.

Antwoord 4, autoriteit 10%

Ik zal je een paar voorbeelden geven van het gebruik van eigenschappen die de versnellingen kunnen laten draaien:

• Luie initialisatie:als je een eigenschap van een object hebt dat is duur om te laden, maar wordt niet zo vaak gebruikt in normale uitvoeringen van de code, je kunt het laden ervan vertragen via de eigenschap. Op die manier zit het daar gewoon, maar de eerste keer dat een andere module die eigenschap probeert aan te roepen, controleert het of het onderliggende veld null is – als dat zo is, gaat het door en laadt het, onbekend voor de aanroepende module. Dit kan de initialisatie van objecten aanzienlijk versnellen.
• Dirty Tracking:waarover ik eigenlijk heb geleerd van mijn eigen vraaghier op StackOverflow. Als ik veel objecten heb waarvan de waarden tijdens een run kunnen zijn gewijzigd, kan ik de eigenschap gebruiken om bij te houden of ze moeten worden opgeslagen in de database of niet. Als er geen enkele eigenschap van een object is gewijzigd, wordt de vlag IsDirty niet geactiveerd, en daarom zal de opslagfunctie deze overslaan bij het beslissen wat terug moet naar de database.

Antwoord 5, autoriteit 5%

Met Eigenschappen kunt u een gebeurtenis activeren wanneer de waarde van de eigenschap wordt gewijzigd (ook wel PropertyChangedEvent genoemd) of voordat de waarde wordt gewijzigd om annulering te ondersteunen.

Dit is niet mogelijk met (directe toegang tot) velden.

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(){       
     NameChanging?.Invoke(this,EventArgs.Empty);       
 }
 private void OnNameChanged(){
     NameChanged?.Invoke(this,EventArgs.Empty);
 }
}

Antwoord 6, autoriteit 4%

VERSCHILLEN – GEBRUIK (wanneer en waarom)

Een veldis een variabele die direct in een klasse of struct wordt gedeclareerd. Een klasse of struct kan instantievelden of statische velden hebben of beide. Over het algemeen moet u velden alleen gebruiken voor variabelen die privé of beschermde toegankelijkheid hebben. Gegevens die uw klas blootstelt aan clientcode moeten worden verstrekt via methoden, eigenschappenen indexeerders. Door deze constructies te gebruiken voor indirecte toegang tot interne velden, kunt u zich beschermen tegen ongeldige invoerwaarden.

A Property is een lid dat een flexibel mechanisme biedt om de waarde van een privéveld te lezen, te schrijven of berekenen. Eigenschappen kunnen worden gebruikt alsof het publieke gegevensleden zijn, maar ze zijn eigenlijk speciale methoden genaamd accessors . Hierdoor kunnen gegevens eenvoudig worden geopend en helpt nog steeds de bevordering van de veiligheid en flexibiliteit van methoden .
Eigenschappen stellen een klasse in staat om een ​​openbare manier van het krijgen en instellen en instellen en instellen en instellen van implementatie- of verificatiecode. Een ontvangen accessor wordt gebruikt om de eigenschapswaarde te retourneren en een ingestelde accessor wordt gebruikt om een ​​nieuwe waarde toe te wijzen.

7

Eigenschappen hebben het primaire voordeel waarmee u de manier waarop gegevens op een object toegankelijk is te kunnen veranderen zonder het openbare interface te verbreken. Als u bijvoorbeeld extra validatie wilt toevoegen of om een ​​opgeslagen veld in een berekend te wijzigen, kunt u dit doen als u aanvankelijk het veld als een woning hebt blootgelegd. Als u net een veld rechtstreeks blootlegt, moet u de openbare interface van uw klasse wijzigen om de nieuwe functionaliteit toe te voegen. Die verandering zou bestaande klanten doorbreken, waardoor ze worden gecompileerd voordat ze de nieuwe versie van uw code kunnen gebruiken.

Als u een klassenbibliotheek schrijft die is ontworpen voor een breed verbruik (zoals het .NET-framework, dat door miljoenen mensen wordt gebruikt), kan dat een probleem zijn. Als u echter een les aan het schrijven bent die intern in een kleine codebasis wordt gebruikt (Say & LT; = 50 K-lijnen), is het echt geen big deal, omdat niemand nadelig zou worden beïnvloed door uw wijzigingen. In dat geval komt het echt gewoon neer op persoonlijke voorkeur.

8

Eigenschappen ondersteunen asymmetrische toegang, d.w.z. u kunt een getter en een setter hebben of slechts een van de twee. Evenzo ondersteunen eigenschappen individuele toegankelijkheid voor getter/setter. Velden zijn altijd symmetrisch, d.w.z. u kunt de waarde altijd zowel ophalen als instellen. Uitzondering hierop zijn alleen-lezen velden die uiteraard niet kunnen worden ingesteld na initialisatie.

Eigenschappen kunnen heel lang actief zijn, bijwerkingen hebben en zelfs uitzonderingen veroorzaken. Velden zijn snel, zonder bijwerkingen, en zullen nooit uitzonderingen veroorzaken. Vanwege bijwerkingen kan een eigenschap voor elke aanroep een andere waarde retourneren (zoals het geval kan zijn voor DateTime.Now, d.w.z. DateTime.Now is niet altijd gelijk aan DateTime.Now). Velden retourneren altijd dezelfde waarde.

Velden kunnen worden gebruikt voor out / ref-parameters, eigenschappen niet.
Eigenschappen ondersteunen extra logica – dit kan onder andere worden gebruikt om lui laden te implementeren.

Eigenschappen ondersteunen een abstractieniveau door alles in te kapselen wat het betekent om de waarde te krijgen/in te stellen.

Gebruik eigenschappen in de meeste / alle gevallen, maar probeer bijwerkingen te vermijden.

Antwoord 9

Op de achtergrond wordt een eigenschap gecompileerd tot methoden. Dus een eigenschap Namewordt gecompileerd in get_Name()en set_Name(string value). U kunt dit zien als u de gecompileerde code bestudeert.
Er is dus een (zeer) kleine prestatie-overhead bij het gebruik ervan. Normaal gesproken gebruik je altijd een eigenschap als je een veld aan de buitenkant blootlegt, en je zult het vaak intern gebruiken als je de waarde moet valideren.

Antwoord 10

Als u wilt dat uw privévariabele(veld) toegankelijk is voor objecten van uw klasse uit andere klassen, moet u eigenschappen voor die variabelen maken.

bijvoorbeeld als ik variabelen heb met de naam “id” en “name” die privé zijn
maar er kan een situatie zijn waarin deze variabele nodig is voor lees-/schrijfbewerkingen buiten de klasse. In die situatie kan de eigenschap me helpen om die variabele te laten lezen / schrijven, afhankelijk van de get / set die voor de eigenschap is gedefinieerd. Een eigenschap kan zowel een alleen-lezen / alleen-schrijven / lezen-schrijven zijn.

hier is de demo

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";
    }
}

Antwoord 11

De tweede vraag hier, “wanneer moet een veld worden gebruikt in plaats van een eigenschap?”, wordt slechts kort besproken in deze andere antwoorden een beetje deze ook, maar niet echt veel details.

Over het algemeen zijn alle andere antwoorden perfect over een goed ontwerp: geef de voorkeur aan het blootleggen van eigenschappen boven het blootleggen van velden. Hoewel je waarschijnlijk niet regelmatigmerkt dat je zegt “wauw, stel je voor hoeveel erger het zou zijn als ik dit een veld had gemaakt in plaats van een eigendom”, is het zo veelzeldzamer om een situatie te bedenken waarin je zou zeggen “wauw, godzijdank heb ik hier een veld gebruikt in plaats van een eigendom.”

Maar er is één voordeel dat velden hebben ten opzichte van eigenschappen, en dat is dat ze kunnen worden gebruikt als “ref” / “out”-parameters. Stel dat je een methode hebt met de volgende handtekening:

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

en stel dat je die methode wilt gebruiken om een array te transformeren die als volgt is gemaakt:

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

Hier denk ik dat de snelste manier om het te doen, aangezien X en y Zijn eigenschappen:

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;
}

En dat zal best goed zijn! Tenzij je metingen hebt die anders bewijzen, is er geen reden om een ​​stank te gooien. Maar ik geloof dat het technisch niet zo snel is als dit:

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);
}

Sommige metingen mezelf, de versie met velden duurt ongeveer 61% van de tijd als De versie met eigenschappen (.NET 4.6, Windows 7, X64, Release-modus, geen debugger bijgevoegd). Hoe duurder de TransformPointmethode krijgt, hoe minder uitgesproken is dat het verschil wordt. Om dit zelf te herhalen, loop je met de eerste regel commentaar uit en daarmee geen commentaar.

Zelfs als er geen prestatievoordelen zouden zijn voor het bovenstaande, zijn er andere plaatsen waar het nuttig kan zijn om ref en out-parameters te gebruiken, zoals bij het aanroepen van de Interlockedof Vluchtigefamilie van methoden. Opmerking: als dit nieuw voor je is, is Volatile in feite een manier om hetzelfde gedrag te krijgen als het trefwoord volatile. Als zodanig lost het, net als volatile, niet op magische wijze alle thread-veiligheidsproblemen op, zoals de naam doet vermoeden.

Ik wil absoluut niet de indruk wekken dat ik pleit voor “oh, ik zou moeten beginnen met het blootleggen van velden in plaats van eigenschappen.” Het punt is dat als je deze leden regelmatig moet gebruiken in aanroepen die “ref”- of “out”-parameters nemen, vooral voor iets dat een eenvoudig waardetype kan zijn dat waarschijnlijk nooit een van de toegevoegde waarde-elementen van eigenschappen nodig heeft, een argument kan worden gemaakt.

Antwoord 12

Ook met eigenschappen kun je logica gebruiken bij het instellen van waarden.

Je kunt dus zeggen dat je alleen een waarde voor een integer veld wilt instellen, als de waarde groter is dan x, anders gooi je een uitzondering.

Echt handige functie.

Antwoord 13

Als je thread-primitieven gaat gebruiken, ben je gedwongen velden te gebruiken. Eigenschappen kunnen uw threaded-code breken. Afgezien daarvan is wat Cory zei juist.

Antwoord 14

(Dit zou eigenlijk een reactie moeten zijn, maar ik kan geen reactie plaatsen, dus excuseer me als het niet gepast is als bericht).

Ik heb ooit op een plek gewerkt waar de aanbevolen praktijk was om openbare velden te gebruiken in plaats van eigenschappen, terwijl de equivalente eigenschapsdef alleen toegang zou hebben tot een veld, zoals in :

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

Hun redenering was dat het openbare veld indien nodig later in de toekomst zou kunnen worden omgezet in een eigendom. Ik vond het toen een beetje vreemd. Afgaande op deze berichten, lijkt het erop dat niet veel mensen het hier mee eens zijn. Wat had je kunnen zeggen om dingen te veranderen?

Bewerken: ik moet hieraan toevoegen dat de hele codebasis op deze plek op hetzelfde moment is gecompileerd, dus ze hadden misschien gedacht dat het geen probleem was om de openbare interface van klassen te veranderen (door een openbaar veld in een eigenschap te veranderen) .

Antwoord 15

Technisch gezien denk ik niet dat er een verschil is, omdat eigenschappen slechts wrappers zijn rond velden die door de gebruiker zijn gemaakt of automatisch worden gemaakt door de compiler. Het doel van eigenschappen is om inkapseling af te dwingen en een lichtgewicht methode-achtige aan te bieden functie.
Het is gewoon een slechte gewoonte om velden openbaar te maken, maar het geeft geen problemen.

Antwoord 16

Velden zijn gewone lidvariabelenof lidinstanties van een klasse. Eigenschappen zijn een abstractie om hun waarden op te halen en in te stellen. Eigenschappen worden ook wel accessors genoemd omdat ze een manier bieden om een veld te wijzigen en op te halen als je een veld in de klasse als privé blootstelt. Over het algemeen moet u uw lidvariabelen privé declareren en vervolgens eigenschappen voor hen declareren of definiëren.

 class SomeClass
  {
     int numbera; //Field
     //Property 
    public static int numbera { get; set;}
  }

Antwoord 17

Mijn ontwerp van een veld is dat een veld alleen door zijn ouder moet worden gewijzigd, vandaar de klasse. Resultaat De variabele wordt privé en vervolgens om het recht te kunnen geven om de klassen / methoden buiten te lezen, door het systeem van onroerend goed met alleen de Get. Het veld wordt vervolgens opgehaald door de accommodatie en alleen-lezen! Als u het wilt wijzigen, moet u door methoden (bijvoorbeeld de constructor) en ik vind dat we dankzij deze manier veilig zijn, we beter controleren over onze code omdat we “flens”. Je zou heel goed alles in het openbaar kunnen zetten, dus elke mogelijke zaak, het idee van variabelen / methoden / klassen etc … Naar mijn mening is slechts een hulpmiddel voor de ontwikkeling, het onderhoud van de code. Als een persoon bijvoorbeeld een code met openbare velden hervat, kan hij alles doen en daarom dingen “onlogisch” in relatie tot het doel, de logica van waarom de code is geschreven. Het is mijn standpunt.

Wanneer ik een klassiek model privéveld / openbare readonly-eigenschappen gebruik, voor 10 FRIVATES-velden zou ik 10 Publics-eigenschappen moeten schrijven! De code kan erg veel sneller zijn. Ik ontdek de privéetter en nu gebruik ik alleen openbare eigenschappen met een privésetter.
De Setter Creëer een privéveld op de achtergrond.

dat waarom mijn oude klassieke programmeerstijl:

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

Mijn nieuwe programmeerstijl:

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

18

Basis en algemeen verschil is:

Velden

• ALTIJDzowel toegang tot krijgen als instellen
• KAN GEENbijwerkingen veroorzaken (uitzonderingen gooien, methoden aanroepen, velden wijzigen behalve degene die wordt opgehaald/ingesteld, enz.)

Eigenschappen

• NIET ALTIJDzowel toegang tot krijgen als instellen
• KANbijwerkingen veroorzaken

Antwoord 19

Eigenschappen kapselen velden in, waardoor u extra bewerkingen kunt uitvoeren op de in te stellen of op te halen waarde. Het is meestal overkill om eigenschappen te gebruiken als u geen voor- of nabewerking op de veldwaarde uitvoert.

Antwoord 20

IMO, Eigenschappen zijn slechts de “SetXXX()” “GetXXX()” functies/methoden/interfaces-paren die we eerder gebruikten, maar ze zijn beknopter en eleganter.

Antwoord 21

Traditioneel worden privévelden ingesteld via getter- en setter-methoden. Omwille van minder code kun je in plaats daarvan eigenschappen gebruiken om velden in te stellen.

Antwoord 22

wanneer je een klas hebt die ‘Auto’ is. De eigenschappen zijn kleur, vorm..

Waar als velden variabelen zijn die zijn gedefinieerd binnen het bereik van een klasse.

Antwoord 23

Van Wikipedia — Objectgeoriënteerd programmeren:

Objectgeoriënteerd programmeren (OOP) is een programmeerparadigma gebaseerd op het concept van “objecten”, dit zijn gegevensstructuren die gegevens bevatten, in de vorm van velden, vaak bekend als attributen; en code, in de vorm van procedures, ook wel bekend als methoden. (nadruk toegevoegd)

Eigenschappen maken eigenlijk deel uit van het gedrag van een object, maar zijn ontworpen om consumenten van het object de illusie/abstractie te geven om met de gegevens van het object te werken.

Antwoord 24

Aanvullende informatie:
Accessors ophalen en instellen zijn standaard net zo toegankelijk als de eigenschap zelf.
Je kunt de toegankelijkheid van de accessor individueel beheren/beperken (voor ophalen en instellen) door er restrictievere toegangsmodifiers op toe te passen.

Voorbeeld:

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

Hier is get nog steeds openbaar toegankelijk (omdat het eigendom openbaar is), maar set is beveiligd (een meer beperkte toegangsspecificatie).

Antwoord 25

Denk er eens over na: je hebt een kamer en een deur om deze kamer binnen te gaan. Als u wilt controleren wie er binnenkomt en uw kamer wilt beveiligen, moet u eigendommen gebruiken, anders is het geen deur en komt iedereen gemakkelijk binnen zonder enige regelgeving

class Room {
   public string sectionOne;
   public string sectionTwo;
}
Room r = new Room();
r.sectionOne = "enter";

Mensen komen vrij gemakkelijk in SectionOne, er was geen controle

class Room 
{
   private string sectionOne;
   private string sectionTwo;
   public string SectionOne 
   {
      get 
      {
        return sectionOne; 
      }
      set 
      { 
        sectionOne = Check(value); 
      }
   }
}
Room r = new Room();
r.SectionOne = "enter";

Nu heb je de persoon gecontroleerd en weet je of hij iets kwaads met hem heeft

Antwoord 26

Velden zijn de variabelen in klassen. Velden zijn de gegevens die u kunt inkapselen door middel van toegangsmodificaties.

Eigenschappen lijken op velden omdat ze staten en de gegevens die aan een object zijn gekoppeld, definiëren.

In tegenstelling tot een veld heeft een eigenschap een speciale syntaxis die bepaalt hoe een persoon de gegevens leest en schrijft, deze staan bekend als de get- en set-operators. De ingestelde logica kan vaak worden gebruikt om validatie uit te voeren.

Antwoord 27

Eigenschappen zijn een speciaal soort klasselid. In eigenschappen gebruiken we een vooraf gedefinieerde Set- of Get-methode. Ze gebruiken accessors waarmee we de waarden van de privévelden kunnen lezen, schrijven of wijzigen.

Laten we bijvoorbeeld een les nemen met de naam Employee, met privévelden voor naam, leeftijd en Employee_Id. We hebben geen toegang tot deze velden van buiten de klas, maar we hebben toegang tot deze privévelden via eigenschappen.

Waarom gebruiken we eigenschappen?

Het klassenveld openbaar maken & blootstellen is riskant, omdat je geen controle hebt over wat wordt toegewezen & teruggestuurd.

Om dit met een voorbeeld duidelijk te begrijpen, laten we een studentenklas nemen die een ID, wachtwoord en naam heeft. Nu in dit voorbeeld een probleem met openbaar veld

• ID mag niet -ve zijn.
• Naam kan niet worden ingesteld op null
• Slagmarkering mag alleen worden gelezen.
• Als de naam van de student ontbreekt, mag geen naam worden geretourneerd.

Om dit probleem op te lossen, gebruiken we de methode Get en 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
    }
}

Nu nemen we een voorbeeld van de methode get en 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;
    }
}

28

Eigenschappen worden gebruikt om veld bloot te leggen. Ze gebruiken accessors (ingesteld, get) waarmee de waarden van de particuliere velden kunnen worden gelezen, geschreven of gemanipuleerd.

Eigenschappen Noem de opslaglocaties niet. In plaats daarvan hebben ze toebehoren die hun waarden lezen, schrijven of berekenen.

Eigenschappen gebruiken We kunnen validatie instellen op het type gegevens dat op een veld is ingesteld.

We hebben bijvoorbeeld een eigen geheel getal-leeftijd waarop we positieve waarden moeten toestaan ​​dat de leeftijd niet negatief kan zijn.

We kunnen dit op twee manieren doen met behulp van Getter en Setters en het gebruik van onroerend goed.

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-implementeerde eigenschap Als we geen logica gebruiken in get en set-accessors, kunnen we auto-implementeerde eigenschappen gebruiken.

Wanneer ude automatisch geïmplementeerde eigenschap compileert, wordt een privé, anoniem veld gemaaktdat alleen toegankelijk is via get en set-accessors.

public int Age{get;set;}

Abstracte eigenschappen
Een abstracte klasse kan een abstracte eigenschap hebben, die moet worden geïmplementeerd in de afgeleide klasse

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;
     }
  }

We kunnen een eigenschap privé instellen
Hierin kunnen we de auto-eigenschap privé instellen (ingesteld met in de klasse)

public int MyProperty
{
    get; private set;
}

U kunt hetzelfde bereiken met deze code. In deze eigenschap is de functie set niet beschikbaar omdat we de waarde direct in het veld moeten instellen.

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