Урок 1 - Понятие класса, объекта
Продолжительность: 18 минут

Этот урок является вводным и направлен на правильное формирование у Вас понятий объектно-ориентированного программирования

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

Какие члены могут определять в себе классы и как они реализовываются в объектах;

Два главных правила следование которым избавит от типичных ошибок начинающего программиста на С#;

Разберем пример из жизни, который наглядно демонстрирует взаимосвязь класса и объекта;

Узнаете, при каких условиях возможно создание объекта.  Ознакомитесь с последовательностью создания классов;

Почему данный урок следует досконально разобрать перед тем, как приступать к изучению следующих;

В чем главный смысл постулатов, изложенных в данном уроке.

Урок 3 - Пространства имён
Продолжительность: 40 минут

В данном уроке Вы познакомитесь с понятием пространства имён

Пример из жизни - неразбериха с идентификацией личности;

Разбор случая когда без пространств имён не обойтись;

Как выглядят пространства имён в коде программы. Разбор синтаксиса объявления пространств имён;

Первые понятия о границах пространств имён, классов, методов. Определение области действия данных понятий;

Как доступаться к необходимому методу, который заключён в пространстве имён. Знакомство с модификатором public;

Интерпретирование и решение первой ошибки, допущенной при разработке;

Повышение удобств c подключением пространств имён используя ключевое слово using;

Какие два правила необходимо знать что б эффективно использовать пространства имён;

Какая ещё причина того, что в платформе .NET используются пространства имён.

Урок 5 - Типы данных (продолжение)
Продолжительность: 36 минут

В этом уроке мы продолжаем изучение переменных на примере практической работы с ними

Как соединять между собой данные нескольких строковых переменных;

В каких случаях вылетает ошибка при использовании не установленных переменных и как она решается;

Другой вариант комментариев - многострочный комментарий;

Иной, быстрый способ задания переменной;

Работа с несколькими переменными на примере выполнения арифметических операций над ними;

Главное правило, которое следует учитывать при работе с целочисленными типами во избежание потери данных при вычислениях;

Ещё один вариант определения переменных;

Инкремент, декремент и их вариации;

Подводим итог: локальные переменные - основные отличия от глобальных переменных. Область видимости этих двух типом переменных. Другое название глобальных переменных.

Урок 7 - Переполнение
Продолжительность: 43 минуты

Очень важный урок о необходимости контроля правильности выполнения увеличения (уменьшения) значения в переменной

Думаете 2147483647 * 2 = 4294967294? Ошибаетесь, - результат составляет "-2". Ловушка, на которую попадается каждый новичок;

Разбор по косточкам действия механизма переполнения;

Предотвращение искажения результатов при помощи инструкции checked;

Первое знакомство с конструкциями try-catch. Принцип работы данного оператора, предотвращающего аварийное завершение работы приложения;

вариация использования конструкции checked для проверки множества возможных переполнений;

Сколько точек входа в программу может быть? Использование нескольких методов Main в одном приложении;

Примеры по работе с использованием значений переменных и примеры занесения значений в переменные - невидимый подвох. Задание на самостоятельное решение.

Урок 9 - Конструкция if-else
Продолжительность: 43 минуты

В этом В этом уроке Вы узнаете о возможных направлениях выполнения программного кода, а также изучите управляющую конструкцию if-else

Повторение и закрепление знаний относительно очерёдности выполнения операторов в коде программы;

На схематическом примере знакомимся с возможными препятствиями для текущего направления выполнения кода;

Множественные разборы всевозможных синтаксических конструкций.

Урок 11 - Тернарный оператор
Продолжительность: 9 минут

В этом уроке приводится ещё одна очень полезная вариация управляющей конструкции if-else

Знакомство с однострочной записью условного оператора на новом примере;

Работа с типом byte;

В каких случаях имеет смысл использовать именно тернарный оператор, а не обычный if-else? Почему тернарный оператор является не полной заменой конструкции if-else?

Урок 13 - Конструкция while
Продолжительность: 31 минута

В этом уроке рассматриваются принципы циклической формы выполнения набора операторов. Знакомимся с конструкцией цикла while

Обзор преимуществ данной конструкции на примере вывода чисел от 1 до 10. Синтаксис записи оператора while. Повышение гибкости и сокращение времени на кодирование;

Акцентирование внимания на ключевых моментах цикла while;

За чем следует следить, что б избежать зацикливания. Эффективное использование бесконечных циклов;

Какие типы данных возможно использовать в блоке выбора switch-case. Преимущества использования констант.

Урок 15 - Устранение ошибок
Продолжительность: 21 минута

Исключительно практический урок направлен на решение всех проблемных мест примера из прошлого урока

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

Урок 17 - Конструкция do-while (продолжение)
Продолжительность: 29 минут

В этом уроке продолжаем работать с предыдущим примером, проводя полное тестирование приложения

Знакомство со свойствами экрана и внешнего вида выводимой информации;

Выводим звуковые системные сигналы.

Урок 19 - Конструкция for (продолжение)
Продолжительность: 26 минут

В этом уроке мы познакомимся со всеми возможными вариантами использования цикла for

Считаете, что после определения цикла for нельзя ставить оператор ";"?! Ошибаетесь. А как на счёт понимания парного оператора "{}"? Новый взгляд на знакомые вещи;

Более сложные варианты определения цикла for;

Эффективное применение циклов для вывода числовых последовательностей - рядов.

Урок 21 - Тип char
Продолжительность: 25 минут

В данном уроке мы поработаем с типом char, а также рассмотрим главные отличия данного типа и типа string

Тип char, некая замена типа string. Три варианта занесения значения в переменную типа char;

Особенности приведение типа char в тип int и обратно;

Плохая альтернатива типу char тип string. В чём заключается основной недостаток;

Как заносить данные типа char в тип string. Специальные два метода для осуществления этого;

Маленькая хитрость для мгновенного обхода проблем конвертации типа char в тип string, о которой мало кто знает.

Разбор динамических методов типа char

Примеры работы с некоторыми динамическими методами типа char.

Урок 23 - Тип string
Продолжительность: 42 минуты

В этом уроке мы детальнейшим образом разбираем всю подноготную типа string

Что представляет из себя тип string и в какой области памяти размещается;

Что общее имеет тип string с простыми типами и в чём его главное отличие;

Варианты создания переменной типа string и занесения в неё значений;

Какое ограничение накладывается на литералы типа string;

Особенности занесения в строковые переменные знаков кавычек. Использования управляющих символов форматирования строки;

Правильное форматирование задания пути к файлу. Дословные строки;

Что нужно знать, применяя управляющие символы в дословных строках;

Случайное и преднамеренное экранирование управляющих символов;

Более высокий уровень форматирования - класс Environment;

Выводим свой компьютер "на чистую воду" - определение с помощью методов класса Environment параметров Вашего компьютера;

Использование параметров для формирования и форматирования строк из отдельных литералов и переменных;

Множество примеров форматирования вывода дат, времени, валюты, дробных чисел, в разных системах счисления ... с помощью флагов форматирования.

