Opérateurs Unity C# indispensables

Unity est un moteur de jeu qui apporte beaucoup de "heavy-lifting" aux développeurs en termes de fonctionnalités et leur permet de se concentrer entièrement sur le processus de développement. Il utilise C# comme langage de programmation principal.

Comme tout langage de programmation, C# se compose d'un ensemble de fonctions spéciales, de types, de classes, de bibliothèques, etc., mais il dispose également d'une liste de symboles spéciaux (opérateurs) qui ont chacun leur propre fonction. Dans cet article, je vais lister ces symboles et expliquer ce qu'ils font, afin que la prochaine fois que vous ouvrirez un script, vous puissiez rapidement comprendre la signification de chaque partie.

Les opérateurs en C# sont des symboles spéciaux qui effectuent une action sur les opérandes.

Dans C#, il existe 6 types d'opérateurs intégrés: les opérateurs arithmétiques, les opérateurs de comparaison, les opérateurs logiques booléens, les opérateurs de bit et de décalage, les opérateurs d'égalité et les opérateurs divers. Les connaître tous fera de vous instantanément un meilleur programmeur.

1. Opérateurs arithmétiques

Les opérateurs suivants effectuent des opérations arithmétiques avec des opérandes de types numériques:

Opérateurs unaires ++ (incrément), -- (décrément), + (plus) et - (moins)
Opérateurs binaires * (multiplication), / (division), % (reste), + (addition) et - (soustraction)

Opérateur d'incrémentation ++

L'opérateur "add one" (ou ++) signifie += 1, autrement dit, c'est un moyen rapide d'ajouter un entier à une valeur numérique, sans avoir à saisir de code supplémentaire. Cet opérateur peut être ajouté avant ou après la valeur, ce qui entraînerait un comportement différent:

//The result of x++ is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i++); // output: 4
Debug.Log(i);   // output: 5

//The result of ++x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(++a); // output: 3.5
Debug.Log(a);   // output: 3.5

Opérateur de décrémentation --

L'opérateur "subtract one" est l'opposé de ++ (-= 1), ce qui signifie qu'il soustrait un entier d'une valeur numérique. Il peut également être ajouté avant ou après une valeur:

The result of x-- is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i--); // output: 4
Debug.Log(i);   // output: 3

The result of --x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(--a); // output: 1.5
Debug.Log(a);   // output: 1.5

Opérateurs unaires + et -

L'opérateur unaire + renvoie la valeur de son opérande et l'opérateur unaire - calcule la négation numérique de son opérande.

Debug.Log(+5);     // output: 5

Debug.Log(-5);     // output: -5
Debug.Log(-(-5));  // output: 5

uint a = 6;
var b = -a;
Debug.Log(b);            // output: -6
Debug.Log(b.GetType());  // output: System.Int64

Debug.Log(-double.NaN);  // output: NaN

Opérateur de multiplication *

L'opérateur de multiplication * calcule le produit multiplié de ses opérandes:

Debug.Log(6 * 3);         // output: 18
Debug.Log(1.5 * 3.5);     // output: 5.25
Debug.Log(0.1m * 24.4m);  // output: 2.44

Opérateur de division /

L'opérateur de division / divise son opérande de gauche par son opérande de droite.

Si l'un des opérandes est décimal, l'autre opérande ne peut être ni float ni double, car ni float ni double ne sont implicitement convertibles en décimal. Vous devez convertir explicitement l'opérande float ou double en type décimal.

