Partage 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 +=.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

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.

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 de 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 gauche, puis appelle l’opérande de droite. Si l’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 combiner les délégués à l’aide de l’opérateur + :

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

Pour supprimer un 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 qui utilise 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 +. Lorsque vous surchargez un opérateur binaire + , vous surchargez implicitement l’opérateur += . À 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

  • Last updated on