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

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

  • Cikk

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

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álás 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 a delegált eltávolítása során a delegált példányok összehasonlítva vannak. Az azonos lambdakifejezések kiértékelése során előállított meghatalmazottak például nem egyenlők . A delegált egyenlőségről további információt a C# nyelvi specifikációjának Delegá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 a Meghatalmazottak cí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ű a

x = x - y

kivéve, hogy csak x egyszer van kiértékelve.

Az alábbi példa az 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últerhelheti az operátort-. Ha egy bináris - operátor túlterhelt, az -= operátor implicit módon túlterhelt is. A felhasználó által definiált típus nem tudja explicit módon túlterhelni az operátort -= .

C# nyelvspecifikáció

További információt a C# nyelvi specifikációjának Unary mínusz operátor és Kivonás operátor szakaszában talál.

Lásd még