Debug.Log(13 / 5);    // output: 2
Debug.Log(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Debug.Log((double)a / b);  // output: 2.6

Debug.Log(16.8f / 4.1f);   // output: 4.097561
Debug.Log(16.8d / 4.1d);   // output: 4.09756097560976
Debug.Log(16.8m / 4.1m);   // output: 4.0975609756097560975609756098

Opérateur de reste %

L'opérateur de reste % calcule le reste après avoir divisé son opérande de gauche par son opérande de droite.

Pour les opérandes de type entier, le résultat de a % b est la valeur produite par a - (a / b) * b

Debug.Log(5 % 4);   // output: 1
Debug.Log(5 % -4);  // output: 1
Debug.Log(-5 % 4);  // output: -1
Debug.Log(-5 % -4); // output: -1

Pour les opérandes décimaux, l'opérateur de reste % est équivalent à l'opérateur de reste de type System.Decimal.

Debug.Log(-5.2f % 2.0f); // output: -1.2
Debug.Log(5.9 % 3.1);    // output: 2.8
Debug.Log(5.9m % 3.1m);  // output: 2.8

Opérateur d'addition +

L'opérateur d'addition + calcule la somme de ses opérandes. Vous pouvez également utiliser l'opérateur + pour la concaténation de chaînes et la combinaison de délégués.

Debug.Log(6 + 5);       // output: 11
Debug.Log(6 + 5.3);     // output: 11.3
Debug.Log(6.1m + 5.2m); // output: 11.3

Opérateur de soustraction -

L'opérateur de soustraction - soustrait son opérande de droite de son opérande de gauche. Vous pouvez également utiliser l'opérateur - pour supprimer un délégué.

Debug.Log(48 - 4);      // output: 44
Debug.Log(6 - 5.3);     // output: 0.7
Debug.Log(8.5m - 3.3m); // output: 5.2

2. Opérateurs de comparaison

Les opérateurs de comparaison < (less than), > (greater than), <= (less than or equal), and >= (supérieur ou égal), également appelés opérateurs relationnels, comparent leurs opérandes. Ces opérateurs sont pris en charge par tous les types numériques entiers et à virgule flottante.

Opérateur inférieur à <

L'opérateur < renvoie vrai si son opérande de gauche est inférieur à son opérande de droite, faux dans le cas contraire.

Debug.Log(8.0 < 6.1);   // output: False
Debug.Log(6.1 < 6.1);   // output: False
Debug.Log(1.0 < 6.1);   // output: True

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

Opérateur supérieur à >

L'opérateur > renvoie vrai si son opérande de gauche est supérieur à son opérande de droite, faux dans le cas contraire.

Debug.Log(8.0 > 6.1);   // output: True
Debug.Log(6.1 > 6.1);   // output: False
Debug.Log(1.0 > 6.1);   // output: False

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

Opérateur inférieur ou égal <=

L'opérateur <= renvoie vrai si son opérande de gauche est inférieur ou égal à son opérande de droite, faux dans le cas contraire.

Debug.Log(8.0 <= 6.1);   // output: False
Debug.Log(6.1 <= 6.1);   // output: True
Debug.Log(1.0 <= 6.1);   // output: True

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

Opérateur supérieur ou égal >=

L'opérateur >= renvoie vrai si son opérande de gauche est supérieur ou égal à son opérande de droite, faux dans le cas contraire.

Debug.Log(8.0 >= 6.1);   // output: True
Debug.Log(6.1 >= 6.1);   // output: True
Debug.Log(1.0 >= 6.1);   // output: False

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

3. Opérateurs logiques booléens

Les opérateurs suivants effectuent des opérations logiques avec des opérandes booléens:

Opérateur unaire ! (négation logique).
Opérateurs binaires & (ET logique), | (OU logique) et ^ (OU exclusif logique). Ces opérateurs évaluent toujours les deux opérandes.
Opérateurs binaires && (ET logique conditionnel) et || (OU logique conditionnel). Ces opérateurs évaluent l'opérande de droite uniquement si cela est nécessaire.

Opérateur de négation logique !

L'opérateur préfixe unaire ! calcule la négation logique de son opérande. Autrement dit, il produit true si l'opérande est false et false si l'opérande est true.

bool passed = false;
Debug.Log(!passed);  // output: True
Debug.Log(!true);    // output: False

Opérateur logique AND &

L'opérateur & calcule le AND logique de ses opérandes. Le résultat de x & y est vrai si x et y sont tous deux évalués à vrai. Sinon, le résultat est faux.

L'opérateur & évalue les deux opérandes même si l'opérande de gauche est évalué à faux, de sorte que le résultat de l'opération est faux quelle que soit la valeur de l'opérande de droite.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

Opérateur logique exclusif OU ^

L'opérateur ^ calcule le OU exclusif logique, également appelé XOR logique, de ses opérandes. Le résultat de x ^ y est vrai si x est vrai et y est faux, ou x est faux et y est vrai. Sinon, le résultat est faux. Autrement dit, pour les opérandes booléens, l'opérateur ^ calcule le même résultat que l'opérateur d'inégalité !=.

Debug.Log(true ^ true);    // output: False
Debug.Log(true ^ false);   // output: True
Debug.Log(false ^ true);   // output: True
Debug.Log(false ^ false);  // output: False

Opérateur OU logique |

L'opérateur | calcule le OU logique de ses opérandes. Le résultat de x | y est vrai si x ou y est évalué à vrai, sinon, le résultat est faux.

L'opérateur | évalue les deux opérandes même si l'opérande de gauche est évalué à vrai, de sorte que le résultat de l'opération est vrai quelle que soit la valeur de l'opérande de droite.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

Opérateur logique conditionnel AND &&

L'opérateur logique AND conditionnel &&, également connu sous le nom d'opérateur logique AND "short-circuiting", calcule l'opérateur logique AND de ses opérandes. Le résultat de x && y est vrai si x et y sont tous deux évalués comme vrais, sinon, le résultat est faux. Si x est évalué comme faux, y n'est pas évalué.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Debug.Log(a);
// Output:
// False

bool b = true && SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

Opérateur logique OU conditionnel ||

L'opérateur logique OU conditionnel ||, également connu sous le nom d'opérateur logique OU "short-circuiting", calcule l'opérateur logique OU de ses opérandes. Le résultat de x || y est vrai si x ou y est évalué à vrai. Sinon, le résultat est faux. Si x est évalué à vrai, y n'est pas évalué.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Debug.Log(a);
// Output:
// True

bool b = false || SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

4. Opérateurs binaires et de décalage

Les opérateurs suivants effectuent des opérations au niveau du bit ou de décalage avec des opérandes de type numérique intégral ou de type char:

Opérateur unaire ~ (complément binaire)
Opérateurs de décalage binaires << (left shift) and >> (décalage vers la droite)
Opérateurs binaires & (ET logique), | (OU logique) et ^ (OU exclusif logique)

Opérateur de complément au niveau du bit ~

L'opérateur ~ produit un complément binaire de son opérande en inversant chaque bit.

uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Debug.Log(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011

Opérateur de décalage vers la gauche <<

L'opérateur << décale son opérande de gauche vers la gauche du nombre de bits défini par son opérande de droite. Pour plus d'informations sur la manière dont l'opérande de droite définit le nombre de décalages, consultez la section Nombre de décalages des opérateurs de décalage.

uint x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2)}");

