Определяемые пользователем операторы составных назначений

Замечание

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

Может возникнуть некоторое несоответствие между спецификацией компонентов и завершенной реализацией. Эти различия отражены в соответствующих заметках с заседания по дизайну языка (LDM) .

Дополнительные сведения о процессе внедрения спецификаций функций в стандарт языка C# см. в статье о спецификациях .

Вопрос чемпиона: https://github.com/dotnet/csharplang/issues/9101

Сводка

Разрешить типам пользователей настраивать поведение операторов составных назначений таким образом, чтобы целевой объект назначения был изменен на месте.

Мотивация

C# поддерживает реализации оператора перегрузки разработчика для определяемого пользователем типа. Кроме того, она обеспечивает поддержку операторов составных назначений, которые позволяют пользователю писать код аналогичным x += y образом, x = x + yа не . Однако язык в настоящее время не позволяет разработчику перегружать эти составные операторы присваивания, и хотя поведение по умолчанию делает правильное, особенно так как оно относится к неизменяемым типам значений, это не всегда является "оптимальным".

В приведенном ниже примере

class C1
{
    static void Main()
    {
        var c1 = new C1();
        c1 += 1;
        System.Console.Write(c1);
    }
    
    public static C1 operator+(C1 x, int y) => new C1();
}

с текущими правилами языка оператор составного назначения c1 += 1 вызывает определяемый + пользователем оператор, а затем назначает возвращаемое значение локальной переменной c1. Обратите внимание, что реализация оператора должна выделять и возвращать новый экземпляр C1, в то время как, с точки зрения потребителя, изменение на исходный экземпляр C1 вместо этого будет работать как хорошо (оно не используется после назначения) с дополнительным преимуществом, чтобы избежать дополнительного выделения.

Если программа использует составную операцию назначения, наиболее распространенное действие заключается в том, что исходное значение "потеряно" и больше не доступно программе. С типами, которые имеют большие данные (например, BigInteger, Tensors и т. д.) стоимость создания чистого назначения, итерации и копирования памяти, как правило, довольно дорого. Мутация на месте позволит пропустить эти расходы во многих случаях, что может обеспечить значительное улучшение таких сценариев.

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

Подробный дизайн

Синтаксис

https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/classes.md#15101-general Грамматика настраивается следующим образом.

Операторы объявляются с помощью operator_declarations:

operator_declaration
    : attributes? operator_modifier+ operator_declarator operator_body
    ;

operator_modifier
    : 'public'
    | 'static'
    | 'extern'
    | unsafe_modifier   // unsafe code support
    | 'abstract'
    | 'virtual'
    | 'sealed'
+   | 'override'
+   | 'new'
+   | 'readonly'
    ;

operator_declarator
    : unary_operator_declarator
    | binary_operator_declarator
    | conversion_operator_declarator
+   | increment_operator_declarator
+   | compound_assignment_operator_declarator
    ;

unary_operator_declarator
    : type 'operator' overloadable_unary_operator '(' fixed_parameter ')'
    ;

logical_negation_operator
    : '!'
    ;

overloadable_unary_operator
-   : '+' | 'checked'? '-' | logical_negation_operator | '~' | 'checked'? '++' | 'checked'? '--' | 'true' | 'false'
+   : '+' | 'checked'? '-' | logical_negation_operator | '~' | 'true' | 'false'
    ;

binary_operator_declarator
    : type 'operator' overloadable_binary_operator
        '(' fixed_parameter ',' fixed_parameter ')'
    ;

overloadable_binary_operator
    : 'checked'? '+'  | 'checked'? '-'  | 'checked'? '*'  | 'checked'? '/'  | '%'  | '&' | '|' | '^'  | '<<'
    | right_shift | '==' | '!=' | '>' | '<' | '>=' | '<='
    ;

conversion_operator_declarator
    : 'implicit' 'operator' type '(' fixed_parameter ')'
    | 'explicit' 'operator' type '(' fixed_parameter ')'
    ;

