Chociaż pola i właściwości wydają się do siebie podobne, są to 2 zupełnie różne elementy językowe.
Pola są jedynym mechanizmem przechowywania danych na poziomie klasy. Pola są zmiennymi koncepcyjnie w zakresie klasy. Jeśli chcesz przechowywać niektóre dane w instancjach swoich klas (obiektów), musisz użyć pól. Nie ma innego wyboru. Właściwości nie mogą przechowywać żadnych danych, choć może się wydawać, że są w stanie to zrobić. Patrz poniżej.
Z drugiej strony właściwości nigdy nie przechowują danych. Są to tylko pary metod (get i set), które można syntaktycznie wywoływać w podobny sposób jak pola, aw większości przypadków uzyskują dostęp (do odczytu lub zapisu) do pól, co jest źródłem pewnych nieporozumień. Ale ponieważ metody własności są (z pewnymi ograniczeniami, takimi jak stały prototyp) zwykłymi metodami C #, mogą robić to, co mogą zrobić zwykłe metody. Oznacza to, że mogą mieć 1000 linii kodu, mogą zgłaszać wyjątki, wywoływać inne metody, mogą być nawet wirtualne, abstrakcyjne lub przesłonięte. Tym, co wyróżnia właściwości, jest fakt, że kompilator C # przechowuje dodatkowe metadane w zestawach, których można użyć do wyszukiwania określonych właściwości - funkcja powszechnie używana.
Pobierz i ustaw metody właściwości ma następujące prototypy.
PROPERTY_TYPE get();
void set(PROPERTY_TYPE value);
Oznacza to, że właściwości mogą być „emulowane” poprzez zdefiniowanie pola i 2 odpowiednich metod.
class PropertyEmulation
{
private string MSomeValue;
public string GetSomeValue()
{
return(MSomeValue);
}
public void SetSomeValue(string value)
{
MSomeValue=value;
}
}
Taka emulacja właściwości jest typowa dla języków programowania, które nie obsługują właściwości - takich jak standardowy C ++. W języku C # zawsze powinieneś preferować właściwości jako sposób dostępu do swoich pól.
Ponieważ tylko pola mogą przechowywać dane, oznacza to, że więcej klas pól zawiera, więcej obiektów pamięci takiej klasy zużyje. Z drugiej strony dodanie nowych właściwości do klasy nie powoduje powiększenia obiektów tej klasy. Oto przykład.
class OneHundredFields
{
public int Field1;
public int Field2;
...
public int Field100;
}
OneHundredFields Instance=new OneHundredFields() // Variable 'Instance' consumes 100*sizeof(int) bytes of memory.
class OneHundredProperties
{
public int Property1
{
get
{
return(1000);
}
set
{
// Empty.
}
}
public int Property2
{
get
{
return(1000);
}
set
{
// Empty.
}
}
...
public int Property100
{
get
{
return(1000);
}
set
{
// Empty.
}
}
}
OneHundredProperties Instance=new OneHundredProperties() // !!!!! Variable 'Instance' consumes 0 bytes of memory. (In fact a some bytes are consumed becasue every object contais some auxiliarity data, but size doesn't depend on number of properties).
Chociaż metody własności mogą zrobić wszystko, w większości przypadków służą one do uzyskiwania dostępu do pól obiektów. Jeśli chcesz, aby pole było dostępne dla innych klas, możesz to zrobić na dwa sposoby.
- Upublicznianie pól - niewskazane.
- Korzystanie z właściwości.
Oto klasa wykorzystująca pola publiczne.
class Name
{
public string FullName;
public int YearOfBirth;
public int Age;
}
Name name=new Name();
name.FullName="Tim Anderson";
name.YearOfBirth=1979;
name.Age=40;
Chociaż kod jest całkowicie poprawny, z punktu widzenia projektu ma kilka wad. Ponieważ pola można zarówno odczytywać, jak i zapisywać, nie można uniemożliwić użytkownikowi pisania do pól. Możesz zastosować readonlysłowo kluczowe, ale w ten sposób musisz zainicjować pola tylko do odczytu tylko w konstruktorze. Co więcej, nic nie stoi na przeszkodzie, aby przechowywać niepoprawne wartości w swoich polach.
name.FullName=null;
name.YearOfBirth=2200;
name.Age=-140;
Kod jest prawidłowy, wszystkie zadania zostaną wykonane, choć są nielogiczne. Agema wartość ujemną, YearOfBirthjest daleko w przyszłości i nie odpowiada Wiekowi i FullNamejest zerowy. Za pomocą pól nie można zapobiec class Namepopełnianiu takich błędów przez użytkowników.
Oto kod z właściwościami, które rozwiązują te problemy.
class Name
{
private string MFullName="";
private int MYearOfBirth;
public string FullName
{
get
{
return(MFullName);
}
set
{
if (value==null)
{
throw(new InvalidOperationException("Error !"));
}
MFullName=value;
}
}
public int YearOfBirth
{
get
{
return(MYearOfBirth);
}
set
{
if (MYearOfBirth<1900 || MYearOfBirth>DateTime.Now.Year)
{
throw(new InvalidOperationException("Error !"));
}
MYearOfBirth=value;
}
}
public int Age
{
get
{
return(DateTime.Now.Year-MYearOfBirth);
}
}
public string FullNameInUppercase
{
get
{
return(MFullName.ToUpper());
}
}
}
Zaktualizowana wersja klasy ma następujące zalety.
FullNamei YearOfBirthsą sprawdzane pod kątem nieprawidłowych wartości.Agenie jest zapisywalny. Jest obliczany od YearOfBirthbieżącego roku.- Nowa właściwość jest
FullNameInUppercasekonwertowana FullNamena UPPER CASE. Jest to trochę wymyślony przykład użycia właściwości, w którym właściwości są powszechnie używane do prezentacji wartości pól w formacie bardziej odpowiednim dla użytkownika - na przykład przy użyciu bieżących ustawień regionalnych dla określonej liczby DateTimeformatów.
Poza tym właściwości można zdefiniować jako wirtualne lub zastąpione - po prostu dlatego, że są to zwykłe metody .NET. Te same zasady dotyczą takich metod własności, jak w przypadku metod zwykłych.
C # obsługuje również indeksatory, które są właściwościami, które mają parametr indeksu w metodach właściwości. Oto przykład.
class MyList
{
private string[] MBuffer;
public MyList()
{
MBuffer=new string[100];
}
public string this[int Index]
{
get
{
return(MBuffer[Index]);
}
set
{
MBuffer[Index]=value;
}
}
}
MyList List=new MyList();
List[10]="ABC";
Console.WriteLine(List[10]);
Ponieważ C # 3.0 pozwala zdefiniować właściwości automatyczne. Oto przykład.
class AutoProps
{
public int Value1
{
get;
set;
}
public int Value2
{
get;
set;
}
}
Mimo że class AutoPropszawiera tylko właściwości (lub tak wygląda), może przechowywać 2 wartości, a wielkość obiektów tej klasy jest równa sizeof(Value1)+sizeof(Value2)= 4 + 4 = 8 bajtów.
Powód tego jest prosty. Po zdefiniowaniu właściwości automatycznej kompilator C # generuje kod automatyczny zawierający ukryte pole oraz właściwość z metodami właściwości umożliwiającymi dostęp do tego ukrytego pola. Oto kompilator kodu, który produkuje.
Oto kod wygenerowany przez ILSpy ze skompilowanego zestawu. Klasa zawiera wygenerowane ukryte pola i właściwości.
internal class AutoProps
{
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int <Value1>k__BackingField;
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int <Value2>k__BackingField;
public int Value1
{
[CompilerGenerated]
get
{
return <Value1>k__BackingField;
}
[CompilerGenerated]
set
{
<Value1>k__BackingField = value;
}
}
public int Value2
{
[CompilerGenerated]
get
{
return <Value2>k__BackingField;
}
[CompilerGenerated]
set
{
<Value2>k__BackingField = value;
}
}
}
Jak więc widać, kompilator nadal używa pól do przechowywania wartości - ponieważ pola są jedynym sposobem przechowywania wartości w obiektach.
Jak widać, chociaż właściwości i pola mają podobną składnię użycia, są to bardzo różne pojęcia. Nawet jeśli korzystasz z automatycznych właściwości lub zdarzeń - ukryte pola są generowane przez kompilator, w którym przechowywane są rzeczywiste dane.
Jeśli chcesz, aby wartość pola była dostępna dla świata zewnętrznego (użytkownicy twojej klasy), nie używaj pól publicznych ani chronionych. Pola zawsze powinny być oznaczone jako prywatne. Właściwości pozwalają na sprawdzanie wartości, formatowanie, konwersje itp. I ogólnie sprawiają, że kod jest bezpieczniejszy, bardziej czytelny i rozszerzalny dla przyszłych modyfikacji.