Урок 25 - Тип string (продолжение)
Продолжительность: 18 минут

В этом уроке мы продолжаем углубляться в тип string, изучаем класс StringBuilder

Вникаем в концепцию строк с позиции платформы .NET. Понимаем ограничения обычного использования строкового типа;

Почему при проектировании серъёзных приложений следует избегать использования обычного класса string;

Почему тип string называют неизменяемым, т.е. immutable;

Что необходимо предпринять, что б иметь возможность использовать возможности класс StringBuilde;

Практическое исследование методов класса StringBuilder дублирующих методы класса string;

Когда всё же не следует применять класс StringBuilder.

Урок 1 - .NET-типы и C#-типы. В чём разница?!
Продолжительность: 19 минут

В этом уроке мы подробно рассмотрим систему типов платформы .NET

Как узнать тип переменной, если её создавали не Вы? Метод GetType;

Почему метод GetType показывает тип не тот, что мы ожидаем получить?

Понятие псевдонима типа;

Рассмотрение иерархии типов платформы .NET;

Главный родительский класс Object;

Подробное рассмотрение всех типов пространства .NET framework;

Особенность типов, относящихся к группе ValueType;

Взаимосвязь ссылочных и значимых типов. Главное отличие.

Урок 3 -Доступ к членам объекта
Продолжительность: 30 минут

Здесь Вы увидите, как доступаться к членам конкретного объекта некоторого класса

Главное правило, которого следует придерживаться при создании объектов;

Вопросы совместимости типа объекта и типа соответствующей ему ссылки;

Синтаксис доступа к членам объекта класса;

Модификаторы доступа - что это и для чего существуют?

Как правильно определять какой модификатор доступа использовать в данный момент?

Взаимная работа полей разных объектов одного класса;

Понятие сигнатуры.

Урок 5 -Массивы (продолжение)
Продолжительность: 31 минута

В этом уроке мы углубляемся в понимание массивов, работаем с более сложными примерами и разбираем класс Array

Более сложные примеры занесения типов в массивы;

Строки и массивы. Взаимные представления. Сортировка массива, изменение порядка следования элементов, реверс массива;

Как сортировать массив пользовательского типа, очищать и копировать.

Урок 7 -Многомерные массивы (продолжение)
Продолжительность: 28 минут

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

Как используя метод ToString быстро представить число в требуемой системе счисления избегая лишнего кода;

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

Как красиво выводить содержимое массива на экран;

Заканчиваем с побитовым разложением числа.

Урок 9 -Методы без возвращаемых значений
Продолжительность: 36 минут

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

Что такое методы и как определять их в пользовательских классах. Полная сигнатура методов;

Правила и условия правильного определения методов в классе;

Момент начала выполнения метода и момент завершения выполнения метода;

Методы призваны управлять полями;

Почему методы эффективно вызывать в цикле;

Почему иногда методы называют методами доступа;

Методы вызывают другие методы.

Урок 11 -Методы с принимаемыми аргументами
Продолжительность: 28 минут

Завершаем первое знакомство с методами и рассматриваем последний аспект - передача в метод данных

Какого размера следует создавать методы;

Синтаксис определения метода с принимаемыми аргументами;

Какие правила определения принимаемых параметров;

Как и по какому принципу следует передавать данные в вызываемый метод;

Особенности передачи параметров - что происходит с аргументами и что происходит с параметрами.

Урок 13 -Немного о рекурсии
Продолжительность: 50 минут

Этот урок посвящен одной щепетильной теме, с которой напрямую связаны методы - понятие рекурсии, а также различия в использовании полных и частичных логических операторов

Понятие рекурсии. Определение;

Демонстрация работы рекурсии на примере вычисления факториала числа

Выяснение действительных шагов вызова одного и того же метода в цикле рекурсии;

В рекурсии всё поставлено задом наперёд. Почему следует избегать использования рекурсии;

Демонстрация разительной разницы в работе разных вариантов логических операторов;

К чему приводит неправильное понимание принципа действия каждого логического оператора.

Урок 15 -Перегрузка методов
Продолжительность: 40 минут

В этом уроке мы познакомимся с отличнейшим инструментом C# - перегрузкой методов

Разбор понятия перегрузки методов, зачем пользоваться перегрузками. Синтаксис определения перегруженного метода

Как перегрузка методов способна сэкономить время разработки приложения и повысить его простоту;

Выгоды, которые дают перегрузки. Типы перегрузок.

Урок 17 -Конструкторы
Продолжительность: 40 минут

Здесь Вы познакомитесь с понятием конструкторов и на практических примерах поработаете с их перегрузками

Что такое конструкторы и для чего они существуют;

Правила определения конструкторов. Конструкторы по умолчанию;

Синтаксические особенности объявления конструкторов;

Конструктор - частный случай методов;

Понимание принципа работы конструктора;

Почему следует всегда помнить о моменте вызова конструктора;

Перегрузка конструкторов - наивысшее удобство;

Закрепляем навыки использования перегрузки конструкторов на примере разработки приложения бронирования номеров;

Когда следует переопределять конструктор по умолчанию.

Урок 19 - Статические поля
Продолжительность: 31 минута

В этом уроке Вы наконец-то поймёте назначение ключевого слова static

Обобщаем и подытоживаем накопленные знания относительно динамических членов класса;

Вспоминаем принцип работы динамических полей и методов;

Осмысление назначения статических членов. Особенности определения статических полей;

Синтаксис доступа к статическим членам;

В чём главная особенность поведения статических членов;

Как организованы в памяти статические поля;

Какое правило следует знать для эффективной работы со статическими методами;

Разрушаем миф о том, что со статическими данными могут работать только статические методы;

Прекрасный пример для закрепления понимания работы статических членов;

Когда выделяется память под статическое поле и когда оно разрушается.

Урок 21 -Статические классы
Продолжительность: 35 минут

Здесь мы систематизируем знания относительно статических членов и переходим на новый уровень абстракции - статические классы

Реальный пример из футбола, демонстрирующий сущность статических членов;

Потихоньку знакомимся с правилами создания кода в принципах ООП;

Варианты доступа к полям - напрямую и через методы доступа;

Приходим к пониманию целесообразности использования статических классов;

Определение статического класса;

Правила создания членов в статическом классе;

Какие конструкторы могут содержать статические классы;

Понимание ситуаций, когда выбрать обычный, а когда статический класс.

Урок 23 -Перечисления
Продолжительность: 33 минуты

В этом уроке мы с Вами переходим от статических полей до перечислений

Обзор перечислений с точки зрения типов .NET;

Разбираем заведомо ошибочный пример эмулирующий работу кнопки на вебстранице показывающий нюансы при работе с перечислениями;

Когда перечисления удобнее массива;

Определение перечисления. Синтаксис объявления и доступа к членам перечисления;

Так что же такое перечисление;

Полная свобода при определении членов в перечислении;

Правила создания членов в перечислении;

Раскрываем карты относительно классов;

Всем бояться циклических зависимостей;

Элементы наследования.

