C# opérateur de surcharge pour `+=`?

Je pense que vous trouverez ce lien instructif: Overloadable Opérateurs

Opérateurs d'affectation ne peut pas être
surchargé, mais +=, par exemple, est
évaluée à l'aide de +, qui peut être
surchargé.

Vous ne pouvez pas surcharger += parce qu'il n'est pas vraiment un opérateur unique, c'est juste sucre syntaxique. x += y est juste une abréviation de l'écriture x = x + y. Parce que += est définie en termes de + et = opérateurs, vous permettant de remplacer séparément pourrait créer des problèmes, dans les cas où x += y et x = x + y ne se comportent pas exactement de la même façon.

À un niveau inférieur, il est très probable que le compilateur C# compile les deux expressions au même bytecode, ce qui signifie qu'il est très probable que l'exécution ne peut pas traiter différemment pendant l'exécution du programme.

Je comprends que vous ayez envie de le traiter comme une opération distincte: dans un énoncé comme x += 10 vous savez que vous pouvez muter le x objet en place et peut-être gagner du temps/de la mémoire, plutôt que de créer un nouvel objet x + 10 avant de l'affecter sur l'ancienne référence.

Mais considérer ce code:

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

Devrait a == b à la fin? Pour la plupart des types, non, a est 10 de plus que b. Mais si vous pouviez surcharge de la += opérateur muer en place, alors oui. Maintenant, considérons que a et b pourrait se passer autour de différentes parties du programme. Votre optimisation possible pourrait créer de la confusion des bugs si votre objet commence à changer, là où le code ne vous attendez pas à.

En d'autres termes, si la performance est si important que cela, il n'est pas trop dur à remplacer x += 10 avec un appel de méthode comme x.increaseBy(10), et c'est beaucoup plus clair pour tout le monde.

Opérateur de surcharge pour + est utilisé dans += opérateur, A += B est égal à A = operator+(A, B).

Il y a toujours la même réponse à ce problème: Pourquoi avez-vous besoin +=, si vous obtenez gratuitement si vous surchargez la +. Mais qu'advient-il si j'ai une classe de ce genre.

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

Avez-vous encore dire qu'il est bon que le += est "auto-mise en œuvre". Si vous essayez de faire le calcul de haute performance en C# vous avez besoin de ces fonctionnalités pour réduire les temps de traitement et la consommation de mémoire, si quelqu'un a une bonne solution, il est très apprécié, mais ne me dites pas que je dois le faire avec des méthodes statiques, ce n'est qu'une solution de contournement et je ne vois pas pourquoi C# ne le += mise en œuvre si elle n'est pas définie, et si elle est définie, il sera utilisé. Certaines personnes disent que ne pas avoir de différence entre + et += permet d'éviter des erreurs, mais ce n'est pas mon problème?

Une meilleure méthode de conception est une conversion Explicite. Vous pouvez certainement la surcharge de Casting.