Синтаксис языка 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.

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

Пример:

namespace System{ // пространство имен с идентификатором System, в котором будет коллекция классов
class Web_Data{ // класс внутри пространства имен

}

class System_data{ // другой класс
class app_data{ // класс внутри класса

}
}

}

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

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

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;

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

System.IO.DirectoryInfo.some_mehod().

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

Directions_Data.some_method().

Главный метод 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. Присвоение: =(присвоить значение) += или -=(сокращенная запись прибавления или отнятия с присвоением), *= или /= (умножение или деление с присвоением), %=(присвоение остатка от деления), &=, ||=, ^=, >>=, <<=(побитовые операции с присвоением). Применяются для присвоения данных переменным, а также результатов выражений. Оператор с присвоением является сокращенной записью x=x+число, то же, что и x+=число.
6. Побитовые операторы: &(0 и 0 = 1 или 0 и 1 = 0 — оператор «и»), ||(0 или 0 = 0, 1 или 0 = 1 — оператор «или»), ^(0 = 1, 1 = 0 — оператор «инверсия»). Конвертируют числа или строки в двоичную систему исчисления и сравнивают значения битов. Каждое сравнение возвращает 0 или 1. Итоговый результат состоит возвращается числом или строкой переведенной из ряда получившихся битов.
7. Доступ к экземплярам классов, объектов, структур: точка. Используется для доступа к свойствам и методам объектов, а также статическим членам классов.
8. Квадратные скобки []. Используются для индексации массивов и экземпляров объектов.
9. Фигурные скобки {}. Отделяют блок кода в функциях, циклах, классах и структурах, списках.
10. Круглые скобки (). Вызов функций и методов, приведение типов, отделение приоритетов выполнения арифметических выражений.
11. Операторы сокращенной условной конструкции: ? и :.
12. Оператор создания нового объекта: new. Применяется в функциях конструкторах при создании новых объектов.
13. Проверка литералов на тип: typeof sizeof, is, as. Результатом проверки является строка указывающая на тип литерала (x = 5, typeof x = int).
14. Проверка на переполнение: checked, unchecked. Возвращают true или false.
15. Операции с указателями: * -> [] &.
16. Операторы сравнения: < и >(меньше и больше), <= и >= (меньше или равно, больше или равно), !=(неравно).

Пример:

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

// Арифметические
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

// оператор < (меньше)

int с = 10;
int d = 4;
bool e = c < d; // false

 

//оператор >= и <= (больше или равно, меньше или равно)

int aa = 100;
int bb = 40;
bool cc = aa <= bb; // false
bool dd = aa <= 25; // true
bool cc = aa >= bb; // true
bool dd = aa <= 100; // true

Логические операторы в условных выражениях

Логические операторы позволяют сопоставить несколько сравнение и в зависимости от результата выдать true или false

Пример:

// Оператор или ||

boоl logOR = 55==55 || 34<12; // true, так как первое сравнение верно

// Оператор и &&

bool log& = 32<234 && 100>=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:, case:, case, default} — конструкция выбора соответствия литерала в скобках одному из 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<1000){
Console.write(«Выполнился блок else if»); // Выполнится этот блок
}else{
Console.write(выполнился блок else);
}

 

// конструкция switch case

string day = «Friday»;

switch(day){
case «Monday»: Console.write(«Не тот день»);
break;
case «Saturday»: Console.write(«Не тот день»);
break;
case «Friday»: Console.write(«Да, сегодня пятница»); // выполнится эта строка, так как значение case и в скобках равны
break;
default: Console.write(«Не угадан не один день»);
}

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

Типы данных в C#

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

Всего в C# 6 типов данных:

1. Целые числа: int, uint, long, ulong, byte, sbyte, short, ushort — каждый из них отличается только размером отводимой памяти для литерала.
2. Числа с плавающей точкой: float, double, decimal.
3. Символьный тип: char — буква или цифра обрамленная в одинарные кавычки
4. Строковой: String — обычный текст обрамленный в двойные качки из любых символов юникода, являющийся массивом символов
5. Объекты: Object — любой из перечисленных типов данных для которых отводится 4 байта в 32-разрядной операционной системе и 8 байт в 64-х.
6. Логические: bool — true или false.