Урок 25 -Ключевое слово out
Продолжительность: 19 минут

В этом уроке мы познакомимся с ещё одним вариантом передачи параметров в метод

Для чего и когда имеет смысл передавать параметры с модификатором out;

Когда модификатор out является наилучшей альтернативой модификатору ref;

Основная выгода от использования модификатора out;

Знакомимся с отладочным механизмом - точки останова;

Вызов методов с входными параметрами при одновременным использованием модификаторов ref и out;

Урок 27 -Структуры
Продолжительность: 20 минут

В этом уроке мы узнаем что такое структуры и когда использовать структуры предпочтительнее классов;

Зачем мы создаём пользовательские классы;

Определение структуры. Общий значимый тип. Особенности размещения структур в памяти;

Понимание структур на практическом примере;

Новый взгляд на оператор new. Что, значимые типы тоже имеют конструкторы? Всё есть объект;

Два варианта создания объекта некоторой пользовательской структуры.

Урок 29 -Значимые и ссылочные типы - различия
Продолжительность: 23 минуты

В этом уроке мы разбираем правила, по которым происходит копирование данных значимых типов.

Проблемы при работе с объектами сборщика мусора;

Нахождение ключевых отличий при удалении значимых и ссылочных данных;

Циклы - лакмусовая бумажка для структур и классов;

Показательное присваивание значимых данных. Особенности в процессах присваивания.

Урок 31 -Значимые и ссылочные типы (продолжение)
Продолжительность: 11 минут

В этом уроке Вы окончательно запутаетесь

В чем разница при копировании одного ссылочного объекта в другой и копирования их внутренних членов;

Снова рисуем стек и управляемую кучу для понимания оператора присваивания;

Наконец-то полностью понимаем оператор "=";

Ещё раз останавливаемся на понятии полного квалифицированного имени переменной.

Урок 33 -Передача ссылочных типов в методы
Продолжительность: 17 минут

В этом уроке мы подробно останавливаемся на процессе передачи ссылочных данных в методы на выполнение

Повторение процесса передачи в метод данных значимого типа;

Почему статический метод может работать не со статическими переменными? В чём подвох? Не обольщайтесь - всё дело в локальности переменной;

Выполняем передачу ссылочного типа. Что происходит?

Обобщение правил, по которым выполняется передача внутренних полей в метод при передаче объектных данных;

Почему передача по значению ссылочных данных не работает так, как для значимых типов?

Обобщение правил, по которым выполняется передача внутренних полей в метод при передаче объектных данных.

Урок 35 -Boxing/UnBoxing - понятие упаковки/распаковки
Продолжительность: 31 минута

В этом уроке мы разберём все вопросы преобразований типов

Какой ключевой момент следует учитывать при выполнении оператора "=";

Что во что конвертируется при присваивании - понятие неявного преобразования;

Когда допустимо неявное преобразование, условия успешного выполнения неявного преобразования;

Явное преобразование. Ключевые моменты и потеря данных;

Больший тип-меньший тип - направление преобразований;

Когда необходимо применять явное преобразование;

Особенности конвертации значимых типов в ссылочные - процесс упаковки (Boxing);

Что происходит со стеком при упаковке;

Снова работаем с типом Object;

Правила распаковки;

С чего начинается процесс распаковки и что необходимо проверять перед распаковкой переменной?

Понимаем, что распаковка - обычное явное приведение;

Сложные примеры составных приведений при распаковке и упаковке;

Примеры практических упаковок;

Наконец-то полностью понимаем оператор "=";

Тип object, - можно расслабиться в отношении с упаковкой в данный тип.

Урок 1 - Понятие ООП, принципы
Продолжительность: 16 минуты

В этом уроке мы знакомимся с философией объектно-ориентированного программирования.

Какие существуют принципы ООП и почему следует так строго их придерживаться;

Понятие принципа инкапсуляции. Что от кого следует скрывать;

Понятие принципа наследования. Создание иерархий в отношении сущностей;

Понятие полиморфизма. Концепция, дающая широкие возможности;

Тип Object - простое объяснение механизмов наследования и полиморфизма.

Урок 3 -Наследование
Продолжительность: 29 минут

В этом уроке мы подробно рассматриваем еще один важный принцип ООП - наследование

Что означает для классов, участвующих в наследовании;

Когда следует применять наследование, а когда лучше отказаться от него;

Какие выгоды можно получить, применив наследование;

Знакомимся с понятием и синтаксическим выражением наследования;

Синтаксис применения наследования;

Понимаем нюансы по членам - кто кому принадлежит;

Множественно наследование, главное правило;

Особенности установки модификаторов видимости для членов участвующих в наследовании;

Закрепляем наследование на примере;

Ступенчатое наследование;

Правила инициализации наследуемых полей в наследованных классах;

Первое столкновение с понятием полиморфизма - механизмом трактовки нескольких объектов одним образом;

Последние нюансы в понимании наследования - больше нет вопросов.

Урок 5 -Включение/делегирование
Продолжительность: 18 минут

Рассмотриваем другой вариант механизма наследования - включение в данном классе иного

Пример отношения "имеет" на примере;

При каких формах отношения классов следует трактовать данное отношение как "имеет";

Почему классическое наследование "является" не всегда подходит для некоторых ситуаций отношений;

Как выполнить делегирование;

Зачем сохранять принцип инкапсуляции при выполнении делегирования.

Урок 7 -Полиморфизм
Продолжительность: 30 минут

В этом уроке изучаем последний обширный и многогранный принцип - полиморфизм

Понятие полиморфизма;

Полиморфизм - механизм трактовки нескольких объектов одним образом;

Полиморфизм - ещё один взгляд на тип object;

Создание иерархии наследования классов геометрических фигур для создания фундамента правильного понимания выгод полиморфизма;

В чём главная проблема использования наследования без соблюдения полиморфизма;

Проблемы решения проблем простого наследования "в лоб" - выход в полиморфизме;

Приходим к пониманию понятия переопределения;

Какие методы и в каких классах следует переопределять;

Ключевые слова virtual и ovveride;

Все тонкости применения модификаторов virtual и ovveride;

Ещё одно назначение оператора base для вызова реализации методов базового класса;

Играем операторами this, base, virtual и ovveride на полную катушку;

Главная выгода написание кода в принципах полиморфизма;

Понимаем, что только одновременное связывание всех столпов ООП - залог создания отличной архитектуры;

Правила именования перекрываемых методов;

Почему модификатор virtual не может совместно применяться с модификаторами public, static, override, abstract.

Урок 9 -Операторы is и as (продолжение)
Продолжительность: 20 минут

В этом уроке мы с Вами продолжаем углублятся в нюансы работы с принципами ООП

От метода ToString не скроешь настоящее происхождение типа;

Следует понять, какой же все-таки тип мы имеем, запутаться раз плюнуть;

Что же делает с типами оператор "=";

Сплошная "Санта Барбара" с наследованием;

Друг твоего друга - твой друг;

Ещё один тип ситуаций, требующий явного приведения типов;

Примеры использования оператора as при проверке получение целевого типа из переданного в метод параметра.

