Не равен в сишарп

Операторы и выражения C# (справочник по C#)

C# предоставляет ряд операторов. Многие из них поддерживаются встроенными типами и позволяют выполнять базовые операции со значениями этих типов. В число этих операторов входят следующие группы:

• Арифметические операторы, выполняющие арифметические операции с числовыми операндами.
• Операторы сравнения, сравнивающие числовые операнды.
• Логические операторы, выполняющие логические операции с операндами bool .
• Битовые операторы и операторы сдвига выполняют битовые операции или операции сдвига с операндами целочисленных типов.
• Операторы равенства проверяют равенство или неравенство своих операндов.

Как правило, можно выполнить перегрузку этих операторов, то есть указать поведение оператора для операндов определяемого пользователем типа.

Простейшими выражениями C# являются литералы (например, целые и реальные числа) и имена переменных. Их можно объединить в сложные выражения с помощью операторов. Приоритет и ассоциативность операторов определяют порядок выполнения операций в выражении. Порядок вычисления, определяемый приоритетом и ассоциативностью операторов, можно изменить с помощью скобок.

В следующем коде примеры выражений находятся в правой части назначений:

int a, b, c; a = 7; b = a; c = b++; b = a + b * c; c = a >= 100 ? b : c / 10; a = (int)Math.Sqrt(b * b + c * c); string s = "String literal"; char l = s[s.Length - 1]; var numbers = new List(new[] < 1, 2, 3 >); b = numbers.FindLast(n => n > 1); 

Как правило, выражение выдает результат и может быть заключено в другое выражение. Вызов метода void является примером выражения, которое дает результат. Его можно использовать только в качестве оператора, как показано в следующем примере:

Console.WriteLine("Hello, world!"); 

Ниже приведены некоторые другие виды выражений, доступные в C#:

Выражения интерполированных строк, которые предоставляют удобный синтаксис для создания форматированных строк:

var r = 2.3; var message = $"The area of a circle with radius is ."; Console.WriteLine(message); // Output: // The area of a circle with radius 2.3 is 16.619. 

int[] numbers = < 2, 3, 4, 5 >; var maximumSquare = numbers.Max(x => x * x); Console.WriteLine(maximumSquare); // Output: // 25 

var scores = new[] < 90, 97, 78, 68, 85 >; IEnumerable highScoresQuery = from score in scores where score > 80 orderby score descending select score; Console.WriteLine(string.Join(" ", highScoresQuery)); // Output: // 97 90 85 

Определение тела выражения можно использовать, чтобы предоставить краткое определение для метода, конструктора, свойства, индексатора или метода завершения.

Приоритет операторов

В выражении с несколькими операторами операторы с более высоким приоритетом оцениваются до операторов с более низким приоритетом. В следующем примере умножение выполняется сначала, так как оно имеет более высокий приоритет, чем сложение:

var a = 2 + 2 * 2; Console.WriteLine(a); // output: 6 

Используйте скобки, чтобы изменить порядок вычисления, накладываемый приоритетом операторов:

var a = (2 + 2) * 2; Console.WriteLine(a); // output: 8 

В следующей таблице перечислены операторы C# в порядке убывания приоритета. Операторы в каждой строке имеют одинаковый приоритет.

Операторы	Категория или имя
x.y, f(x), a[i], x?.y , x?[y] x++, x—, x!, new, typeof, checked, unchecked, default, nameof, delegate, sizeof, stackalloc, x-y>	Основной
+x, -x, !x, ~x, ++x, —x, ^x, ^x, (T)x, await, &x, *x, true и false	Унарный
x..y	Диапазон
switch, with	Выражения switch и with
x * y, x / y, x % y	Мультипликативный
x + y, x – y	Аддитивный
x > y	Сдвиг
x < y, x y, x >= y, is, as	Тестирование типов и относительный
x == y, x != y	Равенство
x & y	Логическое И или побитовое логическое И
x ^ y	Логическое исключающее ИЛИ или побитовое логическое исключающее ИЛИ
x | y	Логическое ИЛИ или побитовое логическое ИЛИ
x && y	Условное И
x || Y	Условное ИЛИ
X?? да	Оператор объединения с NULL
C? t : f	Условный оператор
x = y, x += y, x -= y, x *= y, x /= y, x %= y, x = y, x &|= y, x ^= y, x >= y, x ?? = y, =>	Назначение и объявление лямбда-выражений

