EGround
Редактор
- Сообщения
- 66.101
- Реакции
- 285
Складчина: Чистая архитектура и DDD для 1С-разработчиков через Unity и C# [Евгений Шилов]
Практический курс, на котором вы научитесь проектировать полноценные сценарии и подсистемы в 1С: выделять бизнес-логику, проводить архитектурные границы, управлять зависимостями и интегрировать новые решения в существующие конфигурации.
Что будет:
- Проектируете сценарии с нуля
от целей пользователя до результата - Отделяете бизнес-логику
от форм, хранилок и платформы - Управляете зависимостями
и предотвращаете архитектурные проблемы - Интегрируете новые решения в 1С
в существующие конфигурации - Обосновываете архитектурные решения
и защищаете их перед командой
Этот курс для вас, если:
- Вы начинаете проектирование с форм, кнопок и окон и фактически подстраиваете логику приложения под интерфейс
- Вы начинаете с выбора справочников, документов и регистров, но не умеете сначала определить бизнес-сценарии, правила и границы системы
- Бизнес-логика постепенно расползается по формам, объектам, обработчикам и общим модулям.
- Одно изменение затрагивает сразу несколько частей конфигурации, и невозможно заранее понять ожидаемые последствия.
- Видите, что в коде смешаны разные обязанности, но не понимаете, где именно провести границу.
- Не знаете, как применить архитектурные подходы в существующей доработанной конфигурации.
- Архитектурные решения сложно объяснить и защитить перед командой.
- Не хватает цельной системы, по которой можно принимать решения, проводить код-ревью и развивать проект.
После курса вы сможете:
- Проектировать полноценные сценарии в 1С от начала до конца
От действия пользователя до бизнес-логики, инфраструктуры и конечного результата. - Разделять систему на понятные слои и границы
Определять, что относится к UI, Application, Domain и Infrastructure, и не складывать всю логику в формы, модули объектов и общие модули. - Находить и выделять настоящую бизнес-логику
Формулировать инварианты, проектировать агрегаты и bounded contexts, отделять правила бизнеса от технических деталей платформы. - Применять Clean Architecture и DDD в реальных проектах на 1С
Не копировать C#-подходы механически, а адаптировать их под ограничения платформы — в том числе при работе с типовыми конфигурациями. - Обосновывать и защищать архитектурные решения
Объяснять команде, почему система разделена именно так, устанавливать единые правила проектирования и проводить более осмысленное код-ревью. - Интегрировать свои подсистемы с типовым решением
Не связывать их напрямую с legacy-кодом, сохраняя архитектурные границы и контролируя зависимости.
Зачем 1С-разработчику другой стек:
На Unity и C# архитектурные паттерны видны физически — их нельзя обойти. В 1С те же принципы приходится удерживать дисциплиной. Изучив оба подхода, вы перестанете «копировать приём» и начнёте мыслить архитектурно в любой среде.
На Unity и C# вы увидите:
- как физически разделяются слои
- как запрещаются неправильные зависимости
- как собирается объектный граф
- как модель защищает бизнес-правила
- где заканчивается один bounded context и начинается другой
В 1С вы научитесь:
- переносить архитектурный смысл, а не копировать C#-структуру
- компенсировать ограничения платформы
- отделять форму, модель хранения и бизнес-логику
- встраивать новую подсистему в типовое решение
- контролировать границы соглашениями
Вы не изучаете Unity ради Unity и не создаёте игру с нуля.
Вы работаете с готовым учебным проектом, чтобы увидеть архитектуру там, где 1С не позволяет закрепить её технически.
Программа:
7 модулей — от подготовки учебного проекта до итоговой работы в 1С
0. Подготовка к работе с учебным проектом
Разберётесь в готовом проекте на Unity и C#, чтобы уверенно работать с учебными примерами и не отвлекаться на полноценное изучение нового стека. Научитесь находить нужные объекты и участки кода, запускать проект, вносить изменения и разбираться с базовыми ошибками.
Что изучим:
- зачем часть архитектурных решений рассматривается на другом стеке;
- как открыть и запустить готовый проект;
- где находятся сцена, объекты, параметры и код;
- как найти нужный объект и связанный с ним компонент;
- как открыть C#-скрипт и внести простое изменение;
- как читать сообщения об ошибках и простой stack trace;
- как собрать готовое приложение.
Ваш результат после модуля:
У вас будет настроенный и проверенный учебный проект, готовый к дальнейшей работе. Вы сможете самостоятельно открыть нужную сцену и скрипт, найти связанный с объектом код, внести простое изменение, запустить приложение и понять причину базовой ошибки по сообщению и stack trace.
1. Классы, зависимости и сборка приложения
Научитесь видеть, от чего на самом деле зависит код, делать эти зависимости явными и управлять ими из одной точки. Сможете собирать приложение так, чтобы отдельные реализации можно было заменять без переписывания основной логики и появления скрытых связей.
Что изучим:
- необходимый минимум C# для чтения кода;
- классы, объекты, методы, конструкторы и интерфейсы;
- явные и скрытые зависимости;
- создание, поиск и передача зависимостей;
- глобальный доступ и Service Locator;
- Dependency Injection без привязки к контейнеру;
- объектный граф и композиция объектов;
- Bootstrap и Composition Root;
- отличие сборки приложения от выполнения прикладного сценария.
Ваш результат после модуля:
У вас будет собран прозрачный объектный граф, в котором понятно, какие компоненты создаются, как они связаны и где выбираются их реализации. Вы вынесете сборку приложения в отдельную точку, отделите создание объектов от их работы и сможете заменять инфраструктурные детали, не затрагивая прикладной сценарий.
2. Clean Architecture: от действия пользователя до результата
Научитесь проектировать пользовательский сценарий целиком — от действия в интерфейсе до выполнения бизнес-логики, обращения к данным и отображения результата. Сможете разделять ответственность между UI, Application и Infrastructure так, чтобы форма и технические детали не управляли логикой приложения.
Что изучим:
- акторы, их цели и пользовательские сценарии;
- отличие технического события от Use Case;
- UI, Application, Domain и Infrastructure;
- Controller, Request и Input Boundary;
- Use Case и исходящие порты;
- Gateway и инфраструктурные адаптеры;
- Output Boundary;
- Presenter, ViewModel и View;
- направление управления и направление зависимостей;
- полный стек вызовов от действия до результата.
Ваш результат после модуля:
У вас будет спроектирован полный стек вызовов для самостоятельного Use Case: Controller, Request, Input Boundary, прикладной сценарий, исходящие порты, инфраструктурные адаптеры, Presenter и ViewModel. Для каждого элемента вы определите его ответственность, входные и выходные данные, а также правильное направление управления и зависимостей.
3. Domain и DDD: бизнес-правила внутри модели
Научитесь находить настоящие бизнес-правила и отделять их от интерфейса, сценариев приложения и технических деталей. Сможете собирать доменную модель так, чтобы она не просто хранила данные, а сама защищала важные ограничения и не позволяла системе переходить в некорректное состояние.
Что изучим:
- отличие Domain от UI, Application и Infrastructure;
- единый язык предметной области;
- Entity и идентичность;
- Value Objects, неизменяемость и инкапсуляция;
- бизнес-инварианты;
- Aggregate и Aggregate Root;
- граница согласованности;
- Repository;
- различия между Use Case, Application Service и доменной операцией;
- Domain Service;
- bounded context и локальный язык контекста;
- связь DDD и Clean Architecture.
Ваш результат после модуля:
У вас будет спроектирована доменная модель выбранного сценария: Entity, Value Objects, Aggregate, Aggregate Root и граница согласованности. Вы сформулируете бизнес-инварианты, определите, где должно находиться каждое правило, и разделите ответственность между Use Case, Domain Service и самой доменной моделью.
4. Как сохранить архитектуру при росте системы
Научитесь выстраивать архитектурные границы между модулями: контролировать допустимые зависимости, защищать внутренние части модулей и не допускать циклических связей. Сможете организовать взаимодействие между bounded contexts так, чтобы они не проникали во внутренние модели друг друга и были связаны через понятные контракты.
Что изучим:
Физическая защита архитектурных границ:
- отличие папки и логического слоя от физической границы;
- пространства имён, сборки и ссылки между ними;
- допустимый граф зависимостей;
- публичная и внутренняя поверхность модуля;
- обнаружение циклических связей;
- возможности и ограничения технической защиты архитектуры.
Взаимодействие между bounded contexts:
- внутренняя модель и публичный API контекста;
- контракты взаимодействия;
- передача идентификаторов и значений вместо чужих агрегатов;
- Process Manager;
- межконтекстная координация;
Ваш результат после модуля:
У вас будет спроектирована схема взаимодействия частей системы: допустимый граф зависимостей, публичная и внутренняя поверхность модулей, а также контракты между bounded contexts. Вы сможете находить циклические связи, закрывать внутреннюю модель контекста, передавать между частями системы только необходимые данные и технически предотвращать часть архитектурных нарушений.
5. Применение Clean Architecture и DDD в 1С
Перенесёте изученные принципы в реальную разработку на 1С и разберётесь, как применять их с учётом возможностей и ограничений платформы. Научитесь сохранять архитектурный смысл, не пытаясь механически повторить структуру C#, и выбирать практичные способы организации границ, зависимостей и бизнес-логики.
Что изучим:
- как перенести архитектурные решения в ограничения 1С;
- как защищать инварианты и использовать Value Objects;
- как реализовать интерфейсы, Ports и Adapters;
- чем приблизить Bootstrap и Composition Root;
- как обозначать границы через модули, подсистемы, расширения и префиксы;
- как разделять Domain Model и Persistence Model;
- как отделять форму от модели хранения;
Ваш результат после модуля:
У вас будет спроектирован практический вариант архитектуры для 1С: разделение формы, прикладного сценария, доменной логики и хранения данных, явная композиция зависимостей, Ports и Adapters, а также обозначенные границы модулей и подсистем. Вы поймёте, какие решения можно закрепить средствами платформы.
6. Итоговая работа: полноценная подсистема в 1С
Самостоятельно пройдёте весь путь проектирования и реализации новой подсистемы в 1С — от бизнес-задачи и пользовательских сценариев до рабочего кода и интеграции с типовым решением. Научитесь создавать новые части системы так, чтобы они сохраняли собственные архитектурные границы и не растворялись в legacy-коде существующей конфигурации.
Что изучим:
- определите бизнес-задачу, акторов и ключевые Use Cases подсистемы;
- самостоятельно спроектируете её архитектуру;
- реализуете полный сценарий — от пользовательского действия до бизнес-логики и работы с данными;
- разделите ответственность между слоями и выстроите корректные зависимости;
- выделите Entity, Value Objects, Aggregates и бизнес-инварианты;
- организуете взаимодействие через Ports и Adapters;
- интегрируете новую подсистему с типовым решением, не связывая её напрямую с legacy-кодом;
- предусмотрите ограничения платформы 1С и способы их компенсации;
- проведёте взаимное код-ревью и разберёте архитектурные решения друг друга;
Ваш результат после модуля:
У вас будет полностью спроектированная и реализованная подсистема в 1С с реальной бизнес-логикой, выделенными Use Cases, слоями, зависимостями, Entity, Value Objects, агрегатами, Ports и Adapters. Вы интегрируете её с типовым решением, проведёте взаимное код-ревью, доработаете архитектуру по обратной связи и сможете обосновать каждое ключевое решение.
Бонусы:
- Подробный разбор конфигурации JWT
Показываю, какие слои в ней выделены, где проходят границы ответственности, как устроены сценарии и контроллеры, как организована работа с ошибками и исключениями и какие архитектурные принципы заложены в проект. - Практикум «Как в 1С написать 100 юнит-тестов за час без страданий и слёз»
Разберётесь, как ускорить написание тестов и встроить тестирование в реальную работу, не превращая его в отдельный бесконечный проект. - Шесть дополнительных модулей по разработке игры на Unity
Получите доступ к отдельным блокам программы, которые сможете пройти самостоятельно. В них вы увидите, как изученные архитектурные принципы применяются при разработке полноценного проекта на другом стеке.
Автор Евгений Шилов
- Основатель Clean Games School
- 1С-разработка с 2006 года, практикующий архитектор
- Преподавал в Skillbox, GeekBrains и Нетологии
- Обучил 600+ опытных 1С-разработчиков
- Коммерческие проекты на C# (игры)
Тариф Самостоятельно
- Все модули программы
- 2 живые встречи с Шиловым с разборами ошибок
- 1 групповой хакатон по решению задачи
- Код-ревью итоговой работы от одногруппников
Старт 24 августа
Цену установит организатор