Урок 11 -Абстрактные классы и их члены
Продолжительность: 23 минуты

В этом уроке мы познакомимся с абстрактными классами и абстрактными членами

Когда недопустимо иметь возможность создания объекта некоторого класса;

Что представляют из себя чересчур общие классы;

Запрет на создание экземпляра класса - объявить его конструкторы закрытыми - private;

Почему решение вышеуказанной проблемы через закрытие доступа к конструкторам класса не является допустимым при ситуации когда данный класс есть наследуемым?

Почему использование модификатора доступа protected вместо private для конструктора базового класса является устаревшим решением проблемы?

Иной вариант - объявление класса абстрактным;

Функции, которые несет на себе наследуемый абстрактный класс;

Могут ли в абстрактном классе быть определены виртуальные методы?

Для чего существуют абстрактные методы?

Почему абстрактные методы могут быть описаны только в абстрактных классах;

Какого типа члены может содержать в себе абстрактный класс, а какого типа не может?

Правильное определение абстрактного метода;

О чём следует всегда помнить при создании классов, наследующих базовый абстрактный класс;

Какая связь существует между ключевыми словами virual, abstract и override?

Использование абстрактных классов - неплохой вариант следования полиморфизму - в переменной типа абстрактного класса содержим объекты производных классов.

Урок 13 -Интерфейсы
Продолжительность: 25 минут

В этом уроке мы узнаем о самой главной альтернативой использования абстрактных классов - интерфейсами

Интерфейсы - лучшая альтернатива абстрактным классам - решение проблемы множественного наследования;

Интерфейс - групповой набор абстрактных членов;

Синтаксис создания интерфейсов;

Правила именования интерфейсов;

Особенности определения членов интерфейсов;

Правила определения свойств интерфейса;

Правила определения методов интерфейса;

Пример реализации интерфейса классом;

Множественное наследование интерфейсов;

Главное правило описания одновременного наследованния класса и интерфейсов.

Урок 15 -Применение интерфейсов (продолжение)
Продолжительность: 32 минуты

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

Пример использования оператора as;

Создаём метод, принимающий один тип и возвращающий другой тип - конвертер типов - отличная идея для избавления от кода проверки возможности конвертации;

Оператор as снова втрое сэкономил много кода;

Исследование возможности хранения данного типа в некоторых иных по визуальной диаграмме иерархии классов и интерфейсов;

Ещё раз о явной и неявной конвертации при вызове методов;

Правило "мостика", род типа.

Урок 17 -Явная реализация интерфейсов
Продолжительность: 18 минут

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

Зачем может понадобиться явная реализация интерфейса;

В каких случаях не следует явно реализовывать интерфейсы;

Какие ограничения накладываются на члены интерфейсов реализованных явно;

Синтаксис явной реализации членов интерфейсов, особенности использования модификаторов доступа;

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

Приведение типов - способ вызова явно реализованного члена;

Явная реализация - управление доступом (видимостью) члена через тип;

Что во что можно конвертировать - анализируем не тип ссылки, а тип объекта. Ключ к пониманию правил конвертации - тип объекта;

Правило реализации одноимённых методов интерфейсов в одном классе - скрытый конфликт имён;

Решение конфликта имён в явной реализации интерфейсов.

Урок 19 -Методы ToString и GetHushCode
Продолжительность: 20 минут

В данном уроке речь пойдет о переопределении методов ToString и GetHushCode

Как метод ToString работает по умолчанию;

Модель переопределения метода ToString;

Почему надо стараться всегда перекрывать метод ToString;

Как переопределенный метод ToString поможет переопределить метод Equals;

Почему вылетает сообщение о не переопределении метода GetHushCode при переопределенном методе Equals?

Для чего существует метод GetHushCode и когда он используется?

Демонстрация работы метода GetHushCode;

Как теперь быстро и точно переопределить метод GetHushCode;

Понимаем взаимосвязь переопределений базовых методов типа Object;

Отличие в работе методов Object.Equals и Object.ReferenceEquals.

Урок 21 -Создание сравниваемых объектов
Продолжительность: 17 минут

В этом уроке мы с Вами займёмся организацией процесса для автоматического выполнения сравнивания объектов

Реальный пример из жизни разработчика демонстрирующий необходимость сравнивания объектов;

Проблема сортировки массива пользовательского типа;

Что происходит с элементами массива при попытке его сортировки. Какие операции при этом вызываются;

Интерфейс IComparable. Кто и когда вызывает метод CompareTo;

Правило определения возвращения значения из метода CompareTo;

Определяем алгоритм для сравнивания строковых значений.

Урок 23 -Коллекции. ArrayList
Продолжительность: 32 минуты

Здесь мы с Вами познакомимся с коллекциями и поработаем с типом ArrayList

Разбираем на примере главный недостаток обычных массивов - их размерность;

Обычные массивы - чрезмерный перерасход памяти, вероятность не достатка размерности;

Знакомимся с пространством имен System.Collection;

Что представляют из себя "резиновые" коллекции ArrayList, Hashtable, Queue, Stack, SortedLis;t

Какие удобства мы можем извлечь применяя определенный класс пространства System.Collection;

Самый ходовой класс - класс ArrayList. Создание коллекции ArrayList, добавление элементов и доступ к ним;

Отличие свойства Count и Capasity. Принцип увеличения значений этих свойств;

Как заносить в динамический массив сразу все элементы из обычного массива;

Вставляем любой элемент в любое место легко;

Как быстро преобразовать коллекцию в обычный массив используя оператор typeof и операцию приведения.

Урок 25 -Обработка исключений (продолжение)
Продолжительность: 17 минут

В этом уроке мы с Вами продолжим изучать принципы работы с исключениями

Получение информации о методе (месте) возникновения исключительной ситуации;

Определение последовательности вызовов приведших к исключению, интерпретация полученной информации;

Указание источника информации для решения возникшей исключительной ситуации;

Ручная генерация пользовательских исключений - когда это бывает необходимо;

Синтаксис генерирования исключительной ситуации;

Выбор какого типа следует создавать объект исключения для передачи в соответствующий блок catch;

Как настроить свойства пользовательского исключения;

Что происходит, если генерируя пользовательское исключение, мы не передаем ни один объект класса исключения;

Когда все-таки бывает удобно получать более узконаправленную информацию об исключении.

Урок 27 -Индексаторы (продолжение)
Продолжительность: 18 минут

Здесь мы завершаем работу по созданию и использованию пользовательских индексаторов.

Как использовать созданный индексатор для заполнения объекта-индексатора данными;

Почему индексатор по умолчанию не определяет свойство Length;

Определяем свойство Length самостоятельно;

Почему пользовательский индексатор не может работать с циклом foreach. Интерфейс IEnumerator;

Как цикл foreach работает с методом GetEnumerator?

Реализовываем метод GetEnumerator;

Использование оператора yield.

Урок 29 - Примеры перегрузки операторов
Продолжительность: 27 минут

В этом уроке мы с Вами разработаем приложение которое перемножает матрицы. Для этой цели мы перегрузим оператор "*"