Ассоциативность операторов

Если операторы имеют одинаковый приоритет, порядок их выполнения определяется ассоциативностью операторов:

• Операторы с левой ассоциативностью вычисляются слева направо. За исключением операторов присваивания и оператора объединения со значением NULL, все бинарные операторы имеют левую ассоциативность. Например, выражение a + b — c вычисляется как (a + b) — c .
• Операторы с правой ассоциативностью вычисляются справа налево. Операторы присваивания, операторы объединения null, лямбда-выражения и условные операторы ?: являются правильными ассоциативными. Например, выражение x = y = z вычисляется как x = (y = z) .

Используйте скобки, чтобы изменить порядок вычисления, накладываемый ассоциативностью операторов:

int a = 13 / 5 / 2; int b = 13 / (5 / 2); Console.WriteLine($"a = , b = "); // output: a = 1, b = 6 

Вычисление операнда

Не связанные с приоритетом и ассоциативностью операторов операнды в выражении вычисляются слева направо. В следующих примерах иллюстрируется порядок вычисления операторов и операндов:

Выражение	Порядок вычислений
a + b	a, b, +
a + b * c	a, b, c, *, +
a / b + c * d	a, b, /, c, d, *, +
a / (b + c) * d	a, b, c, +, /, d, *

Как правило, оцениваются все операнды операторов. Однако некоторые операторы оценивают операнды условно. То есть значение крайнего левого операнда такого оператора определяет, следует ли оценивать другие операнды. Эти операторы являются условными логическими операторами И ( && ) и ИЛИ ( || ) , операторами объединения со значением NULL ?? и ??= , условными операторами со значением NULL ?. и ?[] и условным оператором ?: . Дополнительные сведения см. в описании каждого оператора.

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

См. также

Источник

Операторы равенства — проверьте, равны ли два объекта

Операторы == (равенство) и != (неравенство) проверяют равенство или неравенство своих операндов. Типы значений равны, если их содержимое равно. Ссылочные типы равны, если две переменные ссылаются на одно хранилище.

Оператор равенства ==

Оператор равенства == возвращает значение true , если его операнды равны. В противном случае возвращается значение false .

Равенство типов значений

Операнды встроенных типов значений равны, если равны их значения.

int a = 1 + 2 + 3; int b = 6; Console.WriteLine(a == b); // output: True char c1 = 'a'; char c2 = 'A'; Console.WriteLine(c1 == c2); // output: False Console.WriteLine(c1 == char.ToLower(c2)); // output: True 

У операторов == , < , >, = , если какой-то из операндов не является числом (Double.NaN или Single.NaN), результатом операции является false . Это означает, что значение NaN не больше, не меньше и не равно любому другому значению double (или float ), включая NaN . Дополнительные сведения и примеры см. в справочных статьях по Double.NaN или Single.NaN.

Два операнда одного типа enum равны, если равны соответствующие значения базового целочисленного типа.

По умолчанию пользовательские типы struct не поддерживают оператор == . Чтобы поддерживать оператор == , пользовательская структура должна перегружать его.

Операторы и != поддерживаются кортежами == C#. Дополнительные сведения см. в разделе Равенство кортежей статьи Типы кортежей.

Равенство ссылочных типов

По умолчанию два операнда ссылочного типа, отличные от записи, являются равными, если они ссылаются на один и тот же объект.

public class ReferenceTypesEquality < public class MyClass < private int id; public MyClass(int id) =>this.id = id; > public static void Main() < var a = new MyClass(1); var b = new MyClass(1); var c = a; Console.WriteLine(a == b); // output: False Console.WriteLine(a == c); // output: True >> 

