Partager via

Opérateurs d’ajout - + et +=

Les types numériques intégrés et à virgule flottante, le type chaîne de caractères et les types délégués prennent tous en charge les opérateurs + et +=.

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

Lorsqu’un ou les deux opérandes 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 sous forme de 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

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 l’un des opérandes est null, l’opérateur + retourne la valeur d’un 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és, 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 aux événementset se désabonner.

Surcharge des opérateurs

Un type défini par l’utilisateur peut surcharger l’opérateur +. Lorsqu’un opérateur de + binaire est surchargé, l’opérateur += est également implicitement surchargé. À compter de C# 14, un type défini par l’utilisateur peut surcharger explicitement l’opérateur += pour fournir une implémentation plus efficace. En règle générale, un type surcharge l’opérateur += , car la valeur peut être mise à jour en place, plutôt que d’allouer une nouvelle instance pour contenir le résultat de l’ajout. Si un type ne fournit pas de surcharge explicite, le compilateur génère la surcharge implicite.

Spécification du langage C#

Pour plus d’informations, consultez les sections opérateur plus unaire et opérateur d'addition de la spécification du langage C# . Pour plus d’informations sur la surcharge des opérateurs d’affectation composée en C# 14 et versions ultérieures, consultez la spécification de la fonctionnalité d’affectation composée définie par l’utilisateur .

Voir aussi