Основы объектно ориентированного программирования на языке С# для продолжающих
Покупка
Основная коллекция
Тематика:
Программирование на C и C++
Издательство:
Новосибирский государственный технический университет
Год издания: 2025
Кол-во страниц: 100
Дополнительно
Вид издания:
Учебное пособие
Уровень образования:
ВО - Бакалавриат
ISBN: 978-5-7782-5407-7
Артикул: 875021.01.99
Настоящее учебное пособие является продолжением учебного пособия «Основы объектно ориентированного программирования на языке С#. Базовые сведения о языке» и рассчитано на читателей, уже ознакомившихся с ним. В этой книге кратко изложены более сложные понятия языка, отличия стандартов, основные идеи и принципы ООП. Учебное пособие будет полезно студентам, обучающимся на факультете прикладной математики и информатики по дисциплинам «Основы объектно ориентированного программирования», «Современные технологии программирования».
Тематика:
ББК:
УДК:
ОКСО:
- ВО - Бакалавриат
- 09.03.01: Информатика и вычислительная техника
- 09.03.02: Информационные системы и технологии
ГРНТИ:
Скопировать запись
Фрагмент текстового слоя документа размещен для индексирующих роботов
Министерство науки и высшего образования Российской Федерации Федеральное государственное бюджетное образовательное учреждение высшего образования НОВОСИБИРСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ М. Э. Рояк, И. М. Ступаков ОСНОВЫ ОБЪЕКТНО ОРИЕНТИРОВАННОГО ПРОГРАММИРОВАНИЯ НА ЯЗЫКЕ C# ДЛЯ ПРОДОЛЖАЮЩИХ Утверждено Редакционно-издательским советом университета в качестве учебного пособия НОВОСИБИРСК 2025
УДК 004.434 (075.8)
Р816
Рецензенты:
канд. техн. наук А. Н. Игнатьев,
канд. техн. наук, доцент Ю. В. Тракимус
Работа подготовлена на кафедре прикладной математики
Рояк М. Э.
P816
Основы объектно ориентированного программирования на
языке С# для продолжающих: учебное пособие / М. Э. Рояк,
И. М. Ступаков. – Новосибирск: Изд-во НГТУ, 2025. – 100 с.
ISBN 978-5-7782-5407-7
Настоящее учебное пособие является продолжением учебного пособия «Основы
объектно ориентированного программирования на языке С#. Базовые сведения о языке» и рассчитано на читателей, уже ознакомившихся с ним. В этой книге кратко изложены более сложные понятия языка, отличия стандартов, основные идеи и
принципы ООП. Учебное пособие будет полезно студентам, обучающимся на факультете прикладной математики и информатики по дисциплинам «Основы объектно ориентированного программирования», «Современные технологии программирования».
УДК
004.434 (075.8)
ISBN 978-5-7782-5407-7
© Рояк М. Э., Ступаков И. М., 2025
© Новосибирский государственный
технический университет, 2025
ОГЛАВЛЕНИЕ 1. Основные принципы ООП .............................................................................................. 7 1.1. Инкапсуляция ....................................................................................................... 7 1.2. Наследование и полиморфизм ........................................................................... 7 1.3. Абстракция ........................................................................................................... 8 1.4. Пример, поясняющий принципы ООП .............................................................. 8 1.5. Принципы SOLID .............................................................................................. 10 2. Коллекции ....................................................................................................................... 12 2.1. Интерфейсы коллекций ..................................................................................... 12 2.1.1. Интерфейс ICollection<T> ........................................................................... 12 2.1.2. Интерфейс IReadOnlyCollection<out T> ..................................................... 13 2.1.3. Интерфейс IList<T> ...................................................................................... 13 2.1.4. Интерфейс IReadOnlyList<out T> ............................................................... 13 2.1.5. Интерфейс ISet<T> ....................................................................................... 14 2.1.6. Интерфейс IReadOnlySet<T> ....................................................................... 14 2.1.7. Интерфейс IDictionary<TKey, TValue> ...................................................... 15 2.1.8. Интерфейс IReadOnlyDictionary<TKey, TValue> ...................................... 15 2.2. Коллекция List<T> ............................................................................................ 16 2.3. Коллекции Stack<T> и Queue<T> ................................................................... 19 2.4. Коллекция LinkedList<T> ................................................................................. 20 2.5. Коллекция SortedSet<T> ................................................................................... 21 2.6. Коллекция HashSet<T> ..................................................................................... 22 2.7. Коллекция Dictionary<TKey, TValue> ............................................................. 23 2.8. Коллекция SortedDictionary<TKey, TValue> ................................................... 24 2.9. Потокобезопасные коллекции .......................................................................... 24 2.9.1. Коллекция ConcurrentBag<T> .................................................................... 25 2.9.2. Коллекция ConcurrentQueue<T> ................................................................ 25 2.9.3. Коллекция ConcurrentStack<T> .................................................................. 26 2.9.4. Коллекция ConcurrentDictionary <TKey, TValue> ..................................... 26 2.10. Неизменяемые коллекции ............................................................................... 27 3. LINQ ................................................................................................................................ 29 3.1. Синтаксис языка запросов ................................................................................ 30 3.1.1. Оператор from ............................................................................................... 30 3.1.2. Оператор where ............................................................................................. 31 3.1.3. Оператор select .............................................................................................. 31 3.1.4. Оператор group ............................................................................................. 31 3.1.5. Ключевое слово into ..................................................................................... 32
3.1.6. Оператор orderby .......................................................................................... 32 3.1.7. Оператор join ................................................................................................. 33 3.1.8. Оператор let ................................................................................................... 34 3.2. Основные методы расширения ........................................................................ 34 3.2.1. Метод Aggregate ............................................................................................ 36 3.2.2. Метод All ........................................................................................................ 37 3.2.3. Метод Any ...................................................................................................... 37 3.2.4. Метод Append ................................................................................................ 37 3.2.5. Метод Cast ..................................................................................................... 37 3.2.6. Метод Chunk .................................................................................................. 37 3.2.7. Метод Concat ................................................................................................. 38 3.2.8. Метод Contains .............................................................................................. 38 3.2.9. Методы Count и LongCount .......................................................................... 38 3.2.10. Метод DefaultIfEmpty .................................................................................. 38 3.2.11. Методы Distinct и DistinctBy ...................................................................... 38 3.2.12. Методы ElementAt и ElementAtOrDefault .................................................. 39 3.2.13. Методы Except и ExceptBy ......................................................................... 39 3.2.14. Методы First и FirstOrDefault ................................................................... 39 3.2.15. Методы Intersect и IntersectBy ................................................................... 40 3.2.16. Методы Last и LastOrDefault ..................................................................... 40 3.2.17. Метод OfType<TResult> .............................................................................. 40 3.2.18. Метод Prepend ............................................................................................. 40 3.2.19. Метод Reverse .............................................................................................. 40 3.2.20. Метод Select ................................................................................................. 40 3.2.21. Метод SelectMany ........................................................................................ 41 3.2.22. Методы Single и SingleOrDefault ............................................................... 41 3.2.23. Методы Skip, SkipLast, SkipWhile ............................................................... 41 3.2.24. Методы Take, TakeLast, TakeWhile ............................................................ 41 3.2.25. Методы Union и UnionBy ........................................................................... 42 3.2.26. Метод Where ................................................................................................ 42 3.2.27. Метод Zip ..................................................................................................... 42 3.3. Дополнительные статические методы и методы расширения в Enumerable43 3.3.1. Метод AsEnumerable ..................................................................................... 43 3.3.2. Метод SequenceEqual .................................................................................... 43 3.3.3. Метод TryGetNonEnumeratedCount ............................................................. 43 3.3.4. Методы ToArray и ToList .............................................................................. 43 3.3.5. Метод ToDictionary ....................................................................................... 44 3.3.6. Метод ToHashSet ........................................................................................... 44 3.3.7. Метод Range .................................................................................................. 44
3.3.8. Метод Repeat ................................................................................................. 44 4. Атрибуты и рефлексия .................................................................................................. 45 4.1. Применение атрибутов ...................................................................................... 45 4.2. Некоторые полезные атрибуты, интерпретируемые компилятором C# ...... 46 4.2.1. Сведения о вызывающем объекте ............................................................... 46 4.2.2. Атрибуты для анализа состояния со значением null ................................. 47 4.2.3. Атрибут Conditional ...................................................................................... 48 4.2.4. Атрибут Obsolete ........................................................................................... 49 4.2.5. Атрибут Experimental ................................................................................... 49 4.2.6. Атрибут SetsRequiredMembers ..................................................................... 49 4.3. Определение и использование собственных атрибутов ................................ 50 4.4. Некоторые возможности рефлексии ................................................................ 52 5. Работа с файлами и потоками ....................................................................................... 54 5.1. Базовый класс потоков Stream .......................................................................... 54 5.2. Создание потоков (открытие файлов) ............................................................. 55 5.2.1. Поток FileStream ........................................................................................... 55 5.2.2. Поток BufferedStream .................................................................................... 57 5.2.3. Поток MemoryStream .................................................................................... 57 5.3. Работа с потоками .............................................................................................. 57 5.3.1. BinaryReader и BinaryWriter ........................................................................ 57 5.3.2. StreamReader и StreamWriter ........................................................................ 58 5.3.3. Упрощенные методы работы с файлами .................................................... 58 6. Небезопасный код .......................................................................................................... 59 6.1. Указатели ............................................................................................................ 59 6.2. Оператор fixed .................................................................................................... 60 6.3. Оператор stackalloc ............................................................................................ 61 6.4. Подключение и вызов неуправляемых DLL ................................................... 62 7. Параллельное и асинхронное программирование ...................................................... 64 7.1. Использование PLINQ и класса Parallel из TPL ............................................ 65 7.2. Работа с задачами из TPL ................................................................................. 69 7.3. Основные методы и свойства класса Task ...................................................... 75 8. История развития языка ................................................................................................ 77 8.1. Версия 1.0 ........................................................................................................... 77 8.2. Версия 1.2 ........................................................................................................... 77 8.3. Версия 2.0 ........................................................................................................... 78 8.4. Версия 3.0 ........................................................................................................... 78
8.5. Версия 4.0 ........................................................................................................... 79 8.5.1. Тип dynamic ................................................................................................... 79 8.5.2. Класс ExpandoObject .................................................................................... 79 8.6. Версия 5.0 ........................................................................................................... 80 8.7. Версия 6.0 ........................................................................................................... 80 8.8. Версии 7.0-7.3 .................................................................................................... 81 8.9. Версия 8.0 ........................................................................................................... 82 8.10. Версия 9.0 ......................................................................................................... 82 8.11. Версия 10 .......................................................................................................... 83 8.12. Версия 11 .......................................................................................................... 84 8.13. Версия 12 .......................................................................................................... 85 8.14. Версия 13 .......................................................................................................... 85 9. Некоторые полезные возможности .............................................................................. 86 9.1. Сериализация в формат JSON .......................................................................... 86 9.2. Интерфейс командной строки dotnet ............................................................... 92 9.2.1. Команда new .................................................................................................. 92 9.2.2. Команда sln .................................................................................................... 93 9.2.3. Команда build ................................................................................................ 93 9.2.4. Команда run ................................................................................................... 94 9.2.5. Команда format .............................................................................................. 94 9.3. Unit-тестирование .............................................................................................. 94 9.4. BenchmarkDotNet ............................................................................................... 96 Список рекомендуемой литературы ................................................................................ 99
1. ОСНОВНЫЕ ПРИНЦИПЫ ООП Классически в объектно ориентированном программировании выделяют три основных принципа: инкапсуляция, наследование, полиморфизм. Иногда к ним добавляют четвертый – абстракцию. 1.1. Инкапсуляция Инкапсуляцией называют сокрытие внутренних данных компонента (класса) и деталей его реализации от использования в других компонентах приложения и предоставление интерфейса (набора методов, свойств, событий и т.д.) для взаимодействия с ним. В C# для поддержки этого принципа используются, например, модификаторы доступа (public, private и т. д.). Преимущества инкапсуляции: возможность поддержания корректности внутреннего состояния экземпляра при работе с ним; упрощение понимания работы с компонентом, поскольку для его использования требуется разобраться только в его интерфейсе; возможность независимой разработки и отладки компонентов несколькими программистами, поскольку им требуется согласовать и отладить взаимодействие только их интерфейсов. Заметим, что инкапсуляция не подразумевает, что сокрытые члены класса никак нельзя увидеть и использовать. Это всего лишь некоторое условное соглашение между программистами, в большинстве объектных языков поддерживаемое компилятором. При этом получить адрес приватного поля или метода и использовать его обходными путями всё же технически возможно (хотя в некоторых языках и достаточно непросто). 1.2. Наследование и полиморфизм Наследованием называют возможность создавать новые типы на основе существующих, добавляя к ним новые свойства. Понятие тесно связано с полиморфизмом – возможностью переопределять наследуемые свойства разными способами. В большинстве языков программирования под полиморфизмом понимают также то, что тип-наследник может быть использован вместо родительского типа (приведен к родительскому типу).
Наследование может быть множественным, когда новый тип создается на основе нескольких типов, либо одиночным, если наследник имеет
единственного родителя.
Напомним, что в C# множественное наследование классов отсутствует, но в некотором смысле его заменой может являться допустимость
реализации нескольких интерфейсов.
1.3. Абстракция
Абстракцией называют возможность использования основных функций программного компонента без погружения в детали реализации.
Вообще, это один из основных принципов программирования, а не
только ООП. Споры о том, является ли абстракция отдельным принципом ООП или нет, идут до сих пор. Многие считают, что это просто одно
из свойств инкапсуляции, когда публичными объявляются только основные части программного компонента.
В языке C# одним из удобных способов поддержки абстракций можно
считать пространства имен, интерфейсы и области видимости типов.
1.4. Пример, поясняющий принципы ООП
Предположим, мы разрабатываем программы для работы с базой данных университета, и одна из возникших задач – выдать всех людей старше
60 лет, указав их имя и должность. Воспользуемся абстракцией IPerson для
представления людей:
public interface IPerson
{
public string Name { get; }
public int Age { get; }
public string Position { get; }
}
Теперь, не вникая в детали реализации, мы можем написать функцию,
решающую поставленную задачу:
void Print(IEnumerable<IPerson> persons)
{
foreach (var person in persons)
if (person.Age >= 60)
Console.WriteLine($"Name:{person.Name}, position:{person.Position}");
Для пояснения принципа инкапсуляции рассмотрим вариант реализации интерфейса через абстрактный класс Person. Поскольку возраст человека постоянно меняется, хранить его в базе данных не совсем удобно.
Вместо возраста будем хранить дату рождения человека, а возраст вычислять каждый раз в момент обращения к нему. Тому программисту, который будет использовать Person, этот метод вызывать не нужно, поэтому
мы его сделаем приватным1:
public abstract class Person: IPerson
{
public string Name { get; init; }
public DateTime Birthday { get; init; }
private int AgeCalculator(DateTime when)
{
var year = when.Year - Birthday.Year;
if (Birthday.DayOfYear > when.DayOfYear)
year--;
return year;
}
public int Age => AgeCalculator(DateTime.Now);
public abstract string Position { get; }
}
Принципы полиморфизма и наследования используем при создании
классов Student и Teacher:
public class Student : Person // наследование
{
public override string Position => "student"; // полиморфизм
}
public class Teacher : Person // наследование
{
public string CurrentPosition { get; set; }
public override string Position => CurrentPosition; // полиморфизм
}
У свойства Position отличается поведение наследников: поскольку у
студента должность не меняется, в классе Student она постоянна, а для преподавателя заведено хранимое свойство, которое может быть изменено.
1 Обратим внимание, что функция AgeCalculator не совсем правильная, и мы ее обсудим
позже.
1.5. Принципы SOLID Англоязычная аббревиатура SOLID (иногда встречается S.O.L.I.D) предназначена для пяти принципов объектно ориентированного проектирования и программирования, предложенных Р. С. Мартином [1] в начале двухтысячных годов. Разумное следование этим принципам упрощает разработку, поддержку и расширение программной системы. S (single responsibility principle, SRP) – принцип единственной ответственности, согласно которому каждый объект должен иметь одну ответственность, и эта ответственность должна быть полностью инкапсулирована в класс. В формулировке самого Р. С. Мартина классы должны иметь одну и только одну причину для изменений. Например, если наш класс Person (см. с. 9) содержал бы еще методы ввода-вывода, то этот принцип был бы полностью нарушен. O (open-closed principle, OCP) – принцип открытости/закрытости, согласно которому классы должны быть открыты для расширения, но закрыты для изменения. Открытость означает, что у класса должны быть возможности расширения функциональности при наследовании (например, за счет объявления виртуальных методов). Закрытость – необходимость поддержания корректности внутреннего состояния объекта (например, за счет инкапсуляции). Принцип подразумевает, что для расширения функциональности класса нужно создавать новый класс (наследник исходного), а не добавлять или изменять функции исходного класса. L (Liskov substitution principle, LSP) – принцип подстановки Лисков, предложенный Барбарой Лисков в 1987 г.: методы, которые используют базовый тип, должны иметь возможность использовать подтипы базового типа, не зная об этом. Например, этот принцип иллюстрирует программа Print (см. с. 8), которая работает с перечислением базового типа IPerson. I (interface segregation principle, ISP) – принцип разделения интерфейсов: программные сущности не должны зависеть от того, что они не используют. В идеале для каждого заметно отличающегося использования класса должен создаваться отдельный интерфейс. Например, интерфейс IPerson (с. 8) полностью соответствует функции Print и не содержит не используемых в ней свойств (например, пол человека). Если же потребуется функция, использующая паспортные данные человека, то для нее, согласно принципу ISP, лучше создать другой интерфейс.