Belangrijke operatoren in Unity C#

Unity is een game engine die veel "heavy-lifting" doet voor ontwikkelaars in termen van functionaliteit en hen volledig laat focussen op het ontwikkelingsproces. Het gebruikt C# als de belangrijkste programmeertaal.

Zoals elke programmeertaal bestaat C# uit een array van speciale functies, typen, klassen, bibliotheken, etc., maar het heeft ook een lijst met speciale symbolen (operators) die elk een eigen functie hebben. In dit bericht zal ik die symbolen opnoemen en uitleggen wat ze doen, zodat u de volgende keer dat u een script opent, snel kunt begrijpen wat elk onderdeel betekent.

Operatoren in C# zijn speciale symbolen die een bepaalde actie uitvoeren op operanden.

In C# zijn er 6 typen ingebouwde operatoren: rekenkundige operatoren, vergelijkingsoperatoren, Booleaanse logische operatoren, bitwise- en shift-operatoren, gelijkheidsoperatoren en diverse operatoren. Als u ze allemaal kent, wordt u direct een betere programmeur.

1. Rekenkundige operatoren

De volgende operatoren voeren rekenkundige bewerkingen uit met operanden van numerieke typen:

Eenheidsoperatoren ++ (increment), -- (decrement), + (plus) en - (min)
Binaire operatoren * (vermenigvuldiging), / (deling), % (rest), + (optellen) en - (aftrekken)

Verhogingsoperator ++

De operator "add one" (of ++) betekent += 1, met andere woorden, het is een snelle manier om één geheel getal toe te voegen aan een numerieke waarde, zonder extra code te hoeven typen. Deze operator kan zowel vóór als na de waarde worden toegevoegd, wat resulteert in een ander gedrag:

//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

Verlagingsoperator --

De "subtract one" operator is het tegenovergestelde van ++ (-= 1), wat betekent dat het één geheel getal van een numerieke waarde aftrekt. Het kan ook voor of na een waarde worden toegevoegd:

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

Unaire + en - operatoren

De unaire + operator retourneert de waarde van zijn operand en de unaire - operator berekent de numerieke ontkenning van zijn operand.

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

Vermenigvuldigingsoperator *

De vermenigvuldigingsoperator * berekent het vermenigvuldigde product van zijn operanden:

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

Divisie operator /

De delingsoperator / deelt zijn linkeroperand door zijn rechteroperand.

Als een van de operanden decimaal is, kan een andere operand noch float noch double zijn, omdat float noch double impliciet converteerbaar is naar decimaal. U moet de float of double operand expliciet converteren naar het decimale type.

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

Resterende operator %

De restoperator % berekent de rest nadat de linkeroperand door de rechteroperand is gedeeld.

Voor de operanden van gehele getallen is het resultaat van a % b de waarde die wordt geproduceerd door 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

Voor decimale operanden is de restoperator % equivalent aan de restoperator van het 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

Opteloperator +

De opteloperator + berekent de som van zijn operanden. U kunt de + operator ook gebruiken voor string-concatenatie en delegate-combinatie.

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

Aftrekoperator -

De subtractie-operator - trekt de rechteroperand af van de linkeroperand. U kunt de - operator ook gebruiken voor het verwijderen van gedelegeerden.

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

2. Vergelijkingsoperatoren

De vergelijking < (less than), > (greater than), <= (less than or equal), and >= (groter dan of gelijk aan), ook wel relationele operatoren genoemd, vergelijken hun operanden. Deze operatoren worden ondersteund door alle integrale en floating-point numerieke typen.

Kleiner dan operator <

De < operator retourneert true als de linkeroperand kleiner is dan de rechteroperand, anders retourneert hij false.

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

Groter dan operator >

De operator > retourneert true als de linkeroperand groter is dan de rechteroperand, anders retourneert hij false.

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

Kleiner dan of gelijk aan operator <=

