Sobrecarga del operador de C# para'+='?

Esto se debe a la misma razón por la que el operador de asignación no se puede sobrecargar. No puede escribir código que realice la tarea correctamente.

class Foo
{
   // Won't compile.
   public static Foo operator= (Foo c1, int x)
   {
       // duh... what do I do here?  I can't change the reference of c1.
   }
}

Los operadores de asignación no pueden ser sobrecargado, pero +=, por ejemplo, es evaluado usando +, que puede ser sobrecargar.

De MSDN.

No puedes sobrecargar += porque no es realmente un operador único, es solo azúcar sintáctico. x += y es solo una forma abreviada de escribir x = x + y. Debido a que += se define en términos de los operadores + y =, permitir que lo reemplace por separado podría crear problemas, en los casos en que x += y y x = x + y no se comporten exactamente de la misma manera.

En un nivel inferior, es muy probable que el compilador de C# compile ambas expresiones en el mismo bytecode, lo que significa que es muy probable que el runtime no pueda tratarlos de manera diferente durante la ejecución del programa.

Puedo entender que tal vez quieras tratarlo como una operación separada: en una instrucción como x += 10 sabes que puedes mutar el objeto x en su lugar y quizás ahorrar algo de tiempo/memoria, en lugar de crear un nuevo objeto x + 10 antes de asignarlo sobre la referencia anterior.

Pero considere este código:

a = ...
b = a;
a += 10;

Debería a == b al final? Para la mayoría de los tipos, no, a es 10 más que b. Pero si pudiera sobrecargar el operador += para mutar en su lugar, entonces sí. Ahora considere que a y b podrían pasarse a partes distantes del programa. Su posible optimización podría crear errores confusos si su objeto comienza a cambiar donde el código no espera que lo haga.

En otras palabras, si el rendimiento es tan importante, no es demasiado difícil reemplazar x += 10 con una llamada a un método como x.increaseBy(10), y es mucho más claro para todos involucrados.

Creo que encontrará este enlace informativo: Operadores sobrecargables

Los operadores de asignación no pueden ser sobrecargado, pero +=, por ejemplo, es evaluado usando +, que puede ser sobrecargar.

Esto se debe a que este operador no se puede sobrecargar:

Los operadores de asignación no pueden ser sobrecargado, pero +=, por ejemplo, es evaluado usando +, que puede ser sobrecargar.

MSDN

Solo sobrecarga + operador, debido a

x += y igual a x = x + y

La sobrecarga del operador para + se usa en el operador +=, A += B es igual a A = operator+(A, B).

Si se sobrecarga + operador como este:

class Foo
{
    public static Foo operator + (Foo c1, int x)
    {
        // implementation
    }
}

Puedes hacer

 Foo foo = new Foo();
 foo += 10;

O

 foo = foo + 10;

Esto se compilará y ejecutará igualmente.

Siempre hay la misma respuesta a este problema: ¿Por qué necesita el +=, si lo obtiene de forma gratuita si sobrecarga el +. Pero qué pasa si tengo una clase como esta.

using System;
using System.IO;

public class Class1
{
    public class MappableObject
    {
        FileStream stream;

        public  int Blocks;
        public int BlockSize;

        public MappableObject(string FileName, int Blocks_in, int BlockSize_in)
        {
            Blocks = Blocks_in;
            BlockSize = BlockSize_in;

            // Just create the file here and set the size
            stream = new FileStream(FileName); // Here we need more params of course to create a file.
            stream.SetLength(sizeof(float) * Blocks * BlockSize);
        }

        public float[] GetBlock(int BlockNo)
        {
            long BlockPos = BlockNo * BlockSize;

            stream.Position = BlockPos;

            using (BinaryReader reader = new BinaryReader(stream))
            {
                float[] resData = new float[BlockSize];
                for (int i = 0; i < BlockSize; i++)
                {
                    // This line is stupid enough for accessing files a lot and the data is large
                    // Maybe someone has an idea to make this faster? I tried a lot and this is the simplest solution
                    // for illustration.
                    resData[i] = reader.ReadSingle();
                }
            }

            retuen resData;
        }

        public void SetBlock(int BlockNo, float[] data)
        {
            long BlockPos = BlockNo * BlockSize;

            stream.Position = BlockPos;

            using (BinaryWriter reader = new BinaryWriter(stream))
            {
                for (int i = 0; i < BlockSize; i++)
                {
                    // Also this line is stupid enough for accessing files a lot and the data is large
                    reader.Write(data[i];
                }
            }

            retuen resData;
        }

        // For adding two MappableObjects
        public static MappableObject operator +(MappableObject A, Mappableobject B)
        {
            // Of course we have to make sure that all dimensions are correct.

            MappableObject result = new MappableObject(Path.GetTempFileName(), A.Blocks, A.BlockSize);

            for (int i = 0; i < Blocks; i++)
            {
                float[] dataA = A.GetBlock(i);
                float[] dataB = B.GetBlock(i);

                float[] C = new float[dataA.Length];

                for (int j = 0; j < BlockSize; j++)
                {
                    C[j] = A[j] + B[j];
                }

                result.SetBlock(i, C);
            }
        }

        // For adding a single float to the whole data.
        public static MappableObject operator +(MappableObject A, float B)
        {
            // Of course we have to make sure that all dimensions are correct.

            MappableObject result = new MappableObject(Path.GetTempFileName(), A.Blocks, A.BlockSize);

            for (int i = 0; i < Blocks; i++)
            {
                float[] dataA = A.GetBlock(i);

                float[] C = new float[dataA.Length];

                for (int j = 0; j < BlockSize; j++)
                {
                    C[j] = A[j] + B;
                }

                result.SetBlock(i, C);
            }
        }

        // Of course this doesn't work, but maybe you can see the effect here.
        // when the += is automimplemented from the definition above I have to create another large
        // object which causes a loss of memory and also takes more time because of the operation -> altgough its
        // simple in the example, but in reality it's much more complex.
        public static MappableObject operator +=(MappableObject A, float B)
        {
            // Of course we have to make sure that all dimensions are correct.

            MappableObject result = new MappableObject(Path.GetTempFileName(), A.Blocks, A.BlockSize);

            for (int i = 0; i < Blocks; i++)
            {
                float[] dataA = A.GetBlock(i);

                for (int j = 0; j < BlockSize; j++)
                {
                    A[j]+= + B;
                }

                result.SetBlock(i, A);
            }
        }
    }
}

¿Todavía dices que es bueno que el += es "auto-implementado". Si intenta hacer computación de alto rendimiento en C# necesita tener tales características para reducir el tiempo de procesamiento y el consumo de memoria, si alguien tiene una buena solución es muy apreciado, pero no me diga que tengo que hacer esto con métodos estáticos, esto es solo una solución y no veo ninguna razón por la que C# haga la implementación += si no está definida, y si está definida se usará. Algunas personas dicen que no tener una diferencia entre + y += previene errores, pero ¿no es este mi propio problema?

Tuve exactamente la misma pregunta y no puedo responderla mejor que esta persona tiene