В каких ситуациях вы могли бы перегрузить оператор в .NET?
Перегрузка операторов в .NET.
Ответ 1
- Я бы сильно рассмотрел перегрузку == и!= везде, где я переопределяю
Equals
- Я бы рассмотрел (гораздо менее сильно) перегрузку операторов сравнения в любом месте, где я реализую
IComparable<T>
- Я бы рассмотрел перегрузку арифметических операторов для принципиально числовых типов.
- Я бы рассмотрел возможность предоставления явных преобразований для типов "wrapper" (например,
Nullable<T>
) - Я бы очень редко рассматривал возможность предоставления неявных преобразований
Золотое правило заключается не в том, чтобы перегружать операторов, если смысл не совсем очевиден. Например, я думаю, что было бы довольно странно иметь оператор + на Stream
- это может означать "сделать запись в T здесь, так что запись в результат записывается в оба", или это может означать "читать один за другим" "или, возможно, другие вещи.
По моему опыту, довольно редко перегружать все, кроме == и! =.
Ответ 2
Я думаю, что Руководства по дизайну каркаса дают некоторые достойные советы:
- AVOID определяет перегрузки операторов, за исключением типов, которые должны чувствовать себя примитивных (встроенных) типов.
- CONSIDER, определяющий перегрузки операторов в типе, который должен выглядеть как примитивный тип.
- DO определяют перегрузки операторов в структурах, которые представляют числа (такие как System.Decimal).
- Не обращайте внимания при определении перегрузок операторов.
- НЕ предоставлять перегрузки оператора, если хотя бы один из операндов относится к типу, определяющему перегрузку.
- DO перегружает операторы симметричным образом.
- CONSIDER предоставляет методы с дружественными именами, которые соответствуют каждый перегруженный оператор.
Ответ 3
Я попросил закрыть это, но, возможно, он может оставаться открытым (я попытался изменить свое мнение, но, по-видимому, вы не можете отменить закрытый запрос: P)
Я отвечу лично: никогда.
Я никогда не думаю, что это хорошая идея для реализации перегрузки операторов. Существует только одно исключение: если я пишу какую-то коллекцию (это происходит не часто), и я хочу реализовать индексы []
.
По моему личному мнению, я не думаю, что когда-либо было бы целесообразно переопределять ==
и другие подобные вещи. Но опять же, я не работаю в сложных областях математики и финансов, где такие вещи могут быть полезными. Но я не могу говорить из опыта в этом вопросе (на самом деле, я могу в финансовом мире, и мы этого не делали).
Ответ 4
Я рассматриваю переопределяющие операторы я в этих случаях:
- == и!= когда это простой тип значения и реализует сравнение значений. В других типах я ожидаю, что == и!= Так сравнительное сравнение, а также не дорого.
- операторы сравнения ( > , >= и т.д.) в том же случае, что и выше, если это просто числовое значение.
- На самом деле я никогда не перегружаю арифметические операторы, но делал бы это для тех же самых числовых значений, если бы это повысило удобство использования.
- операторы литья, если тип может быть без потерь, превращается в соответствующий другой тип.
Ответ 5
Я бы рассмотрел возможность использования перегрузки операторов для арифметических операций над типами, которые представляют логическое значение. Например, были случаи, когда я хотел, чтобы Point
имел перегрузку для операторов +
и -
.