Пример:

// целочисленные

int x = 578;
short y = 34;

// с плавающей точкой

double x = 3.45;
decimal y = 34342.33434;

// символьные

char h = ‘a’;
char n = ‘V’;
char r = ‘3’;

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

bool s = true;
bool d = false;

// Строки

string m = «Привет, меня зовут Петя»;
string z = «My favourite school subject is geometry»;

// Объекты

object a = 5;
object d = «Hello»;
object f = ‘s’;

Вывод данных в консоль

Для того, чтобы отразить текст или числа программы, их нужно вывести на экран. Один из способов вывода данных является их печать в консоли. Для этого в C# предусмотрен статический класс Console, находящийся в пространстве имен System, а также два его статических метода: write() — выводит все, что в скобках на экран консоли; writeLine() — выводит все содержимое скобок и после этого переводит курсор на новую строку.

Пример:

Consle.write(5);
Consle.write(5);
Consle.write(5);
// Результатом станет 555

Consle.writeline(5);
Consle.writeline(5);
Consle.writeline(5);

// Результат будет
5
5
5

// Вывод содержимого переменных

int num = 78;
Consle.write(num); // 78

Интерполяция — возможность выводить одним методом сразу несколько значений переменных вместе с текстом за счет символа $ и фигурных скобок{}.

Пример:

int digit = 458;
char ch = ‘b’;

Console.log($»code of symbol {ch} equals {digit}»); // code of symbol b equals 458

// альтернативный вариант

Console.log(«code of symbol {0} equals {1}», ch, digit); // будет то же самое, что и в предыдущем выводе

Второй вариант интерполяции имеет свои особенности. К примеру — этот способ подразумевает, что первый параметр в методе Console.WriteLine представляет выводимую строку («Имя: {0} Возраст: {2} Рост: {1}м»). Все последующие параметры представляют значения, которые могут быть встроены в эту строку (name, height, age). При этом важен порядок подобных параметров.

Например, в данном случае вначале идет name, потом height и потом age. Поэтому у name будет представлять параметр с номером 0 (нумерация начинается с нуля), height имеет номер 1, а age — номер 2. Поэтому в строке «Имя: {0} Возраст: {2} Рост: {1}м» на место плейсхолдеров {0}, {2}, {1} будут вставляться значения соответствующих параметров.

Ввод данных из консоли

Можно не только выводить литералы в консоль, но также вводить произвольное значение внутри самой консоли. Для этого предусмотрен статический метод Console.ReadLine(). Когда компилятор столкнется с вызовом этого метода, пользователь должен будет ввести некое значение в рамках предусмотренных типов данных и нажать Enter. После этого выполнение алгоритма продолжится.

Пример:

Console.WriteLine(«Напишите свою фамилию»);

string surname = Console.ReadLine();

Console.WriteLine(surname);

// Вывод: Напишите свою фамилию
Пупкин + Enter
Пупкин

Явное и неявное преобразование типов

Поскольку C # статически типизируется во время компиляции, после объявления переменной ее нельзя объявить снова или присвоить значение другого типа, если этот тип не является неявно преобразованным в тип переменной. Например, string нельзя неявно преобразовать в int. Следовательно, после того, как вы объявляете iобъект int, вы не можете присвоить ему строку «Hello».

Пример:

int some_var;

some_var = «Vova»; // Ошибка, так как числовому идентификатору присваивается строка

Однако иногда может потребоваться скопировать значение в параметр переменной или метода другого типа. Например, у вас может быть целочисленная переменная, которую нужно передать методу, параметр которого имеет тип double. Или вам может потребоваться присвоить переменную класса переменной типа интерфейса. Такие операции называются преобразованием типов.

В C # вы можете выполнять следующие виды преобразований:

1. Неявные преобразования: специального синтаксиса не требуется, поскольку преобразование всегда выполняется успешно и данные не теряются. Примеры включают преобразования из меньших целочисленных типов в большие и преобразования из производных классов в базовые классы.
2. Явные преобразования (приведения) : для явных преобразований требуется выражение приведения . Трансляция требуется, когда информация может быть потеряна при преобразовании или когда преобразование не удалось выполнить по другим причинам. Типичные примеры включают числовое преобразование в тип с меньшей точностью или меньшим диапазоном, а также преобразование экземпляра базового класса в производный класс.
3. Пользовательские преобразования . Пользовательские преобразования выполняются с помощью специальных методов, которые можно определить для включения явных и неявных преобразований между пользовательскими типами, которые не имеют отношения между базовым классом и производным классом. Дополнительные сведения см. В разделе Операторы преобразования, определяемые пользователем.
4. Преобразования с помощью вспомогательных классов : для преобразования между несовместимыми типами, такими как целые числа и объекты System.DateTime , или шестнадцатеричные строки и байтовые массивы, вы можете использовать класс System.BitConverter, класс System.Convert и Parseметоды встроенного -в числовых типах, таких как Int32.Parse . Дополнительные сведения см. В разделах Как преобразовать массив байтов в int , Как преобразовать строку в число и Как преобразовать между шестнадцатеричными строками и числовыми типами.

Неявные преобразования(приведения типов)

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

Например, переменная типа long (64-битное целое число) может хранить любое значение, которое может хранить int (32-битное целое число). В следующем примере компилятор неявно преобразует значение numсправа в тип long перед его присвоением BigDigit.

Пример:

int digit = 3434234234;
long BigDigit = digit; // присвоение успешно, и int преобразовался в long, так как тип long больше, чем int

Явные преобразования типов

Однако, если преобразование не может быть выполнено без риска потери информации, компилятор требует, чтобы вы выполнили явнoе преобразование, которое называется приведением . Приведение — это способ явно сообщить компилятору, что вы собираетесь выполнить преобразование и что вы знаете, что может произойти потеря данных или приведение может завершиться ошибкой во время выполнения.

Чтобы выполнить приведение, укажите тип, к которому вы выполняете преобразование, в круглых скобках перед значением или переменной, которые нужно преобрaзовать. Следующая программа преобразует double в int . Программа не скомпилируется без приведения.

double some_num = 1454.7;
int val;

//Преобразуем целочисленный в тип с плавающей точкой
val = (int)some_num; // тип в скобках говорит о явном преобразовании
Console.WriteLine(a); // 1454

Типы данных: значений и ссылочные

Значимыми типами являются примитивные типы дaнных как числовые, строковые, символы, логические. Ссылочными типами являются объекты. Значимые типы хранятся в стеке. Ссылочные в куче.
Идентификатор объекта является ссылкой на объект в куче. Отличие ссылочного типа в том, что на один объект могут ссылаться несколько идентификаторов. Изменение объекта через один идентификатор, изменит его для всех идентификаторов.

Пример:

// Значимый тип

int b = 5;
int c = b; // 5

c = 10;
Console.write(b); // 5

Как видно из примера выше, мы сохранили первую переменную во вторую. Изменив вторую переменную, значение первой осталось прежним. Теперь рассмотрим ту же операцию с ссылочным типом.

class House(){
public int width: 120;
}

House motel = new House();

House shop = motel;

Console.write(motel.width); // 120
Console.write(shop.width); // 120

//изменим свойство одного из объектов

motel.width = 140;

Console.write(motel.width); // 140
Console.write(shop.width); // 140

Это произошло потому, что при присвоении объекту shop объекта motel — просто был передан один и тот же объект двум ссылкам. Они обе ссылаются на один и тот же объект. Если бы мы создали shop через оператор new, тогда это было бы уже два разных объекта.

Циклы

Как и в любом другом языке, C# поддерживает циклы четырех типов: for, for each, while, do while. Циклы — это способ сократить код, когда нужно множество раз проделать одну и ту же операцию.

Цикл for

Пример:

for(int x = 0; x>=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;

while(s!=10){
Console.Write(«b «);
s++;
}

// Выведет b b b b b b b b b b

Здесь переменная 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 — идентификатор массива;
• {v’, ‘a’ ,’d’, ‘r’} — массив из четырех элементов с индексами [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<=massiv.Length; x++){
massiv[x] = x+5;
}

//выведем содержимое массива

foreach(num in massiv){
Console.WriteLine(massiv[num]);
}

// вывод:
Длина массива 5

6, 7, 8, 9, 10

// Попробуем обратиться за пределы массива.

Console.WriteLine(massiv[6]); // IndexOutOfRangeException — Ошибка: обращение к индексу, находящегося за пределами массива

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

Многомерный массив

Многомерный массив — массив массивов. То есть — элементами массива являются другие массивы. Двухмерный массив — массив массивов. Трехмерный массив — массив массивов, элементами которых также являются массивы. Рассмотрим на примере создание двухмерного массива.

Пример:

int[][] two_dimension_array = {{23, 34, 56}, {54, 89, 10}}; // объявление двумерного массива осуществляется через двойные скобки

Console.WriteLine(two_dimension_array[0][0]); // 23
Console.WriteLine(two_dimension_array[1][0]); // 54
Console.WriteLine(two_dimension_array[1][2]); // 10

// также можно объявить двумерный массив с фиксированной длиной

int[][] two_dimension_array = new int[2][4]; // объявлен массив двух массивов, каждый из которых содержит по 4 элемента

Console.WriteLine(two_dimension_array.Length); // 2
Console.WriteLine(two_dimension_array[0].Length); // 4

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

for(int i = 0; i<=two_dimension_array.Length; i++){ // количество итераций равно количеству массивов в массиве
for(int j = 0; j<=two_dimension_array[i].Length; j++){ // количество массивов равно количеству элементов в итерациях
two_dimension_array[i][j] = j;
}
}

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

Методы (функции)

Функции имеют огромное значение в программировании. Можно бесконечно обсуждать какую пользу они приносят. Однако их основной смысл — экономия времени программиста, упрощение алгоритма и экономия памяти. В объектно-ориентированных языках функции являются методами. Любая, даже однострочная программа в C# является экземпляром класса. Главная функция Main также является методом.

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

В C#, как и других С-подобных языках, методы могут находиться в основной программе или могут находиться в библиотеках, которые представляют собой внешние файлы, содержащие классы и подпрограммы, которые можно импортировать в программу. Это позволяет легко распространять их и использовать несколькими программами.

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

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

Рассмотрим на условном примере, не имеющему отношения к синтаксису C#. Пример:

функция вскипятить чайник{
налить в чайник воды;
включить чайник;
дождаться срабатывания автоматики;
}

Представьте, что нам в коде нужно 25 раз вскипятить чайник. Как видно в блоке метода у нас 3 строки кода. И того: 25 * 3 = 75. На придется написать 75 строчек кода, чтобы 25 раз вскипятить чайник. Только представьте как это скажется на самом программисте, сколько текстовой памяти займет. Это называется нелепо распоряжаться памятью.

Вызов функции, как уже упоминалось ранее, осуществляется всего в одну строчку. Наша функция будет вызвана следующим образом: вскипятить чайник(). Эта команда выполнит те строки кода, которые заключены в блоке. Таким образом нам надо всего 25 раз вызвать эту функцию. Если же требуется вызвать ее 25 раз подряд, а не в разных участках кода, то лучше сделать это через цикл следующим образом. Также разберем это на условном примере.

Пример:

for(int h = 0; h<=25; h++){
вскипятить чайник();
}

Как видно данный способ позволил нам обойтись всего тремя строками кода, что значительно экономит на размере исполнительного файла. Программисту не нужно нагромождать код однотипными вызовами.
Упаковка набора операторов в один модуль помогает сократить количество повторений одного и того же кода снова и снова или снова и снова использовать какую-либо конкретную операцию.

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

Определение метода

С основными понятиями о методах мы разобрались более чем подробно. Теперь пришло время понять как методы определяются по правилам C#. Есть два вида методов: те которые просто обрабатывают данные и те которые обрабатывают данные и возвращают результат. Оператор определения метода, который ничего не возвращает выглядит следующим образом: public static void method_name(){}. Он состоит из следующих элементов:

1. Public static- модификатор доступа. В ООП все члены классов имеют свой модификатор доступа. В главном классе вне функции Main все методы должны быть статическими. Всего есть несколько модификаторов доступа. Это public(публичный), static(статический), private(закрытый), protected(защищенный). В нашем случае метод публичный и статический одновременно.
2. Void — это ключевое слово, которое свидетельствует о том, что метод ничего не возвращает. Аналогичный присутствует в методе Main.
3. method_name — Идентификатор метода, то есть — его имя.
4. () — скобки указывают на то, что это метод, а также принимают в себя параметры. Наш метод без парамеров.
5. {} — блок кода, который выполняется при вызове метода.

Пример:

public static void sayHelloThreeTimes(){ // определяем и описываем метод один раз
Console.Write(«Hello «);
Console.Write(«Hello «);
Console.Write(«Hello «);
}

// вызов метода

sayHelloThreeTimes();
sayHelloThreeTimes();
sayHelloThreeTimes();

Вывод в консоль:
Hello Hello Hello
Hello Hello Hello
Hello Hello Hello

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

Пример:

public static int Multy_two_digits()
{
int x = 5;
int y = 5;
return x * y;

}

int result = Multy_two_digits();
Console.Write(result); // 25

В блоке метода мы определили только три строки кода. Оператор return возвращает результат арифметического выражения.

Методы с параметрами

Параметры позволяют вводить произвольные значения для использования их при каждом вызове метода. Список параметров — это действительные идентификаторы, разделенные запятой-разделителем, используемые для ввода параметров разных типов, и тип данных предшествует каждому из них. Они заключены в круглые скобки. Также возможно, что у метода не может быть параметра в списке параметров. Рассмотрим на примере определения метода с параметрами.

Пример:

public static int Multy_two_variable(int a, int b)
{

return a * b;

}

Console.WriteLine(Multy_two_variable(2,2)); // 4
Console.WriteLine(Multy_two_variable(25,2)); // 50

Как видно метод аналогичен предыдущему. Параметры указываются с определенным типом и могут иметь любой идентификатор. Если в качестве параметров указать идентификаторы глобальных переменных, то это не будет иметь к глобальным переменным никакого отношения. Просто в параметры передадутся их значения.

Этому методу были переданы два параметра, целое число a и целое число b, таким образом вы предоставляете ввод для подпрограммы (метода). Оператор return останавливает подпрограмму и (в зависимости от типа вывода) может выводить значение того же типа, что и тип вывода.

Оператор return может быть использован не только для возврата какого-либо значения. Он применяется просто для выхода из функции. Разберем это нагляднее, немного изменив предыдущий метод.

public static int Multy_two_variable(int a, int b)
{
if(a==0 && b==0) return; // досрочный выход из функции если параметры не определены
else return a * b; // если параметры больше 0, то выполняется умножение и возврат результата

}

int a = Multy_two_variable(0, 0);
int b = Multy_two_variable(3, 3);

Console.WriteLine(a); // Ошибка — переменная не содержит результата. Тут мы ничего не вернули
Console.WriteLine(b); // 9

Более компактное определение методов

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

Пример:

static void SaySomething() // простой метод написанный определенный обычным образом
{
Console.WriteLine(«My name is Petya»);
}

Теперь давайте сократим его с помощью лямбда выражений.

Пример:

static string SaySomething() => 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 < integ.Length; i++)
{
result += integ[i];
}
Console.WriteLine(result);
}