Как показано в примере, определяемые пользователем ссылочные типы поддерживают оператор == по умолчанию. Однако ссылочный тип может перегружать оператор == . Если ссылочный тип перегружает оператор == , воспользуйтесь методом Object.ReferenceEquals, чтобы проверить, что две ссылки этого типа указывают на один и тот же объект.

Равенство типов записей

Типы записей, доступные в C# 9.0 и более поздних версий, поддерживают операторы == и != , которые по умолчанию обеспечивают семантику равенства значений. То есть два операнда записи равны, когда оба они равны null или равны соответствующие значения всех полей и автоматически реализуемых свойств.

public class RecordTypesEquality < public record Point(int X, int Y, string Name); public record TaggedNumber(int Number, ListTags); public static void Main() < var p1 = new Point(2, 3, "A"); var p2 = new Point(1, 3, "B"); var p3 = new Point(2, 3, "A"); Console.WriteLine(p1 == p2); // output: False Console.WriteLine(p1 == p3); // output: True var n1 = new TaggedNumber(2, new List() < "A" >); var n2 = new TaggedNumber(2, new List() < "A" >); Console.WriteLine(n1 == n2); // output: False > > 

Как показано в предыдущем примере, для элементов ссылочного типа, не относящихся к записям, сравниваются их ссылочные значения, а не упоминаемые экземпляры.

Равенство строк

Два операнда string равны, если они оба имеют значение null или оба экземпляра строки имеют одинаковую длину и идентичные символы в каждой позиции символа.

string s1 = "hello!"; string s2 = "HeLLo!"; Console.WriteLine(s1 == s2.ToLower()); // output: True string s3 = "Hello!"; Console.WriteLine(s1 == s3); // output: False 

Сравнения на равенство строк — это порядковые сравнения с учетом регистра. Дополнительные сведения о том, как сравнивать строки, см. в статье Сравнение строк в C#.

Равенство делегатов

Два операнда делегатов одного типа среды выполнения равны, если оба из них имеют значение null или их списки вызовов имеют одинаковую длину и содержат одинаковые записи в каждой позиции:

Action a = () => Console.WriteLine("a"); Action b = a + a; Action c = a + a; Console.WriteLine(object.ReferenceEquals(b, c)); // output: False Console.WriteLine(b == c); // output: True 

Подробные сведения см. в разделе Delegate equality operators (Операторы равенства делегатов) в спецификации языка C#.

Делегаты, созданные в результате вычисления семантически идентичных лямбда-выражений , не равны, как показано в следующем примере:

Action a = () => Console.WriteLine("a"); Action b = () => Console.WriteLine("a"); Console.WriteLine(a == b); // output: False Console.WriteLine(a + b == a + b); // output: True Console.WriteLine(b + a == a + b); // output: False 

Оператор неравенства !=

Оператор != неравенства возвращает значение true , если его операнды не равны, false в противном случае . Для операндов встроенных типов выражение x != y дает тот же результат, что и выражение !(x == y) . Дополнительные сведения о равенстве типов см. в разделе Оператор равенства.

В следующем примере иллюстрируется использование оператора != .

int a = 1 + 1 + 2 + 3; int b = 6; Console.WriteLine(a != b); // output: True string s1 = "Hello"; string s2 = "Hello"; Console.WriteLine(s1 != s2); // output: False object o1 = 1; object o2 = 1; Console.WriteLine(o1 != o2); // output: True 

Возможность перегрузки оператора

Определяемый пользователем тип может перегружать операторы == и != . Если тип перегружает один из двух операторов, он должен также перегружать и другой.

Тип записи не может явно перегружать операторы == и != . Если необходимо изменить поведение операторов == и != для типа записи T , реализуйте метод IEquatable.Equals со следующей сигнатурой.

public virtual bool Equals(T? other); 

Спецификация языка C#

Дополнительные сведения о равенстве типов записей см. в разделе Элементы равенствапредложения функции записей.

См. также

Источник