Opérateurs Unity C# incontournables

Unity est un moteur de jeu qui fait beaucoup de "heavy-lifting" pour les 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 pour tout langage de programmation, C# se compose d'un tableau de fonctions spéciales, de types, de classes, de bibliothèques, etc., mais il possède également une liste de symboles spéciaux (opérateurs) qui ont chacun leur propre fonction. Dans cet article, je listerai ces symboles et expliquerai ce qu'ils font, afin que la prochaine fois que vous ouvrirez un script, vous puissiez comprendre rapidement ce que signifie chaque partie.

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

En 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 binaires 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émentation), -- (décrémentation), + (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, en d'autres termes, 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é soit avant la valeur, soit 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, un 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 flottant 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 restant %

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 types entiers, 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 du 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 droit de son opérande 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 relationnels, comparent leurs opérandes. Ces opérateurs sont pris en charge par tous les types numériques intégraux et à virgule flottante.

Inférieur à l'opérateur <

L'opérateur < renvoie vrai si son opérande gauche est inférieur à son opérande droit, faux sinon.

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 gauche est supérieur à son opérande droit, faux sinon.

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 gauche est inférieur ou égal à son opérande droit, faux sinon.

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 gauche est supérieur ou égal à son opérande droit, faux sinon.

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:

Unaire ! opérateur (négation logique).
Binaire & (ET logique), | (OU logique) et ^ (OU exclusif logique). Ces opérateurs évaluent toujours les deux opérandes.
Binaire && (ET logique conditionnel) et || (OU logique conditionnel). Ces opérateurs n'évaluent l'opérande de droite que si c'est nécessaire.

Opérateur de négation logique !

Le préfixe unaire ! L'opérateur calcule la négation logique de son opérande. Autrement dit, il produit vrai, si l'opérande est évalué à faux, et faux, si l'opérande est évalué à vrai.

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

Opérateur ET logique &

L'opérateur & calcule le ET logique de ses opérandes. Le résultat de x & y est vrai si x et y sont é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 OU exclusif logique ^

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 évalué à vrai et y est évalué à faux, ou x est évalué à faux et y est évalué à 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 logique OU |

Le | 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.

Le | 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 ET logique conditionnel &&

L'opérateur ET logique conditionnel &&, également appelé opérateur ET logique "short-circuiting", calcule l'opérateur ET logique de ses opérandes. Le résultat de x && y est vrai si x et y sont évalués à vrai, sinon, le résultat est faux. Si x prend la valeur false, 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 OU logique conditionnel ||

L'opérateur OR logique conditionnel ||, également connu sous le nom d'opérateur OR logique "short-circuiting", calcule l'OR 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. Si x prend la valeur true, 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 de bit 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 au niveau du bit)
Opérateurs de décalage binaires << (left shift) and >> (décalage à droite)
Binaire & (ET logique), | (OU logique) et ^ (OU exclusif logique)

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

L'opérateur ~ produit un complément au niveau du bit 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 à 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 façon 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 gauche vers la droite du nombre de bits défini par son opérande droit.

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 bit vides de poids fort 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 de poids fort (le bit de signe) de l'opérande de gauche est propagée au bit vide de poids fort postes. C'est-à-dire que les positions de bit vides de poids fort sont définies sur zéro si l'opérande de gauche est non négatif et définies 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 des bits vides de poids fort sont toujours mises à 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 ET logique &

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

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 OU exclusif logique ^

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égraux.

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 logique OU |

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

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 vrai si ses opérandes ne sont pas égaux, faux 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 donne la valeur true ou false, 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 pouvez utiliser le qualificatif:: uniquement entre deux identifiants. L'identifiant de gauche peut être l'un des alias suivants:

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

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 des espaces de noms et des types qui ne sont pas déclarés dans un espace de noms nommé. Lorsqu'il est utilisé avec le qualificatif::, l'alias global fait toujours référence à l'espace de noms global, même s'il existe l'alias d'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 sous forme 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 un littéral de chaîne en tant que chaîne interpolée, faites-le précéder du symbole $. Vous ne pouvez pas avoir d'espace blanc entre le $ et le " qui commence 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.

unity unity3d csharp programmation opérateurs microsoft windows dotnet