Хоча поля та властивості схожі між собою, вони є 2 абсолютно різними мовними елементами.
Поля - єдиний механізм зберігання даних на рівні класу. Поля є концептуально змінними в межах класу. Якщо ви хочете зберегти деякі дані до примірників своїх класів (об'єктів), вам потрібно використовувати поля. Іншого вибору немає. Властивості не можуть зберігати будь-які дані, хоча це може здатися, що вони можуть це зробити. Дивіться нижче.
Властивості, з іншого боку, ніколи не зберігають дані. Вони є лише парами методів (get and set), які можна синтаксично викликати аналогічно як поля, і в більшості випадків вони отримують доступ (для читання чи запису) поля, що є джерелом певної плутанини. Але оскільки властивості методів є (з деякими обмеженнями на зразок фіксованого прототипу) звичайними методами C #, вони можуть робити все, що може робити звичайний метод. Це означає, що вони можуть мати 1000 рядків коду, вони можуть кидати винятки, викликати інші методи, можуть бути навіть віртуальними, абстрактними або переопределеними. Що робить властивості особливими, це той факт, що компілятор C # зберігає додаткові метадані в збори, які можна використовувати для пошуку конкретних властивостей - широко використовуваної функції.
Методи отримання та встановлення властивостей мають такі прототипи.
PROPERTY_TYPE get();
void set(PROPERTY_TYPE value);
Таким чином, це означає, що властивості можна "емулювати" шляхом визначення поля та 2 відповідних методів.
class PropertyEmulation
{
private string MSomeValue;
public string GetSomeValue()
{
return(MSomeValue);
}
public void SetSomeValue(string value)
{
MSomeValue=value;
}
}
Така емуляція властивостей типова для мов програмування, які не підтримують властивості - як стандартний C ++. У C # там завжди слід віддавати перевагу властивостям як способу доступу до ваших полів.
Оскільки лише поля можуть зберігати дані, це означає, що чим більше клас класів містить, тим більше об’єктів пам'яті такого класу буде споживатися. З іншого боку, додавання нових властивостей у клас не збільшує об'єкти такого класу. Ось приклад.
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).
Хоча методи властивості можуть робити що завгодно, у більшості випадків вони служать способом доступу до полів об’єктів. Якщо ви хочете зробити поле доступним для інших класів, це можна зробити двома способами.
- Робити поля загальнодоступними - недоцільно.
- Використання властивостей.
Ось клас із використанням публічних полів.
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;
Незважаючи на те, що код є абсолютно дійсним, з точки зору дизайну він має кілька недоліків. Оскільки поля можна читати і записувати, ви не можете перешкодити користувачеві писати в поля. Ви можете застосувати readonlyключове слово, але таким чином вам доведеться ініціалізувати поля для читання лише у конструкторі. Більше того, ніщо не заважає вам зберігати недійсні значення у своїх полях.
name.FullName=null;
name.YearOfBirth=2200;
name.Age=-140;
Код дійсний, всі завдання виконуватимуться, хоча вони нелогічні. Ageмає негативне значення, YearOfBirthзнаходиться далеко в майбутньому і не відповідає віку та FullNameє нульовим. За допомогою полів ви не можете перешкодити користувачам class Nameробити такі помилки.
Ось код із властивостями, який вирішує ці проблеми.
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());
}
}
}
Оновлена версія класу має такі переваги.
FullNameі YearOfBirthперевіряються на недійсні значення.Ageне підлягає написанню. Це обчислюється з YearOfBirthпоточного року.- Нова властивість
FullNameInUppercaseперетворюється FullNameна ГОЛОВНУ СЛУЧАЮ. Це трохи надуманий приклад використання властивостей, коли властивості зазвичай використовуються для подання значень поля у форматі, який є більш підходящим для користувача - наприклад, використовуючи поточну локаль у конкретному числовому DateTimeформаті.
Крім цього, властивості можна визначити як віртуальні або переосмислені - просто тому, що вони є звичайними методами .NET. Ті ж правила застосовуються для таких властивостей, як і для звичайних методів.
C # також підтримує індексатори, які є властивостями, які мають параметр індексу в методах властивостей. Ось приклад.
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]);
Оскільки C # 3.0 дозволяє визначати автоматичні властивості. Ось приклад.
class AutoProps
{
public int Value1
{
get;
set;
}
public int Value2
{
get;
set;
}
}
Хоча він class AutoPropsмістить лише властивості (або це схоже), він може зберігати 2 значення, а розмір об'єктів цього класу дорівнює sizeof(Value1)+sizeof(Value2)= 4 + 4 = 8 байт.
Причина цього проста. Коли ви визначаєте автоматичну властивість, компілятор C # генерує автоматичний код, який містить приховане поле та властивість із методами властивості, що мають доступ до цього прихованого поля. Ось компілятор коду виробляє.
Ось код, сформований ILSpy від складеної збірки. Клас містить генеровані приховані поля та властивості.
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;
}
}
}
Отже, як ви бачите, компілятор все ще використовує поля для зберігання значень - оскільки поля - єдиний спосіб зберігання значень в об'єктах.
Як ви бачите, хоча властивості та поля мають подібний синтаксис використання, вони є дуже різними поняттями. Навіть якщо ви використовуєте автоматичні властивості або події - приховані поля формуються компілятором, де зберігаються реальні дані.
Якщо вам потрібно зробити значення поля доступним для зовнішнього світу (користувачів вашого класу), не використовуйте загальнодоступні чи захищені поля. Поля завжди слід позначати як приватні. Властивості дозволяють робити перевірки цінності, форматування, перетворення тощо і, як правило, роблять ваш код більш безпечним, зрозумілим і розширюваним для майбутніх модифікацій.