Создаем предлог для перегрузки оператора * - создаем класс Matrix, все необходимые поля и свойства для них, а также пользовательский двумерный индексатор;

Уточнение правил математического умножения матриц - определений условий для успешного выполнения произведения;

Совершенствуем существующую формулу перемножения матриц;

Переписываем полученную формулу на языке тройных циклов;

Более пристальный взгляд на тройной цикл на примере рассмотрения механических часов.

Урок 31 -Ещё примеры перегрузок (продолжение)
Продолжительность: 20 минут

В этом последнем для данного раздела уроке мы заканчиваем с переумножителем матриц

Выводим содержимое матриц, используя флаги форматирования;

Создаем заготовку перегружаемого оператора "*";

Определяем логику операции перемножения матриц и проверяем полученные результаты;

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

Урок 1 - Отражение (рефлексия)
Продолжительность: 22 минуты

В этом уроке мы с Вами рассмотрим понятие рефлексии и выясним, когда она применяется

Понятие рефлексии

В каком пространстве имен находятся типы для работы с рефлексией;

Базовый класс System.Type - получение ссылки на тип, а не объект типа;

Пример создания ссылки на тип;

Рассмотрение классов связанных с рефлексией;

Понятие метаданных. Зачем они формируются, кем и когда. Связь метаданных и рефлексии;

Пример использования класса Type. Оператор typeof;

Главное отличие оператора typeof и динамического метода Get.Type;

Получение ссылки на тип методом Type.GetType. В каком представлении следует указывать тип параметра данного метода?

Достаем всю необходимую информацию о пользовательском типе;

Понятие о позднем связывании.

Урок 3 -Позднее связывание. Создание библиотек -.dll
Продолжительность: 25 минут

В этом уроке мы с Вами создадим заготовку примера расширяемого приложения

Позднее связывание - лучшее применение рефлексии;

Объяснение понятия позднего связывания на примере автомобиля;

Яблоки - лучший пример позднего связывания - преимущества и недостатки применения позднего связывания;

Простой пример раннего связывания;

Что представляют из себя библиотеки классов;

Как подключать библиотеку кода - сборку;

Что происходит внутри приложения при подключении новой сборки;

Создаем и добавляем в проект новую библиотеку кода;

Как в проекте добавить ссылку на библиотеку кода;

Пример позднего связывания.

Урок 5 -Обход запрета на вызов запретных методов
Продолжительность: 8 минут

В этом уроке мы с Вами разберём технологию, позволяющую вызывать закрытые методы, используя рефлексию

Первый шаг - получение метаданных класса, содержащего целевой метод;

Шаг второй - получение метаданных целевого метода. Нюанс при указании составного входного параметра - флага для метода GetMethod;

Почему данный урок я не хотел выносить на DVD-диск?

Урок 7 -Обобщенные методы
Продолжительность: 17 минут

В этом уроке мы познакомимся с обобщенными методами и выясним некоторые очень интересные нюансы относительно этого

Когда могут понадобиться обобщенные методы;

Синтаксис определения обобщенного метода;

Что использовать: перегрузку метода, или его обобщенный вариант;

Пример создания и вызова обобщенного метода с разного типа параметрами;

Особенности вызова обобщенного метода без входных параметров;

О каких ключевых моментах следует помнить, используя обобщенные методы.

Урок 9 -Указание ограничений в обобщенных типах
Продолжительность: 24 минуты

Здесь мы выясним ключевые моменты относительно указания ограничений и шаблонов для пользовательских типов

Определяем ограничения, которые ждут нас при использовании обобщенных классов;

Сложный пример создания экземпляра обобщенного типа настроенного на пользовательский тип-наследник;

Какие проблемы возникают при настройке обобщенного класса на пользовательский тип;

Оператор where. Как применить, когда и что он дает;

Варианты использования оператора where;

Правила указания нескольких ограничений и условий;

Примеры накладывания ограничений на обобщенные методы.

Урок 11 -Групповые делегаты. Делегаты-параметры
Продолжительность: 10 минут

В этом уроке мы закончим с делегатами и рассмотрим групповые делегаты

Множественный вызов методов - прерогатива группового делегата;

Как зарегистрировать в делегате несколько методов для вызова?

Как снимать с регистрации метод?

Пример передачи в метод делегата в качестве входного параметра.

Урок 13 -Примеры использования событий
Продолжительность: 25 минут

В этом уроке мы поработаем с практическими примерами по работе с событиями

Варианты размещения в разных классах обработчиков событий;

Регистрация на событие нескольких обработчиков события;

Отличительная особенность снятия метода с регистрации;

Статические и динамические обработчики событий. Различия в определении и декларировании.

Какие классы в лице методов могут уведомляться о наступлении события?

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

Разбиваем логику приложения инкапсулируя по классам;

Разработка циклов для ввода текста и для определения момента его печати.

Урок 15 -Введение в многопоточность
Продолжительность: 28 минут

В этом уроке мы знакомимся с понятием многопоточности и самого потока

Приложение и поток для него;

Пример работы многопоточного windows;

Многопоточность на примере мясорубки;

Преимущества, которые дают потоки;

Почему потоки следует использовать не всегда;

Когда же все-таки следует использовать многопоточность;

Почему многопоточность не дает выигрыш в производительности, а тем более в скорости работы приложения?

Раскрытие глаз относительно параллельнсти выполнения одновременно запущенных потоков?

Потоки не дают параллельнсти, так что же они дают?

Потоки выполняют методы, потоки не соотносятся с объектами, а соотносятся с методами;

Проблемы доступа к переменным из разных потоков;

Варианты и причины завершения работы потока;

Что такое домен приложения. Домены и потоки;

Прекрасная демонстрация принципа многопоточности на примере способа ношения сумок пожилыми людьми.

Урок 17 -Потоки (продолжение)
Продолжительность: 34 минуты

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

Так почему же мы получили неожидаемые результаты - все дело в псевдопараллельности;

Оператор lock для синхронизации потоков;

Важное обстоятельство при применении параметра для оператора lock;

Как использовать конструкцию lock для статических методов?

Еще один способ синхронизации - использование класса Monitor;

Альянс методов Monitor.Exit, Monitor.Enter и блоков try-catch;

Ещё один вариант синхронизации - метод Join. Принцип работы метода Join;

Ещё способ синхронизации - добавление к классу атрибута Synchronization;

Наследуемый класс ContextBoundObject

Что следует учитывать прежде чем решиться на синхронизацию классовых членов применив атрибут?

Как вручную приостанавливать выполнение потока. Зачем и где может понадобиться приостановка потока;

Пример, демонстрирующий периодическую приостановку выполнения потока;

Еще примеры по периодичности выполнения нескольких потоков с применением метода Thread.Sleep;

Выставление приоритетности выполнения конкретного потока по отношению к остальным запущенным;

Урок 19 -Обзор вопросов
Продолжительность: 50 минут

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

Длительный разбор тестовых вопросов и заданий, которые обычно задаются на собеседованиях.

