Мое самое большое схватывание с автосвойствами - то, что они разработаны, чтобы сэкономить время, но я часто нахожу, что должен развернуть их в полноценные свойства позже.

то, Что пропускает VS2008, , Взрываются, Автосвойство осуществляют рефакторинг.

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

@Domenic: Я не получаю его.. разве Вы не можете сделать этого с автосвойствами?:

public string Title { get; }

или

public string Title { get; private set; }

это, к чему Вы обращаетесь?

Хорошо с фрагментами кода автосвойство того же имени было бы семью нажатиями клавиш всего;)

Я использую CodeRush, это быстрее, чем автосвойства.

, Чтобы сделать это:

 private string title;
public string Title
{
    get { return title;  }
    set { title = value;  }
}

Требует восьми общих количеств нажатий клавиш.

По-моему, необходимо всегда использовать автосвойства вместо общедоступных полей. Однако вот компромисс:

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

• доступ потребности к полю снаружи его блока, или
• потребность присоединить логику к методу get/методу set

Делают это:

1. переименовывают поле
2. , делают, оно частный
3. добавляет общественную собственность

, Ваш клиентский код не должен будет изменяться.

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

Одна вещь отметить вот состоит в том, что к моему пониманию это всего синтаксический сахар на конце C# 3.0, означая, что IL, сгенерированный компилятором, является тем же. Я соглашаюсь о предотвращении черной магии, но все равно, меньше строк для того же самого обычно является хорошей вещью.

Это просто, это коротко и если Вы захотите создать реальную реализацию в теле свойства где-нибудь по линии, это не повредит внешний интерфейс Вашего типа.

Настолько простой.

Я думаю любая конструкция, которая интуитивна И уменьшает строки кода, большое плюс.

Те виды функций - то, что делает языки как Ruby столь мощными (что и динамические функции, которые также помогают уменьшить избыточный код).

Ruby имел это все время как:

attr_accessor :my_property
attr_reader :my_getter
attr_writer :my_setter

Единственная проблема, которую я имею с ними, состоит в том, что они не заходят достаточно далеко. Тот же релиз компилятора, который добавил автоматические свойства, добавил частичные методы. То, почему они не соединяли эти два, вне меня. Простой "частичный On< PropertyName> Измененный" сделал бы эти вещи действительно действительно полезными.

Автосвойства являются так же черной магией как что-либо еще в C#. Как только Вы думаете об этом с точки зрения компиляции вниз в IL, а не это расширяемый до нормального свойства C# сначала это - намного меньше черной магии, чем много других конструкций языка.

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

Одна вещь, которую никто, кажется, не упомянул, состоит в том, как автосвойства, к сожалению, не полезны для неизменных объектов (обычно неизменные структуры). Поскольку для этого действительно необходимо сделать:

private readonly string title;
public string Title
{
    get { return this.title; }
}

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

, Таким образом, это имеет преимущества перед простым get / private set автосвойство.

От Bjarne Stroustrup, создателя C++:

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

И Вы знаете что? Он прав. Как часто Вы просто обертываете частные поля в то, чтобы получать и набор, ничего на самом деле не делая в рамках получения/устанавливания, просто потому что это - "объектно-ориентированная" вещь сделать. Это - решение Microsoft проблемы; они - в основном общедоступные поля, с которыми можно связать.

Я лично люблю автосвойства. Что случилось с сохранением строк кода? Если Вы хотите сделать материал в методах get или методах set, нет никакой проблемы преобразовать их в нормальные свойства позже.

, Поскольку Вы сказали, что могли использовать поля, и если бы Вы хотели добавить логику к ним позже, то Вы преобразовали бы их в свойства. Но это могло бы подарить проблемам с каким-либо использованием отражения (и возможно в другом месте?).

Также свойства позволяют Вам устанавливать различные уровни доступа для метода get и метода set, который Вы не можете сделать с полем.

я предполагаю, что это совпадает с ключевым словом var. Вопрос персонального предпочтения.

Три больших оборотных стороны к использованию полей вместо свойств:

1. Вы не можете связать с данными к полю, тогда как Вы можете к свойству
2. , Если Вы начинаетесь с помощью поля, Вы не можете позже (легко) изменить их на свойство
3. существуют некоторые атрибуты, что можно добавить к свойству, что Вы не можете добавить к полю

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

можно установить различные объемы:

public string PropertyName { get; private set; }

Так, чтобы свойство могло только быть изменено в классе. Это не действительно неизменно, поскольку можно все еще получить доступ к частному методу set посредством отражения.

С C#6 можно также создать верный readonly свойства - т.е. неизменные свойства, которые не могут быть изменены за пределами конструктора:

public string PropertyName { get; }

public MyClass() { this.PropertyName = "whatever"; }

Во время компиляции, который станет:

readonly string pName;
public string PropertyName { get { return this.pName; } }

public MyClass() { this.pName = "whatever"; }

В неизменных классах с большим количеством участников это сохраняет много избыточного кода.

Я использую автосвойства все время. Перед C#3 я не мог быть побеспокоен всем вводом и просто используемыми общедоступными переменными вместо этого.

единственной вещью, которую я пропускаю, является способность сделать это:

public string Name = "DefaultName";

необходимо сместить значения по умолчанию в конструкторов со свойствами. утомительный:-(