+increment_operator_declarator
+   : type 'operator' overloadable_increment_operator '(' fixed_parameter ')'
+   | 'void' 'operator' overloadable_increment_operator '(' ')'
+   ;

+overloadable_increment_operator
+   : 'checked'? '++' | 'checked'? '--'
+    ;

+compound_assignment_operator_declarator
+   : 'void' 'operator' overloadable_compound_assignment_operator
+       '(' fixed_parameter ')'
+   ;

+overloadable_compound_assignment_operator
+   : 'checked'? '+=' | 'checked'? '-=' | 'checked'? '*=' | 'checked'? '/=' | '%=' | '&=' | '|=' | '^=' | '<<='
+   | right_shift_assignment
+   | unsigned_right_shift_assignment
+   ;

operator_body
    : block
    | '=>' expression ';'
    | ';'
    ;

Существует пять категорий перегруженных операторов: унарные операторы, двоичные операторы, операторы преобразования, операторы добавочного увеличения, составные операторы назначения.

Следующие правила применяются ко всем объявлениям операторов:

Объявление оператора должно включать ~~как модификатор, public и static~~ модификатор.

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

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

Унарные операторы

См. https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/classes.md#15102-unary-operators.

Объявление оператора должно включать static модификатор и не включать override модификатор.

Удаляется следующая точка маркера:

Унарный ++ или -- оператор должен принимать один параметр типа T или T? возвращать тот же тип или тип, производный от него.

Следующий абзац больше не упоминается ++ и -- маркеры операторов.

Сигнатура унарного оператора состоит из маркера оператора (+, , -!, ~++, --trueилиfalse) и типа одного параметра. Возвращаемый тип не является частью подписи унарного оператора и не является именем параметра.

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

Двоичные операторы

См. https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/classes.md#15103-binary-operators.

Объявление оператора должно включать static модификатор и не включать override модификатор.

Операторы преобразования

См. https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/classes.md#15104-conversion-operators.

Объявление оператора должно включать static модификатор и не включать override модификатор.

Операторы добавочного увеличения

Следующие правила применяются к объявлениям операторов статического добавочного увеличения, где T обозначает тип экземпляра класса или структуры, содержащей объявление оператора:

Объявление оператора должно включать static модификатор и не включать override модификатор.
Оператор должен принимать один параметр типа T или T? возвращать тот же тип или тип, производный от него.

Сигнатура статического инкрементного оператора состоит из маркеров операторов ('checked'? ++, 'checked'? --) и типа одного параметра. Тип возвращаемого значения не является частью подписи оператора статического добавочного значения, а также не является именем параметра.

Статические операторы добавок очень похожи на унарные операторы.

Следующие правила применяются к объявлениям операторов добавочного экземпляра:

Объявление оператора не должно включать static модификатор.
Оператор не принимает параметров.
Оператор должен иметь void тип возвращаемого значения.

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

Сигнатура оператора инкремента экземпляра состоит из операторных токенов ('checked'? '++' | 'checked'? '--').

Для checked operator объявления требуется парное объявление regular operator. Ошибка во время компиляции возникает в противном случае. См. также .. /csharp-11.0/checked-user-defined-operators.md#semantics.

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

Пример:

class C1
{
    public int Value;

    public void operator ++()
    {
        Value++;
    }
}

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

Для поддержки экземплярных версий операторов инкремента и декремента в ECMA-335 необходимо добавить следующие "зарезервированные" специальные имена: | Имя | Оператор | | -----| -------- | |op_DecrementAssignment| -- | |op_IncrementAssignment| ++ | |op_CheckedDecrementAssignment| проверенный -- | |op_CheckedIncrementAssignment| проверенный ++ |

Составные операторы присваивания

Следующие правила применяются к объявлениям операторов составного назначения:

Объявление оператора не должно включать static модификатор.
Оператор должен принимать один параметр.
Оператор должен иметь void тип возвращаемого значения.

Фактически оператор составного назначения — это метод возвращающего экземпляра void, который принимает один параметр и имеет специальное имя в метаданных.

