Что значит в си шарп

7

Операторы в C#

Язык C# содержит большое количество разнообразных операторов. Далее представлен структурированный в виде таблиц список операторов доступных в C#.

Арифметические операторы C#

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

Операторы присваивания C#

Эта группа операторов базируется на базовом операторе присваивания =:

Операторы сравнения C#

Логические операторы в C#

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

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Она выглядит вот так:

Комментарии ( 3 ):

В этом примере не двойка ли должна быть после логической "И" — "&&"? x < 2 && x < 3 То есть вот так: x < 2 && x < 2 вот теперь компьютер должен вернуть true. Кстати, очень интересно, а есть такой оператор в языке C#, оператор эквивалентности, как в php "===", или нужно писать специальный скрипт?

1. x < 2 && x < 3 — это просто пример, поэтому можно и так x < 2 && x < 2 — суть не изменится 2. C# — строго типизированный язык, Вы не сможете сравнить, например, (строку и число) "20" == 20, поэтому, если я Вас правильно понял, то такое в С# достигается преобразованием типов

Если я правильно помню, то эквивалентность — это тогда, когда сравниваются не только сами значения, но переменные. И переменные и значение должны быть одинаковы, тогда компьютер вернёт true, а иначе, вернёт false.

Для добавления комментариев надо войти в систему.
Если Вы ещё не зарегистрированы на сайте, то сначала зарегистрируйтесь.

Синтаксис языка C sharp

C Sharp или C# — язык программирования для создания прикладных компьютерных программ под операционные системы семейства Microsoft. Язык был выпущен в 2001-м году несколькими разработчиками во главе которых находился Андерс Хейлсберг и Скотт Вильтаумот. Приложения, разрабатываемые на C#, предназначены для платформы Microsoft .NET Framework. На сегодняшний день для С# создано огромное количество библиотек классов.

Язык является потомком C языка и является самым совершенным творением семейства С-подобных языков. Он вобрал в себя все самое лучшее из C и C++, синтаксис очень схож с Java, а также имеет свои особенности.

Сам по себе С# является объектно ориентированным языком программирования. Он объединяет в себе строгую и динамическую типизацию. Язык поддерживает все парадигмы ООП:

• наследование,
• полиморфизм,
• инкапсуляцию,
• абстракцию.

Он поддерживает огромный набор структур данных, позволяющих гибкую систему хранения различных данных. Огромным плюсом языка является автоматизированная очистка памяти — удаление ссылок на объекты запускает механизм удаления самих объектов в куче, что позволяет избежать утечек памяти. Но в этой стать не об этом. Мы будем рассматривать самые азы. А именно — синтаксис языка C#.

Что такое синтаксис языка?

Синтаксис языка программирования — это стек правил, которые образуют единую систему для написания программ. Написание кода осуществляется по строгому соответствию правил написания программ на определенном языке. То есть — есть определенная система написания программ, отклонение от которой не позволит процессору выполнить алгоритм и приведет к индикации ошибки.

К примеру — русские человек понимает русский язык, китаец — китайский, англичанин — английский. Если англичанину сказать что либо на китайском или просто набор букв, то он не сможет понять информацию, поступающую в его мозг.

Программа должна писать в соответствии с правилами структуры программ, подпрограмм, написания произвольных имен, с использованием ограниченных наборов операторов и зарезервированных слов. Компилятор языка C# понимает только синтаксически правильно написанные команды. В ином случае он выдаст синтаксическую ошибку.

Теперь пришло время познакомиться с синтаксисом C#, вобравшего в себя все особенности синтаксиса C, как и все C-подобные языки. Мы не будем рассматривать механику работы тех или иных конструкций языка. А лишь разберем правила их описания.

Идентификаторы

Идентификаторами являются все произвольные имена, которые выполняют функцию ссылки на область памяти. Это имена переменных, функций, объектов, классов, массивов и других структур. Имена идентификаторов оформляются по определенным правилам:

• Имя может начинаться с символа подчеркивания «_».
• Имя может начинаться с заглавной и строчной буквы — С# является регистрозависимым языком. Если создать вторую переменную с аналогичным именем, но в строке будет хотя бы одна буква, отличающаяся по регистру, то это уже две разные переменные.

Пример: имена car и car — две одинаковые переменные; car и Car — создаются разные переменные.

Недопустимо объявление идентификаторов в следующих случаях:

1. Имя не может начинаться с цифры.
2. Ключевое слово языка не может использоваться в качестве идентификатора — можно только в том случае, если перед ключевым словом будет стоять символ @.
3. Имя не может быть длиннее, чем 511 символов.

