Книжная полка Сохранить
Размер шрифта:
А
А
А
|  Шрифт:
Arial
Times
|  Интервал:
Стандартный
Средний
Большой
|  Цвет сайта:
Ц
Ц
Ц
Ц
Ц

Основы объектно ориентированного программирования на языке С# для продолжающих

Покупка
Основная коллекция
Артикул: 875021.01.99
Доступ онлайн
500 ₽
В корзину
Настоящее учебное пособие является продолжением учебного пособия «Основы объектно ориентированного программирования на языке С#. Базовые сведения о языке» и рассчитано на читателей, уже ознакомившихся с ним. В этой книге кратко изложены более сложные понятия языка, отличия стандартов, основные идеи и принципы ООП. Учебное пособие будет полезно студентам, обучающимся на факультете прикладной математики и информатики по дисциплинам «Основы объектно ориентированного программирования», «Современные технологии программирования».
  3. LINQ
29
Рояк, М. Э. Основы объектно ориентированного программирования на языке С# для продолжающих : учебное пособие / М. Э. Рояк, И. М. Ступаков. - Новосибирск : Изд-во НГТУ, 2025. - 100 с. - ISBN 978-5-7782-5407-7. - Текст : электронный. - URL: https://znanium.ru/catalog/product/2244382 (дата обращения: 19.11.2026). – Режим доступа: по подписке.
Фрагмент текстового слоя документа размещен для индексирующих роботов
Министерство науки и высшего образования Российской Федерации 
Федеральное государственное бюджетное образовательное учреждение высшего образования 
НОВОСИБИРСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ 
 
 
 
М. Э.  Рояк, И. М.  Ступаков 
 
 
 
 
ОСНОВЫ ОБЪЕКТНО 
ОРИЕНТИРОВАННОГО 
ПРОГРАММИРОВАНИЯ  
НА ЯЗЫКЕ 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, лучше создать другой интерфейс.  


Доступ онлайн
500 ₽
В корзину