Сигнатура оператора составного назначения состоит из токенов оператора ('checked'? '+=', 'checked'? '-=', 'checked'? '*=', 'checked'? '/=', '%=', '&=', '|=', '^=', '<<=', right_shift_assignment, unsigned_right_shift_assignment) и типа единственного параметра. Имя параметра не является частью подписи оператора составного назначения.

Назначение метода заключается в настройке значения экземпляра на результат <instance> <binary operator token> parameter.

Пример:

class C1
{
    public int Value;

    public void operator +=(int x)
    {
        Value+=x;
    }
}

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

ECMA-335 уже зарезервированы следующие специальные имена для определяемых пользователем операторов добавок: | Имя | Оператор | | -----| -------- | |op_AdditionAssignment|' +=' | |op_SubtractionAssignment|' -=' | |op_MultiplicationAssignment|' *=' | |op_DivisionAssignment|' /=' | |op_ModulusAssignment|'%=' | |op_BitwiseAndAssignment|' &=' | |op_BitwiseOrAssignment|'|=' | |op_ExclusiveOrAssignment|' ^=' | |op_LeftShiftAssignment|'<<='| |op_RightShiftAssignment| right_shift_assignment| |op_UnsignedRightShiftAssignment|unsigned_right_shift_assignment|

Однако в нем указывается, что соответствие CLS требует, чтобы методы оператора были непустыми статическими методами с двумя параметрами, т. е. соответствует тому, какие двоичные операторы C# являются. Мы должны рассмотреть вопрос о соблюдении требований к clS, чтобы позволить операторам быть пустыми возвращающими методами экземпляра с одним параметром.

Для поддержки проверенных версий операторов необходимо добавить следующие имена: | Имя | Оператор | | -----| -------- | |op_CheckedAdditionAssignment| проверенный '+=' | |op_CheckedSubtractionAssignment| проверенный '-=' | |op_CheckedMultiplicationAssignment| проверенный '*=' | |op_CheckedDivisionAssignment| проверенный '/=' |

Префиксные операторы инкремента и декремента

См. https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/expressions.md#1296-prefix-increment-and-decrement-operators

Если x он «op» x классифицируется как переменная, а новая языковая версия ориентирована, приоритет присваивается операторам добавочного экземпляра, как показано ниже.

Во-первых, предпринята попытка обработать операцию путем применения разрешения перегрузки оператора добавочного увеличения экземпляра. Если процесс не приводит к возникновению ошибки, операция обрабатывается путем применения разрешения перегрузки унарного оператора, как https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/expressions.md#1296-prefix-increment-and-decrement-operators указано в данный момент.

В противном случае операция «op»x оценивается следующим образом.

Если тип x является ссылочным типом, x он оценивается для получения экземпляра x₀, метод оператора вызывается в этом экземпляре и x₀ возвращается в результате операции. В противном x₀ случае nullвызов метода оператора вызовет nullReferenceException.

Рассмотрим пример.

var a = ++(new C()); // error: not a variable
var b = ++a; // var temp = a; temp.op_Increment(); b = temp; 
++b; // b.op_Increment();
var d = ++C.P1; // error: setter is missing
++C.P1; // error: setter is missing
var e = ++C.P2; // var temp = C.op_Increment(C.get_P2()); C.set_P2(temp); e = temp;
++C.P2; // var temp = C.op_Increment(C.get_P2()); C.set_P2(temp);

class C
{
    public static C P1 { get; } = new C();
    public static C P2 { get; set; } = new C();

    public static C operator ++(C x) => ...;
    public void operator ++() => ...;
}

Если тип не известен как ссылочный тип x :

Если используется результат добавок, x вычисляется получение экземпляра x₀, метод оператора вызывается в этом экземпляре, x₀ назначается x и x₀ возвращается в результате составного назначения.
В противном случае вызывается xметод оператора.

Обратите внимание, что побочные эффекты x оцениваются только один раз в процессе.

Рассмотрим пример.