Урок 1-Введение в Windows Forms. Понятие формы
Продолжительность: 13 минута

В этом уроке мы поговорим о том, как устроены множество всевозможных приложений с точки зрения программной логики

Понятие форм и окон и принципов работы с ними на примере нескольких реальных приложений (Microsoft Word);

Действия - события. Примеры работы действий-событий и действий-реагирования;

Модальные и немодальные окна. Отличия. Пример модальных и немодальных окон в программе Microsoft Word.

Урок 3 -Первая форма (продолжение)
Продолжительность: 18 минут

В этом уроке мы детально рассмотрим все классы участвующие в работе оконного приложения

Зачем один класс разбит на два файла;

Детальный разбор содержимого данных файлов;

Варианты настройки свойств контролов и окна;

Что представляет из себя класс Form?

Где находится точка входа в приложение. Разбор назначения атрибута STAThread;

Место создания и запуска формы;

Время создания формы и время запуска формы на отображение на экране;

Метафора "Большой взрыв".

Урок 5 -Добавление кнопки на форму (продолжение)
Продолжительность: 22 минуты

В этом уроке мы продолжаем экспериментировать с событиями некоторых контролов

Нюансы принудительного изменения размеров контрола. класс Size;

Выводим на экран новое окно с сообщением о нажатой кнопке мыши;

Используем входной параметр для определения, какая именно кнопка была нажата;;

Работаем с событиями закрытия приложения. Запрашиваем у пользователя подтверждения желания закрытия приложения;

Какие параметры следует дать методу MesageBox.Show для правильного создания диалогового окна;

Как определить, что решил пользователь относительно закрытия приложения.

Урок 7 -Группировка контролов. Контрол Panel
Продолжительность: 17 минут

В этом уроке мы научимся группировать контролы на форме и другом родительском контроле. Узнаем для чего это делается и как все это используется

Как управлением одним контролом Panel позволяет управлять одновременно со всеми её дочерними контролами;

Как добавить на панель полосы прокрутки;

При каких обстоятельствах появляются полосы прокрутки;

Дополнительные настройки полосы прокрутки;

Работаем с контролом TextBox. Настраиваем внешний вид;

Работаем с контролом Label.

Урок 9 -Кросспоточная работа. Метод Invoke
Продолжительность: 22 минуты

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

Почему мы не можем сдвинуть кнопки с места, используя потоки. Что за ошибка вылетает?

Оптимизируем код путем замены множества методов одним общим и доступным для разных потоков;

Решаем проблему кросспоточности посредством использования делегатов;

С помощью перегруженного метода Invoke получаем возможность вызывать метод делегата;

Кнопки двигаются. Но появились новые проблемы с кнопкой старт и закрытием приложения;

Добавляем в движение кнопок различные скоростные режимы.

Урок 11 -Создание пользовательского контрола. Работа с изображениями
Продолжительность: 21 минута

В этом уроке мы добавляем изображение финиша в проект, а также расширяем функциональность класса Button

Быстро и легко устраняем возникновение ошибки при закрытии приложения;

Работаем с ресурсами. Примеры типов файлов-ресурсов;

Создаем финишную прямую в ресурсах проекта. Рисуем в редакторе графических ресурсов;

Помещаем изображение финишной прямой на форму;

Мгновенно определение лидирующей кнопки на протяжении всего движения путём сортировки массива;

Загоняем кнопки в обычный массив;

Исключение при попытке сортировать массив кнопок. Интерфейс IComparable;

Создаем пользовательский класс для своих собственных кнопок;

Реализовываем интерфейс IComparable для класса пользовательских кнопок;

Изменяем в файле-дизайнере тип контролов button на пользовательский тип.

Урок 13 -Обзор разработанного кода
Продолжительность: 20 минут

В этом уроке мы повторяем ключевые моменты этапа разработки

Выводим на экран информацию о победившей кнопке;

Повторяем ключевые этапы разработки проекта;

Насыщаем код комментариями.

Урок 15 -Добавление звуковых эффектов в проект
Продолжительность: 20 минут

В этом уроке мы добавим в наш проект немного звуковых эффектов

Добавляем звуковой файл в качестве ресурса;

Добавляем необходимое пространство имен необходимое для работы с медиаресурсами;

Определяем место и время начала воспроизведения звукового эффекта;

Выводим звук езды на устройство воспроизведения звука;

Определяем время и место остановки звучания эффектов;

Какой формат звукового файла проще всего использовать в проекте?

Выполняем конвертацию звукового файла в необходимый формат с помощью программы Quick Mp3 Wav Converter;

Добавляем в ресурсы полученный файл;

Определяем моменты запуска и остановки фоновой мелодии приложения;

Быстро решаем проблему временной задержки перед началом проигрывания фоновой мелодии.

Урок 1 -Разбор требований
Продолжительность: 20 минут

В этом уроке мы разбираем и анализируем техническое задание на проект

Выяснение среды разработки и целевого языка;

Определение принципа движения и управления сущностей игры;

Выясняем ключевые моменты при запуске игры;

Оговорка необходимости применения паттернов. Понятие паттернов;

Определяем перечень необходимых технологий требуемых для реализации проекта.

Урок 3 -Паттерны проектирования (продолжение)
Продолжительность: 32 минуты

В этом уроке мы продолжаем детальный разбор распространенных паттернов проектирования

Разбираем все детали шаблона Adapter и две его модификации: Object Adapter и Class Adapter;

Разбираем шаблон Memento (память). В каких приложениях не обойтись без данного паттерна;

Разбираем все ключевые моменты паттерна Stratege;

Выясняем все моменты относительно паттерна MVC на практическом примере.

Урок 5 -Создание проекта
Продолжительность: 10 минут

В этом уроке мы создаем проект и выполняем первые настройки главного окна приложения

Создаем windows-проект и настраиваем главное окно;

Создаем и добавляем в проект иконку;

Запрещаем форме изменять свой размер - задаем фиксированный размер.

Урок 7 -Работа над запуском приложения
Продолжительность: 16 минут

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

Добавляем в конструктор контролера необходимые параметры входных данных;

Создаем 4 перегрузки данного конструктора;

Изменяем метод Main так, что бы он мог принимать переменное число входных параметров и в зависимости от этого вызывал соответствующую перегрузку конструктора для контролера.

Урок 9 -Создание необходимых потоков
Продолжительность: 11 минут

В этом уроке мы закладываем фундамент для будущего "движения" объектов в работающем приложении

В классе Model создаем метод для движения сущностей;

Определяемся с базовой минимальной логикой данного метода;

Добавляем кнопку на форму для запуска /остановки игры. Определяем событие;

Почему кнопка "Стоп" не реагирует на нажатие во время проигрывания игры. Решаем данную проблему многопоточностью;

В классе Controller создаем отдельный поток. Выясняем место, где необходимо создавать экземпляр данного потока.

Урок 11 -Движение танка по экрану
Продолжительность: 9 минут

В этом уроке мы с Вами будем решать проблему не отображения реального движения танка по форме

