Megosztás a következőn keresztül:

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

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

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 lesz kiszámítva:

  • Ha mindkét operandus nem null értékű, é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, amely a jobb oldali operandus bejegyzéseinek a bal oldali operandus meghívási listájából való eltávolításával érhető el. Ha a jobb oldali operandus listája megegyezik a bal oldali operandus listájában található több egybefüggő allistával, csak a jobb oldali allista lesz eltávolítva. 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 –=

A -= 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 a -= operátor használatát mutatja be:

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. Ha egy bináris - operátor túlterhelt, a -= operátor is implicit módon túlterhelt. 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