uint y = x << 4;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After:  10010000000000000000000100010000

Opérateur de décalage vers la droite >>

L'opérateur >> décale son opérande de gauche vers la droite du nombre de bits défini par son opérande de droite.

uint x = 0b_1001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2), 4}");

uint y = x >> 2;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2), 4}");
// Output:
// Before: 1001
// After:    10

Les positions de bits vides d'ordre élevé sont définies en fonction du type de l'opérande de gauche comme suit:

Si l'opérande de gauche est de type int ou long, l'opérateur de décalage vers la droite effectue un décalage arithmétique: la valeur du bit le plus significatif (le bit de signe) de l'opérande de gauche est propagée vers les positions de bits vides de poids fort. Autrement dit, les positions de bits vides de poids fort sont définies sur zéro si l'opérande de gauche n'est pas négatif et sur un s'il est négatif.

int a = int.MinValue;
Debug.Log($"Before: {Convert.ToString(a, toBase: 2)}");

int b = a >> 3;
Debug.Log($"After:  {Convert.ToString(b, toBase: 2)}");
// Output:
// Before: 10000000000000000000000000000000
// After:  11110000000000000000000000000000

Si l'opérande de gauche est de type uint ou ulong, l'opérateur de décalage vers la droite effectue un décalage logique: les positions de bits vides d'ordre supérieur sont toujours définies sur zéro.

uint c = 0b_1000_0000_0000_0000_0000_0000_0000_0000;
Debug.Log($"Before: {Convert.ToString(c, toBase: 2), 32}");

uint d = c >> 3;
Debug.Log($"After:  {Convert.ToString(d, toBase: 2), 32}");
// Output:
// Before: 10000000000000000000000000000000
// After:     10000000000000000000000000000

Opérateur logique AND &

L'opérateur & calcule le ET logique au niveau du bit de ses opérandes entiers.

uint a = 0b_1111_1000;
uint b = 0b_1001_1101;
uint c = a & b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10011000

Opérateur logique exclusif OU ^

L'opérateur ^ calcule le OU exclusif logique au niveau du bit, également appelé XOR logique au niveau du bit, de ses opérandes intégrales.

