Хотя поля и свойства похожи друг на друга, они представляют собой 2 совершенно разных языковых элемента.
Поля являются единственным механизмом хранения данных на уровне класса. Поля являются концептуально переменными в области видимости класса. Если вы хотите сохранить некоторые данные в экземплярах ваших классов (объектов), вам нужно использовать поля. Другого выбора нет. Свойства не могут хранить какие-либо данные, хотя может показаться, что они могут это сделать. Смотрите ниже.
Свойства с другой стороны никогда не хранят данные. Это просто пары методов (get и 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;
}
}
}
Итак, как вы можете видеть, компилятор по-прежнему использует поля для хранения значений - поскольку поля являются единственным способом хранения значений в объектах.
Итак, как вы можете видеть, хотя свойства и поля имеют одинаковый синтаксис использования, они представляют собой совершенно разные понятия. Даже если вы используете автоматические свойства или события - скрытые поля генерируются компилятором, в котором хранятся реальные данные.
Если вам нужно сделать значение поля доступным для внешнего мира (пользователей вашего класса), не используйте открытые или защищенные поля. Поля всегда должны быть помечены как частные. Свойства позволяют вам выполнять проверку значений, форматирование, преобразования и т. Д. И, как правило, делают ваш код более безопасным, более читаемым и расширяемым для будущих изменений.