C#: Les opérateurs

C#: Les opérateurs unaires.

1. +x :

renvoie la valeur de x.

2. Négation unaire (-)(-x):

Négation numérique.
L’opérateur de négation unaire précède son opérande et prend son opposé.

int i = 3;
j = -i; // j = -3, i = 3

3. Négation logique (!x) :

bool estVrai = true;
if (!estVrai)
    Console.WriteLine("C'est faux !");
else
    Console.WriteLine("C'est vrai !");

4. ~x :

complément au niveau du bit.

• L’opérateur de complément à un (~), parfois appelé l’opérateur de complément de bits, génère un complément à un au niveau du bit de son opérande. Autrement dit, chaque bit qui est 1 dans l’opérande est 0 dans le résultat. Inversement, chaque bit qui est 0 dans l’opérande est 1 dans le résultat. L’opérande de l’opérateur de complément à un doit être un type intégral.

Exemple: 0000 0010 → 1111 1101

5. Incrément (++):

L’opérateur d’incrément ajoute une unité à son opérande et renvoie une valeur.

• Si l’opérateur est utilisé en suffixe (par exemple : x++), il renvoie la valeur avant l’incrémentation.
• Si l’opérateur est utilisé en préfixe (par exemple : ++x), il renvoie la valeur après l’incrémentation.

Exemple:

// Suffixe
int i = 3;
j = i++; // j = 3, i = 4

// Préfixe
int a = 2;
b = ++a; // a = 3, b = 3

6. Décrément (–) :

L’opérateur de décrément soustrait une unité à son opérande et renvoie une valeur.

7. Si l’opérateur est utilisé en suffixe (par exemple : x–), il renvoie la valeur avant la décrémentation.
8. Si l’opérateur est utilisé en préfixe (par exemple : –x), il renvoie la valeur après la décrémentation.

// Suffixe
int i = 2;
j = i--; // j = 2, i = 1

// Préfixe
int a = 3;
b = --a; // a = 2, b = 2

9. (T)x :

cast de type.
Await : attend un Task.

10. &x :

adresse de.

11. *x :

déréférencement.

C#: Les opérateurs de décalage.

• Les opérateurs de décalage de bits sont l’opérateur de décalage vers la droite (>>), qui déplace les bits de shift_expression vers la droite et l’opérateur de décalage vers la gauche (<<), qui déplace les bits de shift_expression vers la gauche.
1. Décalages vers la gauche(<<)
• Décale la valeur d’une variable vers la gauche, du nombre de bits spécifié dans la valeur d’une expression, et assigne le résultat à la variable.

• Exemple

  var temp
  temp = 14
  temp <<= 2
  

• La variable temp a la valeur 56 puisque 14 (00001110 en binaire) décalé vers la gauche de deux bits est égal à 56 (00111000 en binaire). Les bits sont remplis de zéros lors du décalage.
• Pour illustrer le fonctionnement du masquage, examinons l’exemple suivant.
• L’emploi de cet opérateur est presque équivalent à celui de result = result << expression, sauf que result n’est évalué qu’une seule fois.
• L’opérateur <<= décale les bits de result vers la gauche, du nombre de bits spécifié dans expression. L’opérateur masque expression pour éviter un décalage trop important de result.
• En effet, si le nombre de positions de décalage était supérieur au nombre de bits dans le type de données de result, tous les bits d’origine seraient décalés hors des limites et donneraient un résultat non significatif.
• Pour garantir que chaque décalage laisse au moins un des bits d’origine, les opérateurs de décalage utilisent la formule suivante pour calculer le nombre réel de positions de décalage : masquer expression (avec l’opérateur de bits AND) avec un de moins que le nombre de bits dans result.

var x : byte = 15;
// Un octet stocke 8 bits.
// Les bits sont stockés dans x 00001111
x <<= 10;
// changement réel est 10 & (8-1) = 2
// Les bits sont stockés dans x 00111100
// La valeur de x est 60
print(x); // Prints 60

C#: L’opérateur is.

• L’opérateur is vérifie si un objet est compatible avec un type donné.
• Opération réalisée: comparaison de type de variable avec le type de donnée.
• Par exemple, le code suivant peut déterminer si un objet est une instance du type de MonObjet, ou d’ un type qui dérive de MonObjet:

if (obj is MyObject)
{
}

class Class1 {}
class Class2 {}
class Class3 : Class2 { }

class IsTest
{
    static void Test(object o)
    {
        Class1 a;
        Class2 b;

        if (o is Class1)
        {
            Console.WriteLine("o is Class1");
            a = (Class1)o;
            // Do something with "a."
        }
        else if (o is Class2)
        {
            Console.WriteLine("o is Class2");
            b = (Class2)o;
            // Do something with "b."
        }

        else
        {
            Console.WriteLine("o is neither Class1 nor Class2.");
        }
    }
    static void Main()
    {
        Class1 c1 = new Class1();
        Class2 c2 = new Class2();
        Class3 c3 = new Class3();
        Test(c1);
        Test(c2);
        Test(c3);
        Test("a string");
    }
}
/*
Output:
o is Class1
o is Class2
o is Class2
o is neither Class1 nor Class2.
*/

C#: Les opérateurs de conversion.

• Une déclaration d’opérateur de conversion comprend le mot clé implicit ou explicit

1. Conversion qui comprend le mot clé implicit
• Une déclaration d’opérateur de conversion qui comprend le mot clé implicit présente une conversion implicite définie par l’utilisateur.
• Les conversions implicites peuvent se produire dans diverses situations, y compris dans des appels de fonctions membres, des expressions cast et des assignations.
2. Conversion qui comprend le mot clé explicit
• Une déclaration d’opérateur de conversion qui comprend le mot clé explicit présente une conversion explicite définie par l’utilisateur.
• Les conversions explicites peuvent se produire dans des expressions cast.

C#: L’opérateur as.

• Vous pouvez utiliser l’opérateur as pour exécuter certains types de conversions entre des types de référence compatibles ou des types Nullable.
• Le code suivant est fourni à titre d’exemple.

class csrefKeywordsOperators
{
    class Base
    {
        public override string  ToString()
        {
           return "Base";
        }
    }
    class Derived : Base 
    { }

    class Program
    {
        static void Main()
        {

            Derived d = new Derived();

            Base b = d as Base;
            if (b != null)
            {
                Console.WriteLine(b.ToString());
            }

        }
    }
}

• Le seul opérateur disponible dans cette catégorie est l’opérateur =. Il permet d’affecter une valeur à une variable. Le même opérateur est utilisé quel que soit le type de la variable (numérique, chaîne de caractères…).

C#: Opérateur de concaténation.

• L’opérateur est utilisé pour la concaténation de chaînes de caractères. C’est le même opérateur qui est utilisé pour l’addition. Cependant il n’y a pas de risque de confusion car Visual C# ne fait pas de conversion implicite des chaînes de caractères en numérique. Il détermine donc que si l’un des deux opérandes et une chaîne de caractères c’est une concaténation qui doit être exécutée. même si une des chaînes représente une valeur numérique.

Le code suivant

– string chaîne – « 123 »:
– Console .WriteLine (chaine + 456) ;
–affiche
–123456
• L’inconvénient de l’opérateur + est qu’il n’est pas très rapide pour la concaténation. Si vous avez de nombreuses concaténations à exécuter sur une chaîne, il est préférable d’utiliser StringBuilder.