uint a = 0b_1111_1000;
uint b = 0b_0001_1100;
uint c = a ^ b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 11100100

Opérateur OU logique |

L'opérateur | calcule le OU logique au niveau du bit de ses opérandes entiers.

uint a = 0b_1010_0000;
uint b = 0b_1001_0001;
uint c = a | b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10110001

5. Opérateurs d'égalité

Les opérateurs == (égalité) et != (inégalité) vérifient si leurs opérandes sont égaux ou non.

Opérateur d'égalité ==

L'opérateur d'égalité == renvoie vrai si ses opérandes sont égaux, faux sinon.

int a = 1 + 2 + 3;
int b = 6;
Debug.Log(a == b);  // output: True

char c1 = 'a';
char c2 = 'A';
Debug.Log(c1 == c2);  // output: False
Debug.Log(c1 == char.ToLower(c2));  // output: True

Opérateur d'inégalité !=

L'opérateur d'inégalité != renvoie true si ses opérandes ne sont pas égaux, false sinon. Pour les opérandes des types intégrés, l'expression x != y produit le même résultat que l'expression !(x == y).

int a = 1 + 1 + 2 + 3;
int b = 6;
Debug.Log(a != b);  // output: True

string s1 = "Hello";
string s2 = "Hello";
Debug.Log(s1 != s2);  // output: False

object o1 = 2;
object o2 = 2;
Debug.Log(o1 != o2);  // output: True

6. Opérateurs divers

Les opérateurs divers courants sont ?: pour les vérifications conditionnelles, :: pour accéder à un membre d'un espace de noms aliasé et $ pour l'interpolation de chaîne.

?: opérateur

L'opérateur conditionnel ?:, également connu sous le nom d'opérateur conditionnel ternaire, évalue une expression booléenne et renvoie le résultat de l'une des deux expressions, selon que l'expression booléenne est évaluée à vrai ou à faux, comme le montre l'exemple suivant:

bool condition = true;
Debug.Log(condition ? 1 : 2); // output: 1

:: opérateur

Utilisez le qualificateur d'alias d'espace de noms:: pour accéder à un membre d'un espace de noms avec alias. Vous ne pouvez utiliser le qualificateur:: qu'entre deux identifiants. L'identifiant de gauche peut être l'un des alias suivants:

Un alias d'espace de noms créé avec une directive d'alias d'utilisation:

using forwinforms = System.Drawing;
using forwpf = System.Windows;

public class Converters
{
    public static forwpf::Point Convert(forwinforms::Point point) => new forwpf::Point(point.X, point.Y);
}

Un alias externe.
L'alias global, qui est l'alias de l'espace de noms global. L'espace de noms global est l'espace de noms qui contient les espaces de noms et les types qui ne sont pas déclarés à l'intérieur d'un espace de noms nommé. Lorsqu'il est utilisé avec le qualificateur::, l'alias global fait toujours référence à l'espace de noms global, même s'il existe l'alias de l'espace de noms global défini par l'utilisateur.

namespace MyCompany.MyProduct.System
{
    class Program
    {
        static void Main() => global::System.Console.WriteLine("Using global alias");
    }

    class Console
    {
        string Suggestion => "Consider renaming this class";
    }
}

opérateur $

Le caractère spécial $ identifie un littéral de chaîne comme une chaîne interpolée. Une chaîne interpolée est un littéral de chaîne qui peut contenir des expressions d'interpolation. Lorsqu'une chaîne interpolée est résolue en une chaîne de résultat, les éléments avec des expressions d'interpolation sont remplacés par les représentations de chaîne des résultats de l'expression.

Dans les chaînes interpolées, le signe dollar ($) est utilisé pour indiquer au compilateur C# que la chaîne qui le suit doit être interprétée comme une chaîne interpolée. Les accolades encapsulent les valeurs (des variables) à inclure dans le texte.

Pour identifier une chaîne littérale comme chaîne interpolée, ajoutez-lui le symbole $ avant. Vous ne pouvez pas avoir d'espace entre le $ et le " qui démarre une chaîne littérale.

string name = "John";
var date = DateTime.Now;
Debug.Log($"Hello, {name}! Today is {date.DayOfWeek}, it's {date:HH:mm} now.");
// Output:
// Hello, John! Today is Wednesday, it's 19:40 now.

unité unity3d csharp programmation opérateurs microsoft windows dotnet