Новая проблема - изображение танка не двигается по форме, хотя координаты танка действительно изменяются;

В необходимом месте заставляем форму себя перерисовывать;

Устанавливаем танку постоянную скорость движения.

Урок 13 -Создаем перечисление статуса игры
Продолжительность: 15 минут

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

Создаем перечисление для определения статуса игры;

На основе имеющегося перечисления расширяем функционал кнопки "Старт/Стоп";

Изменяем метод OnPaint на более экономичную работу через использование статуса игры;

Маленькое дополнение в контролере по поводу отрисовки формы.

Урок 15 -Анализ и выбор способа движения
Продолжительность: 29 минут

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

Определяем возможности в своем движении танков;

Какие случаи могут происходить с танками при их взаимодействии с другими сущностями;

Определяем поочередность вывода сущностей на форме. Для чего это обдумывать;

Важное замечание по поводу появления блока на игровом поле;

Определяем границы игрового поля. Определяемся с размерами сущностей;

Варианты ситуации столкновения танков друг-с-другом;

Анализируем вариант зависимости танка от стен. Преимущества такого подхода;

Анализируем вариант независимости танка от стен - зависимость танка от пройденного им пути. Главный недостаток;

Находим самую эффективную и независимую модель движения танков.

Урок 17 -Создание первых интерфейсов и стен
Продолжительность: 22 минуты

В этом уроке мы создадим новые классы под остальные сущности. А также создадим несколько интерфейсов для реализации паттерна Strategy

Создаем первый интерфейс перемещения танка IRun и определяем в нем метод Run;

В классе Tank реализовываем данный интерфейс;

Создаем интерфейс поворота танка ITurn и определяем в нем метод Turn;

Создаем интерфейс для инкапсуляции процесса подбора яблок;

Создаем интерфейс столкновений ICollision;

Определяем, что из себя должен представлять класс стен;

Создаем класс стен и соответствующий ему класс изображений стен;

Создаем изображение стены и добавляем его в ресурсы;

Наполняем кодом класс изображения для стен;

Наполняем кодом класс Wall, выводим множественные изображения стен на экран;

Впервые сталкиваемся с потребностью использовать буферизированную графику;

Вывод танка и вывод стен на экране разносим по отдельным методам.

Урок 19 -Прозрачность стен для танка
Продолжительность: 18 минут

В этом уроке мы заставим наш танк проходить сквозь прозрачные границы игрового поля

Под прозрачные стены создаем интерфейс ITransparent и описываем в нем метод;

Реализовываем данный интерфейс в классе танка;

Определяем логику действия прозрачных стен;

Наполняем метод Transparent соответствующим кодом прозрачных стен;

Важный нюанс действия прозрачных стен - потеря 1-го пиксела;

Определяем ключевые моменты попытки выезда танка за границы поля.

Урок 21 -Внедрение анимации движения танка
Продолжительность: 23 минуты

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

Определяемся с подходом для создания эффекта анимированных гусениц движущегося танка;

Создаем великое множество дополнительных изображений танка, которые будут участвовать в анимированном движении;

Полностью переписываем класс, отвечающий за предоставление изображения танка, загоняя все группы картинок по 4-м массивам;

Инкапсулируем все 4-е массива изображений;

Выполняем соответствующие изменения в классе Tank.

Урок 23 -Создание множества танков
Продолжительность: 25 минут

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

Создаем массив танков. Определяемся с типом массива. Выясняем все "за" и "против";

Выясняем механизм размещения танков на игровом поле;

Создаем новый метод для размещения множества танков на поле;

Заменяем все вхождения в коде одиночного танка на массив танков;

Выясняем достаточный и эффективный подход для быстрого и правильного расположения танков на поле;

Реализовываем данный подход в методе расстановки танков.

Урок 25 -Столкновение танков
Продолжительность: 21 минута

В этом уроке мы разбираем процесс столкновения танков на показательных рисунках и анимациях

Разбираем варианты столкновения танков: лобовое, угловое и смешанное столкновение;

Определяем возможные места столкновения танков;

Обдумываем логику метода, отвечающего за механизм столкновения танков;

Рассматриваем "под микроскопом" процесс движения двух танков навстречу друг-другу

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

Выясняем значение расстояния между двумя танками в момент столкновения;

Определяемся с классом, отвечающего за контролирование столкновения танков.

Урок 27 -Столкновение танков (продолжение)
Продолжительность: 15 минут

Здесь мы завершаем с реализацией процесса столкновения двух танков

Совершенствуем логику разворота танков;

Анализируем условия углового столкновения и реализуем это в коде;

Заставляем танки правильно разъезжаться при столкновении.

Урок 29 -Прическа кода
Продолжительность: 26 минут

В этом уроке мы настраиваем иерархию и взаимозависимость всех классов и интерфейсов нашего приложения - организовываем более связанную архитектуру приложения

Анализируем диаграмму имеющихся в нашем проекте классов и интерфейсов;

Добавляем описание методов в интерфейсах прямо в визуализаторе диаграмм;

Удаляем лишние (не использованные) интерфейсы и те, функциональность для которых реализована другими интерфейсами;

Определяем набор функциональности для каждой единицы кода проекта. Разносим данную функциональность по имеющимся сущностям;

Поддержку изображений для каждой сущности выносим на отдельный интерфейс;

Создаем список яблок в классе Model и расставляем яблоки на поле;

Размышляем над целесообразностью вынесения координат любой сущности в отдельную структуру.

Урок 31 -Отображение и движение "Пакмена"
Продолжительность: 8 минут

В этом уроке мы добиваемся вывода "Пакмена" на екран и его непрерывного движения по игровому полю

Добавляем в класс View метод вывода изображения "Пакмена" на экране;

Добавляем объект "Пакмена" в классе Model;

Устраняем все ошибки и наблюдаем движение "Пакмена" на игровом поле.

Урок 33 -Поворот "Пакмена" (продолжение)
Продолжительность: 13 минут

В этом уроке мы завершаем разработку метода, отвечающего за управление "Пакменом" с клавиатуры

Расширяем класс "Пакмена" посредством ввода новых свойств относительно направления движения;

Добиваемся правильного поведения "Пакмена" между перекрестками.

Урок 35 -Подбор яблок (продолжение)
Продолжительность: 16 минут

В данном уроке мы завершаем работу над процессом подбора и вывода подобранных яблок

Расширяем функционал выше использованного метода на ведение счета количества подобранных яблок;

Модифицируем метод создания новых яблок;

Исправляем досадную и не всегда заметную ошибку связанную с динамическими коллекциями яблок;

Добавляем условие завершения игры при подборе необходимого количества яблок;

Реализовываем правильный вывод собранных яблок - вряд по одной линии.

Урок 37 -Столкновение "Пакмена" с танком
Продолжительность: 9 минут

В этом уроке мы реализуем механизм столкновения "Пакмена" с одним из вражеских танков

Решаем постоянный вопрос относительно класса, в котором будет выполняться проверка факта столкновения "Пакмена" с танками;

