1.47M

Category:

programming

Введение C#

ВВЕДЕНИЕ В C#
C# – объектно-ориентированный язык программирования. Разработан в 1998—2001
годах группой инженеров компании Microsoft под руководством Андерса Хейлсберга и
Скотта Вильтаумота как язык разработки приложений для платформы Microsoft .NET
Framework и .NET Core.
C# относится к семье языков с C- подобным синтаксисом, его синтаксис наиболее
близок к C++ и Java.
Язык имеет статическую типизацию, поддерживает полиморфизм, перегрузку
операторов, делегаты, атрибуты, события, переменные, свойства, обобщённые типы и
методы, итераторы, анонимные функции с поддержкой замыканий, исключения,
комментарии в формате XML.
C# в отличие от C++ не поддерживает множественное наследование классов
Текущей версией языка является версия C# 10.0, которая вышла 8 ноября 2021 года
вместе с релизом .NET 6.

3.

Название
Название «Си шарп» (от англ. sharp — диез) происходит от буквенной
музыкальной нотации, где латинской букве C соответствует нота До, а
знак диез означает повышение соответствующего ноте звука на
полутон, что аналогично названию языка C++, где «++» обозначает
инкремент переменной.
Название также является игрой с цепочкой C → C++ → C++++(C#), так
как символ «#» можно представить состоящим из 4 знаков «+»
Из-за технических ограничений на отображение , а также из-за того, что
знак диеза ♯ не представлен на стандартной клавиатуре компьютера,
при записи имени языка программирования используют знак решётки #.
Тем не менее, на практике (например, при размещении рекламы и
коробочном дизайне), «Майкрософт» использует знак диеза.

4.

С помощью языка программирования C# вы можете создавать приложения
самых разных типов, включая следующие:
бизнес-приложения для сбора, анализа и обработки данных;
динамические веб-приложения для работы через веб-браузер;
двухмерные и трехмерные игры;
финансовые и научные приложения;
Облачные приложения
Мобильные приложения

5.

6.

.NET
.Net – платформа от компании MicroSoft, которая состоит
из полного набора инструментов для разработчиков
(.NetFramework):
Клиентская и серверная ОС
Инструменты разработки
сервисы

7.

Достоинства платформы .NET
Универсальный API
На каком бы языке вы ни программировали вам
предоставляются одни и те же имена классов и методов
Все типы данных C# абсолютно совместимы с другим
языком платформы
Защищенный код
Полная ориентированность на объекты
Сборка мусора

8.

Достоинства платформы .NET
Визуальное программирование
Распределенные вычисления
Открытость стандартов
Кроссплатформенность.
Производительность.
Согласно ряду тестов веб-приложения на .NET 6 в ряде
категорий сильно опережают веб-приложения,
построенные с помощью других технологий.

9.

Достоинства платформы .NET
Разнообразие технологий.
Общеязыковая среда исполнения CLR и базовая библиотека классов
являются основой для целого ряда технологий, которые разработчики
могут задействовать при построении тех или иных приложений.
Например, для работы с базами данных предназначена технология
ADO.NET и Entity Framework Core. Для построения графических
приложений - технология WPF и WinUI, для создания простых
графических приложений - Windows Forms.
Для разработки кроссплатформенных мобильных и десктопных
приложений - Xamarin/MAUI.
Для создания веб-сайтов и веб-приложений - ASP.NET и т.д.

10.

.NET Framework и .NET 6
.NET долгое время развивался как платформа для Windows
под названием .NET Framework. В 2019 вышла последняя
версия этой платформы - .NET Framework 4.8. Она больше не развивается
С 2014 Microsoft стал развивать альтернативную платформу - .NET Core,
которая предназначалась для разных платформ и должна была вобрать в
себя все возможности устаревшего .NET Framework
Затем Microsoft последовательно выпустил ряд версий этой
платформы: .NET Core 1, .NET Core 2, .NET Core 3, .NET 5. И текущей
версией является платформа .NET 6.
Поэтому следует различать .NET Framework, который предназначен для
Windows, и кросплатформенный .NET 6.
У нас будет речь идти о C# 10 в связке с .NET 6

11.

Платформа .Net
Состоит из:
Базовых классов
Операционной системы
Общеязыковой среды исполнения CLR (Common Language
Runtime)
Web – сервисов, форм.

12.

Платформа .Net
Среда выполнения (CLR) --- это виртуальная машина, которая обрабатывает
IL-- код программы (Intermediate Language – промежуточный язык)
Нередко приложение, созданное на C#, называют управляемым кодом
(managed code).
это значит, что данное приложение создано на основе платформы .NET и
поэтому управляется общеязыковой средой CLR, которая загружает
приложение и при необходимости очищает память.
Но есть приложения, например, созданные на языке С++, которые
компилируются не в общий язык CIL, как C#, VB.NET или F#, а в обычный
машинный код. В этом случае .NET не управляет приложением...

13.

JIT-компиляция
Код на C# компилируется в приложения или сборки с расширениями exe
или dll на языке CIL.
При запуске на выполнение подобного приложения происходит JITкомпиляция (Just-In-Time) в машинный код, который затем выполняется.
При этом, поскольку приложение может быть большим и содержать
много инструкций, в текущий момент времени будет компилироваться
лишь та часть приложения, к которой непосредственно идет обращение.
Если мы обратимся к другой части кода, то она будет скомпилирована
из CIL в машинный код. При том уже скомпилированная часть
приложения сохраняется до завершения работы программы.

14.

JIT-компиляция
** Машинный код выполняется напрямую процессором, и
ОС не может управлять этим кодом.
А вот IL-- код выполняется на .Net платформе, и уже она
решает , как его выполнять, какие процессорные
инструкции использовать.

15.

Термин «Сборка»
Сборка – это просто конечные файлы, являющиеся результатом
компиляции
Библиотеки *.dll
Исполняемые файлы *.exe
Программы .Net содержат не инструкции процессора, как
классические Win-приложения, а IL – код.
Этот код создается компилятором и сохраняется в файле.
Когда пользователь запускает программу, то она на лету
компилируется в машинный код и выполняется на процессоре

16.

Термин «Сборка»
В сборке хранится информация (метаданные) об
используемых типах данных.
Кроме того, хранятся данные самого файла о версии
сборки и ссылки на внешние сборки.
Код делят по сборкам по принципу логической
завершенности
За выполнение сборки отвечает CLR
mscoree.dll, mscorlib.dll

17.

Console Application
Итак, создадим первое приложение на языке C#.
Что для этого потребуется?
Во-первых, нам нужен текстовый редактор,
в котором мы могли бы напечатать код программы.
Во-вторых, нам нужен компилятор, который бы скомпилировал набранный
в текстовом редакторе код в приложение exe.
В-третьих, нам нужен фреймворк .NET, который требуется для
компиляции и выполнения программы.
Чтобы облегчить написание, а также тестирование и отладку
программного кода обычно используют специальные среды разработки, в
частности, Visual Studio.
Для создания приложений на C# будем использовать бесплатную и
полнофункциональную среду разработки - Visual Studio Community 2022

18.

Console Application

19.

Console Application

20.

21.

22.

23.

Справа находится окно Solution Explorer, в котором можно увидеть
структуру нашего проекта.
по умолчанию структура: узел Dependencies - это узел содержит
сборки dll, которые добавлены в проект по умолчанию. Эти сборки
как раз содержат классы библиотеки .NET, которые будет
использовать C#.
Однако не всегда все сборки нужны. Ненужные потом можно
удалить, в то же время если понадобится добавить какую-нибудь
нужную библиотеку, то именно в этот узел она будет добавляться.
Далее идет непосредственно файл кода программы Program.cs,
который по умолчанию открыт в центральном окне и который имеет
всего две строки:
// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

24.

Несмотря на то, что программа содержит только одну
строку кода, это уже программа, которую мы можем
запустить с помощью клавиши F5 или с панели
инструментов, нажав на зеленую стрелку. И если вы все
сделали правильно, то при запуске приложения на консоль
будет выведена строка "Hello World!".

25.

Изменение в коде
Console.Write("Введите свое имя: ");
string? name = Console.ReadLine();
// вводим имя
Console.WriteLine($"Привет {name}");
// выводим имя на консоль
// Выражение string? name указывает, что определяется переменная name
типа string?, которая может хранить строки.
А знак вопроса ? указывает, что переменная также может хранить значение
null, то есть не иметь никакого значения.
//Чтобы ввести значение переменной name внутрь выводимой на консоль
строки, применяются фигурные скобки {}. То есть при выводе строки на
консоль выражение {name} будет заменяться на значение переменной name.
Однако чтобы можно было вводить таким образом значения переменных
внутрь строки, перед строкой указывается знак доллара $.

26.

Первая программа на C#
Программу можно найти на жестком диске в папке проекта в
каталоге bin\Debug\net6.0. Она будет называться по имени
проекта и иметь расширение exe.
Этот файл можно будет запускать без Visual Studio, а также
переносить его на другие компьютеры, где установлен .NET 6.

27.

Весь код программы на языке C# помещается в файлы с
расширением .cs. По умолчанию в проекте, который
создается в Visual Studio (а также при использовании .NET
CLI) уже есть один файл с кодом C# - файл Program.cs со
следующим содержимым:
//
Console.WriteLine("Hello, World!");

28.

Файл проекта
В каждом проекте проекте C# есть файл, который отвечает за общую конфгурацию
проекта. По умолчанию этот файл называется Название_проекта.csproj.
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
</Project>

29.

Файл проекта
Этот файл в виде кода xml определяет конфигурацию проекта и может
содержать множество элементов.
OutputType: определяет выходной тип проекта. Это может быть
выполняемое приложение в виде файла с расширением exe, которое
запускается по нажатию. И также это может быть файл с расширением .dll некоторый набор функциональностей, который используется другими
проектами. По умолчанию здесь установлено значение "Exe", что значит,
что мы создаем исполняемое приложение.
TargetFramework: определяет применяемую для компиляции версию
фреймворка .NET. В данном случае это значение "net6.0", то есть
применяется .NET 6.0.

30.

Код программы
using System;
class Hello
{
// Hello1.cpp : Этот файл содержит
функцию "main". Здесь начинается
и заканчивается выполнение
программы.
static void Main()
//
{
#include <iostream>
int main()
{
Console.WriteLine("Hello, World");
}
}
std::cout << "Hello World!\n";
}

31.

Код программы
Класс Hello, объявленный в программе "Hello, World", имеет только один
член — это метод с именем Main.
Метод Main объявлен с модификатором static. Методы экземпляра могут
ссылаться на конкретный экземпляр объекта, используя ключевое слово
this, а статические методы работают без ссылки на конкретный объект.
По стандартному соглашению точкой входа программы C# является
статический метод с именем Main.
Выходные данные программы создаются в методе WriteLine класса Console
из пространства имен System. Этот класс предоставляется библиотеками
стандартных классов, ссылки на которые компилятор по умолчанию
добавляет автоматически.

32.

33.

Замечание по Visual Studio

34.

Замечание по Visual Studio
SharpDevelop — свободная среда разработки для C#,
Visual Basic .NET, Boo, IronPython, IronRuby, F#, C++.
Обычно используется как альтернатива Visual
Studio .NET. Существует также форк на Mono/GTK+
— MonoDevelop.
SharpDevelop 2.0 предоставляет интегрированный
отладчик, который использует собственные
библиотеки и взаимодействует с исполняющей
средой .NET через COM Interop.

35.

36.

Возможности и особенности
Написана полностью на C#.
Подсветка синтаксиса для C#, IronPython, HTML, ASP, ASP.NET, VBScript, VB.NET, XML, XAML.
Визуальный редактор для WPF и форм Windows Forms (COM-компоненты не
поддерживаются).
Интегрированная поддержка NUnit, MbUnit и NCover.
Интегрированная поддержка анализатора сборок FxCop.
Интегрированный отладчик.
Интегрированный профайлер.
Интегрированная поддержка SVN, Mercurial и Git.
Конвертор кода между языками C#, VB.NET, IronPython и Boo.
Предпросмотр документации, полученной из документирующих комментариев.
Расширяемость внешними инструментами.
Расширяемость на основе механизма Add-Ins.

37.

38.

Основы C#
В .Net используется общая система типов (Common Type System,
CLS)
Все типы данных являются объектами
Все типы C#, включая типы-примитивы, такие как int и double,
наследуют от одного корневого типа object. Все типы используют
общий набор операций, а значения любого типа можно хранить,
передавать и обрабатывать схожим образом.
Делятся на размерные (типы значений) и ссылочные
Ссылочные типы – это объекты, а имя переменной – это ссылка на
объект. (не указатель!)
Основные типы данных описаны в пространстве имен System

39.

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

40.

Типы
Типы значений в C# делятся на
простые типы,
типы перечислений,
типы структур,
типы, допускающие значение NULL,
и типы значений кортежей.
Ссылочные типы в C# подразделяются на типы классов,
типы интерфейсов, типы массивов и типы делегатов.

41.

Объект
Псевдоним
Object
object
Базовый класс для всех
типов CLS
String
string
строка
SByte
sbyte
-128.. 127 (8 разрядов)
Byte
byte
0..255(8разрядов)
Int16
short
-32768..32767(16
разрядов)
UInt16
ushort
0.. 65535
Int32
int
-2147483648..2147483647
Основы C#
Описание

42.

Объект
Псевдоним
UInt32
uint
0.. 4294967295
Int64
long
-9223372036854775808..
9223372036854775807
UInt64
ulong
0..18446744073709551615
Decimal
decimal
128-разрядное число
Char
char
16-разрядный символ
Single
float
32-разрядное число с
плавающей точкой
Double
double
64-разрядное число с
плавающей точкой
Boolean
bool
Булево значение
Основы C#
Описание

43.

Основы C#
Выше при перечислении всех базовых типов данных для
каждого упоминался системный тип. Название встроенного типа
по сути представляет собой сокращенное обозначение
системного типа. Например, следующие переменные будут
эквивалентны по типу:
System. int32
int i;
Для простых переменных память выделяется или уничтожается
автоматически

44.

Использование суффиксов
При присвоении значений надо иметь в виду: все вещественные литералы
(дробные числа) рассматриваются как значения типа 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;

45.

Неявная типизация
Ранее мы явным образом указывали тип переменных, например, int x;. И
компилятор при запуске уже знал, что x хранит целочисленное значение.
Однако мы можем использовать и модель неявной типизации:
var hello = "Hell to World";
var c = 20;
Для неявной типизации вместо названия типа данных используется
ключевое слово var. Затем уже при компиляции компилятор сам выводит
тип данных исходя из присвоенного значения. Так как по умолчанию все
целочисленные значения рассматриваются как значения типа int, то
поэтому в итоге переменная c будет иметь тип int. Аналогично переменной
hello присваивается строка, поэтому эта переменная будет иметь тип string

46.

Неявная типизация: ограничения
Во-первых, мы не можем сначала объявить неявно типизируемую
переменную, а затем инициализировать:
// этот код работает
int a;
// код не работает
var c; c= 20;
a = 20;
Во-вторых, мы не можем указать в качестве значения неявно
типизируемой переменной null:
// код не работает
var c=null;
Так как значение null, то компилятор не сможет вывести тип данных.

47.

Пространство имен
Пространство имен – это область, внутри которой все имена должны
быть уникальными
В .Net все: классы, переменные, структуры – разбито по пространствам
имен.
namespace Имя
{
namespace MyCompany. Namespace
{
//определение типов
// определение типов, классов,
переменных
}
}

48.

Пространство имен
using System
В этом пространстве описаны все основные типы данных,
все основные инструменты и функции работы с системой
System. Console. WriteLine („Hello, World!“);

49.

Переменные
Объявляются в любом месте кода до ее применения
System.Int32 i; // int i;
i=10;
Console.WriteLine(i);
Язык C# чувствителен к регистру!
System.String s;
s=“Hello“;
Console.WriteLine(s);
Все строки заключаются в двойные кавычки!

50.

Строки
string str; // память не выделена
string str=“Это строка“;
string str= „Это еще одна строка“;
Нельзя изменять строки!
При каждой попытке изменения строки создается ее новый
экземпляр.

51.

Массивы
int [ ] intArray;
intArray= new int[3];
//
int [] intArray=new int[3];
// если значения элементов массива известны заранее
string[ ] weekDays={ „Sunday“, „Monday“,“Tuesday“};
каждый массив имеет свойство Length, которое хранит длину массива.
Например, получим длину массива numbers:
int[] numbers = { 1, 2, 3, 5 };
Console.WriteLine(numbers.Length);

52.

Массивы
int[,] myArray;
myArray= new int[3,3];
int [,,] myArray= new int[6,6,5];
myArray[1,2,3]=10;

53.

Массив массивов
int [][] nums = new int[3][ ];
nums[0] = new int[2] { 1, 2 };
// выделяем память для первого подмассива
nums[1] = new int[3] { 1, 2, 3 };
// выделяем память для второго подмассива
nums[2] = new int[5] { 1, 2, 3, 4, 5 }; // выделяем память для третьего подмассива
Здесь две группы квадратных скобок указывают, что это массив массивов, то есть такой
массив, который в свою очередь содержит в себе другие массивы. Причем длина массива
указывается только в первых квадратных скобках, все последующие квадратные скобки
должны быть пусты: new int[3][]. В данном случае у нас массив nums содержит три
массива. Причем размерность каждого из этих массивов может не совпадать.
Альтернативное определение массива массивов:
int[][] numbers = {
new int[] { 1, 2 },
new int[] { 1, 2, 3 },
new int[] { 1, 2, 3, 4, 5 } };

54.

Консольный вывод
если мы хотим вывести некоторую информацию на консоль,
то нам надо передать ее в метод Console.WriteLine:
string hello = "Привет мир";
Console.WriteLine(hello);
Console.WriteLine("Добро пожаловать в C#!");
Console.WriteLine("Пока мир...");
Console.WriteLine(24.5);

55.

Консольный вывод
Нередко возникает необходимость вывести на консоль в одной
строке значения сразу нескольких переменных. В этом случае мы
можем использовать прием, который называется интерполяцией:
string name = "Tom";
int age = 34;
double height = 1.7;
Console.WriteLine($"Имя: {name} Возраст: {age} Рост: {height}м");

56.

Консольный вывод
Для встраивания отдельных значений в выводимую на
консоль строку используются фигурные скобки, в которые
заключается встраиваемое значение. Это может быть
значение переменной ({name}) или более сложное
выражение (например, операция сложения {4 + 7}). А перед
всей строкой ставится знак доллара $.
При выводе на консоль вместо помещенных в фигурные
скобки выражений будут выводиться их значения:
Имя: Tom Возраст: 34 Рост: 1,7м

57.

Консольный вывод
Есть другой способ вывода на консоль сразу нескольких
значений:
string name = "Tom";
int age = 34;
double height = 1.7;
Console.WriteLine("Имя: {0} Возраст: {2} Рост: {1}м", name,
height, age);

58.

Консольный вывод
Здесь строка в Console.WriteLine содержит числа в фигурных скобках: {0},
{1}, {2}. Это плейсхолдеры, вместо которых при выводе строки на консоль
будут подставляться некоторые значения. Подставляемые значения
указываются после строки через запятую.
При этом важен порядок плейсхолдеров. Например, в данном случае
после строки первой указана переменная name, потом height и потом age.
Поэтому значение переменной name будет вставляться вместо первого
плейсхолдера - {0} (нумерация начинается с нуля), height - вместо {1}, а
age - вместо {2}.
"Имя: {0} Возраст: {2} Рост: {1}м"
будет заменена на
"Имя: Tom Возраст: 34 Рост: 1,7м"

59.

Console.Write()
можно использовать метод Console.Write(), он работает
точно так же, , но не добавляет переход на следующую
строку, то есть последующий консольный вывод будет
выводиться на той же строке.
string name = "Tom";
int age = 34;
double height = 1.7;
Console.Write($"Имя: {name} Возраст: {age} Рост: {height}м");

60.

Консольный ввод
Мы можем получать информацию с консоли. Метод
Console.ReadLine() позволяет получить введенную строку.
Console.Write("Введите свое имя: ");
string? name = Console.ReadLine();
Console.WriteLine($"Привет {name}");
В данном случае все, что вводит пользователь, с помощью
метода Console.ReadLine() передается в переменную name.

61.

Консольный ввод
Особенностью метода Console.ReadLine() является то, что он может
считать информацию с консоли только в виде строки.
возможна ситуация, когда для метода Console.ReadLine не окажется
доступных для считывания строк, то есть когда ему нечего
считывать, он возвращает значение null.
И чтобы отразить эту ситуацию мы определяем переменную name, в
которую получаем ввод с консоли, как переменную типа string?.
Здесь string указывает, что переменная может хранить значения типа
string, а знак вопроса ? указывает, что переменная также может
хранить значение null, то есть по сути не иметь никакого значения.

62.

как нам быть, если мы хотим ввести возраст в переменную
типа int или другую информацию в переменные типа double
или decimal? По умолчанию платформа .NET
предоставляет ряд методов, которые позволяют
преобразовать различные значения к типам int, double и т.д.
Convert.ToInt32() (преобразует к типу int)
Convert.ToDouble() (преобразует к типу double)
Convert.ToDecimal() (преобразует к типу decimal)

63.

Пример
Console.Write("Введите имя: ");
string? name = Console.ReadLine();
Console.Write("Введите возраст: ");
int age = Convert.ToInt32(Console.ReadLine());
Console.Write("Введите рост: ");
double height = Convert.ToDouble(Console.ReadLine());
Console.Write("Введите размер зарплаты: ");
decimal salary = Convert.ToDecimal(Console.ReadLine());
Console.WriteLine($"Имя: {name} Возраст: {age} Рост: {height}м Зарплата:
{salary}$");

64.

ПЕРЕЧИСЛЕНИЯ
enum WeekDays {Monday, Tuesday, Wednesday, Thusday,
Friday, Saturday, Sunday}
WeekDays day;
day=WeekDays.Thusday;

65.

class Program
{
enum WeekDays {Monday, Tuesday, Wednesday, Thusday, Friday, Saturday,
Sunday}
static void Main (string[] args)
{ string WeekDaysRussian[ ]= {„Понедельник“, «Вторник», «Среда», «Четверг»,
«Пятница», «Суббота», «Воскресенье»};
WeekDays day=WeekDays.Thusday;
Console. WriteLine( „Сегодня“ +day);
Console.Writeline( „ Сегодня“ +WeekDaysRussian[(int)day]);
int dayIndex=(int) day+1;
Console.Writeline( «номер дня»+dayIndex);
if(day= = WeekDays.Friday) Console.Writeline(„Скоро выходной“);
Console.Readline();
}}

66.

замечание
Значения перечислений могут быть написаны только на
английском языке и не могут содержать пробелы.

67.

Простейшая математика
int i=1;
int j=i++;
Чему равны переменные после выполнения?
int j=++i; //результат?
int i=1;
Console.Writeline(„i=“+i++);// результат?
i=i++; // результат?
int j= i++; //Результат?

68.

Простейшая математика
int d= 10*10.0;// В чем ошибка?
int i=10;
byte b=10*i;//В чем ошибка?
long i=1000000*1000000;// В чем ошибка?
long i=1000000*1000000L;
byte a = 4;
byte b = a + 70; // ошибка?
byte a = 4;
byte b = (byte)(a + 70);

69.

Потеря данных и ключевое слово checked
int a = 33;
int b = 600;
byte c = (byte)(a+b);
Console.WriteLine(c); // 121
// число 633 не попадает в допустимый диапазон для типа byte, и старшие
биты будут усекаться.
В итоге получится число 121. Поэтому мы можем либо взять такие числа a и
b, которые в сумме дадут число не больше 255, либо мы можем выбрать
вместо byte другой тип данных, например, int.
Однако мы можем точно не знать, какие значения будут иметь числа a и b. И
чтобы избежать подобных ситуаций, в c# имеется ключевое слово checked:

70.

try
{
int a = 33;
int b = 600;
byte c = checked((byte)(a + b));
Console.WriteLine(c);
}
catch (OverflowException ex)
{
Console.WriteLine(ex.Message);
}

71.

При использовании checked приложение выбрасывает
исключение о переполнении.
Поэтому для его обработки в данном случае используется
конструкция try...catch.

72.

В C# имеются следующие виды циклов:
for
foreach
while
do...while

73.

for (int i = 1; i < 4; i++)
int i = 6;
{
while (i > 0)
{
Console.WriteLine(i);
}
Console.WriteLine(i);
i--;
int i = 6;
do
{
Console.WriteLine(i);
i--;
}
while (i > 0);
}

74.

foreach
Цикл foreach предназначен для перебора набора или
коллекции элементов.
foreach(тип_данных переменная in коллекция)
{
// действия цикла
}

75.

foreach(char c in "Tom")
{
Console.WriteLine(c);
}
не всегда бывает очевидно, какой тип представляют элементы
коллекции.
foreach(var c in "Tom")
{
Console.WriteLine(c);
}

76.

Иногда возникает ситуация, когда требуется выйти из цикла, не
дожидаясь его завершения.
for (int i = 0; i < 9; i++)
{
if (i == 5)
break;
Console.WriteLine(i);
}

77.

если мы хотим, чтобы при проверке цикл не завершался, а
просто пропускал текущую итерацию.
for (int i = 0; i < 9; i++)
{
if (i == 5)
continue;
Console.WriteLine(i);
}

78.

Методы
Если переменные хранят некоторые значения, то методы содержат собой набор инструкций,
которые выполняют определенные действия. По сути метод - это именованный блок кода,
который выполняет некоторые действия.
Общее определение методов :
[модификаторы] тип_возвращаемого_значения название_метода ([параметры])
{
// тело метода
}
Модификаторы и параметры необязательны. Ранее мы уже использовали как минимум один
метод - Console.WriteLine(), который выводит информацию на консоль.
Определим один метод:
void SayHello()
{
Console.WriteLine("Hello");
}

79.

При этом в данном случае нет разницы, сначала определяется
метод, а потом вызывается или наоборот.
SayHello(); // Hello
SayHello(); // Hello
void SayHello()
{
Console.WriteLine("Hello");
}

80.

Сокращенная запись методов
Если метод в качестве тела определяет только одну инструкцию, то мы можем
сократить определение метода.
void SayHello()
{
Console.WriteLine("Hello");
}
Мы можем его сократить следующим образом:
void SayHello() => Console.WriteLine("Hello");
То есть после списка параметров ставится оператор =>, после которого идет
выполняемая инструкция.

81.

ПАРАМЕТРЫ
void Sum(int x, int y)
{
int result = x + y;
Console.WriteLine($"{x} + {y} = {result}");
}
Sum(10, 15);
// 10 + 15 = 25

82.

Необязательные параметры
По умолчанию при вызове метода необходимо предоставить значения для
всех его параметров. Но C# также позволяет использовать
необязательные параметры. Для таких параметров нам необходимо
объявить значение по умолчанию. Также следует учитывать, что после
необязательных параметров все последующие параметры также должны
быть необязательными:
void PrintPerson(string name, int age = 1, string company = "Undefined")
{
Console.WriteLine($"Name: {name} Age: {age} Company: {company}");
}

83.

Возвращение значений и выход из метода
string GetMessage()
{
return "Hello";
}
void PrintMessage(string message)
{
Console.WriteLine(message);
}
PrintMessage(GetMessage());

84.

Также мы можем сокращать методы, которые возвращают
значение:
string GetMessage()
{
return "hello";
}
аналогичен следующему методу:
string GetMessage() => "hello";

85.

Мы можем использовать оператор return и в методах с типом void. В этом случае после
оператора return не ставится никакого возвращаемого значения . Типичная ситуация - в
зависимости от определенных условий произвести выход из метода:
void PrintPerson(string name, int age)
{
if(age > 120 || age < 1)
{
Console.WriteLine("Недопустимый возраст");
return;
}
Console.WriteLine($"Имя: {name} Возраст: {age}");
}
PrintPerson("Tom", 37);
PrintPerson("Dunkan", 1234);
// Имя: Tom Возраст: 37
// Недопустимый возраст

86.

Передача параметров по ссылке и
модификатор ref
При передаче параметров по ссылке перед параметрами используется
модификатор ref:
void Increment(ref int n)
{
n++;
Console.WriteLine($"Число в методе Increment: {n}");
}
int number = 5;
Console.WriteLine($"Число до метода Increment: {number}");
Increment(ref number);
Console.WriteLine($"Число после метода Increment: {number}");

87.

РЕЗУЛЬТАТ
Число до метода Increment: 5
Число в методе Increment: 6
Число после метода Increment: 6
При передаче значений параметрам по ссылке метод получает адрес
переменной в памяти. И, таким образом, если в методе изменяется значение
параметра, передаваемого по ссылке, то также изменяется и значение
переменной, которая передается на его место..
Так, в метод Increment передается ссылка на саму переменную number в памяти.
И если значение параметра n в Increment изменяется, то это приводит и к
изменению переменной number, так как и параметр n и переменная number
указывают на один и тот же адрес в памяти.
!!! модификатор ref указывается как перед параметром при объявлении метода,
так и при вызове метода перед аргументом, который передается параметру.

88.

Выходные параметры. Модификатор out
Чтобы сделать параметр выходным, перед ним ставится модификатор out:
void Sum(int x, int y, out int result)
{
result = x + y;
}
Здесь результат возвращается через выходной параметр result.
void Sum(int x, int y, out int result)
{
result = x + y;
}
int number;
Sum(10, 15, out number);
Console.WriteLine(number); // 25

89.

Причем, как и в случае с ref ключевое слово out используется как при определении метода, так и
при его вызове.
Методы, использующие такие параметры, обязательно должны присваивать им определенное
значение. То есть следующий код будет недопустим, так как в нем для out-параметра не указано
никакого значения:
void Sum(int x, int y, out int result)
{
Мы можем вернуть из метода не одно значение, а несколько.
void GetRectangleData(int width, int height, out int rectArea, out int rectPerimetr)
{
Console.WriteLine(x + y); }
rectArea = width * height;
// площадь прямоугольника - произведение ширины на высоту
rectPerimetr = (width + height) * 2; // периметр прямоугольника - сумма длин всех сторон
}
int area; int perimetr;
GetRectangleData(10, 20, out area, out perimetr);
Console.WriteLine($"Площадь прямоугольника: {area}");
Console.WriteLine($"Периметр прямоугольника: {perimetr}"); // 60
// 200

90.

Массив параметров
Во всех предыдущих примерах мы использовали постоянное число параметров. Но, используя
ключевое слово params, мы можем передавать неопределенное количество параметров:
void Sum(params int[] numbers)
{
int result = 0;
foreach (var n in numbers)
{
result += n;
}
Console.WriteLine(result);
}
int[] nums = { 1, 2, 3, 4, 5}; Sum(nums); Sum(1, 2, 3, 4); Sum(1, 2, 3); Sum();
Сам параметр с ключевым словом params при определении метода должен представлять
одномерный массив того типа, данные которого мы собираемся использовать. При вызове
метода на место параметра с модификатором params мы можем передать как отдельные
значения, так и массив значений, либо вообще не передавать параметры.

91.

После параметра с модификатором params мы НЕ можем
указывать другие параметры. То есть следующее
определение метода недопустимо:
//Так НЕ работает
void Sum(params int[] numbers, int initialValue)
{
}

92.

Объекты на C#
C# – полностью объектный язык, в нем все построено на понятиях класс
и объект. Программу на C# можно представить в виде взаимосвязанных
взаимодействующих между собой объектов.
Описанием объекта является класс, а объект представляет экземпляр
этого класса.
Пусть наш объект – это сарай.
Он обладает свойствами: высотой, шириной, глубиной
Сараев в городе много, все они обладают одними и теми же свойствами.
Чтобы обращаться ко всем сараям сразу, можно ввести для них класс.

93.

Класс САРАЙ
{
class Shed
{
Число высота;
int height;
Число ширина;
int width;
Число глубина;
int depth;
}
Shed myShed;
myShed= new Shed();
}

94.

У объекта могут быть методы, т. е. присущие ему действия.
Пусть на сарае есть кнопка, по нажатию на которую мы
узнаем размеры сарая
Метод – ПолучитьОбъем()

95.

Класс САРАЙ
{
class Shed
{
Число высота;
int height;
Число ширина;
int width;
Число глубина;
int depth;
Число ПолучитьОбъем();
int getVolume();
}
Shed myShed;
myShed= new Shed();
}

96.

Модификаторы доступа
public – свойство или метод доступен всем
protected – член объекта доступен самому объекту или его
потомкам
private – член объекта не доступен за пределами объекта
даже для потомков
internal – член объекта доступен в пределах текущей сборки
protected internal – доступен всем из данной сборки, также
типам, производным от данного

97.

Свойства
Объект может обладать свойствами. Свойства отличаются
от переменных и являются отдельной структурой данных
class Shed
{
public int Width
{
int height;
get { return width; }
int width;
set { width=value;}
}

98.

Внутри свойства нужно реализовать аксессоры – get, set
Аксессоры позволяют указать доступ к свойству на чтение
и запись
Значение свойства находится в виртуальной переменной
value
Свойство – обертка для переменной объекта

99.

public int Width
{
get { return width; }
set
{
if (value>0 && value <100)
width=value;
}
}

100.

Зачем нужны свойства?
public int Width
{
get { return width; }
}
Мы можем только прочитать переменную width через
свойство Width

101.

Если переменных много
Рефакторинг – Refactor | Encapsulated Field
Сокращенное объявление свойства
public int Lengthwise( get; set);
Свойство Lengthwise будет являться одновременно
свойством для внешних источников и переменной для
внутреннего использования

102.

Доступ к свойству
Имя_объекта. Свойство
Shed myFirstShed= new Shed();
myFirstShed. Height=10;
int h=myFirstShed. Height;

103.

using System;
using System.Text;
namespace PropertiesExample
{
class Program
{
static void Main(string[] args)
{
Shed myFirstShed=new Shed();
MyFirstShed. Height=10;
MyFirstShed. Width= 20;
MyFirstShed. Lengthwise=myFirstShed.Width;

104.

Console.WriteLine( „Высота : “+ myFirstShed.Height);
Console. WriteLine („ Ширина :“ + myFisrtShed.Width);
ConsoleWriteLine („ Глубина :“ +myFirstShed.Lenthwise);
Console.ReadLine();
}
}
class Shed
{ int width;
int height;

105.

public int Width
{
get {return width;}
set {width=value;}
}
public int Height
{
get {return height;}
set {height=value;}
}
public int Lengthwise {get; set;}
}
}

106.

Модификаторы доступа для аксессоров
public (по умолчанию)
private
public int Width
{
get {return width;}
private set {width=value;}
}
Если аксессор закрытый, к нему нет доступа извне!

107.

Замечания
Программа начинает выполнение с метода Main().
Main() может находиться в любом месте программы.
В С# реализация и описание методов происходит
одновременно.
В С++ объявление методов идет в отдельном файле *.h, а
реализация находится в файле *.cpp

108.

Примеры методов
class Shed
{….
public int GetSize()
{
int size= width*height*Lengthwise;
return size;
// return Width*Height*Lengthwise;
}

109.

Примеры методов
class Shed
{….
public void ExpandSize( int x, int y, int h)
{
Width+=x;
Height+=y;
Lengthwise+=h;
}
}

110.

Примеры методов
class Shed
{….
public void ExpandAndGetSize( int x, int y, int h)
{
ExpandSize(x,y,h);
x=Width;
y=Height;
h=Lengthwise;
}
}

111.

Примеры методов
class Shed
{….
public void ExpandAndGetSize(ref int x, ref int y,ref int h)
{
ExpandSize(x,y,h);
x=Width;
y=Height;
h=Lengthwise;
}
}

112.

Примеры методов
class Shed
{….
public void ExpandAndGetSize(out int x, out int y, out int h)
{
ExpandSize(x,y,h);
x=Width;
y=Height;
h=Lengthwise;
}
}

113.

замечание
Если параметр объявлен как out, то его значение
обязательно должно измениться внутри программы!
Если параметр объявлен как ref , то его значение не
обязательно должно меняться внутри программы.

114.

static void Main (string[] args)
{
int sum;
Sum( 1, 2, out sum);
}
static int Sum( int x, int y, out unt result)
{
return x+y;
}

115.

static int Sum2( params int[] values)
{
int result=0;
foreach ( int value in values)
result+=value;
return result;
}
Sum2(1,2,3);
Sum2(1,2,3,4,5);

116.

Где ошибка?
int Sum2( params int[] values, string str);
int Sum2( params string[] str, params int[] values);
int Sum2( string str, params int[] values);

117.

Конструктор
public Shed( int w, int l, int height)
{
width=w;
Lengthwise=l;
this. height=height; // Shed.height
}
Shed sh=new Shed(1,2,3);

118.

Замечание
Если в классе нет конструктора, то будет вызван
конструктор по умолчанию.
Если в классе есть конструктор с параметрами, но нет
конструктора по умолчанию, то строка вызовет ошибку
Shed sh=new Shed();
public Shed(): this(1,1,1)
{
//
}

119.

Замечание
public Shed ()
{
LoadTexture();
}
public Shed( int w, int l,int height): this()
{
//
}
// InitVariables()

120.

Замечание
static
К статичным методам можно обращаться без создания
класса!
Статичный метод может использовать только переменные,
объявленные внутри этого метода или внешние статичные
переменные.
Статичные переменные создаются системой автоматически
и прикрепляются к классу.

121.

static int ObjectNumber=0;
public int GetObjectNumber()
{
// Main
Shed shed=new Shed();
return ObjectNumber;
}
public Shed()
{
ObjectNumber++;
}
Статичное поле разделяется
между объектами класса!
Console.WriteLine( shed.
GetObjectNumber());
Shed shed1=new Shed();
Console. WriteLine( shed1.
GetObject Number());

122.

Инициализация статичных переменных
static Shed()
{
ObjectNumber++;
}

123.

Статичный конструктор
Выполняется один раз независимо от количества
созданных объектов класса
Не может иметь параметров, его нельзя перегружать
Нельзя создать больше одного статичного конструктора
Не имеет модификаторов доступа
Вызывается автоматически при создании первого объекта
класса

124.

Статичные классы
static class MyStaticParams
{
public static void SomeMethod()
{
}
}
MyStaticParams. Somemethod();

125.

Рекурсивные методы
class Program
{
static int[] array={ 10,98,78, 4,54,25,84,41,30,87,6};
static void Main( string[] args)
{
sort(0, array.Length-1);
foreach (int i in array)
Console.WriteLine( i);
Console.ReadLine();
}

126.

Рекурсивные методы
static void sort ( int l, int r)
{
int y=array[i];
int i=l;
array[i]=array[j];
int j=r;
array[j]=y;
i++;
j++;
{
int x= array[(l+r)/2];
do
{
}
} while (i<j);
if (l<j)
while (array[i]<x)i++;
while (array[j]>x)j++;
if (i<=j)
sort (i,r);
} }

127.

деструктор
Сборщик мусора
GS. Collect();
Close(), Dispose()
IDisposable

128.

static int Sum2( params int[] values)
{
int result=0;
foreach ( int value in values)
result+=value;
return result;
}
Sum2(1,2,3);
Sum2(1,2,3,4,5);

129.

Main()
static void Main()
static void Main( string[] args)
{
{
}
}
static int Main()
static public int Main(string[] args)
{
{
return целое_число;
}
return целое_число;
}

130.

Main()
private static void Main( string[] args)
{
foreach (string s in args)
Console. WriteLine(s);
Console.ReadLine();
}

131.

Environment
GetCommandLineArgs()
private static void Main( )
{
String[] args=Environment .GetCommandLineArgs();
foreach (string s in args)
Console. WriteLine(s);
Console.ReadLine();
}
// string fullpath= Environment. GetCommandLineArgs()[0];

132.

Пространства имен
using System
Console.WriteLine(„Hello, world!“);
using System.Console
WriteLine(„Hello, world!“);
using output= System.Console;
class EasySharp
{
public Static void Main()
{
output. WriteLine(„Hello, world!“);
}
}

133.

Пространства имен
Кнопка для web-формы
System. Web. UI. Controls
Кнопка для оконного приложения
System. Windows. Forms
using winbutton= System. Windows. Forms. Button

134.

Начальные значения переменных
Числовые =0
Char= \0
Bool =false
Объекты =null
Строки =null

135.

Объекты только для чтения
const Shed sh=new Shed();
static readonly Shed sh=new Shed();
static void Main(string[] args)
{
sh=new Shed();
}

136.

Наследование
Объект Дом происходит от
Сарая
{
Количество окон
}
Объект Дом происходит от Сарая
{
Количество окон
Число ПолучитьОбъем()
{
// посчитать объем дома
}
}

137.

Наследование
Сарай
Дом
Будка
Дом
Многоэтажный дом
Дом
Подземная парковка
Многоэтажный дом

138.

Инкапсуляция
Инкапсуляция – это возможность спрятать от конечного
пользователя внутреннее устройство объекта и
предоставить доступ только к тем методам, которые
необходимы.
Пользователи: наследник и программист, сам объект
Console.WriteLine(„ Hello,world!“);
Модификаторы доступа: public, protected, private

139.

Инкапсуляция
class EasySharp
class Shed
{
{
public static void Main( )
Shed shed= new Shed();
Shed.OutString();
}
{
{
private void OutString
Console.WriteLine(„Hello, world!“);
}
}

140.

Замечание
Методы private доступны только текущему классу
Методы protected доступны текущему классу и его
наследникам

141.

Полиморфизм
Позволяет использовать предку свойства и методы классапотомка
Object shed=new Shed();
(Shed) shed. GetSize();

142.

Наследование от класса Object
Все классы имеют в предках класс Object
class Person
{
}
class Person: System.Object
{
}

143.

Наследование от класса Object
Equals()
GetHashCode()
GetType()
ToString()
Finalize()
MemberwiseClone()

144.

Наследование от класса Object
class Person
{
public Person( string firstName, string lastName)
{
FirstName=firstName;
LastName=lastName;
Person p=new Person(„Ivan“,
„Ivanov“);
}
public string FirstName { get; set;}
public string LastName {get; set;}
}
Console.WriteLine(p.ToString()
);
„PersonClass.Person “

145.

Переопределение методов
Метод должен быть объявлен в базовом классе как virtual
public virtual string ToString();
public override string ToString() //new
{
return FirstName+ „“+ Lastname;
}
Person p=new Person („Ivan“, „Ivanov“);
Console.WriteLine(p. ToString());
Object o=p;
Console.WriteLine(o.ToString());

146.

Person p1=new Person( „Ivan“, „Ivanov“);
Person p2=new Person („Ivan“, „Ivanov“);
Person p3=p1;
Console.WriteLine( p1.Equals(p2));
Console. WriteLine (p1. Equals(p3));

147.

public new bool Equals( Object obj)
{
Person person=(Person) obj;
return (FirstName= = person. FirstName)&& (LastName= =
person. LastName);
}

148.

static string ComparePersons( Person person1, Person person2)
{
bool equalParams=person1. Equals(person2);
Object personobj=person1;
bool fullEqual=personobj.Equals(person2);
if (fullEqual)return „Absolute equal“;
if (equalParams) return „equal property“;
return „different objects“;
}

149.

Обращение к предку из класса
Как внутри класса обращаться к предку?
base
class Person
{
public string ComparePersons( Person person)
{
bool equalParams= Equals(person);
bool fullEqual=base.Equals(person);
if (fullEqual)return „Absolute equal“;
if (equalParams) return „equal property“;
return „different objects“;
}

150.

Вложенные классы
public class Shed
{
// свойства и методы класса Shed
public class Window
{
// свойства и методы класса Window
public void ShutWindow()
{
// код метода
}
}
Window window= new Window();
public Window FrontWindow
{
get {return window;}
set { window=value;}
}
}

151.

Shed sh= new Shed();
sh.Window.ShutWindow();
Класс, объявленный внутри другого класса, называется
вложенным

152.

public class Window
{
// свойства и методы класса Window
public void ShutWindow()
{
// код метода
}
}
public class Shed
{
// свойства и методы класса Shed
Window window= new Window();
public Window FrontWindow
{
get {return window;}
set { window=value;}
}
}

153.

Если вложенный класс объявлен как private, то его
экземпляр может создать только объект точно такого же
класса или объект родительского класса.
При этом объект не будет виден наследникам
Объекты класса protected могут создаваться как
родительским объектом так и наследниками от
родительского.

154.

Область видимости
Если объявление переменной находится вне метода, но
внутри класса, то она доступна любому методу класса
независимо от модификаторов доступа
Если переменная объявлена внутри метода, то она
доступна до конца метода
Чтобы запретить наследование, перед объявлением класса
ставим sealed

155.

sealed class Person
{
// члены класса
}
public class MyPerson: Person
{
}

156.

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

157.

Ссылочные и простые типы данных
Для простых переменных, размеры которых фиксированы,
выделяется память в стеке. В ячейке памяти стека
хранится само значение
Ссылочные типы создаются оператором new, система
выделяет память в куче для хранения объекта и в стеке
для хранения ссылки на область памяти в куче.

158.

Абстрактные классы
Классы, экземпляры которых нельзя создавать
abstract class Figure
{
public inf left {get; set;}
public int top {get; set;}
public void Draw()
{
}
}
Figure f1=new Figure();

159.

Абстрактные классы
class RectangleFigure : Figure
{
public inf Width {get; set;}
public int Height {get; set;}
{
public inf Radius {get; set;}
public override void Draw()
public override void Draw()
{
Console. WriteLine(„Rectangle class»);
}
class CircleFigure : Figure
}
{
Console. WriteLine(„Circle class»);
}
}

160.

Абстрактные классы
Figure rect;
rect= new RectangleFigure();
rect.Draw();
rect= new CircleFigure();
rect.Draw();
// Если бы класс Figure не содержал метод Draw()
((RectangleFigure)rect).Draw();
// abstract public void Draw();

161.

Проверка класса объекта
Как узнать, является ли объект экземпляром
определенного класса?
is
Figure shape= new CircleFigure();
if (shape is CircleFigure )
// выполнить действие

162.

Проверка класса объекта
as
Figure shape= new CircleFigure();
CircleFigure circle= ( CircleFigure) shape;
CircleFigure circle= shape as CircleFigure;

163.

Проверка класса объекта
Тип данных в переменной var не будет конвертирован в
зависимости от контекста:
var numberVariable=10;
var stringVariable= „string“;
var numberVariable=“не работает“
// var Person=GetFirstPerson();
// var i= Calculate();

164.

Инициализация свойств
Person person=new Person();
Person person=new Person()
person. FirstName=“Ivan’;
{
person. LastName=“Ivanov“;
FirstName=“Ivan’;
person. country=“Russia“;
LastName=“Ivanov“;
country=“Russia“;
}

165.

Интерфейсы
Нужно наделить два разных класса одним и тем же методом.
Интерфейс – это объявление, схожее с классом, но в нем нет
реализации методов.
Интерфейсы не наследуют никакого класса, даже Object
Все методы интерфейса считаются открытыми
Интерфейсы создаются для того, чтобы описать методы, которые
будут общедоступны для любых классов.
Интерфейсы не могут иметь переменные, но могут иметь свойства.

166.

interface Ipurse
{
int Sum
{ get; set;
}
void AddMoney( int sum);
int DecMoney( int sum);
}

167.

namespace InterfaceProject
{
interface Ipurse
{
}
class SomeClass
{
}
}

168.

Реализация интерфейсов
Класс наследует интерфейс
Класс может наследовать несколько интерфейсов
class Person : IPurse
class Person: Object, IPurse
{
{
// реализация класса
}
//
}
Если класс наследует и класс, и интерфейс – имя класса должно
быть написано первым

169.

Реализация интерфейсов
Вы должны написать внутри своего класса реализацию
всех свойств и методов интерфейса!
Все они должны быть открытыми!

170.

сlass Person : IPurse
public void AddMoney( int sum)
{
{
// методы класса Person
Sum+=sum;
// реализация интерфейса
}
int sum=0;
public int DecMoney( int sum)
public int Sum
{
{
Sum-= sum;
get { return sum;}
return Sum;
set { sum= value;}
}
}

171.

Использование реализации интерфейсов
Person person= new Person(„Ivan“, „Ivanov“);
person. AddMoney(100000);

172.

public partial class Form1: Form
{
// переменные класса
Person person= new Person(„Ivan“, „Ivanov“);
Object personObject;
IPurse purse;
public Form1()
{
InitializeComponent();
// инициализация переменных

173.

// инициализация переменных
PersonObject= person;
purse=person;
}
// добавление денег в кошелек
private void addButton_Click ( object sender, EventArgs e)
{
if (personObject is IPurse)
{
((IPurse)personObject).AddMoney((int)numericUpDown1.Value;
sumLabel. Text=((IPurse)personObject).Sum. ToString();
}
}

174.

// уменьшение денег в кошелке
private void decButton_Click ( object sender, EventArgs e)
{
purse.DecMoney((int)numericUpDown1.Value);
sumLabel.Text=purse. Sum.ToString();
}
}

175.

Интерфейсы в качестве параметров
void DecMoney( Ipurse purse)
{
purse. DecMoney((int) numericUpDown1.Value;
sumLabel.text= purse.Sum. ToString();
}

176.

Перегрузка интерфейсов
public void AddMoney( int sum)
V76
{
oid IPurse. AddMoney( int sum)
{
Sum+=sum;
}
Person.person=new
Person(„Ivan“, „Ivanov“);
Sum+=sum;
person. AddMoney(10);
}
((IPurse) person).AddMoney
((int)numericUDown1.Value);

177.

class Person : IPurse, ITripplePurse
{
// методы класса Person
// реализация Ipurse
void IPurse. AddMoney( int sum)
{
// ITripplePurse
void ITripplePurse. AddMoney( int sum)
{
}
int ITripplePurse. DecMoney( int sum)
Sum+=sum;
}
int IPurse. DecMoney(int sum)
{
Sum-=sum*3;
return Sum;
Sum-=sum;
return Sum;
}
{
Sum+=sum*3;
}
}