Por que não é possível sobrecarregar o operador de atribuição composta em C #?

O título é enganoso, portanto, leia a pergunta inteira :-) .

Por "operador de atribuição composta", tenho em mente uma construção como esta op=, por exemplo +=. O operador de atribuição pura ( =) não pertence à minha pergunta.

Por "por que" não quero dizer uma opinião, mas um recurso (livro, artigo, etc.) quando alguns dos designers ou colegas de trabalho etc. expressam seu raciocínio (ou seja, a fonte da escolha do design).

Estou intrigado com a assimetria encontrada em C ++ e C # ( sim, eu sei que C # não é C ++ 2.0 ) - em C ++ você sobrecarregava o operador +=e depois escrevia quase automaticamente o +operador apropriado , dependendo do operador definido anteriormente. Em C #, é inverso - você sobrecarrega +e +=é sintetizado para você.

Se não me engano, a abordagem posterior mata uma chance de otimização em caso de real +=, porque um novo objeto deve ser criado. Portanto, deve haver uma grande vantagem dessa abordagem, mas o MSDN é muito tímido para falar sobre isso.

E eu me pergunto qual é essa vantagem - por isso, se você descobriu uma explicação em algum livro em C #, vídeo de conversa sobre tecnologia, entrada de blog, ficarei grato pela referência.

A coisa mais próxima que encontrei é um comentário no blog de Eric Lippert. Por que os operadores sobrecarregados sempre estão estáticos em C #? de Tom Brown. Se a sobrecarga estática foi decidida primeiro, ela simplesmente determina quais operadores podem ser sobrecarregados para estruturas. Isso determina ainda o que pode ser sobrecarregado para as classes.

Não consigo encontrar a referência para isso, mas meu entendimento era que a equipe de C # queria fornecer um subconjunto sensato de sobrecarga de operadores. Naquela época, a sobrecarga do operador teve uma má reputação. As pessoas afirmavam que ele ofuscava o código e só podia ser usado para o mal. No momento em que o C # estava sendo projetado, o Java havia nos mostrado que nenhuma sobrecarga de operador era meio irritante.

Portanto, o C # queria equilibrar a sobrecarga do operador para que fosse mais difícil fazer mal, mas você também poderia fazer coisas legais. Mudar a semântica da atribuição era uma daquelas coisas que sempre eram consideradas más. Ao permitir que +=seus parentes fossem sobrecarregados, permitiria esse tipo de coisa. Por exemplo, se +=a referência fosse modificada em vez de criar uma nova, ela não seguiria a semântica esperada, levando a erros.