var a = ++(new S()); // error: not a variable
var b = ++S.P2; // var temp = S.op_Increment(S.get_P2()); S.set_P2(temp); b = temp;
++S.P2; // var temp = S.op_Increment(S.get_P2()); S.set_P2(temp);
++b; // b.op_Increment(); 
var d = ++S.P1; // error: set is missing
++S.P1; // error: set is missing
var e = ++b; // var temp = b; temp.op_Increment(); e = (b = temp); 

struct S
{
    public static S P1 { get; } = new S();
    public static S P2 { get; set; } = new S();

    public static S operator ++(S x) => ...;
    public void operator ++() => ...;
}

Постфиксный инкремент и декремент

См. https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/expressions.md#12816-postfix-increment-and-decrement-operators

Если результат операции используется или xx «op» не классифицируется как переменная или старая версия языка, операция обрабатывается путем применения разрешения перегрузки унарного оператора, как https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/expressions.md#12816-postfix-increment-and-decrement-operators указано в данный момент. Причина, по которой мы даже не пытаемся использовать операторы добавочного экземпляра при использовании результата, заключается в том, что, если мы имеем дело с ссылочным типом, невозможно создать значение x перед операцией, если она мутируется на месте. Если мы имеем дело с типом значения, нам придется делать копии в любом случае и т. д.

В противном случае приоритет присваивается операторам добавочного увеличения экземпляра, как показано ниже.

Во-первых, предпринята попытка обработать операцию путем применения разрешения перегрузки оператора добавочного увеличения экземпляра. Если процесс не приводит к возникновению ошибки, операция обрабатывается путем применения разрешения перегрузки унарного оператора, как https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/expressions.md#12816-postfix-increment-and-decrement-operators указано в данный момент.

В противном случае операция x«op» оценивается следующим образом.

Если тип x является ссылочным типом, метод оператора вызывается в x. В противном x случае nullвызов метода оператора вызовет nullReferenceException.

Рассмотрим пример.

var a = (new C())++; // error: not a variable
var b = new C(); 
var c = b++; // var temp = b; b = C.op_Increment(temp); c = temp; 
b++; // b.op_Increment();
var d = C.P1++; // error: missing setter
C.P1++; // error: missing setter
var e = C.P2++; // var temp = C.get_P2(); C.set_P2(C.op_Increment(temp)); e = temp;
C.P2++; // var temp = C.get_P2(); C.set_P2(C.op_Increment(temp));

class C
{
    public static C P1 { get; } = new C();
    public static C P2 { get; set; } = new C();

    public static C operator ++(C x) => ...; 
    public void operator ++() => ...;
}

Если тип x не является ссылочным типом, вызывается xметод оператора.

Рассмотрим пример.

var a = (new S())++; // error: not a variable
var b = S.P2++; // var temp = S.get_P2(); S.set_P2(S.op_Increment(temp)); b = temp;
S.P2++; // var temp = S.get_P2(); S.set_P2(S.op_Increment(temp));
b++; // b.op_Increment(); 
var d = S.P1++; // error: set is missing
S.P1++; // error: missing setter
var e = b++; // var temp = b; b = S.op_Increment(temp); e = temp; 

struct S
{
    public static S P1 { get; } = new S();
    public static S P2 { get; set; } = new S();

    public static S operator ++(S x) => ...; 
    public void operator ++() => ...;
}

Разрешение перегрузки оператора добавочного увеличения экземпляра

Операция формы «op» x или x «op», где "op" является оператором добавочного экземпляра и x является выражением типа X, обрабатывается следующим образом:

Набор пользовательских операторов, предоставляемых X операциейoperator «op»(x), определяется с помощью правил операторов добавочного экземпляра кандидата.
Если набор операторов, определяемых пользователем, не является пустым, то он становится набором операторов-кандидатов для операции. В противном случае разрешение перегрузки не дает результата.
Правила разрешения перегрузки применяются к набору операторов-кандидатов, чтобы выбрать лучший оператор, и этот оператор становится результатом процесса разрешения перегрузки. Если разрешению перегрузки не удаётся выбрать единственный лучший оператор, возникает ошибка времени связывания.

Операторы увеличения экземпляра-кандидата