Пример синтаксически правильных идентификаторов: price, size, _size_of_box, sizeOfBox, SIZEOFBox, _price, price12, _@void(символ @ перед ключевым словом делает из него идентификатор), идентификатор (С# поддерживает юникод).

Пример синтаксически неправильных идентификаторов: 12price, int(ключевое слово), void(ключевое слово), 12444_hellO.

Пример: идентификаторы для переменных:

// Правильные
int digit;
float _Digit;
double diGIt;
string произвольное_имя;
string @string; // ключевое слово с символом @

//Неправильные идентификаторы
int 89digit;
int Integer; // ключевое слово
int Object; // ключевое слово

Ключевые слова языка C#

Ключевые слова являются идентификаторами языка по умолчанию и не могут использоваться при объявлении ссылок на память (переменные, массивы и т. п.). Это зарезервированные слова, которые имеют особый синтаксический смысл в языке. К примеру, ключевое слово отмечает циклы, функции, делегаты, события — специальные конструкции языка.

Существует два вида зарезервированных слов в C# — общие и контекстные. Первый тип используется только в качестве ключевых слов, второй тип имеет ограничения и используются только в определенном контексте. Еще раз стоит упомянуть, что ключевые слова нельзя использовать в качестве идентификаторов, то если перед ним поставлен символ @.

В С# по умолчанию предусмотрены следующие общие ключевые слова:

• abstract,
• as,
• base,
• bool,
• break,
• byte,
• case,
• catch,
• char,
• checked,
• class,
• const,
• continue,
• decimal,
• default,
• delegate,
• do,
• double,
• else,
• enum,
• event,
• explicit,
• extern,
• false,
• finally,
• fixed,
• float,
• for,
• foreach,
• goto,
• if,
• implicit,
• protected,
• public,
• readonly,
• ref,
• return,
• sbyte,
• sealed,
• short,
• sizeof,
• stackalloc,
• static,
• string,
• struct,
• switch,
• this,
• throw,
• true,
• try,
• typeof,
• uint,
• ulong,
• unchecked,
• unsafe,
• ushort,
• using,
• virtual,
• void,
• volatile,
• while,
• params,
• private.

В список контекстных зарезервированных слов входит:

• remove,
• select,
• set,
• value,
• global,
• group,
• into,
• join,
• add,
• dynamic,
• from,
• get,
• yield,
• var.

Литералы в языке C#

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

Литералы C# бывают следующих видов:

1. Десятичные: 1, 2, 34, 1289, 444, 53454, 21…;
2. Шестнадцатиричные: 0*E5, 0*F2, A, F, F8…;
3. С плавающей точкой: 1.54, 234.54, 4.3…;
4. Символы, обрамленные одинарными кавычками: ‘a’, ‘v’, ‘r’, ‘D’, ‘A’, ‘Ф’, «2», «0» и другие символы юникода;
5. Строки, обрамленные в парные кавычки: «My name is Daniel», «Hello everybody!», «сколько времени?»;
6. Символы экранирования: \u(и символ юникода), \n, \t, \r, \f, \\, и другие. Используются для редактирования вывода строк на экран.

Переменные

Переменная представляет собой ссылку на область памяти, где хранятся литералы определенного типа. Имя переменной является идентификатор, который может иметь произвольный набор символов в соответствии с правилами синтаксиса C#. В языке присутствует как строгая, так и динамическая типизация. Переменные могут быть определенного типа или без него.

Объявление типизированной переменной начинается с установки ее типа: int, string, boolean и т.п. Затем пишется идентификатор.

Пример:

int num; // объявлена переменная типа int с идентификатором num, в которую можно сохранить значение исключительно типа int
float num_float;
char letter;
string word;
var some_var; // объявление переменной без явного указания ее типа

Инициализация переменной — присвоение ей значения (литерала) того типа, в котором она объявлена. Переменные могут быть инициализированы при объявлении или динамически во время выполнения программы. В примере выше были объявлены переменные без инициализации. Теперь рассмотрим пример объявления переменных с инициализацией.

Пример:

int digit = 24; // присвоение переменной целочисленного литерала во время ее объявления
string name = «Fred»;
char some_symbol = «s»;

// объявление, а затем инициализация в коде

int d; // простое объявление целочисленной переменной
d = 349; // присвоение (инициализация) в коде программы

Объявление нескольких переменных одного типа можно выполнить в сокращенном виде.

Пример:

// без инициализации

char a, b, v;

// с инициализацией

int f = 5, x = 9, y = 999;

Константы в C#

Константой является идентификатор, значение которого фиксировано. То есть — значение константе дается один раз и не может быть изменено во время выполнения программы и не может быть присвоено новое значение. Сама константа состоит из ключевого слова const, типа, идентификатора и присвоенного литерала.

Пример:

//объявим константу без инициализации

const double digit;

// с инициализацией

const string company_name = «General Motors»;

company_name = «Hello»; // ошибка — литерал константы не может быть изменен и предназначен только для чтения

Также константой могут являться и свойства объектов. Значение этих свойств уже не может быть изменено. Альтернативой являются свойства, объявленные с ключевым словом readonly.

Блоки

Блок в C# это написанный алгоритм в отдельном контексте от глобального. Блок создается операторами <> — первая скобка открывает блок, вторая закрывает его. Глобальным контекстом является блок функции Main. В ее пределах или за ним другие блоки создают локальный контекст. Блоки внутри функций также обладают сублокальным контекстом.

Пример:

public static void Main() < // глобальный контекст (блок)
string g = «Hello!»; // глобальная переменная

<
string g = «Hy!»; // блок локального контекста
>

Console.print(g); // ошибка — в глобальном контексте нет переменной g и она находится в области видимости глобального контекста
>

static int func() <
int x = 6; // локальная переменная в локальном контексте
>

Основная структура всех программ в C#

Программы на C# состоят из классов. Основной алгоритм выполняется внутри функции Main. Классы хранятся в пространствах имен (namespaces) и внутри других классов. Классы содержат различные данные и функции. Классы внутри себя могут содержать другие классы. Пространства имен можно подключать к основной программе для доступа к функционалу различных классов. Основная программа состоит из пространства имен, основного класса с методом Main.

Пространства имен и классы

Пример:

Структура программы

Скелет программы состоит из трех основных конструкций:

1. Пространство имен.
2. Главный класс.
3. Метод Main как экземпляр главного класса и, являющийся блоком, в котором выполняется основной алгоритм.

Пример:

using System
using WindowsForms
using WebObjectsLibrary

namespace Some_NS <
// здесь могут быть описаны другие классы, структуры, интерфейсы и т. п.
class main_program <
//здесь описываются функции, события или делегаты основного алгоритма
public static void Main() <
// здесь пишется основной алгоритм
>
>
>

Подключение внешних классов и пространств имен

Пространства имен и классы подключается для того, чтобы можно было пользоваться их функционалом. При создании нового проекта в среде разработки, автоматически подключается пространство имен System, в котором еcть огромное количество классов, структур и интерфейсов, позволяющих взаимодействовать с аппаратной и программной частью компьютера.

В примере раздела «Структура программы» в самом на чале видно такие строки, как using System и подобные. Это и есть подключение внешних пространств имен и библиотек классов. Ключевое слово uses говорит о том, что в основную программу будет подключено определенное пространство имен или класс.

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

Также можно подключить отдельный класс из пространства имен таким образом: uses System.DataCollections. Здесь DataCollections может быть классом, интерфейсом, или внутренним пространством имен. Остальные классы System подключены не будут. Также для упрощенного доступа к экземплярам пространства имен можно использовать псевдонимы.

Пример:

using WEB = System.Net;
using Directions_Data = System.IO.DirectoryInfo;

Теперь для доступа к статическим методам и свойствам не нужно писать полный доступ к классу:

Достаточно ввести имя идентификатора:

Главный метод Main

Метод Main по умолчанию является экземпляром основного класса программы. Он вызывается по умолчанию при запуске программы. Вне метода Main описываются другие классы и функции. В методе Main создаются объекты, обрабатываются данные, вызываются функции, создаются объекты. Данный метод может быть двух типов: не возражающий значение и возвращающий 0 при успешном выполнении программы.

Пример:

// пример без возврата значения
public static void Main() < // метод всегда статический, а ключевое слово void говорит о том, что метод ничего не возвращает
// здесь пишется основной алгоритм
>

// пример с возвратом значения

public static int Main()< // int обозначает, что метод возвращает целое число

return 0; // возврат ноля если код выполнился без ошибок
>

Операторы языка C#

Операторы в C# и в программировании в целом — это основной инструмент обработки литералов. Операторы позволяют проводить математические операции над числовыми литералами, различные операции над текстом, создавать условия для выполнения определенного участка кода, отделять блок кода и многое другое.

В языке C# существует 16 категорий операторов:

1. Арифметические: +(прибавить), -(отнять), /(разделить), *(умножить), %(получение остатка от деления). Данные операторы применяются для выполнения арифметических действий над целыми числами и числами с плавающей точкой.
2. Конкатенация: +(соединение строк). Применяют для сложения двух строк в дону: «Hello»+»World» = «HelloWorld».
3. Логические: &&(true и true = true — оператор «и»), ||(true = если есть хоть одно true — оператор «или»), !(не true = true — оператор «не»). Применяются как в условных конструкциях, так и простых логических выражениях, результат всегда true или false.
4. Энкримент, декримент: ++(прибавить 1), —(отнять 1). Используются для сокращенной записи арифметического выражения x = x+1(++), x = x-1(—).
5. Присвоение: =(присвоить значение) += или -=(сокращенная запись прибавления или отнятия с присвоением), *= или /= (умножение или деление с присвоением), %=(присвоение остатка от деления), &=, ||=, ^=, >>=, [] &.
6. Операторы сравнения: (меньше и больше), = (меньше или равно, больше или равно), !=(неравно).

Пример:

// Рассмотрим несколько простейших примеров

// Арифметические
int x = 5;
int y = 10;
int z;

y+x // 15
y*x // 50

// Конкатенация

string a = «two»;
string b = «three»;
a+b // twothree

// сравнения
4==5 // false
88==88 // true
90>40 // true
70!=22 // true

// логические

«hello» == «hello» && «hy» == «hy» // оба true, значит результат true
«potatoe» == «orange» || «strawberry» == «strawberry» // одно из сравнений true, значит результатом будет true

Присваивание данных

Присваивание — передача литерала переменной. Или сохранения данных в память. Простое присваивание выполняется следующим образом: x = 5. Здесь x это целочисленная переменная, оператор «=» присваивает значение 5 переменной.

Чтобы не присваивать одинаковое значение нескольким переменным, в C# предусмотрена короткая инициализация: int num1, num2, num3. Теперь инициализируем их коротко: num1=num2=num3=250.
Операция присваивания обладает самым низким приоритетом.

Сначала выполняется выражение, только затем происходит присваивание. К примеру, нам нужно присвоить результат выражения num = 5+5*5. Сначала выполнится произведение, затем сложение, а в конце присваивание.

Теперь рассмотрим примеры операций сокращенного присваивания.

Пример:

int digit = 5;

digit +=5; // digit = digit+5 — результат будет 10
digit -=5; // 5
digit *=5 // 25

Условные выражения

Условные выражения всегда возвращают один из двух результатов. Это true или false. Условные выражения выполняются условными и логическими операторами. Их используют как в простых выражениях, так и логических конструкциях, позволяющих разделить алгоритм на составляющие.

Пример:

// Операции сравнения

//оператор ==(равно)

int varA = 10;
int varB = 4;
bool varC = varA == varB; // false

//оператор !=(неравно)

int digitA = 20;
int digitB = 14;
bool digitC = digitA != digitB; // true
bool digitD = digitA!=20; // false

// оператор > (больше)

int с = 10;
int d = 4;
bool e = c > d; // true

// оператор = и = bb; // true
bool dd = aa =100; // true, так как оба сравнения верны — если хоть одно сравнение не верно, то false

// Оператор не !

bool not = !»hello»; // false, строка равна true, а оператор ! проверяет: строка не true?

Условные конструкции

Условные конструкции необходимы для выбора выполнения того или иного алгоритма на одном участке программы. Если true, то выполняется один блок кода, если false, то другой. Есть несколько видов условных операторов:

• if()<> — если true, то выполняется блок кода, в ином случае алгоритм выполняется дальше, а блок пропускается
• if()<>else<> — при true выполняется блок if, при false выполняется блок else
• if()<>else if()<>else — если false в if, тогда проверяется else if, в ином случае выполняется else
• switch() — конструкция выбора соответствия литерала в скобках одному из case, если не соответствует, то выполняется блок default

Пример:

// if()<>

int numberValue = 10
if(numberValue==10) <
Console.write(«correct»); // если выражение true, то выполнится эта строка кода
// если в блоке только одна строка, то фигурные скобки можно не ставить
>

// if()<>else<>

String name = «Jonathan»;

if(name == «Jon») <
Console.write(«correct name»)
>else <
Console.write(«It is mistake»); // выполнится этот блок, так как в if выражение вернет false
>

// if()<> else if()<> else<>

int digit_value = 345;

if(digit_value>1000) <
Console.write(«Выполнился блок if»);
>else if(digit_value =10; x++) <
Console.Write(«a «);
>

// вывод: a a a a a a a a a a

Здесь объявленная переменная x = 0 является стартовой позицией счетчика, x>=10 конечной позицией. Инкремент x++ увеличивает счетчик на 1 при каждой итерации цикла. Итерация — это одно выполнение цикла. У нас выполнилось 10 итераций.

Операторы break и continue определяют как будет выполняться цикл. Break полностью прекращает работу цикла, затем продолжается дальнейшее выполнение алгоритма вне блока цикла. Оператор continue пропускает одну итерацию.

Пример:

// continue

for(int x = 0; x>=10; x++) <
if(x==10) continue; // пропуск последней итерации
Console.Write(«a «);
>

//Итог: a a a a a а а а а = 9 раз

// break

for(int x = 0; x>=10; x++) <
if(x>5) break; // выход из цикла
Console.Write(«a «);
>

//Итог: a a a a a

Цикл while и do while

Данный работает как со счетчиком, так и с логическими выражениями. Увеличение счетчика нужно указывать не в скобках, а самом блоке int s = 0;

Здесь переменная s равна 0. Каждая итерация увеличивает счетчик на 1 за счет s++, а в скобках true. Когда s будет равна 10, то в скобках будет false. Цикл прекращает свою работу. Здесь также можно применять операторы break и continue.

Аналогичным синтаксисом обладает цикл do while, его отличие лишь в том, что первая итерация выполняется в обязательном порядке, если в ней нет continue. Остальные итерации выполняются как и положено до выполнения условия в скобках.

Пример:

do <
//первый раз выполняется, остальные итерации в зависимости от условия
>while(true)

Цикл foreach

Данный цикл применяется для перебора массивов, которые будут подробнее обсуждаться далее. Конечно массив можно перебрать и ранее рассматриваемыми циклами. Но foreach лучше подстроен именно для массивов и позволяет экономить память(совсем мало) на его создание.

Пример:

char[] symbols = <‘a’, ‘b’, ‘c’, ‘ d’>; // создали массив символов

// теперь переведем все символы в верхний регистр с помощью цикла

foreach(int x in symbols) <
symbols[x] = symbols[x].ToUpper();
>

Console.Write(symbols); // A B C D

Массивы

Массивы представляют собой набор значений одного типа, обладающих порядковым индексом и одним идентификатором. Примером может послужить список учеников: Журнал класса Б(идентификатор), Пупкин, Пушкин, Жориков, Самсонова. В программировании массив выглядит следующим образом: char[] arr = <‘v’, ‘a’ ,’d’, ‘r’>; Здесь мы создали массив из четырех элементов. Каждый элемент обладает своим порядковым индексом. Символ v обладает нулевым индексом, остальные в порядке очереди. Отсчет элементов массива начинается с нуля.

Что есть в нашем массиве:

• char[] — объявление типа элементов массива, а квадратные скобки указывают на то, что создается массив;
• arr — идентификатор массива;
• — массив из четырех элементов с индексами [0], [1], [2], [3].

Зачем нужны массивы, если каждое значение можно упаковать в отдельную переменную? Ответ прост — для удобства. Нецелесообразно хранить логически связанные литералы в разных переменных. Гораздо удобнее использовать для этого массивы, как было показано в нашем журнале учеников. Есть несколько способов создания массивов. Рассмотрим их на примерах.

Пример:

// создадим один и тот же массив разными способами

int[] numbers = <34, 43, 72, 90>;

int[] numbers = new [] <34, 43, 72, 90>;

int[] numbers = new int[] <34, 43, 72, 90>;

int[] numbers = new int[4] < 1, 2, 3, 5 >; // с указанием его длины

// ручная инициализация

int[] numbers = new int[];
numbers[0] = 34;
numbers[1] = 43;
numbers[2] = 72;
numbers[3] = 90;

Если массив создан с указанием длины, но, без присвоенных элементов, то есть пустой массив, то в этом случае пустые элементы получат значение по умолчанию. Для чисел и символов это значение 0, для строк — пустые строки «».

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

Рассмотрим на примере вывод всех значений массива. Пример:

int[] massiv = new int[5]; // создали новый массив
Console.WriteLine(«Длина массива <0>», massiv.Length); // выводим на экран длину массива, свойство Length позволяет узнать длину массива

// заполняем массив через цикл for

for(int x = 0; x Console.WriteLine(«My name is Petya»);

// Если бы мы вместо вывода на экран использовали оператор return, то лямбда выражения выглядели бы так:

static string SaySomething() =>»My name is Petya»;

Массив в качестве параметров

Параметрами могут быть не только простые локальные переменные. В качестве параметра можно передавать и массив. Для этого применяется ключевое слово params. При этом, речь не идет о передачи простого массива. Речь идет о передаче неопределенного количества параметров.

Пример:

static void arr_params(params int[] integ)
<
int result = 0;
for (int i = 0; i

Операторы в C#

Операторы — это символы, которые используются для выполнения операций с операндами. Операндами могут быть переменные и/или константы.

Например, в выражении 2 + 3 , + — это оператор, который используется для выполнения операции сложения, а 2 и 3 — операнды.

Операторы используются для управления переменными и их значениями в программе. C# поддерживает ряд операторов, разделенных по типам выполняемых ими операций.

Простой оператор присваивания

Основной оператор присваивания = используется для присвоения значений переменным.

Здесь переменной x присваивается значение 50.05.

Пример 1. Используем простой оператор присваивания

Вывод:

Вы могли заметить в примере фигурные скобки <> . Такой метод называется форматированием строк, о нем мы поговорим в другой статье. Сейчас вам достаточно знать, что <0>заменяется на firstNumber , следующей за строкой, а <1>заменяется на secondNumber .

Арифметические операторы

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

Оператор

Название оператора

Пример

Оператор взятия остатка.

Пример 2. Используем арифметические операторы

Вывод:

Операторы сравнения

Операторы сравнения (они же — операторы отношения) используются для проверки связи между двумя операндами. Если сравнение истинно, результат будет true , иначе — false . Операторы отношения обычно используются в условиях и циклах.

Оператор

Название оператора

Пример

Больше или равно.

Меньше или равно.

Пример 3. Используем операторы сравнения

Вывод:

Логические операторы

Логические операторы используются для выполнения таких логических операций, как AND (ИЛИ), OR (И) и т. д. Логические операторы работают с булевыми выражениями и возвращают булевые значения true и false . Логические операторы нужны для принятия решений и в циклах.

Операнд 1

Операнд 2

OR ( || )

AND ( && )

• Если один из операндов true , то OR вернет true .
• Если один из операндов равен false , оператор AND вернет false .

Пример 4. Используем логические операторы

Вывод:

Унарные операторы

Унарные операторы работают только с одним операндом — это отличает их от всех остальных операторов.

Оператор

Название оператора

Описание

Оставляет знак операнда таким же.

Меняет знак операнда.

Увеличивает значение операнда на 1.

Уменьшает значение операнда на 1.

Инвертирует логическое значение операнда.

Пример 5. Используем унарные операторы

Вывод:

Когда ++ используется после операнда, значение сначала оценивается, а затем увеличивается на 1. Следовательно, оператор Console.WriteLine((number++)); выводит 10 вместо 11. После того, как значение выведено, оно увеличивается на 1.

Если ++ используется в качестве префикса, процесс обратный. Значение сначала увеличивается, а затем выводится. Следовательно, выражение Console.WriteLine((++number)); выводит 12.

То же самое и с оператором декремента — .

Тернарный оператор

Тернарный оператор ? : работает с тремя операндами. Это сокращение для конструкции if-then-else. Тернарный оператор можно использовать следующим образом:

Тернарный оператор работает вот так:

• Если выражение, указанное в условии равно true, переменной присваивается результат выражения1.
• Если же выражение равно false, переменной присваивается результат выражения2.

Пример 7. Используем тернарный оператор

Вывод:

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

Побитовые операторы и операторы побитового сдвига используются для выполнения манипуляций с битами.

C# Language
операторы

В C # оператор — это программный элемент, который применяется к одному или нескольким операндам в выражении или инструкции. Операторы, которые принимают один операнд, такой как оператор приращения (++) или новый, называются унарными операторами. Операторы, которые принимают два операнда, такие как арифметические операторы (+, -, *, /), называются двоичными операторами. Один оператор, условный оператор (? :), принимает три операнда и является единственным тернарным оператором в C #.

Синтаксис

• публичный статический оператор OperandType оператораSymbol (операнд операнда1)
• публичный статический оператор OperandType оператораSymbol (OperandType operand1, OperandType2 operand2)

параметры

замечания

Все операторы определяются как static methods и они не являются virtual и они не наследуются.

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

Все операторы имеют особый «приоритет» в зависимости от того, к какой группе относится оператор (операторы той же группы имеют одинаковый приоритет). Значение некоторых операторов будет применено к другим. Ниже следует список групп (содержащих их соответствующие операторы), упорядоченные по приоритету (сначала по высоте):

Первичные операторы

• ab — доступ к члену.
• a?.b — Нулевой доступ к условному члену.
• -> — разыменование указателя в сочетании с доступом участника.
• f(x) — вызов функции.
• a[x] — индекс.
• a?[x] — Нулевой условный индекс.
• x++ — Постерическое приращение.
• x— — Постфиксный декремент.
• new — Создание экземпляра.
• default(T) — Возвращает инициализированное значение по умолчанию типа T
• typeof — Возвращает объект Type операнда.
• checked — Включает проверку числового переполнения.
• unchecked — отключает проверку числового переполнения.
• delegate — объявляет и возвращает экземпляр делегата.
• sizeof — Возвращает размер в байтах операнда типа.

Унарные операторы

• +x — Возвращает x .
• -x — Числовое отрицание.
• !x — Логическое отрицание.

Мультипликативные операторы

• x * y — Умножение.
• x / y — Отдел.
• 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 — Логическое / побитовое И.

Логический оператор XOR

• x ^ y — Логический / побитовый XOR.

Логический оператор ИЛИ

• x | y — логическое / побитовое ИЛИ.

Условный И Оператор

• x && y — Короткое замыкание логического И.

Условный ИЛИ Оператор

• x || y — Короткое замыкание логического ИЛИ.

Оператор Null-coalescing

• x ?? y — возвращает x если он не равен нулю; в противном случае возвращает y .

Условный оператор

• x ? y : z — вычисляет / возвращает y если x истинно; в противном случае — z .

Связанный контент

Перегружаемые операторы

C # позволяет пользовательским типам перегружать операторы путем определения статических функций-членов с использованием ключевого слова operator .
Следующий пример иллюстрирует реализацию оператора + .

Если у нас есть класс Complex представляющий комплексное число:

И мы хотим добавить опцию для использования оператора + для этого класса. то есть:

Нам нужно будет перегрузить оператор + для класса. Это делается с использованием статической функции и ключевого слова operator :

Операторы, такие как + , — , * , / могут быть перегружены. Сюда также входят операторы, которые не возвращают один и тот же тип (например, == и != Могут быть перегружены, несмотря на возврат булевых элементов). Здесь также применяется правило, относящееся к парам.

Операторы сравнения должны быть перегружены парами (например, если < перегружен, > также необходимо перегрузить).

Полный список перегружаемых операторов (а также неперегружаемых операторов и ограничений, помещенных на некоторые перегружаемые операторы) можно увидеть в MSDN — Overloadable Operators (Руководство по программированию на C #) .

перегрузка operator is была введена с помощью механизма сопоставления шаблонов C # 7.0. Для получения дополнительной информации см Pattern Matching

Учитывая тип Cartesian определенный следующим образом

Перегружаемый operator is может быть определен, например, для Polar координат

который можно использовать следующим образом

Реляционные операторы

Равно

Проверяет, равны ли поставленные операнды (аргументы)

В отличие от Java, оператор сравнения равенства работает со строками.

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

В отличие от Visual Basic.NET оператор сравнения равенства не совпадает с оператором присваивания равенства.

Не путать с оператором присваивания ( = ).

Для типов значений оператор возвращает true если оба операнда равны по значению.
Для ссылочных типов оператор возвращает true если оба операнда равны в ссылке (не значение). Исключением является то, что строковые объекты будут сравниваться со значением равенства.

Неравномерно

Проверяет, не равны ли поставленные операнды.

Этот оператор фактически возвращает обратный результат к результату оператора equals ( == )

Лучше чем

Проверяет, превышает ли первый операнд второй операнд.

Меньше, чем

Проверяет, является ли первый операнд меньше второго операнда.

Больше, чем равно

Проверяет, является ли первый операнд больше, чем второй операнд.

Меньше, чем равно

Проверяет, является ли первый операнд меньше, чем второй операнд.

Операторы короткого замыкания

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

Это означает, что, если вы используете && operator как firstCondition && secondCondition, он будет оценивать secondCondition только в том случае, когда firstCondition является истинным, а fromcource — общий результат будет истинным, только если оба firstOperand и secondOperand оценены как true. Это полезно во многих сценариях, например, представьте, что вы хотите проверить, в то время как ваш список содержит более трех элементов, но вы также должны проверить, был ли список инициализирован, чтобы не запускаться в исключение NullReferenceException . Вы можете достичь этого, как показано ниже:

mList.Count> 3 не будет проверяться до тех пор, пока myList! = null не будет выполнен.

Логические И

&& является короткозамкнутым аналогом стандартного логического оператора AND ( & ).

Логический ИЛИ

|| является короткозамкнутым аналогом стандартного булева оператора OR ( | ).

Пример использования

размер

Возвращает int содержащий размер типа * в байтах.

* Поддерживает только определенные примитивные типы в безопасном контексте.

В небезопасном контексте sizeof может использоваться для возврата размера других примитивных типов и структур.

Перегрузка операторов равенства

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

1. object.Equals и object.GetHashCode
2. IEquatable<T>.Equals (необязательно, позволяет избежать бокса)
3. operator == и operator != (необязательно, позволяет использовать операторы)

При переопределении Equals , GetHashCode также должен быть переоценен. При реализации Equals существует множество особых случаев: по сравнению с объектами другого типа, по сравнению с самим собой.

Когда НЕ переопределенный метод Equals и оператор == работают по-разному для классов и структур. Для классов сравниваются только ссылки, а для структур значения свойств сравниваются посредством отражения, что может отрицательно повлиять на производительность. == не может использоваться для сравнения структур, если он не переопределен.

Как правило, операция равенства должна подчиняться следующим правилам:

• Не нужно бросать исключения .
• Рефлексивность: A всегда равна A (может быть неверна для значений NULL в некоторых системах).
• Транзитивность: если A равно B , а B равно C , то A равно C
• Если A равно B , то A и B имеют одинаковые хэш-коды.
• Независимость дерева наследования: если B и C являются экземплярами Class2 унаследованными от Class1 : Class1.Equals(A,B) всегда должны возвращать то же значение, что и вызов Class2.Equals(A,B) .

Операторы класса: членский доступ

Операторы класса: Null Conditional Member Access

Операторы класса: вызов функции

Операторы класса: индексирование агрегированных объектов

Операторы класса: нулевая условная индексация

«Эксклюзив» или «Оператор»

Оператор для «исключительного» или «(для короткого XOR): ^

Этот оператор возвращает true, когда один, но только один, из предоставленных bools являются истинными.

Операторы битового сдвига

Операторы сдвига позволяют программистам настраивать целое число, сдвигая все его биты влево или вправо. Следующая диаграмма показывает влияние сдвига значения слева на одну цифру.

Сдвиг влево

Правый-Shift

Неявные трансляции и явные операторы

C # позволяет пользовательским типам управлять назначением и кастом посредством использования explicit и implicit ключевых слов. Подпись метода принимает вид:

Метод не может принимать больше аргументов и не может быть методом экземпляра. Тем не менее, он может получить доступ к любым частным членам типа, которые определены внутри.

Пример как implicit и explicit приведения в действие:

Разрешить следующий синтаксис:

Операторы литья могут работать в обоих направлениях, переходя от вашего типа и переходя к вашему типу:

И, наконец, в as ключевых слов, которые могут быть вовлечены в литейном в иерархии типов, не действуют в этой ситуации. Даже после определения explicit или implicit броска вы не можете:

Он будет генерировать ошибку компиляции.

Бинарные операторы с присвоением

C # имеет несколько операторов, которые могут быть объединены с знаком = чтобы оценить результат оператора, а затем назначить результат исходной переменной.

• +=
• -=
• *=
• /=
• %=
• &=
• |=
• ^=
• <<=
• >>=

? : Тернарный оператор

Возвращает одно из двух значений в зависимости от значения булевого выражения.

Тернарный оператор является право-ассоциативным, что позволяет использовать сложные тернарные выражения. Это делается путем добавления дополнительных тернарных уравнений в истинную или ложную позицию родительского тройного уравнения. Следует проявлять осторожность, чтобы обеспечить читаемость, но в некоторых случаях это может быть полезным сокращением.

В этом примере сложная тройная операция оценивает функцию clamp и возвращает текущее значение, если оно находится в пределах диапазона, min значение, если оно находится ниже диапазона, или max значение, если оно находится выше диапазона.

Тернарные операторы также могут быть вложенными, например:

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

Типы expression_if_true и expression_if_false должны быть идентичными или должны быть неявным преобразованием из одного в другое.

Требования типа и преобразования применяются также к вашим собственным классам.

Возвращает объект System.Type для типа.

Чтобы получить тип времени выполнения, используйте метод GetType для получения System.Type текущего экземпляра.

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

по умолчанию

Тип значения (где T: struct)

Встроенные примитивные типы данных, такие как char , int и float , а также пользовательские типы, объявленные с помощью struct или enum . Их значением по умолчанию является new T() :

Тип ссылки (где T: класс)

Любой class , interface , массив или тип делегата. Их значение по умолчанию равно null :

имя оператора

Возвращает строку, которая представляет неквалифицированное имя variable , type или member .

Оператор nameof был введен в C # 6.0. Он оценивается во время компиляции, а возвращаемое строковое значение вставляется встроенным компилятором, поэтому его можно использовать в большинстве случаев, где может использоваться константная строка (например, метки case в инструкции switch , атрибуты и т. Д. .). Это может быть полезно в таких случаях, как повышение и регистрация исключений, атрибутов, ссылок на действия MVC и т. Д. .

?. (Null условный оператор)

Представлен в C # 6.0 , Null Conditional Operator ?. будет немедленно возвращать значение null если выражение в левой части оценивается как null , а не бросает NullReferenceException . Если его левая часть оценивается как null значение, она рассматривается как нормальная . оператор. Обратите внимание, что поскольку он может возвращать значение null , его возвращаемый тип всегда является типом с null значением. Это означает, что для структурного или примитивного типа он завернут в Nullable<T> .

Это удобно при запуске событий. Обычно вам придется обернуть вызов события в инструкции if, проверяющей значение null и затем поднять событие, что будет означать возможность гонки. Используя условный оператор Null, это можно зафиксировать следующим образом:

Приращение и уменьшение префиксов и префиксов

Постерическое приращение X++ добавит 1 к x

Постфиксный декремент X— вычитает один

++x называется приращением префикса, он увеличивает значение x, а затем возвращает x, в то время как x++ возвращает значение x, а затем увеличивает

оба они обычно используются в цикле for

=> Лямбда-оператор

Оператор => имеет тот же приоритет, что и оператор присваивания = и является право-ассоциативным.

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

При использовании в расширениях LINQ или запросах тип объектов обычно может быть пропущен, поскольку он выводится компилятором:

Общая форма лямбда-оператора следующая:

Параметры выражения лямбда указаны перед оператором => , а фактическое выражение / оператор / блок, который должен быть выполнен, находится справа от оператора:

Этот оператор может использоваться для простого определения делегатов без написания явного метода:

Оператор присваивания '='

Оператор присваивания = устанавливает значение левого операнда в значение правого операнда и возвращает это значение:

?? Оператор Null-Coalescing

Нуль-Коалесцентный оператор ?? будет возвращать левую сторону, если не null. Если он равен нулю, он вернет правую часть.