Megosztás:

- és -= operátorok - matematikai kivonás (mínusz)

A beépített delegálttípusok, valamint az integrál- és lebegőpontos numerikus típusok mind támogatják az operátorokat és -= az - operátorokat.

A C# nyelv referenciadokumentuma a C# nyelv legújabb kiadású verzióját ismerteti. Emellett a közelgő nyelvi kiadás nyilvános előzetes verziójú funkcióinak kezdeti dokumentációját is tartalmazza.

A dokumentáció azonosítja azokat a funkciókat, amelyeket először a nyelv utolsó három verziójában vagy az aktuális nyilvános előzetes verziókban vezetnek be.

Jótanács

Ha meg szeretné tudni, hogy mikor jelent meg először egy funkció a C#-ban, tekintse meg a C# nyelvi verzióelőzményeiről szóló cikket.

Az aritmetikai - operátorral kapcsolatos információkért lásd az Unary plusz és mínusz operátorokat és a Kivonás operátort – az Aritmetikai operátorok cikkének szakaszait .

Delegált eltávolítása

Az azonos delegált típusú operandusok esetében az operátor egy - delegált példányt ad vissza, amely a következőképpen van kiszámítva:

  • Ha mindkét operandus nem null , és a jobb oldali operandus meghívási listája a bal oldali operandus meghívási listájának megfelelő egybefüggő allistája, a művelet eredménye egy új meghívási lista, amelyet úgy kap, hogy eltávolítja a jobb oldali operandus bejegyzéseit a bal oldali operandus meghívási listájából. Ha a jobb oldali operandus listája megegyezik a bal oldali operandus listájában lévő több egybefüggő allistával, a művelet csak a jobb oldali allistát távolítja el. Ha az eltávolítás üres listát eredményez, az eredmény a következő null: .

    Action a = () => Console.Write("a");
Action b = () => Console.Write("b");

var abbaab = a + b + b + a + a + b;
abbaab();  // output: abbaab
Console.WriteLine();

var ab = a + b;
var abba = abbaab - ab;
abba();  // output: abba
Console.WriteLine();

var nihil = abbaab - abbaab;
Console.WriteLine(nihil is null);  // output: True

  • Ha a jobb oldali operandus meghívási listája nem a bal oldali operandus meghívási listájának megfelelő egybefüggő allistája, a művelet eredménye a bal oldali operandus lesz. Ha például eltávolít egy olyan meghatalmazottat, amely nem része a csoportos küldési meghatalmazottnak, nem tesz semmit, és a csoportos küldési meghatalmazott nem változik.

    Action a = () => Console.Write("a");
Action b = () => Console.Write("b");

var abbaab = a + b + b + a + a + b;
var aba = a + b + a;

var first = abbaab - aba;
first();  // output: abbaab
Console.WriteLine();
Console.WriteLine(object.ReferenceEquals(abbaab, first));  // output: True

Action a2 = () => Console.Write("a");
var changed = aba - a;
changed();  // output: ab
Console.WriteLine();
var unchanged = aba - a2;
unchanged();  // output: aba
Console.WriteLine();
Console.WriteLine(object.ReferenceEquals(aba, unchanged));  // output: True

    Az előző példa azt is szemlélteti, hogy amikor a delegáltakat eltávolítják, összehasonlítják a delegált példányokat. Az azonos lambdakifejezések kiértékeléséből előállított delegáltak például nem egyenlők. A delegált egyenlőségről további információt a C# nyelvi specifikációjánakDelegálási egyenlőség operátorok című szakaszában talál.

  • Ha a bal oldali operandus az null, akkor a művelet eredménye .null Ha a jobb oldali operandus az null, a művelet eredménye a bal oldali operandus.

    Action a = () => Console.Write("a");

var nothing = null - a;
Console.WriteLine(nothing is null);  // output: True

var first = a - null;
a();  // output: a
Console.WriteLine();
Console.WriteLine(object.ReferenceEquals(first, a));  // output: True

A meghatalmazottak kombinálásához használja az operátort+.

A delegálttípusokról további információt Meghatalmazottakcímű témakörben talál.

Kivonás-hozzárendelés operátora -=

Az operátort -= használó kifejezés, például

x -= y

Egyenértékű azzal, hogy

x = x - y

Kivéve, hogy a x csak egyszer lesz kiértékelve.

Az alábbi példa bemutatja az operátor használatát -= :

int i = 5;
i -= 9;
Console.WriteLine(i);
// Output: -4

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

Console.WriteLine();
printer -= a;
printer();  // output: ab

Az operátorral -= egy eseménykezelő metódust is megadhat, amely eltávolítható az eseményről való leiratkozáskor. További információ: Hogyan iratkozhat fel és iratkozhat le az eseményekről.

Operátorok túlterhelése

A felhasználó által definiált típus túlterhelést. Bináris operátor túlterhelése - esetén implicit módon is túlterheli az operátort -= . A C# 14-től kezdve a felhasználó által definiált típus explicit módon túlterhelheti az operátort a -= hatékonyabb megvalósítás érdekében. Egy típus általában túlterheli az -= operátort, mert az érték frissíthető a helyén, ahelyett, hogy egy új példányt osztanak ki a kivonás eredményének tárolására. Ha egy típus nem biztosít explicit túlterhelést, a fordító implicit túlterhelést hoz létre.

C# nyelvspecifikáció

További információt a C# nyelvi specifikációjánakUnary mínusz operátor és Kivonás operátor szakaszában talál. Az összetett hozzárendelési operátorok C# 14-ben és újabb verzióiban történő túlterheléséről további információt a felhasználó által megadott összetett hozzárendelési funkció specifikációjában talál.

Lásd még

  • Last updated on