Учитывая тип T и операцию «op», где «op» является оператором добавочного экземпляра, набор пользовательских операторов, предоставляемых T пользователем, определяется следующим образом:

В unchecked контексте оценки это группа операторов, которые будут создаваться процессом подстановки членов, когда только операторы экземпляров operator «op»() считались соответствующими целевому имени N.
В checked контексте оценки это группа операторов, которые будут создаваться процессом подстановки членов, когда рассматривались только операторы экземпляра operator «op»() и экземпляра operator checked «op»() , соответствующие целевому имени N. Операторы operator «op»() , имеющие парные объявления сопоставления operator checked «op»() , исключаются из группы.

Комбинированное присваивание

См. https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/expressions.md#12214-compound-assignment

Абзац в начале, с dynamic которым связана, по-прежнему применим.

В противном случае, если x он x «op»= y классифицируется как переменная и новая языковая версия, приоритет присваивается операторам составных назначений , как показано ниже.

Во-первых, предпринята попытка обработать операцию формы x «op»= y путем применения разрешения перегрузки оператора составного назначения. Если процесс не приводит к возникновению ошибки, операция обрабатывается путем применения разрешения перегрузки двоичного оператора, как https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/expressions.md#12214-compound-assignment указано в данный момент.

В противном случае операция оценивается следующим образом.

Если тип x является ссылочным типом, x он оценивается для получения экземпляра x₀, метод оператора вызывается в этом экземпляре в y качестве аргумента и x₀ возвращается в результате составного назначения. В противном x₀ случае nullвызов метода оператора вызовет nullReferenceException.

Рассмотрим пример.

var a = (new C())+=10; // error: not a variable
var b = a += 100; // var temp = a; temp.op_AdditionAssignment(100); b = temp; 
var c = b + 1000; // c = C.op_Addition(b, 1000)
c += 5; // c.op_AdditionAssignment(5);
var d = C.P1 += 11; // error: setter is missing
var e = C.P2 += 12; // var temp = C.op_Addition(C.get_P2(), 12); C.set_P2(temp); e = temp;
C.P2 += 13; // var temp = C.op_Addition(C.get_P2(), 13); C.set_P2(temp);

class C
{
    public static C P1 { get; } = new C();
    public static C P2 { get; set; } = new C();

    // op_Addition
    public static C operator +(C x, int y) => ...;

    // op_AdditionAssignment
    public void operator +=(int y) => ...;
}

Если тип не известен как ссылочный тип x :

Если используется результат составного назначения, x он оценивается для получения экземпляра x₀, метод оператора вызывается в этом экземпляре в y качестве аргумента, x₀ назначается x и x₀ возвращается в результате составного назначения.
В противном случае метод оператора вызывается x в y качестве аргумента.

Обратите внимание, что побочные эффекты x оцениваются только один раз в процессе.

Рассмотрим пример.

var a = (new S())+=10; // error: not a variable
var b = S.P2 += 100; // var temp = S.op_Addition(S.get_P2(), 100); S.set_P2(temp); b = temp;
S.P2 += 100; // var temp = S.op_Addition(S.get_P2(), 100); S.set_P2(temp);
var c = b + 1000; // c = S.op_Addition(b, 1000)
c += 5; // c.op_AdditionAssignment(5); 
var d = S.P1 += 11; // error: setter is missing
var e = c += 12; // var temp = c; temp.op_AdditionAssignment(12); e = (c = temp); 

struct S
{
    public static S P1 { get; } = new S();
    public static S P2 { get; set; } = new S();

    // op_Addition
    public static S operator +(S x, int y) => ...;

    // op_AdditionAssignment
    public void operator +=(int y) => ...;
}

Разрешение перегрузки операторов составных назначений

Операция формы x «op»= y, где «op»= является перегруженным оператором составного назначения, x является выражением типа X , как показано ниже.