De operator <= retourneert true als de linkeroperand kleiner of gelijk is aan de rechteroperand; anders retourneert de operator false.

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

Groter dan of gelijk aan operator >=

De operator >= retourneert true als de linkeroperand groter is dan of gelijk is aan de rechteroperand; anders retourneert de operator false.

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. Booleaanse logische operatoren

De volgende operatoren voeren logische bewerkingen uit met bool-operanden:

Unaire ! (logische ontkenning) operator.
Binaire & (logische AND), | (logische OR) en ^ (logische exclusieve OR) operatoren. Deze operatoren evalueren altijd beide operanden.
Binaire && (voorwaardelijke logische AND) en || (voorwaardelijke logische OR) operatoren. Deze operatoren evalueren de rechteroperand alleen als dat nodig is.

Logische negatie-operator !

De unaire prefix ! operator berekent de logische ontkenning van zijn operand. Dat wil zeggen, het produceert true, als de operand evalueert naar false, en false, als de operand evalueert naar true.

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

Logische EN-operator &

De operator & berekent de logische AND van zijn operanden. Het resultaat van x & y is true als zowel x als y worden geëvalueerd als true. Anders is het resultaat false.

De operator & evalueert beide operanden, zelfs als de linkeroperand wordt geëvalueerd als false, zodat het resultaat van de bewerking false is, ongeacht de waarde van de rechteroperand.

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

Logische exclusieve OF-operator ^

De ^ operator berekent de logische exclusieve OF, ook bekend als de logische XOR, van zijn operanden. Het resultaat van x ^ y is waar als x wordt geëvalueerd naar waar en y wordt geëvalueerd naar onwaar, of als x wordt geëvalueerd naar onwaar en y wordt geëvalueerd naar waar. Anders is het resultaat onwaar. Dat wil zeggen, voor de bool-operanden berekent de ^ operator hetzelfde resultaat als de ongelijkheidsoperator !=.

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

Logische OF-operator |

De | operator berekent de logische OF van zijn operanden. Het resultaat van x | y is waar als x of y wordt geëvalueerd als waar, anders is het resultaat onwaar.

De | operator evalueert beide operanden, zelfs als de linkeroperand wordt geëvalueerd als waar, zodat het resultaat van de bewerking waar is, ongeacht de waarde van de rechteroperand.

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

Voorwaardelijke logische AND-operator &&

De voorwaardelijke logische AND-operator &&, ook bekend als de "short-circuiting" logische AND-operator, berekent de logische AND van zijn operanden. Het resultaat van x && y is true als zowel x als y worden geëvalueerd als true, anders is het resultaat false. Als x wordt geëvalueerd als false, wordt y niet geëvalueerd.

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

Voorwaardelijke logische OF-operator ||

De voorwaardelijke logische OR-operator ||, ook bekend als de "short-circuiting" logische OR-operator, berekent de logische OR van zijn operanden. Het resultaat van x || y is true als x of y wordt geëvalueerd als true. Anders is het resultaat false. Als x wordt geëvalueerd als true, wordt y niet geëvalueerd.

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. Bitgewijze en verschuivingsoperatoren

De volgende operatoren voeren bitgewijze of verschuivingsbewerkingen uit met operanden van het integrale numerieke type of het char-type:

Unaire ~ (bitgewijs complement) operator
Binaire << (left shift) and >> (rechtsverschuiving) verschuivingsoperatoren
Binaire operatoren & (logische AND), | (logische OR) en ^ (logische exclusieve OR)

Bitgewijze complementaire operator ~

De ~ operator produceert een bitgewijs complement van zijn operand door elke bit om te draaien.

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

Linker shift-operator <<

De << operator verschuift zijn linkeroperand naar links met het aantal bits dat is gedefinieerd door zijn rechteroperand. Voor informatie over hoe de rechteroperand de shift count definieert, zie de Shift count van de shift operators sectie.

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

Operator voor rechtse verschuiving >>

