Использование суффиксов
При присвоении значений надо иметь в виду следующую тонкость: все вещественные литералы рассматриваются как значения типа double. И чтобы указать, что дробное число представляет тип float или тип decimal, необходимо к литералу добавлять суффикс: F/f - для float и M/m - для decimal.
| float a = 3.14F; float b = 30.6f; decimal c = 1005.8M; decimal d = 334.8m; |
Подобным образом все целочисленные литералы рассматриваются как значения типа int. Чтобы явным образом указать, что целочисленный литерал представляет значение типа uint, надо использовать суффикс U/u, для типа long - суффикс L/l, а для типа ulong - суффикс UL/ul:
| uint a = 10U; long b = 20L; ulong c = 30UL; |
Использование системных типов
Выше при перечислении всех базовых типов данных для каждого упоминался системный тип. Потому что название встроенного типа по сути представляет собой сокращенное обозначение системного типа. Например, следующие переменные будут эквивалентны по типу:
| int a = 4; System.Int32 b = 4; |
Неявная типизация
Ранее мы явным образом указывали тип переменных, например, int x;. И компилятор при запуске уже знал, что x хранит целочисленное значение.
Однако мы можем использовать и модель неявной типизации:
| var hello = "Hell to World"; var c = 20; Console.WriteLine(c.GetType().ToString()); Console.WriteLine(hello.GetType().ToString()); |
Для неявной типизации вместо названия типа данных используется ключевое слово var. Затем уже при компиляции компилятор сам выводит тип данных исходя из присвоенного значения. В примере выше использовалось выражение Console.WriteLine(c.GetType().ToString());, которое позволяет нам узнать выведенный тип переменной с. Так как по умолчанию все целочисленные значения рассматриваются как значения типа int, то поэтому в итоге переменная c будет иметь тип int или System.Int32
Эти переменные подобны обычным, однако они имеют некоторые ограничения.
Во-первых, мы не можем сначала объявить неявно типизируемую переменную, а затем инициализировать:
| // этот код работает int a; a = 20; // этот код не работает var c; c= 20; |
Во-вторых, мы не можем указать в качестве значения неявно типизируемой переменной null:
| // этот код не работает var c=null; |
Так как значение null, то компилятор не сможет вывести тип данных.
Double или decimal
Из выше перечисленного списка типов данных очевидно, что если мы хотим использовать в программе числа до 256, то для их хранения мы можем использоват переменные типа byte. При использовании больших значений мы можем взять тип short, int, long. То же самое для дробных чисел - для обычных дробных чисел можно взять тип float, для очень больших дробных чисел - тип double. Тип decimal здесь стоит особняком в том плане, что несмотря на большую разрядность по сравнению с типом double, тип double может хранить большее значение. Однако значение decimal может содержать до 28-29 знаков после запятой, тогда как значение типа double - 15-16 знаков после запятой.
Decimal чаще находит применение в финансовых вычислениях, тогда как double - в математических операциях. Общие различия между этими двумя типами можно выразить следующей таблицей:
| Decimal | Double | |
| Наибольшее значение | ~1028 | ~10308 |
| Наименьшее значение (без учета нуля) | 10-28 | ~10-323 |
| Знаков после запятой | 28-29 | 15-16 |
| Разрядность | 16 байт | 8 байт |
| Операций в секунду | сотни миллионов | миллиарды |
Таблица байтов:
1 байт = 8 бит
1 Кб (1 Килобайт) = 210 байт = 2*2*2*2*2*2*2*2*2*2 байт =
= 1024 байт (примерно 1 тысяча байт – 103 байт)
1 Мб (1 Мегабайт) = 220 байт = 1024 килобайт (примерно 1 миллион байт – 106 байт)
1 Гб (1 Гигабайт) = 230 байт = 1024 мегабайт (примерно 1 миллиард байт – 109 байт)
1 Тб (1 Терабайт) = 240 байт = 1024 гигабайт (примерно 1012 байт). Терабайт иногда называют тонна.
1 Пб (1 Петабайт) = 250 байт = 1024 терабайт (примерно 1015 байт).
1 Эксабайт = 260 байт = 1024 петабайт (примерно 1018 байт).
1 Зеттабайт = 270 байт = 1024 эксабайт (примерно 1021 байт).
1 Йоттабайт = 280 байт = 1024 зеттабайт (примерно 1024 байт).
2.Определение переменных
Для хранения данных в программе применяются переменные. Переменная представляет именнованную область памяти, в которой хранится значение определенного типа. Переменная имеет тип, имя и значение. Тип определяет, какого рода информацию может хранить переменная.
Перед использованием любую переменную надо определить. Синтаксис определения переменной выглядит следующим образом:
| тип имя_переменной; |
Вначале идет тип переменной, потом ее имя. В качестве имени переменной может выступать любое произвольное название, которое удовлетворяет следующим требованиям:
- имя может содержать любые цифры, буквы и символ подчеркивания, при этом первый символ в имени должен быть буквой или символом подчеркивания
- в имени не должно быть знаков пунктуации и пробелов
- имя не может быть ключевым словом языка C#. Таких слов не так много, и при работе в Visual Studio среда разработки подсвечивает ключевые слова синим цветом.
Хотя имя переменой может быть любым, но следует давать переменным описательные имена, которые будут говорить об и предназначении.
Например, определим простейшую переменную:
| string name; |
В данном случае определена переменная name, которая имеет тип string. то есть переменная представляет строку. Поскольку определение переменной представляет собой инструкцию, то после него ставится точка с запятой.
При этом следует учитывать, что C# является регистрозависимым языком, поэтому следующие два определения переменных будут представлять две разные переменные:
| string name; string Name; |
После определения переменной можно присвоить некоторое значение:
| string name; name = "Tom"; |
Так как переменная name представляет тип string, то есть строку, то мы можем присвоить ей строку в двойных кавычках. Причем переменной можно присвоить только то значение, которое соответствует ее типу.
В дальнейшем с помощью имени переменной мы сможем обращаться к той области памяти, в которой хранится ее значение.
Также мы можем сразу при определении присвоить переменной значение. Данный прием называется инициализацией:
| string name = "Tom"; |
Отличительной чертой переменных является то, что в программе можно многократно менять их значение. Например, создадим небольшую программу, в которой определим переменную, поменяем ее значение и выведем его на консоль:
| using System; namespace HelloApp { class Program { static void Main(string[] args) { string name = "Tom"; // определяем переменную и инициализируем ее Console.WriteLine(name); // Tom name = "Bob"; // меняем значение переменной Console.WriteLine(name); // Bob Console.Read(); } } } |
Консольный вывод программы:
Tom
Bob
3.Константы:десятичные,шестнадцатеричные,вещественные.
Литералы представляют неизменяемые значения (иногда их еще называют константами). Литералы можно передавать переменным в качестве значения. Литералы бывают логическими, целочисленными, вещественными, символьными и строчными. И отдельный литерал представляет ключевое слово null.
Логические литералы
Есть две логических константы - true (истина) и false (ложь):
| Console.WriteLine(true); Console.WriteLine(false); |
Целочисленные литералы
Целочисленные литералы представляют положительные и отрицательные целые числа, например, 1, 2, 3, 4, -7, -109. Целочисленные литералы могут быть выражены в десятичной, шестнадцатеричной и двоичной форме.
С целыми числами в десятичной форме все должно быть понятно, так как они используются в повседневной жизни:
| Console.WriteLine(-11); Console.WriteLine(5); Console.WriteLine(505); |
Числа в двоичной форме предваряются символами 0b, после которых идет набор из нулей и единиц:
| Console.WriteLine(0b11); // 3 Console.WriteLine(0b1011); // 11 Console.WriteLine(0b100001); // 33 |
Для записи числа в шестнадцатеричной форме применяются символы 0x, после которых идет набор символов от 0 до 9 и от A до F, которые собственно представляют число:
| Console.WriteLine(0x0A); // 10 Console.WriteLine(0xFF); // 255 Console.WriteLine(0xA1); // 161 |
Вещественные литералы
Вещественные литералы представляют вещественные числа. Этот тип литералов имеет две формы. Первая форма - вещественные числа с фиксированной запятой, при которой дробную часть отделяется от целой части точкой. Например:
| 3.14 100.001 -0.38 |
Также вещественные литералы могут определяться в экспоненциальной форме MEp, где M — мантисса, E - экспонента, которая фактически означает "*10^" (умножить на десять в степени), а p — порядок. Например:
| Console.WriteLine(3.2e3); // по сути равно 3.2 * 10<sup>3</sup> = 3200 Console.WriteLine(1.2E-1); // равно 1.2 * 10<sup>-1</sup> = 0.12 |
Символьные литералы
Символьные литералы представляют одиночные символы. Символы заключаются в одинарные кавычки.
Символьные литералы бывают нескольких видов. Прежде всего это обычные символы:
| '2' 'A' 'T' |
Специальную группу представляют управляющие последовательности Управляющая последовательность представляет символ, перед которым ставится обратный слеш. И данная последовательность интерпретируется определенным образом. Наиболее часто используемые последовательности:
'\n' - перевод строки
'\t' - табуляция
'\' - обратный слеш
И если компилятор встретит в тексте последовательность \t, то он будет воспринимать эту последовательность не как слеш и букву t, а как табуляцию - то есть длинный отступ.
Также символы могут определяться в виде шестнадцатеричных кодов, также заключенный в одинарные кавычки.
Еще один способ определения символов представляет использования шестнадцатеричных кодов ASCII. Для этого в одинарных кавычках указываются символы '\x', после которых идет шестнадцатеричный код символа из таблицы ASCII. Коды символов из таблицы ASCII можно посмотреть здесь.
Например, литерал '\x78' представляет символ "x":
| Console.WriteLine('\x78'); // x Console.WriteLine('\x5A'); // Z |
И последний способ определения символьных литералов представляет применение кодов из таблицы символов Unicode. Для этого в одинарных кавычках указываются символы '\u', после которых идет шестнадцатеричный код Unicode. Например, код '\u0411' представляет кириллический символ 'Б':
| Console.WriteLine('\u0420'); // Р Console.WriteLine('\u0421'); // С |
Строковые литералы
Строковые литералы представляют строки. Строки заключаются в двойные кавычки:
| Console.WriteLine("hello"); Console.WriteLine("фыва"); Console.WriteLine("hello word"); |
Если внутри строки необходимо вывести двойную кавычку, то такая внутренняя кавычка предваряется обратным слешем:
| Console.WriteLine("Компания \"Рога и копыта\""); |
Также в строках можно использовать управляющие последовательности. Например, последовательность '\n' осуществляет перевод на новую строку:
| Console.WriteLine("Привет \nмир"); |
При выводе на консоль слово "мир" будет перенесено на новую строку:
Привет
мир
Null
null представляет ссылку, которая не указывает ни на какой объект. То есть по сути отсутствие значения.
4.Ключевые слова.
Ключевые слова C#
Ключевые слова — это предварительно определенные зарезервированные идентификаторы, которые имеют специальные значения для компилятора. Их нельзя использовать как идентификаторы в программах без префикса @. Например, допустимым идентификатором является @if, но не if, поскольку if является ключевым словом.
В первой таблице этой статьи перечислены ключевые слова, которые нельзя использовать как идентификаторы в любой части программы C#. Во второй таблице этой статьи перечислены контекстные ключевые слова C#. Контекстные ключевые слова имеют особое значение только в определенном контексте программы, а за пределами этого контекста могут использоваться в качестве идентификаторов. Как правило, новые ключевые слова добавляются в язык C# в качестве контекстных ключевых слов, чтобы не нарушать работу программ, созданных в предыдущих версиях.
Контекстные ключевые слова
Контекстное ключевое слово используется для предоставления в коде конкретного значения, но не является зарезервированным словом в C#. Некоторые контекстные ключевые слова, например partial и where, имеют особое значение в двух или более контекстах.
| 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 | ||
| in | int | interface | internal | ||
| is | lock | long | namespace | ||
| new | null | object | operator | ||
| out | override | params | private | ||
| 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 | using static | virtual | void | ||
| volatile | while | ||||
| add | alias | ascending |
| async | await | by |
| descending | dynamic | equals |
| from | get | global |
| group | into | join |
| let | nameof | on |
| orderby | partial (тип) | partial (метод) |
| remove | select | set |
| value | var | when (условие фильтра) |
| where (ограничение универсального типа) | where (предложение запроса) | yield |
5.Операции арифмитические,отношения, логические,побитовые.
Арифметические операции языка C#
В C# используется большинство операций, которые применяются и в других языках программирования. Операции представляют определенные действия над операндами - участниками операции. В качестве операнда может выступать переменной или какое-либо значение (например, число). Операции бывают унарными (выполняются над одним операндом), бинарными - над двумя операндами и тернарными - выполняются над тремя операндами. Рассмотрим все виды операций.
Бинарные арифметические операции:
- +
Операция сложения двух чисел:
| int x = 10; int z = x + 12; // 22 |
- -
Операция вычитания двух чисел:
| int x = 10; int z = x - 6; // 4 |
- *
Операция умножения двух чисел:
| int x = 10; int z = x * 5; // 50 |
- /
операция деления двух чисел:
| int x = 10; int z = x / 5; // 2 double a = 10; double b = 3; double c = a / b; // 3.33333333 |
При делении стоит учитывать, что если оба операнда представляют целые числа, то результат также будет округляться до целого числа:
| double z = 10 / 4; //результат равен 2 |
Несмотря на то, что результат операции в итоге помещается в переменную типа double, которая позволяет сохранить дробную часть, но в самой опеации участвуют два литерала, которые по умолчанию рассматриваются как объекты int, то есть целые числа, и результат то же будет целочисленный.
Для выхода из этой ситуации необходимо определять литералы или переменные, участвующие в операции, именно как типы double или float:
| double z = 10.0 / 4.0; //результат равен 2.5 |
- %
Операция получение остатка от целочисленного деления двух чисел:
| double x = 10.0; double z = x % 4.0; //результат равен 2 |
Также есть ряд унарных операций, в которых принимает участие один операнд:
- ++
Операция инкремента
Инкремент бывает префиксным: ++x - сначала значение переменной x увеличивается на 1, а потом ее значение возвращается в качестве результата операции.
И также существует постфиксный инкремент: x++ - сначала значение переменной x возвращается в качестве результата операции, а затем к нему прибавляется 1.
| int x1 = 5; int z1 = ++x1; // z1=6; x1=6 Console.WriteLine($"{x1} - {z1}"); int x2 = 5; int z2 = x2++; // z2=5; x2=6 Console.WriteLine($"{x2} - {z2}"); |
- --
Операция декремента или уменьшения значения на единицу. Также существует префиксная форма декремента (--x) и постфиксная (x--).
| int x1 = 5; int z1 = --x1; // z1=4; x1=4 Console.WriteLine($"{x1} - {z1}"); int x2 = 5; int z2 = x2--; // z2=5; x2=4 Console.WriteLine($"{x2} - {z2}"); |
При выполнении сразу нескольких арифметических операций следует учитывать порядок их выполнения. Приоритет операций от наивысшего к низшему:
- Инкремент, декремент
- Умножение, деление, получение остатка
- Сложение, вычитание
Для изменения порядка следования операций применяются скобки.
Рассмотрим набор операций:
| int a = 3; int b = 5; int c = 40; int d = c---b*a; // a=3 b=5 c=39 d=25 Console.WriteLine($"a={a} b={b} c={c} d={d}"); |
Здесь мы имеем дело с тремя операциями: декремент, вычитание и умножение. Сначала выполняется декремент переменной c, затем умножение b*a, и в конце вычитание. То есть фактически набор операций выглядел так:
| int d = (c--)-(b*a); |
Но с помощью скобок мы могли бы изменить порядок операций, например, следующим образом:
| int a = 3; int b = 5; int c = 40; int d = (c-(--b))*a; // a=3 b=4 c=40 d=108 Console.WriteLine($"a={a} b={b} c={c} d={d}"); |