Набор пользовательских операторов, предоставляемых X операцией operator «op»=(y) , определяется с помощью правил операторов составных назначений кандидатов.
Если в наборе (y)применяется по крайней мере один определяемый пользователем оператор, то это становится набором операторов-кандидатов для операции. В противном случае разрешение перегрузки не дает результата.
Правила разрешения перегрузки применяются к набору операторов-кандидатов, чтобы выбрать лучший оператор в отношении списка (y)аргументов, и этот оператор становится результатом процесса разрешения перегрузки. Если разрешению перегрузки не удаётся выбрать единственный лучший оператор, возникает ошибка времени связывания.

Операторы составного назначения кандидатов

Учитывая тип T и операцию «op»=, где «op»= является перегруженным оператором составного назначения, набор пользовательских операторов, предоставляемых T пользователем, определяется следующим образом:

В unchecked контексте оценки это группа операторов, которые будут создаваться процессом подстановки членов, когда только операторы экземпляров operator «op»=(Y) считались соответствующими целевому имени N.
В checked контексте оценки это группа операторов, которые будут создаваться процессом подстановки членов, когда рассматривались только операторы экземпляра operator «op»=(Y) и экземпляра operator checked «op»=(Y) , соответствующие целевому имени N. Операторы operator «op»=(Y) , имеющие парные объявления сопоставления operator checked «op»=(Y) , исключаются из группы.

Открытые вопросы

[Разрешено] Должен ли `readonly` модификатор быть разрешен в структурах?

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

Заключение: Мы разрешаем readonly модификаторы, но в настоящее время мы не будем ослаблять целевые требования.

[Решено] Следует ли разрешать шадоуинг?

Если производный класс объявляет оператор составного назначения/'экземпляра с той же сигнатурой, что и один в базе, следует ли требовать override модификатор?

Заключение: Тень будет разрешена с теми же правилами, что и методы.

[Разрешено] Должны ли мы иметь какое-либо принудительное применение согласованности между объявленными `+=` и `+` операторами?

Во время LDM-2025-02-12 возникла озабоченность по поводу того, как авторы могут случайно подвергнуть своих пользователей необычным сценариям, где один может работать, а другой нет (или наоборот), поскольку одна форма объявляет больше операторов, чем другая.

Заключение: Проверки не будут выполняться по согласованности между различными формами операторов.

Альтернативы

Продолжайте использовать статические методы

Мы могли бы рассмотреть возможность использования методов статических операторов, в которых экземпляр передается в качестве первого параметра. В случае типа значения этот параметр должен быть параметром ref . В противном случае метод не сможет изменить целевую переменную. В то же время в случае типа класса этот параметр не должен быть параметром ref . Так как в случае класса передаваемый экземпляр должен быть мутирован, а не расположение, в котором хранится экземпляр. Однако, если оператор объявлен в интерфейсе, он часто не знает, будет ли интерфейс реализован только классами или только структурами. Поэтому неясно, должен ли первый параметр быть параметром ref .

Совещания по проектированию

Обратная связь

Была ли эта страница полезна?

Last updated on 2025-08-15

Поделиться через

Определяемые пользователем операторы составных назначений

Сводка

Мотивация

Подробный дизайн

Синтаксис

Унарные операторы

Двоичные операторы

Операторы преобразования

Операторы добавочного увеличения

Составные операторы присваивания

Префиксные операторы инкремента и декремента

Постфиксный инкремент и декремент

Разрешение перегрузки оператора добавочного увеличения экземпляра

Операторы увеличения экземпляра-кандидата

Комбинированное присваивание

Разрешение перегрузки операторов составных назначений

Операторы составного назначения кандидатов

Открытые вопросы

[Разрешено] Должен ли readonly модификатор быть разрешен в структурах?

[Решено] Следует ли разрешать шадоуинг?

[Разрешено] Должны ли мы иметь какое-либо принудительное применение согласованности между объявленными += и + операторами?

Альтернативы

Продолжайте использовать статические методы

Совещания по проектированию

Обратная связь

Дополнительные ресурсы

[Разрешено] Должен ли `readonly` модификатор быть разрешен в структурах?

[Разрешено] Должны ли мы иметь какое-либо принудительное применение согласованности между объявленными `+=` и `+` операторами?