De operator >> verschuift de linkeroperand naar rechts met het aantal bits dat door de rechteroperand wordt gedefinieerd.

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

De posities van de hogere lege bits worden ingesteld op basis van het type van de linkeroperand, als volgt:

Als de linkeroperand van het type int of long is, voert de right-shift operator een rekenkundige verschuiving uit: de waarde van de meest significante bit (het tekenbit) van de linkeroperand wordt doorgegeven aan de hogere lege bitposities. Dat wil zeggen dat de hogere lege bitposities op nul worden gezet als de linkeroperand niet-negatief is en op één als deze negatief is.

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

Als de linkeroperand van het type uint of ulong is, voert de operator voor rechts verschuiven een logische verschuiving uit: de lege bitposities van de hoogste orde worden altijd op nul gezet.

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

Logische EN-operator &

De &-operator berekent de bitsgewijze logische AND van zijn integrale operanden.

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

Logische exclusieve OF-operator ^

De ^-operator berekent de bitsgewijze logische exclusieve OF, ook bekend als de bitsgewijze logische XOR, van zijn integrale operanden.

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

Logische OF-operator |

De operator | berekent de bitsgewijze logische OF van zijn integrale operanden.

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

5. Gelijkheidsoperatoren

De operatoren == (gelijkheid) en != (ongelijkheid) controleren of hun operanden gelijk zijn of niet.

Gelijkheidsoperator ==

De gelijkheidsoperator == retourneert true als de operanden gelijk zijn, anders false.

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

Ongelijkheidsoperator !=

De ongelijkheidsoperator != retourneert true als de operanden niet gelijk zijn, anders false. Voor de operanden van de ingebouwde typen produceert de expressie x != y hetzelfde resultaat als de expressie !(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. Diverse operatoren

Veelgebruikte operatoren zijn ?: voor voorwaardelijke controles, :: voor toegang tot een lid van een gealiaste naamruimte en $ voor tekenreeksinterpolatie.

?: operator

De voorwaardelijke operator ?:, ook bekend als de ternaire voorwaardelijke operator, evalueert een Booleaanse expressie en retourneert het resultaat van een van de twee expressies, afhankelijk van of de Booleaanse expressie wordt geëvalueerd als waar of onwaar, zoals het volgende voorbeeld laat zien:

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

:: exploitant

Gebruik de namespace alias qualifier:: om toegang te krijgen tot een lid van een gealiaste namespace. U kunt de:: qualifier alleen gebruiken tussen twee identifiers. De linker identifier kan een van de volgende aliassen zijn:

Een naamruimte-alias die is gemaakt met een using alias-richtlijn:

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);
}

Een externe alias.
De globale alias, wat de globale namespace-alias is. De globale namespace is de namespace die namespaces en types bevat die niet binnen een named namespace zijn gedeclareerd. Wanneer gebruikt met de::-kwalificatie, verwijst de globale alias altijd naar de globale namespace, zelfs als er een door de gebruiker gedefinieerde globale namespace-alias is.

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

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

$ operator

Het speciale teken $ identificeert een stringliteral als een geïnterpoleerde string. Een geïnterpoleerde string is een stringliteral die interpolatie-expressies kan bevatten. Wanneer een geïnterpoleerde string wordt omgezet in een result string, worden items met interpolatie-expressies vervangen door de stringrepresentaties van de expressie results.

In Interpolated Strings wordt het dollarteken ($) gebruikt om de C#-compiler te vertellen dat de string die erop volgt, moet worden geïnterpreteerd als een Interpolated String. De accolades kapselen de waarden (van de variabelen) in die in de tekst moeten worden opgenomen.

Om een tekenreeksliteraal te identificeren als een geïnterpoleerde tekenreeks, voegt u het $-symbool toe. U mag geen spatie hebben tussen de $ en de " waarmee een tekenreeksliteraal begint.

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 programmeren operators microsoft windows dotnet