Addition(1, 2, 3, 4, 5); // вызов метода с произвольным количеством параметров

int[] array = new int[] { 1, 2, 3, 4 };
Addition(array); // количество параметров равно количеству элементов массива, а в качестве значений ставятся значения массива

Addition(); // вызов без параметров также не приведет к ошибке

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

Пример:

static void Many_Params( int a, string s, params int[] integ){} // одиночные параметры указаны до массива params

static void Many_Params(params int[] integ, int a, string s){} // такое определение не сработает, так как массив указан до одиночных параметров

Бывают ситуации, когда вместо массива параметров указывают просто массив в качестве параметра: static void Many_Params( int a, string s, int[] integ). В этом случае нельзя варьировать с количеством параметров при вызове функции. В качестве параметра обязательно должен быть передан массив не иначе.

Локальные переменные в методах

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

Пример:

int x = 5;
int z = 10; // глобальные переменные функции main

static void change_variables(int a, int b){
a = a+5;
b = b+5;
Console.WriteLine(a);
Console.WriteLine(b);
}

change_variables(a, b); // 10 15

Console.WriteLine(a); // 5 — глобальные переменные не изменились, так как в качестве параметра были переданы только их значения.
Console.WriteLine(b); //10

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

Передача параметров по ссылке

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

1. Чтобы передать аргумент методу по его ссылке.
2. Чтобы определить сигнатуру метода, чтобы вернуть ссылку на переменную.
3. Чтобы объявить структуру как ref struct.
4. Как местная ссылка.

