Перегрузка оператора C# для`+='?

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

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.
   }
}

операторы присваивания не может быть перегружен, но +=, например, есть оценка +, который может быть перегруженный.

С MSDN.

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

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

я могу понять, что вы можете рассматривать его как отдельную операцию: в заявлении, как x += 10 вы знаете, что вы можете мутировать x объект на месте и, возможно, сэкономить время/память, а не создавать новый объект x + 10 перед назначением его по старой ссылке.

но подумайте код:

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

должны a == b в конце? Для большинства типов, нет, a - это на 10 больше, чем b. Но если бы вы могли перегрузить += оператор мутировать на месте, тогда да. Теперь подумайте, что a и b может быть передано в отдаленные части программы. Ваша возможная оптимизация может создать запутанные ошибки, если ваш объект начнет меняться там, где код этого не ожидает.

другими словами, если производительность так важна, это не так слишком трудно заменить x += 10 с вызовом метода, как x.increaseBy(10), и это намного яснее для всех участников.

Я думаю, что вы найдете эту ссылку информативной:Перегружаемые Операторы

операторы присваивания не может быть перегружен, но +=, например, есть оценка +, который может быть перегруженный.

Это из-за этого оператор не может быть перегружен:

операторы присваивания не может быть перегружен, но +=, например, есть оценка +, который может быть перегруженный.

MSDN

просто перегрузка + оператора, из-за

x += y равна x = x + y

перегрузку оператора + используется += оператор A += B равна A = operator+(A, B).

если вы перегружаете + оператор как это:

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

можно сделать

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

или

 foo = foo + 10;

это будет компилироваться и работать одинаково.

всегда один и тот же ответ на эту проблему: зачем вам нужен +=, Если вы получаете его бесплатно, если вы перегружаете +. Но что произойдет, если у меня есть такой класс.

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);
            }
        }
    }
}

вы все еще говорите, что это хорошо, что += "Авто-реализован". Если вы пытаетесь сделать высокопроизводительные вычисления в C# вы должны иметь такие характеристики, чтобы сократить время обработки и потребление памяти, если у кого-то есть хорошее решение, это высоко ценится, но не скажите мне, что я должен сделать это со статическими методами, это только обходной путь и я не вижу причин, почему C# не += имплементация, если она не определена, и если она определена, она будет использоваться. Некоторые люди говорят, что не имея разницы между + и += предотвращает ошибки, но разве это мои проблемы?

У меня был точно такой же вопрос и я не могу ответить, это лучше, чем этот человек