В чем разница между полем и свойством?

Свойства инкапсулируют поля, таким образом позволяя Вам выполнить дополнительную обработку на значении, которое будет установлено или получено. Это обычно - излишество для использования свойств, если Вы не будете делать никого пред - или постобрабатывать на значении поля.

Свойства имеют основное преимущество разрешения Вам изменить способ, которым к данным по объекту получают доступ, не повреждаясь, это - открытый интерфейс. Например, если необходимо добавить дополнительную проверку, или изменить сохраненное поле в расчетное можно сделать так же легко, если Вы первоначально представили поле как свойство. Если бы Вы просто представили поле непосредственно, то необходимо было бы изменить открытый интерфейс класса для добавления новой функциональности. То изменение повредило бы существующие клиенты, требуя, чтобы они были перекомпилированы, прежде чем они могли использовать новую версию Вашего кода.

, Если Вы пишете библиотеку классов, разработанную для широкого потребления (как Платформа.NET, которая используется миллионами людей), который может быть проблемой. Однако, если Вы пишете, класс, используемый внутренне в небольшой кодовой базе (скажите < = 50 строк K), это - действительно не грандиозное предприятие, потому что ни на кого не оказали бы негативное влияние Ваши изменения. В этом случае это действительно просто сводится к персональному предпочтению.

Если Вы собираетесь использовать примитивы потока, Вы вынуждены использовать поля. Свойства могут повредить Ваш потоковый код. Кроме этого, какой сказанный cory корректен.

Кроме того, свойства позволяют Вам использовать логику при устанавливании значений.

, Таким образом, можно сказать, Вы только хотите установить значение к целочисленному полю, если значение больше, чем x, иначе выдайте исключение.

Действительно полезная функция.

Свойства поддерживают асимметричный доступ, т.е. у Вас могут быть или метод get и метод set или только один из двух. Так же свойства поддерживают отдельную доступность для метода get/метода set. Поля всегда симметричны, т.е. можно всегда оба получать и устанавливать значение. Исключением к этому являются поля только для чтения, которые, очевидно, не могут быть установлены после инициализации.

Свойства могут работать в течение очень долгого времени, иметь побочные эффекты и могут даже выдать исключения. Поля быстры, без побочных эффектов, и никогда не будут выдавать исключения. Из-за побочных эффектов свойство может возвратить различное значение для каждого вызова (как может иметь место для DateTime. Теперь, т.е. DateTime. Теперь не всегда равно DateTime. Теперь). Поля всегда возвращают то же значение.

Поля могут использоваться для / касательно параметров, свойства не могут. Свойства поддерживают дополнительную логику †“, это могло использоваться для реализации ленивой загрузки среди прочего.

Свойства поддерживают уровень абстракции путем инкапсуляции независимо от того, что это означает получать/устанавливать значение.

свойства Use в большинстве / все случаи, но стараются избегать побочных эффектов.

Я дам Вам пару примеров использования свойств, которые могли бы получить механизмы, поворачивающиеся:

• Ленивая Инициализация : , Если у Вас есть свойство объекта, это дорого для загрузки, но не получено доступ все так очень в нормальных выполнениях кода, можно задержать его загрузку через свойство. Тем путем это просто находится там, но в первый раз другой модуль пытается назвать то свойство, это проверяет, является ли базовое поле пустым - если это, это идет вперед и загружает его, неизвестный модулю вызова. Это может значительно ускорить объектную инициализацию.
• Грязное Отслеживание: , О котором я на самом деле узнал от моего собственный вопрос здесь на StackOverflow. Когда у меня есть много объектов, которые значения, возможно, изменили во время выполнения, я могу использовать свойство, чтобы отследить, если они должны быть сохранены назад к базе данных или нет. Если ни одно свойство объекта не изменилось, флаг IsDirty не будет смещен, и поэтому функциональность сохранения перескочит через него при решении что потребности возвратиться к базе данных.

В фоновом режиме свойство компилируется в методы. Так Name свойство компилируется в get_Name() и set_Name(string value). Вы видите это при изучении скомпилированного кода. Таким образом, существует (очень) маленькая производительность наверху при использовании их. Обычно Вы будете всегда использовать Свойство, если Вы представите поле внешней стороне, и Вы будете часто использовать ее внутренне, если необходимо сделать проверку значения.

Важное различие - то, что интерфейсы могут иметь свойства, но не поля. Это, мне, подчеркивает, что свойства должны использоваться для определения открытого интерфейса класса, в то время как поля предназначены, чтобы использоваться в частных, внутренних работах класса. Как правило, я редко создаю общедоступные поля, и так же я редко создаю непубличные свойства.

Объект, ориентируемый, программируя принципы, говорит, что, внутренние работы класса должны быть скрыты от внешнего мира. Если Вы представляете поле, Вы в сущности представляете внутреннюю реализацию класса. Поэтому мы обертываем поля со Свойствами (или методы в случае Java), чтобы дать нам способность изменить реализацию, не повреждая код в зависимости от нас. Наблюдение, поскольку мы можем поместить логику в Свойство также, позволяет нам выполнять логику проверки и т.д., если нам нужен он. C# 3 имеет возможно запутывающее понятие автосвойств. Это позволяет нам просто определять Свойство, и компилятор C#3 генерирует частное поле для нас.

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
}

(Это действительно должен быть комментарий, но я не могу опубликовать комментарий, извините, если он не подходит для публикации).

Однажды я работал в месте, где рекомендовалось использовать общедоступные поля вместо свойств, когда эквивалентное свойство def просто обращалось к полю, как в:

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

Их аргументация заключалась в том, что общедоступное поле может быть преобразовано в собственность позже, если потребуется. Тогда мне это показалось немного странным. Судя по этим постам, похоже, что и здесь не многие согласятся. Что вы могли бы сказать, чтобы попытаться что-то изменить?

Изменить: я должен добавить, что вся база кода в этом месте была скомпилирована одновременно, поэтому они могли подумать, что изменение открытого интерфейса классов (путем изменения публичное поле к собственности) не было проблемой.

Используя Свойства, вы можете генерировать событие, когда значение свойства изменяется (также известное как PropertyChangedEvent) или до того, как значение будет изменено для поддержки отмены.

Это невозможно с полями (прямым доступом к).

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(){
   EventHandler localEvent = NameChanging;
   if (localEvent != null) {
     localEvent(this,EventArgs.Empty);
   }
 }

 private void OnNameChanged(){
   EventHandler localEvent = NameChanged;
   if (localEvent != null) {
     localEvent(this,EventArgs.Empty);
   }
 }
}