Используя координаты танков и "Пакмена", а также перечисление статуса игры дополняем класс Model проверкой на столкновение "Пакмена" с одним из танков;

Тестируем и оптимизируем условие проверки столкновения.

Урок 39 -Работа над "Охотником"
Продолжительность: 31 минута

В этом уроке мы создаем основу для реализации процесса погони "Охотника" за "Пакменом"

анализируем проблемы наследования в классах танка и "Охотника";

Наполняем класс "Охотника" его личными членами;

Благодаря наследованию мы помещаем в список танков еще и "Охотника";

Определяем логику движения "Охотника."

Урок 41 -Устранение ошибок в коде
Продолжительность: 7 минут

В этом уроке мы исправляем некоторые ошибки в логике движения "Охотника"

Устраняем невидимую ошибку в логике поворота "Охотника";

класс "Охотника" избавляем от неиспользуемых полей.

Урок 43 -Движение снаряда
Продолжительность: 15 минут

В этом уроке мы продолжаем настраивать движение "капризного" снаряда

В классе Controll определяем направление, скорость движения и координаты вылета снаряда при нажатии соответствующей клавиши на клавиатуре;

Изменяем класс View на вывод изображения снаряда;

Настраиваем модификаторами члены класса снаряда;

Решаем возникновение исключительной ситуации при попытке вывода невыпущенного снаряда.

Урок 45 -Подбитые танки. Создание, внедрение
Продолжительность: 24 минуты

В этом уроке мы осуществляем процесс подбития вражеских танков снарядом и отображение анимированного огня на них

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

Создаем класс пылающего танка и класса изображений пылающего танка;

Наполняем данные классы привычным содержимым;

Расширяем класс Model объектами класса пылающего танка;

Реализуем главный метод пылающего танка, отвечающего за отображение огня на подбитом танке;

Определяем условия, при которых вражеский танк может считаться подбитым;

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

Урок 47 -Правильное движение снаряда (продолжение)
Продолжительность: 15 минут

В этом уроке мы окончательно настраиваем поведение снаряда, а главное - ограничиваем максимальную дальность полета снаряда

Задаем снаряду граничную дальность полета;

В классе снаряда вводим счетчик километража для определения момента прекращения дальнейшего движения снаряда;

Подчищаем последние штрихи по движению снаряда.

Урок 49 -Обработка событий клавиатуры
Продолжительность: 6 минут

В этом уроке мы снова работаем с кодом определения нажатой клавиши клавиатуры для управления поведением "Пакмена"

Создаем новый метод определения нажатой клавиши клавиатуры для новой кнопки "Start";

Переписываем код определения значения нажатой клавиши из-за особенностей данного события для контрола PictureBox;

Автоматическое упрощение кода относительно поддержки нескольких языковых раскладок клавиатуры;

Зачем принудительно устанавливать новую кнопку в фокус и где это делать.

Урок 51 -Работа с элементами меню - подменю
Продолжительность: 16 минут

В этом уроке мы работаем с динамическим поведением подпунктов меню

Работаем с пунктом меню создания новой игры;

Взвешиваем все "за" и "против" относительно повторного использования существующих сущностей с предыдущего запуска игры;

Создаем и наполняем кодом метод для запуска новой игры;

Решаем проблему стирания части игрового поля вылетевшим подпунктом меню. Устанавливаем причину;

Реализовываем вывод окна подсказки после выбора соответствующего подпункта меню;

Работаем с подпунктом меню включения/выключения звука игры;

Добиваемся смены иконки подпункта меню звука в зависимости от выбранного звукового режима.

Урок 53 -"Прическа" кода и метод Invoke
Продолжительность: 9 минут

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

Наводим порядок в организации кода - упорядочиваем поля и методы, а также инкапсулируем все открытые поля классов;

Группируем закрытые, открытые и полуоткрытые члены классов в отдельные группы;

Обращаемся к знакомому методу для решения проблемы кросспоточной работы;

Снова закрываем возможность изменять размер главного окна приложения.

Урок 55 -Последние исправления
Продолжительность: 14 минут

В этом уроке мы придадим коду программы товарного вида. Подтяним недочеты и повыбрасываем излишние блоки кода

Разбиваем многострочные методы на несколько более мелких методов;

Выносим все литералы, встречающиеся в коде в константы, в статические поля, или в переменные другого типа;

Опять группируем члены классов по их уровню видимости.

Урок 1-Прогон проекта по утилите FxCop
Продолжительность: 30 минут

В этом уроке мы знакомимся с принципом работы утилиты FxCop. Проверяем наш готовый проект и фиксим все найденные ошибки и несоответствия тем, или иным стандартам.

Для чего существует программа FxCop и что она позволяет проверять в проектах;

Знакомимся с интерфейсов программы FxCop;

Какой файл проекта следует загружать для проверки в программе FxCop и как это делать;

Как запустить анализатор на поиск несоответствий;

Знакомимся с описанием ошибок и учимся правильно их интерпретировать;

Как быстро найти в интернете описание исследуемой ошибки;

Следуя инструкциям устраняем первое несоответствие относительно нейтрального языка сборки;

Решаем проблему подписания сборки строгим именем;

Решаем проблему CLS-совместимости нашей сборки;

Решаем проблему несоответствия имен некоторых членов общепризнанным соглашениям об именовании переменных;

Настраиваем все MessageBox на правильный вывод информации в соответствии с мировыми требованиями;

Решаем проблемы потенциальных ошибок при конвертации из-за не указания информации о целевом культурном регионе.

Урок 3 -Создание пользовательского (расширенного) инсталлятора
Продолжительность: 23 минуты

В этом уроке мы создадим расширенный инсталлятор для нашей видеоигры

Создаем особого вида новый проект пакетного установщика;

Рассматриваем назначение каждой папки, присутствующей в только что созданном проекте пакетного установщика;

Используем горячие клавиши для открытия вкладки свойств конечного приложения;

Указываем автора, производителя, название продукта, опции удаления предыдущих версий продукта;

Открываем свойства текущего проекта инсталлятора;

Настраиваем некоторые базовые опции для получения конечного пакета установки;

Как и в какую папку следует добавлять инсталлируемый проект;

Создаем ярлыки для помещения их на рабочий стол и в меню "Пуск->Программы";

Каждому ярлыку назначаем соответствующие иконки;

Как открыть редактор пользовательского интерфейса процесса установки приложения;

Добавляем в шапку мастера установки заранее подготовленный баннер;

Добавляем в мастер процесса установки окно лицензионного соглашения;

Добавляем текстовый файл содержимого лицензионного соглашения;

Генерируем исполняемый файл инсталлятора целевого проекта;

Проверяем правильность работы полученного инсталляционного пакета, выполнив полную установку приложения на целевом компьютере;

Проверяем работоспособность всех созданных ярлыков данного приложения;

Какой файл необходимо добавить на оптический диск для того, что при вставке диска в DVD(CD)-ROM автоматически происходил запуск начала установки приложения;

Создаем своими силами требуемый файл за 1 минуту;

Добавляем файл иконки и копируем на диск необходимые файлы.