Пример:

public static void addValue(int a){
a += 10;
}

// Define subtractValue
// передаем параметры через ссылку ref

public static void subtractValue(ref int b){
b -= 5;
}

// Запись основного алгоритма

// Инициализируем переменные
int a = 10, b = 12;

// Отображения установленных значений
Console.WriteLine(«Initial value of a is {0}», a);
Console.WriteLine(«Initial value of b is {0}», b);
Console.WriteLine();

// Вызов метода по значению
addValue(a);

Console.WriteLine(«Value of a after addition»+
» operation is {0}», a);

// Вызов метода по ссылке
subtractValue(ref b);

// Отображение значения b без ссылки но по значению
Console.WriteLine(«Value of b after «+
«subtration operation is {0}», b);

Выводом будет следующий текст:

Начальное значение a равно 10
Начальное значение b равно 12

Значение операции сложения 10
Значение b после операции вычитания равно 7

Что здесь произошло? Здeсь мы определяем два метода addValue и subtractValue . Метод addValue — это метод, который изменяет только значение своего параметра. Поэтому, когда значение ‘a’ отображается после передачи его в качестве параметра в addValue, его значение не различается.

В то время как метод subtractValue использует ссылку на параметр, ключевое слово ref указывает то же самое. Следовaтельно, когда значение ‘b’ отображается после передачи его в качестве параметра для subtractValue , вы можете видеть, что изменения отражаются в его значении. Ключевое слово ref должно использовaться в определении методa, а также при его вызове.

Вы также можете использовать ключевое слово ref с экземпляром класса. В приведенной ниже программе у нас есть класс Complex для представления комплексных чисел. Класс также состоит из метода обновления, который использует ссылку на объект и отражает обновления, сделанные в значении реальной и мнимой части объекта.

Ключевое слово out

Оно похоже по функциональности на ключевое слово ref. При этом, в отличии от ref, out не требует инициализации переменной перед ее передачей в качестве параметра.

Пример:

static int Add_numbers(out int a)
{
a = 0;//присвоили начальное значение
a++; //нарастил на 1
return a;
}

// запишем основной алгоритм в функцию main
int b;
Console.WriteLine($»Результат выполнения метода: {Addition(out b)}. Значение переменной после выполнения метода: {b}»);

Вывод будет Результат выполнения метода:1. Значение переменной после выполнения метода: 1.

Кортежи в C#

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

Пример:

// Способы объявления кортежей

var tupleOne = new Tuple(1);

var tupleTwo = new Tuple(1, «test»);

var sevenelementTuple = new Tuple(1,2,3,4,5,6,7);

Как видно из приведенного выше кода, были созданы три типа кортежей. У каждого есть свойства только для чтения с именами Item1, Item2, Item3 и т. д. Мы можем обращаться к элементам кортежей через свойства. tupleOne.Item1 выдаст 1, больше у этого кортежа нет никаких других значений, поэтому обращение к свойству Item2 приведет к ошибке.

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

Итог

Синтаксис C# вобрал в себя все самое лучшее из языков C, C++, Java. У него более структурированная программа в отличии от других языков. Для него написано огромное количество библиотек и классов. Он предназначен для разработки приложений под Windows и вэб-приложений. Он является частью движка Unity и используется для разработки игр.

В этой статье были перечисленные основные правила написания программ на C#. Однако это не полное руководство по программированию. Так как мы не разобрали в этой статье такое понятие как «Объектно-ориентированное программирование».

По этой парадигме программирования создано огромное количество книг. Упрощая разработку программ, эта парадигма не проста для изучения. Те, кто изучал функциональное или процедурное программирование могут столкнуться с трудностями при переходе на ООП.

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

Все таки C# был создан для создания мощных прикладных приложений для операционной системы Windows. Он позволяет создавать высоко нагруженные приложения для Web с помощью ASP.NEt, а также работать с реляционными базами данных.