Перегрузка операторов в .NET.

Ответ 1

• Я бы сильно рассмотрел перегрузку == и!= везде, где я переопределяю Equals
• Я бы рассмотрел (гораздо менее сильно) перегрузку операторов сравнения в любом месте, где я реализую IComparable<T>
• Я бы рассмотрел перегрузку арифметических операторов для принципиально числовых типов.
• Я бы рассмотрел возможность предоставления явных преобразований для типов "wrapper" (например, Nullable<T>)
• Я бы очень редко рассматривал возможность предоставления неявных преобразований

Золотое правило заключается не в том, чтобы перегружать операторов, если смысл не совсем очевиден. Например, я думаю, что было бы довольно странно иметь оператор + на Stream - это может означать "сделать запись в T здесь, так что запись в результат записывается в оба", или это может означать "читать один за другим" "или, возможно, другие вещи.

По моему опыту, довольно редко перегружать все, кроме == и! =.

Ответ 2

Я думаю, что Руководства по дизайну каркаса дают некоторые достойные советы:

• AVOID определяет перегрузки операторов, за исключением типов, которые должны чувствовать себя примитивных (встроенных) типов.
• CONSIDER, определяющий перегрузки операторов в типе, который должен выглядеть как примитивный тип.
• DO определяют перегрузки операторов в структурах, которые представляют числа (такие как System.Decimal).
• Не обращайте внимания при определении перегрузок операторов.
• НЕ предоставлять перегрузки оператора, если хотя бы один из операндов относится к типу, определяющему перегрузку.
• DO перегружает операторы симметричным образом.
• CONSIDER предоставляет методы с дружественными именами, которые соответствуют каждый перегруженный оператор.

Ответ 3

Я попросил закрыть это, но, возможно, он может оставаться открытым (я попытался изменить свое мнение, но, по-видимому, вы не можете отменить закрытый запрос: P)

Я отвечу лично: никогда.

Я никогда не думаю, что это хорошая идея для реализации перегрузки операторов. Существует только одно исключение: если я пишу какую-то коллекцию (это происходит не часто), и я хочу реализовать индексы [].

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

Ответ 4

Я рассматриваю переопределяющие операторы я в этих случаях:

• == и!= когда это простой тип значения и реализует сравнение значений. В других типах я ожидаю, что == и!= Так сравнительное сравнение, а также не дорого.
• операторы сравнения ( > , >= и т.д.) в том же случае, что и выше, если это просто числовое значение.
• На самом деле я никогда не перегружаю арифметические операторы, но делал бы это для тех же самых числовых значений, если бы это повысило удобство использования.
• операторы литья, если тип может быть без потерь, превращается в соответствующий другой тип.

Ответ 5

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