Opérateurs d’addition - + et +=

  • Article

Les opérateurs + et += sont pris en charge par les types numériques intégraux et à virgule flottante intégrés, le type de chaîne et les types délégués .

Pour plus d’informations sur l’opérateur arithmétique +, consultez les sections Opérateurs plus et moins unaires et Opérateur d’addition + de l’article Opérateurs arithmétiques.

Concaténation de chaînes

Quand les deux opérandes ou l’un d’entre eux sont de type chaîne, l’opérateur + concatène les représentations sous forme de chaîne de ses opérandes (la représentation en chaîne de null est une chaîne vide) :

Console.WriteLine("Forgot" + "white space");
Console.WriteLine("Probably the oldest constant: " + Math.PI);
Console.WriteLine(null + "Nothing to add.");
// Output:
// Forgotwhite space
// Probably the oldest constant: 3.14159265358979
// Nothing to add.

L’interpolation de chaîne fournit un moyen plus pratique de mettre en format les chaînes :

Console.WriteLine($"Probably the oldest constant: {Math.PI:F2}");
// Output:
// Probably the oldest constant: 3.14

À compter de C# 10, vous pouvez utiliser l’interpolation de chaîne pour initialiser une chaîne constante lorsque toutes les expressions utilisées pour les espaces réservés sont également des chaînes constantes.

À compter de C# 11, l’opérateur + effectue la concaténation de chaînes pour les chaînes littérales UTF-8. Cet opérateur concatène deux objets ReadOnlySpan<byte>.

Combinaison de délégués

Pour les opérandes du même type délégué, l’opérateur + retourne une nouvelle instance de délégué qui, lorsqu’elle est appelée, appelle l’opérande de partie gauche, puis l’opérande de partie droite. Si un des opérandes est null, l’opérateur + retourne la valeur de l’autre opérande (qui peut également être null). L’exemple suivant montre comment les délégués peuvent être combinés avec l’opérateur + :

Action a = () => Console.Write("a");
Action b = () => Console.Write("b");
Action ab = a + b;
ab();  // output: ab

Pour effectuer la suppression de délégué, utilisez l’opérateur -.

Pour plus d'informations sur les types de délégués, consultez Délégués.

Opérateur d’assignation d’addition +=

Expression utilisant l’opérateur +=, par exemple

x += y

équivaut à :

x = x + y

sauf que x n’est évalué qu’une seule fois.

L’exemple suivant illustre l’utilisation de l’opérateur += :

int i = 5;
i += 9;
Console.WriteLine(i);
// Output: 14

string story = "Start. ";
story += "End.";
Console.WriteLine(story);
// Output: Start. End.

Action printer = () => Console.Write("a");
printer();  // output: a

Console.WriteLine();
printer += () => Console.Write("b");
printer();  // output: ab

Vous utilisez également l’opérateur += pour spécifier une méthode de gestionnaire d’événements lorsque vous vous abonnez à un événement. Pour plus d’informations, consultez Guide pratique pour s’abonner et annuler l’abonnement à des événements.

Capacité de surcharge de l’opérateur

Un type défini par l’utilisateur peut surcharger l’opérateur +. Quand un opérateur binaire + est surchargé, l’opérateur += est aussi implicitement surchargé. Un type défini par l’utilisateur ne peut pas surcharger explicitement l’opérateur +=.

spécification du langage C#

Pour plus d’informations, consultez les sections Opérateur unaire plus et Opérateur d’addition de la spécification du langage C#.

Voir aussi