12 svar · 325 visningar · startad av Dino
Om man har en vanlig private filed som nedan, vilken constructor(1 eller 2) kör ni med då.
public class Hmm
{
private string _grr;
public string Grr
{
get{return _grr;}
set{_grr = value;}
}
}
// 1
public Hmm(string grr)
{
this.Grr = grr;
}
// 2
public Hmm(string grr)
{
this._grr = grr;
}
Jag kör med ettan, propertyn. Fått lära mig att det är god programmeringssed, sen kanske du i framtiden utvecklar din property
Håller med erkan.
Jag kör med tvåan. Anledningen är att konstruktören används för att sätta grundvärden och det man skickar in i dessa ska vara rätt för själva variabeln.
Propertyn kan användas för att omvandla en variabel som skickas ut eller in.
Att det skulle vara "god programmeringssed" att använda ettan internt i en klass har jag nog missat i så fall för alla exempel och böcker jag sett använder tvåan.
Håller med föregående talare, alternativ två gäller för mig då jag tänker som så att man använder de lokala (private) properties inom klassen och låter utomstående ta del av datan via de publika get/set.
Tänkte göra ett litet tillägg.
En anledningen till att man internt i klassen använder de privata variablerna är att man, som erka nämner, kanske vill utveckla sin property i framtiden.
T.ex. så kanske man vill formatter ett värde innan man skickar ut det till det objekt som anropar klassen. Ett exempel är i min blogg. In min property för en blogentrytext så formatterar jag texten så att kod innför [code] block blir kodformatterad. Däremot så är min privata strängvariabel oformatterad och det är så den lagras i databasen.
Sen är det också så att Get/Set properties är klassen interface, det gränssnitt som anropande objekt använder för att komma åt privata variabler. Alltså ett interface utåt, inte inåt eftersom man inne i klassen har tillgång till de privata variablerna.
Använder altenativ 1.
Det är en egentligen omöjlig fråga då det är beroende på vilken situation man använder den i.
Personligen så hävdar jag att alternativ 1 inte är något alternativ. Internt i en klass används privata variabler, externt används gränssnittet (property).
Det är något som kommer från min erfarenhet som programmerare och det i sin tur kommer från det faktum att jag aldrig sett något kodexempel, bok eller artikel som använder alternativ 1.
Men jag har ju inte sett allt. ;)
Håller med föregående talare!
Jag använder båda beroende på hur min klass fungerar. 1an använder jag nog flitigast då jag vill få rätt status på klassen. I mina properties så ligger det valideringsfunktioner för klassen och dessa vill jag giventivs trigga när jag skapar objektet. Men ibland så har jag exceptions som kastas då något är fel, och då använder jag 2an och kan välja att köra validate när jag satt dem..
Det hela beror på. Och man kan inte säga generellt vilket som är bäst.
Eftersom du skickar med ett värde till din konstruktor så kanske du vill kontrollera att detta värde är okej (typ inte negativa tal) eftersom du även har en properties som gör just detta då sätter du värdet via propertyn och slipper göra kontrollen på 2 ställen i din kod.
Om du däremot räknar ut något i din konstruktor och skall sätta en privat variabel i din kod, så är det lite onödigt att gå via propertiesen eftersom du uträkning bör ha tagit höjd för att talet inte får vara negativt, det är dock inte säkert och då bör du gå via propertyn. Alltså båda sätten är fel och rätt vid olika situationer. Oftas finns inget rätt/fel i programmerin (om programmet inte kraschar vill säga) det finns bara: bra, mindre bra och dåliga lösningar
- Magnus
Hittade äntligen länken som ändrade mitt sätt att koda i frågan. Så nu för tiden ser det oftast ut så här.
public class Hmm
{
public Hmm(string grr)
{
CheckString(grr);
this._grr = grr;
}
private string _grr;
public string Grr
{
get{return _grr;}
set
{
CheckString(value);
_grr = value;
}
}
private void CheckString(string s)
{
if(s == null || s.Length == 0)
throw new Exception("Lalala");
}
}