Любая причина использования автоматически реализованных свойств по сравнению с ручными реализованными свойствами?

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

Мне гораздо удобнее пользоваться:

private string _postalCode; public string PostalCode { get { return _postalCode; } set { _postalCode = value; } } 

Вместо:

 public string PostalCode { get; set; } 

прежде всего потому, что, если я когда-либо захочу выполнить какую-либо индивидуальную реализацию get и set, я должен создать свое собственное свойство, в любом случае поддерживаемое частным полем. Так почему бы просто не укусить пулю с самого начала и не дать все свойства этой гибкости сразу, для согласованности? На самом деле это не займет всего несколько секунд, учитывая, что все, что вам нужно сделать в Visual Studio, – это щелкнуть имя своего частного поля и нажать Ctrl + E, и все готово. И если я делаю это вручную, то я получаю несогласованность, в которой есть НЕКОТОРЫЕ вручную созданные общедоступные свойства, поддерживаемые частными полями, и НЕКОТОРЫЕ автоматически реализованные свойства. Я чувствую себя намного лучше, так как он совместим со всеми, либо с авто, либо с любым руководством.

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

Это не дает вам ничего лишнего, кроме краткости. Если вы предпочитаете более подробный синтаксис, то, во что бы то ни стало, используйте это.

Одним преимуществом использования авторезистов является то, что он может потенциально избавить вас от глупой ошибки кодирования, например, случайного присвоения неправильной частной переменной свойству. Поверь мне, я сделал это раньше!

Ваша точка в том, что авторезист не очень гибкий, является хорошим. Единственная гибкость, которую вы имеете, заключается в использовании private get или private set для ограничения объема. Если ваши получатели или сеттеры имеют для них какую-либо сложность, тогда авторезист уже не является жизнеспособным вариантом.

Автореализованные свойства не гарантируют сохранение одного и того же имени поля поддержки между assemblyми. Поэтому теоретически возможно, что сериализация объекта в одной версии сборки, а затем повторная сериализация этого же объекта в другой сборке может привести к нарушению изменений.

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

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

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

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

Одна из причин, по которым вы потеряете контроль, – это возможность указать поле поддержки как NonSerialized, но в этом случае достаточно легко создать поле поддержки для этого свойства.

Забыл: если вы или какой-либо продукт, который вы используете, отражают участников (например, WCF), тогда вы увидите искомое имя поля поддержки вместо созданного вами «красивого» поля поддержки.

Это может быть очень важно, если вы ранее предоставляли доступ к службе или если вы десериализуете на принимающей стороне в той же структуре classа (т.е. те же classы используются на обоих концах WCF-канала). В этом случае вы не обязательно сможете десериализовать, потому что вы можете гарантировать, что имя поля поддержки одинаково, если вы не используете одну и ту же DLL, а не исходный код.

Еще немного уточнений: предположим, что у вас есть веб-сервис, который предоставляет некоторые из ваших бизнес-объектов над WCF клиенту silverlight, который вы создали. Чтобы повторно использовать свою бизнес-логику, клиент Silverlight добавляет ссылки на исходный код для ваших бизнес-объектов. Если у вас есть автоматически реализованные свойства, у вас нет контроля над именем поля поддержки. Поскольку WCF выполняет сериализацию членов, а не свойств, вы не можете быть уверены, что объект, переданный silverlight из службы WCF, будет десериализован правильно, потому что имена полей поддержки почти наверняка будут несовместимы.

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

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

Когда мне нужно резервное поле, я должен сделать паузу два раза , поэтому он немного замедляет разработку 🙂

То, как я это делаю:

  1. Сделать его частной переменной в начале
  2. При необходимости измените его на публичное автоприменение.
  3. Измените его в поле поддержки, если мне нужен код в get или set.

Нет ничего плохого в том, что разные свойства classа подвергаются по-разному.

Одно из преимуществ, которое я вижу при использовании свойств auto; при отладке приложения он не войдет в ненужный раздел Get / Set . Я знаю, что мы можем избежать этого, используя атрибуты отладчика или шаг за шагом; однако в большинстве случаев это может быть отладка большого приложения.

  • Сравнение свойств объекта в c #
  • Какова видимость переменных экземпляра @synthesized?
  • Давайте будем гением компьютера.