Udostępnij za pośrednictwem

Operatory - i -= - odejmowanie (minus)

Wbudowane typy liczbowe całkowite i zmiennoprzecinkowe oraz typy delegatów obsługują oba operatory - oraz -=.

Aby uzyskać informacje na temat operatora arytmetycznego -, zapoznaj się z sekcjami Jednoargumentowe operatory plus i minus oraz Operator odejmowania - w artykule Operatory arytmetyczne.

Usuwanie delegatów

W przypadku operandów tego samego typu delegata, operator - zwraca wystąpienie delegata obliczane w następujący sposób:

  • Jeśli oba operandy nie zawierają wartości null, a lista wywołań operandu po prawej stronie jest właściwą ciągłą podlistą listy wywołań operandu po lewej stronie, wynikiem operacji jest nowa lista wywołań, która powstaje przez usunięcie wpisów prawego operandu z listy wywołań operandu po lewej stronie. Jeśli lista operandu po prawej stronie pasuje do wielu ciągłych podlist w liście operandu po lewej stronie, zostanie usunięta tylko najbardziej zgodna lista podrzędna z prawej strony. Jeśli usunięcie spowoduje wyświetlenie pustej listy, wynikiem jest 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

  • Jeśli lista wywołań operandu po prawej stronie nie jest odpowiednią ciągłą podlistą listy wywołań operandu po lewej stronie, wynikiem operacji jest operand po lewej stronie. Na przykład usunięcie delegata, który nie jest częścią delegata wielokrotnej emisji, nie ma żadnego wpływu i powoduje, że delegat wielokrotnej emisji pozostaje niezmieniony.

    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

    Poprzedni przykład również pokazuje, że podczas usuwania delegatów wystąpienia delegatów są porównywane. Na przykład delegaty generowane na podstawie oceny identycznych wyrażeń lambda nie są równe. Aby uzyskać więcej informacji na temat równości delegatów, zobacz sekcję Operatorzy równości delegatów w specyfikacji języka C#.

  • Jeśli null jest operantem po lewej stronie, wtedy wynikiem operacji jest null. Jeśli operand po prawej stronie to null, wynikiem operacji jest operand po lewej stronie.

    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

Aby połączyć delegatów, użyj + operatora .

Aby uzyskać więcej informacji na temat typów delegatów, zobacz Delegates.

Operator przypisania odejmowania -=

Wyrażenie używające operatora -=, takiego jak

x -= y

Jest odpowiednikiem

x = x - y

Z tą różnicą, że x jest obliczana tylko raz.

W poniższym przykładzie pokazano użycie operatora -=:

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

Również używasz operatora -= do określania metody obsługi zdarzeń do usunięcia przy anulowaniu subskrypcji zdarzenia. Aby uzyskać więcej informacji, zobacz Jak subskrybować i zrezygnować z subskrypcji zdarzeń.

Przeciążenie operatora

Typ zdefiniowany przez użytkownika może przeciążenia operatora -. Gdy operator binarny - jest przeciążony, operator -= jest również przeciążony niejawnie. Począwszy od języka C# 14, typ zdefiniowany przez użytkownika może jawnie przeciążyć -= operator, aby zapewnić wydajniejszą implementację. Zazwyczaj typ przeciąża operator -=, ponieważ można zaktualizować wartość, zamiast przydzielać nową instancję do przechowywania wyniku odejmowania. Jeśli typ nie zapewnia jawnego przeciążenia, kompilator generuje niejawne przeciążenie.

Specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz sekcje jednoargumentowego operatora minus i operatora odejmowaniaspecyfikacji języka C#. Aby uzyskać więcej informacji na temat przeciążania operatorów przypisania złożonego w języku C# 14 lub nowszym, zobacz specyfikację funkcji przypisania złożonego zdefiniowanego przez użytkownika .

Zobacz także