Как собрать решение visual studio

Visual Studio: Build, Rebuild, Clean and Batch Build

In this blog post we will look into the build configuration of our project or solution in Visual Studio application.

Visual Studio Logo

Build Configuration

The build solution will always perform an incremental build i.e. it will only build those files (dll and .exe) which have changed.

When we develop our .NET application in Visual Studio we see following build configuration:

Debug
Release Now, if we look into more details.

Debug

Debug mode allows developer to break the execution of program and step through the code. Compiled code dll in debug is not optimized. Therefore, size of dll file in debug mode is comparatively larger than release mode. Some additional instructions are added to enable the developer to set a breakpoint on every source code line like «symbolic information». For example, adding following code block will only execute in debug and in release mode this code block will get ignored.

Exit fullscreen mode

Release

This mode is for final deployment of the source code on production server. Release mode dll file contains optimized code, and it is generated for end user. Debugging symbol information is also gets omitted from the dll file in this mode.

Solution Structure

Rebuild Solution

Rebuild solution will delete all the files (dll and .exe) or «bin and obj» and perform build from scratch irrespective of whether the files are modified or not. Please note that «Rebuild» will clean then build each project, one at a time, rather than cleaning all and then building all projects.

Clean Solution

The clean solution will delete all the compiled files (dll and .exe) from «bin and obj» directories. You may notice that not all of the files are actually removed from the project folder. This might happen because clean only removes files that are associated with a build and not everything else.

Build vs. Rebuild vs. Clean

The difference lies in what happens in each build configuration
for every projects.

For example, if the solution has two projects: Project A & Project B and you perform rebuild operation, it will take Project A, clean the compiled files for Project A, and build it. After that, it will take Project B, clean the files for Project B, and build it.

On the other hand, if you do a clean and then build separately, it will first clean all compiled files (dlls and .exe) for both the projects – Project A & Project B and then it will build Project A first then Project B.

Batch Build

When we build our project our project in visual studio we can only build it into one configuration mode at a time like Debug or Release etc. So, if we want to build our project into multiple configuration i.e. Debug and Release or build the project for multiple platforms, such as x86 and x64, all at once at the same time then we can do that with Batch Build operation. Batch build allows you to build multiple configurations with a single command instead of building them individually.

To perform a batch build, you can go to the «Build» menu, select «Batch Build,» and then select the configurations and platforms that you want to build.

Concluiton

In summary, it is important to keep in mind that what happens in each build configuration in Visual Studio and based on our requirement we can select how our project or solution can be build.

Как собрать проект в Visual Studio 2022 и получить единый exe файл?

Visual Studio 2022 — это развитая среда разработки программного обеспечения, которая была выпущена в 2021 году. В этой среде разработки можно создавать проекты на разных языках программирования, таких как C++, C#, F# и многих других. После написания и тестирования кода, важным этапом является сборка приложения в единый exe файл. Рассмотрим, как это сделать.

Шаг 1: Открыть решение в Visual Studio

Первым шагом является открытие решения в Visual Studio 2022. Для этого запустите Visual Studio и выберите "Открыть проект или решение" в меню Файл. Затем найдите решение, которое нужно собрать в единый exe файл, и выберите его.

Шаг 2: Выбрать конфигурацию сборки

Далее нужно выбрать конфигурацию сборки. Конфигурация сборки определяет параметры компилятора, которые будут использоваться при сборке проекта. Если вы создаете проект в Visual Studio в первый раз, то стандартными настройками являются "Отладка" и "Релиз". Для выбора нужной конфигурации откройте выпадающий список на панели инструментов и выберите нужный вариант.

Шаг 3: Собрать проект

После выбора конфигурации сборки, проект можно собрать. Для этого выберите "Сборка" в меню "Сборка" на панели инструментов. Если сборка проекта пройдет успешно, то вы получите два файла: .exe и .pdb.

Шаг 4: Объединить .exe файлы в единый файл

Получение единого .exe файла может быть необходимым для удобства использования, например, для того, чтобы разместить приложение в интернете или чтобы запустить его с помощью скрипта на другом компьютере. Чтобы объединить .exe файлы, нужно использовать утилиту ILMerge. ILMerge — это утилита, которая может объединять несколько .exe файлов в один.

Скачайте утилиту ILMerge с помощью менеджера пакетов NuGet (Установить-Package ilmerge в окне консоли NuGet).

Запустите утилиту ILMerge через командную строку, указав параметры:

/target:winexe — указывает, что в результирующем файле будет использоваться подсистема Windows GUI.
/out:Merged.exe — задает имя результирующего файла.
Project.exe, ReferencedLibrary.dll — это имена файлов, которые нужно объединить.

Шаг 5: Запустить единый .exe файл

После объединения всех .exe файлов в один, вы получите единый .exe файл, который можно запустить на любом компьютере без установки каких-либо дополнительных компонентов.

Вывод

Сборка проекта и получение единого .exe файла в Visual Studio 2022 достаточно простые процессы. Следуя описанным выше шагам, разработчик может успешно собрать проект и получить единый .exe файл, который можно запустить на любом компьютере.

Настраиваем удобную сборку проектов в Visual Studio

Эта статья является руководством по настройке сборки C++ проектов Visual Studio. Частично она сводилась из материалов разрозненных статей на эту тему, частично является результатом реверс-инжениринга стандартных конфигурационных файлов Студии. Я написал ее в основном потому что полезность документации от самой Microsoft на эту тему стремится к нулю и мне хотелось иметь под рукой удобный референс к которому в дальнейшем можно будет обращаться и отсылать других разработчиков. Visual Studio имеет удобные и широкие возможности для настройки по-настоящему удобной работы со сложными проектами и мне досадно видеть что из-за отвратительной документации эти возможности очень редко сейчас используются.

В качестве примера попробуем сделать так чтобы в Студию можно было добавлять flatbuffer schema, а Студия автоматически вызывала flatc в тех случаях когда это нужно (и не вызывала — когда изменений не было) и позволяла задавать настройки напрямую через File Properties

ЗАМЕЧАНИЕ: все приведенные в статье примеры проверялись в VS 2017. В рамках моего понимания они должны работать и в более ранних версиях студии начиная по крайней мере с VS 2012, но обещать я этого не могу.

Level 1: лезем внутрь .vcxproj файлов

Давайте взглянем внутрь типичного .vcxproj автоматически сгенеренного Visual Studio.

Довольно нечитаемое месиво, не правда ли? И это ведь еще очень небольшой и практически тривиальный файл. Попробуем превратить его во что-то более читабельное и удобное для восприятия.

Поговорим о .props файлах

Для этого обратим пока внимание на то что взятый нами файл — это обычный XML-документ и его можно логически разделить на две части, в первой из которых перечисляются настройки проекта, а во второй — входящие в него файлы. Давайте эти половинки разделим физически. Для этого нам понадобится уже встречающийся в коде тэг Import который является аналогом сишного #include и позволяет включить один файл в другой. Скопируем наш .vcxproj в какой-нибудь другой файл и уберем из него все объявления относящиеся к файлам входящим в проект, а из .vcxproj-а в свою очередь наоборот уберем все кроме объявлений относящихся к файлам собственно входящим в проект. Получившийся у нас файл с настройками проекта но без файлов в Visual Studio принято называть Property Sheets и сохранять с расширением .props. В свою очередь в .vcxproj мы поставим соответствующий Import

Его можно упростить еще больше, убрав лишние XML-элементы. К примеру свойство «PrecompiledHeader» объявляется сейчас 4 раза для разных вариантов конфигурации (release / debug) и платформы (win32 / x64) но каждый раз это объявление одно и то же. Кроме того у нас здесь используется несколько разных ItemGroup тогда как в реальности вполне достаточно одного элемента. В результате приходим к компактному и понятному .vcxproj который просто перечисляет 1) входящие в проект файлы, 2) то чем является каждый из них (плюс настройки специфичные для конкретных отдельных файлов) и 3) содержит в себе ссылку на хранящиеся отдельно настройки проекта.

Перезагружаем проект в студии, проверяем сборку — все работает.

Но зачем вообще разделять .vcxproj и .props?

Поскольку в сборке ничего не поменялось, то на первый взгляд может показаться что мы поменяли шило на мыло, сделав бессмысленный «рефакторинг» файла в который нам до этого собственно и не было никакой нужды заглядывать. Однако допустим на минутку что в наш solution входит более одного проекта. Тогда, как несложно заметить, несколько разных .vcxproj-файлов от разных проектов могут использовать один и тот же .props файл с настройками. Мы отделили правила сборки используемые в solution от исходного кода и можем теперь менять настройки сборки для всех однотипных проектов в одном месте. В подавляющем большинстве случаев подобная унификация сборки — это хорошая идея. К примеру добавляя в solution новый проект мы в одно действие тривиально перенесем в него подобным образом все настройки из уже существующих в solution проектов.

Но что если нам все же нужны разные настройки для разных проектов? В этом случае мы можем просто создать несколько разных .props-файлов для разных типов проектов. Поскольку .props-файлы могут совершенно аналогичным образом Import-ить другие .props-файлы, то довольно легко и естественно можно выстроить «иерархию» из нескольких .props-файлов, от файлов описывающих общие настройки для всех проектов в solution до узкоспециализированных версий задающих специальные правила для всего одного-двух проектов в solution. В MSBuild действует правило что если одна и та же настройка объявляется во входном файле дважды (скажем вначале импортится в base.props а затем объявляется повторно в derived.props который import-ит в своем начале base.props) то более позднее объявление перекрывает более раннее. Это позволяет легко и удобно задавать произвольные иерархии настроек просто перекрывая в каждом .props файле все необходимые для данного .props-а настройки не заботясь о том что они могли быть где-то уже объявлены ранее. В числе прочего где-нибудь в .props-ах разумно импортировать стандартные настройки окружения Студии которые для C++-проекта будут выгледеть вот так:

Отмечу что на практике весьма удобно класть собственные .props файлы в ту же папку что и .sln файл

Делаем настройку проекта читабельнее

Теперь когда нам больше не требуется возиться с каждым проектом по отдельности мы можем уделить больше внимания настройке процесса сборки. И для начала я рекомендую дать с помощью .props-файлов вменяемые имена большинству интересных объектов в файловой системе относящихся к solution. Для этого нам следует создать тэг PropertyGroup с пометкой UserMacros:

Тогда в настройках проектов вместо конструкций вида «..\..\..\ThirdParty\protobuf\src\protoc.exe» мы сможем написать просто «$(ProtoBufRoot)\protoc.exe». Помимо большей читабельности это делает код намного мобильнее — мы можем свободно перемещать .vcxproj не боясь что у него слетят настройки и можем перемещать (или обновлять) Protobuf изменив всего одну строчку в одном из .props файлов.

При последовательном объявлении нескольких PropertyGroups их содержимое будет объединено — перезапишутся только макросы имена которых совпадают с ранее объявлявшимися. Это позволяет легко дополнять объявления во вложенных .props файлах не боясь потерять макросы уже объявленные ранее.

Делаем удобным подключение сторонних библиотек

Обычный процесс включения зависимости от thirdparty-библиотеки в Visual Studio частенько выглядит примерно вот так:

Процесс соответствующей настройки включает в себя редактирование сразу нескольких параметров находящихся на разных вкладках настроек проекта и потому довольно зануден. Вдобавок его обычно приходится проделывать по нескольку раз для каждой отдельно взятой конфигурации в проекте, так что нередко в результате подобных манипуляций оказывается что проект в Release-сборке собирается, а в Debug-сборке — нет. Так что это неудобный и ненадежный подход. Но как Вы наверное уже догадываетесь, те же самые настройки можно «упаковать» в props-файл. К примеру для библиотеки ZeroMQ подобный файл может выглядеть примерно так:

Обратите внимание что если мы просто определим тэг типа AdditionalLibraryDirectories в props-файле, то он перекроет все более ранние определения. Поэтому здесь используется чуть более сложная конструкция в которой тэг завершается последовательностью символов ;%(AdditionalLibraryDirectories) образующих ссылку тэга самого на себя. В семантике MSBuild этот макрос раскрывается в предыдущее значение тэга, так что подобная конструкция дописывает параметры в начало строки хранящейся в парамере AdditionalLibraryDirectories.

Для подключения ZeroMQ теперь достаточно просто импортировать данный .props файл.

И на этом манипуляции с проектом заканчиваются — MSBuild автоматически подключит необходимые заголовочные файлы и библиотеки и в Release и в Debug сборках. Таким образом потратив немного времени на написание zeromq.props мы получаем возможность надежно и безошибочно подключать ZeroMQ к любому проекту всего в одну строчку. Создатели Студии даже предусмотрели для этого специальный GUI который называется Property Manager, так что любители мышки могут проделать ту же операцию в несколько кликов.

Правда как и остальные инструменты Студии этот GUI вместо читабельного однострочника добавит в код .vcxproj что-то вроде

Так что я предпочитаю добавлять ссылки на сторонние библиотеки в .vcxproj файлы вручную.

Аналогично тому что уже обсуждалось ранее, работа с ThirdParty-компонентами через .props файлы позволяет так же легко в дальнейшем обновлять используемые библиотеки. Достаточно отредактировать единственный файл zeromq.props — и сборка всего solution синхронно переключится на новую версию. К примеру в наших проектах сборка проекта через этот механизм увязана с менеджером зависимостей Conan который собирает необходимый набор thirdparty-библиотек по манифесту зависимостей и автоматически генерирует соответствующие .props-файлы.

Project Templates — автоматизируем создание проектов

Править вручную .vcxproj-файлы созданные Студией конечно довольно скучно (хотя при наличии навыка и недолго). Поэтому в Студии предусмотрена удобная возможность по созданию собственных шаблонов для новых проектов, которые позволяют провести ручную работу по настройке .vcxproj лишь один раз, после чего повторно использовать ее одним кликом в любом новом проекте. В простейшем случае для этого даже не надо ничего править вручную — достаточно открыть проект который нужно превратить в шаблон и выбрать в меню Project \ Export Template. В открывшемся диалоговом окне можно задать несколько тривиальных параметров вроде имени для шаблона или строки которая будет показываться в его описании, а так же выбрать, будет ли вновь созданный шаблон сразу добавлен в диалоговое окно «New Project». Созданный таким способом шаблон создает копию использованного для его создания проекта (включая все файлы входящие в проект), заменяя в нем только имя проекта и его GUID. В довольно большом проценте случаев этого более чем достаточно.

При более детальном рассмотрении сгенерированного Студией шаблона можно легко убедиться в том что это просто zip архив в котором лежат все файлы использованные в шаблоне и один дополнительный конфигурационный файл с расширением .vstemplate. В этом файле хранится список метаданных проекта (вроде использованной иконки или строки с описанием) и список файлов которые необходимо создать при создании нового проекта. Например,

Обратите внимание на параметр ReplaceParameters=«true». В данном случае он применяется только к vcxproj-файлу который выглядит следующим образом:

На месте GUID и RootNamespace как видите стоят не конкретные значения, а «заглушки» $guid1$ и $safeprojectname$. При использовании шаблона, Студия проходит по файлам помеченным ReplaceParamters=«true», ищет в них заглушки вида $name$ и заменяет их на вычисляемые значения по специальному словарю. По умолчанию Студия поддерживает не очень много параметров, но при написании Visual Studio Extensions (о чем мы поговорим чуть позже) туда нетрудно добавить сколько угодно своих собственные параметров вычисляемых (или вводимых пользователем) при запуске диалога по созданию нового проекта из шаблона. Как можно увидеть в файле .vstemplate, тот же словарь может использоваться и для формирования имени файла что позволяет, в частности, сформировать шаблону уникальные имена .vcxproj-файлов для разных проектов. При задании ReplaceParameters=false файл указанный в шаблоне будет просто скопирован без дополнительной обработки.

Полученный ZIP-архив с шаблоном можно добавить в список шаблонов известных Студии одним из нескольких способов. Проще всего просто скопировать этот файл в папку %USERPROFILE%\Documents\Visual Studio XX\Templates\ProjectTemplates. Стоит заметить, что несмотря на то что в этой папке Вы найдете множество разных подпапок совпадающих по названиям с папками в окне создания нового проекта, по факту шаблон следует положить просто в корневую папку поскольку положение шаблона в дереве новых проектов определяется Студией из тэгов ProjectType и ProjectSubType в .vstemplate-файле. Этот способ удобнее всего подходит для создания «персональных» шаблонов уникальных только для Вас и если Вы выберете в диалоге Export Template галочку «Automatically import template into Visual Studio» то Студия именно это и сделает, поместив созданный при экспорте zip-архив в эту папку с шаблонами. Однако делиться такими шаблонами с коллегами путем их ручного копирования конечно не очень удобно. Поэтому давайте познакомимся с чуть более продвинутым вариантом — создадим Visual Studio Extension (.vsix)

Для создания VSIX нам понадобится установить опциональный компонент Студии который так и называется — средства для разработки Visual Studio Extensions:

После этого в разделе Visual C# \ Extensibility появится вариант «VSIX project». Обратите внимание, что несмотря на свое расположение (C#), он используется для создания любых расширений, в том числе и наборов шаблонов проектов на C++.

В созданном VSIX проекте можно делать массу самых разных вещей — к примеру, создать свое собственное диалоговое окно которое будет использоваться для настройки создаваемых по шаблону проектов. Но это отдельная огромная тема для обсуждения которую я не буду в этой статье затрагивать. Для создания же шаблонов в VSIX все устроено предельно просто: создаем пустой VSIX проект, открываем файл .vsixmanifest и прямо в GUI задаем все данные для проекта. Вписываем метаданные (название расширения, описание, лицензия) на вкладке Metadata. Обратите внимание на расположенное в правом верхнем углу поле «Version» — его желательно указать правильно, поскольку Студия впоследствии использует именно его для определения того какая версия расширения установлена на компьютере. Затем идем на вкладку Assets и выбираем «Add new Asset», с Type: Microsoft.VisualStudio.ProjectTemplate, Source: File on filesystem, Path: (имя к zip-архиву с шаблоном). Нажимаем OK, повторяем процесс пока не добавим в VSIX все желаемые шаблоны.

После этого остается выбрать Configuration: Release и скомандовать Build Solution. Код писать не требуется, править конфигурационные файлы вручную — тоже. На выходе получается переносимый файл с расширением .vsix, который является, по сути, инсталлятором для созданного нами расширения. Созданный файл будет «запускаться» на любом компьютере с установленной Студией, показывать диалог с описанием расширения и лицензией и предлагать установить его содержимое. Разрешив установку — получаем добавление наших шаблонов в диалоговое окно «Создать новый проект»

Подобный подход позволяет легко унифицировать работу большого количества человек над проектом. Для установки и использования шаблонов от пользователя не требуется никакой квалификации кроме пары кликов мышкой. Установленное расширение можно посмотреть (и удалить) в диалоге Tools \ Extensions and Updates

Level 2: настраиваем кастомную компиляцию

ОК, на этом этапе мы разобрались как организованы vcxproj и props файлы и научились их организовывать. Давайте теперь предположим что мы хотим добавить в наш проект парочку .proto схем для сериализации объектов на основе замечательной библиотеки Google Protocol Buffers. Напомню основную идею этой библиотеки: Вы пишите описание объекта («схему») на специальном платформонезависимом мета-языке (.proto-файл) которая компилируется специальным компилятором (protoc.exe) в набор .cpp / .cs / .py / .java / etc. файлов которые реализуют сериализацию / десериализацию объектов по этой схеме в нужном языке программирования и которые Вы можете использовать в своём проекте. Таким образом при компиляции проекта нам нужно первым делом позвать protoc который создаст для нас набор .cpp файлов которые мы в дальнейшем будем использовать.

Традиционный подход

Классическая реализация «в лоб» прямолинейна и состоит в том чтобы просто добавить вызов protoc в pre-build step для проекта которому нужны .proto-файлы. Примерно вот так:

Требуется явно указывать список обрабатываемых файлов в команде
При изменении этих файлов билд НЕ будет пересобран автоматически
При изменении ДРУГИХ файлов в проекте которые Студия распознает как исходные коды, напротив, без нужды будет выполнен pre-build step
Сгенерированные файлы не входят по умолчанию в сборку проекта
Если мы включим сгенерированные файлы в проект вручную, то проект будет выдавать ошибку когда мы его будем открывать в первый раз (поскольку файлы еще не сгенерированы первой сборкой).

Знакомимся с MSBuild targets

С точки зрения MSBuild, сборка любого проекта состоит из последовательности сборки сущностей которые называются build targets, сокращенно targets. К примеру сборка проекта может включать в себя выполнение таргета Clean который удалит оставшиеся от предыдущих билдов временные файлы, затем выполнение таргета Compile который скомпилирует проект, затем таргета Link и наконец таргета Deploy. Все эти таргеты вместе с правилами по их сборке не фиксированы заранее а определяются в самом .vcxproj файле. Если Вы знакомы с nix-овой утилитой make и Вам на ум в этот момент приходит слово «makefile», то Вы совершенно правы: .vcxproj является XML-вариацией на тему makefile.

Но стоп-стоп-стоп скажет тут сбитый с толку читатель. Как это так? Мы просмотрели до этого .vcxproj в простом проекте и там не было ни target-ов ни какого-либо сходства с классическим makefile. О каких target-ах тогда может идти речь? Оказывается что они просто «спрятаны» вот в этой строчке включающей в .vcxproj набор стандартных target-ов для сборки C++ — кода.

«Стандартный» билд-план предлагаемый Студией довольно обширен и предлагает большой набор правил для компиляции C++-кода и «стандартных» таргетов типа Build, Clean и Rebuild к которым умеет «цепляться» Студия. Этот набор часто известен под собирательным названием toolset и заменяя в импорте toolset можно заставить Студию компилировать один и тот же проект с помощью другой версии Студии или, к примеру, интеловским компилятором или Clang. Кроме того при желании от стандартного toolset-а можно вообще отказаться и написать свой собственный toolset с нуля. Но мы будем рассматривать в этой статье более простой вариант в котором мы ничего не будем заменять, а лишь дополним стандартные правила необходимыми нам дополнениями.

Список входов (inputs)
Список выходов (outputs)
Зависимости от других targets (dependencies)
Настройки target-а
Последовательность фактических шагов выполняемых target-ом (tasks)

то мы добавляем (Include) файл protobuf_tests.cpp в список входов (inputs) данного таргета, а когда пишем

то присваем значение «Use» настройке ClCompile.PrecompiledHeader которую target затем превратит в флаг /Yu переданный компилятору cl.exe.

Попробуем создать target для сборки .proto файлов

Добавление нового target-а реализуется с помощью тэга target:

Традиционно target-ы выносят в подключаемый файл с расширением .targets. Не то чтобы это было строго необходимо (и vcxproj и targets и props файлы внутри являются равнозначным XML-ем), но это стандартная схема именования и мы будем ее придерживаться. Чтобы в коде .vcxproj файла теперь можно было писать что-то вроде

созданный нами target необходимо добавить в список AvailableItemName

Нам также понадобится описать что же конкретно мы хотим сделать с нашими входными файлами и что должно получиться на выходе. Для этого в MSBuild используется сущность которая называется «task». Таска — это какое-то простое действие которое нужно сделать в ходе сборки проекта. К примеру «создать директорию», «скомпилировать файл», «запустить команду», «скопировать что-то». В нашем случае мы воспользуемся таской Exec чтобы запустить protoc.exe и таской Message чтобы отобразить этот шаг в логе компиляции. Укажем так же что запуск данного target-а следует провести сразу после стандартного таргета PrepareForBuild. В результате у нас получится примерно вот такой файлик protobuf.targets

Мы использовали здесь довольно нетривиальный оператор «%» (batching operator) который означает «для каждого элемента из списка» и автоматически добавляемые метаданные. Идея тут в следующем: когда мы записываем код вида

то мы этой записью добавляем в список с названием «ProtobufSchema» дочерний элемент «test.proto» у которого есть дочерний элемент (метадата) AdditionalData содержащая строку «Test». Если мы напишем «ProtobufSchema.AdditionalData» то мы получим доступ к записи «Test». При этом помимо явно объявленных нами метаданных AdditionalData, хитрый MSBuild ради нашего удобства автоматически добавляет к записи еще добрый десяток полезных часто используемых дочерних элементов описанных вот здесь из числа которых мы использовали Identity (исходная строка), Filename (имя файла без расширения) и FullPath (полный путь к файлу). Запись же со знаком % заставляет MSBuild применить описанную нами операцию к каждому элементу из списка — т.е. к каждому .proto файлу по отдельности.

в protobuf.props, переписываем наши proto-файлы в .vcxproj-е на тэг ProtobufSchema

и проверяем сборку

1>—— Rebuild All started: Project: protobuf_test, Configuration: Debug x64 ——
1>Compiling schema test.proto
1>Compiling schema test2.proto
1>pch.cpp
1>protobuf_test.cpp
1>protobuf_test.vcxproj -> S:\Temp\msbuild\protobuf_msbuild_integration\x64\Debug\protobuf_test.exe
========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

Ура! Заработало! Правда наши .proto файлы теперь стали не видны в проекте. Лезем в .vcxproj.filters и вписываем там по аналогии

Перезагружаем проект — файлы снова видны.

Доводим наш модельный пример до ума

Впрочем на самом деле я немного схитрил. Если не создать вручную перед началом билда папку generated, то билд на самом деле падает

1>. \protobuf_test\protobuf.targets(13,6): error MSB3073: The command «. \ThirdParty\protobuf\bin\protoc.exe —cpp_out=.\generated test.proto» exited with code 1.

Чтобы это исправить добавим вспомогательный target который создаст необходимую папку

С помощью свойства DependsOnTargets мы указываем что перед тем как запускать любую из задач GenerateProtobuf следует запустить PrepareToGenerateProtobuf, а запись @(ProtobufSchema) ссылается на список ProtobufSchema целиком, как единую сущность используемую как вход для этой задачи, так что запущена она будет лишь один раз.

Перезапускам сборку — работает! Давайте попробуем сделать теперь еще раз Rebuild, чтобы уж на этот раз точно во всем убедиться

1>—— Rebuild All started: Project: protobuf_test, Configuration: Debug x64 ——
1>pch.cpp
1>protobuf_test.cpp
1>protobuf_test.vcxproj -> S:\Temp\msbuild\protobuf_msbuild_integration\x64\Debug\protobuf_test.exe
========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

Эм, а куда же пропали наши новые таски? Небольшая отладка — и мы видим что таски на самом деле запускаются MSBuild, но не выполняются поскольку в указанной нами выходной папке уже есть сгенерированные файлы. Проще говоря в Rebuild у нас не работает Clean для .\generated файлов. Исправим это, добавив еще один таргет

Проверяем — работает. Clean очищает созданные нами файлы, Rebuild пересоздает их заново, повторный вызов Build не запускает без нужды пересборку еще раз.

========== Build: 0 succeeded, 0 failed, 1 up-to-date, 0 skipped ==========

Вносим правку в один из C++ файлов, пробуем сделать Build еще раз

1>—— Build started: Project: protobuf_test, Configuration: Debug x64 ——
1>protobuf_test.cpp
1>protobuf_test.vcxproj -> S:\Temp\msbuild\protobuf_msbuild_integration\x64\Debug\protobuf_test.exe
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

.proto-файл не менялся, поэтому protoc не перезапускался, все ожидаемо. Пробуем теперь изменить .proto файл.

========== Build: 0 succeeded, 0 failed, 1 up-to-date, 0 skipped ==========

Интересно что если запустить сборку MSBuild через командную строку вручную, а не через UI из Студии то такой проблемы не будет — MSBuild корректно пересоберет необходимые .pp.cc файлы. Если мы поменяем какой-нибудь .cpp то запустившийся в студии MSBuild пересоберет не только его, но и .props файл который мы меняли раньше

1>—— Build started: Project: protobuf_test, Configuration: Debug x64 ——
1>Compiling schema test.proto
1>protobuf_test.cpp
1>protobuf_test.vcxproj -> S:\Temp\msbuild\protobuf_msbuild_integration\x64\Debug\protobuf_test.exe
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

U2DCheck и tlog файлы

Оказывается что создатели Visual Studio посчитали что вызывать MSBuild на каждый чих слишком накладно и… реализовали собственную «быструю проверку» на то нужно ли собирать проект или нет. Она называется U2DCheck и если по ее мнению проект не менялся, то Студия просто не станет запускать MSBuild для этого проекта. Обычно U2DCheck работает настолько «тихо» что про ее существование мало кто догадывается но в реестре можно включить полезный флажок который заставит U2DCheck выводить более подробные отчеты.

В своей работе U2DCheck опирается на специальные .tlog файлы. Их легко можно найти в intermediate-output папке (имя_проекта).tlog и чтобы U2DCheck корректно реагировал на изменения в исходных файлах нам надо сделать в этой папке запись в один из read tlog — файлов, а чтобы U2DCheck корректно реагировал на удаление выходных файлов — запись в одном из write tlog — файлов.

Чертыхнувшись, возвращаемся к соответствующей правке нашего target-а

Проверяем — работает: правка .props файла триггерит необходимый ребилд, сборка в отсутствие правки показывает что проект up-to-date. В данном примере для простоты я не стал писать write tlog отслеживающий удаление созданных при компиляции файлов, но он добавляется в target аналогичным образом.

Начиная с Visual Studio 2017 update 15.8 в MSBuild была добавлена новая стандартная таска GetOutOfDateItems которая автоматизирует эту черную магию, но поскольку это произошло совсем недавно то практически все кастомные .target-ы продолжают работать с .tlog файлами вручную.

При желании можно так же полностью отключить U2DCheck для любого проекта добавив одну строчку в поле ProjectCapability

Однако в этом случае Студия будет гонять MSBuild для этого проекта и всех зависящих от него при каждой сборке и да, U2DCheck добавляли не просто так — это работает не так быстро как мне хотелось бы.

Финализуем наш кастомный .target

Получившийся у нас результат вполне работоспособен, но его есть еще куда совершенствовать. К примеру в MSBuild существует режим «выборочной сборки» когда в командной строке указывается что требуется собрать не весь проект в целом, а лишь отдельные конкретно выбранные в нем файлы. Поддержка этого режима требует чтобы таргет проверял содержимое списка @(SelectedFiles).

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

Наконец мы все еще не реализовали обещанную в самом начале задумку — автоматическое включение сгенерированных файлов в проект. Мы уже можем #include-ить сгенерированные protobuf-ом заголовочные файлы зная что они будут автоматически созданы до того как дело дойдет до компиляции, но с линковщиком этот номер не проходит :). Поэтому просто дописываем сгенерированные файлы в список ClCompile.

Общие настройки здесь были вынесены в PropertyGroup, а списки входных и выходных файлов заполняет новый target ComputeProtobufInput. Попутно (чтобы продемонстрировать работу со списками выходных файлов) была добавлена генерация кода из схемы для интеграции с python. Запускаем и проверяем что все работает правильно

А что насчет CustomBuildStep?

Надо сказать что разработчики из Майкрософт вполне здраво оценивали что все вышеописанное, хм, несколько нетривиально и плохо задокументировано и попытались облегчить жизнь программистов введя специальный таргет CustomBuildStep. В рамках этой концепции мы должны были бы в настройках файла отметить что наши .props файлы относятся к типу Custom Build Step

Затем следовало бы указать необходимые шаги по сборке во вкладке Custom Build Step

В .vcxproj-е это выглядит примерно вот так

Эта конструкция работает за счет того что введенные таким образом данные подставляются в недрах Microsoft.CppCommon.targets в специальный таргет CustomBuildStep который делает, в общем-то, все то же самое что я описал выше. Но работает все через GUI и не надо задумываться о реализации clean и tlog-ах :). При желании этот механизм вполне можно использовать, но я бы не рекомендовал этого делать в силу следующих соображений:

CustomBuildStep может быть только один на весь проект

Соответственно так обработать можно лишь 1 тип файлов на весь проект
Включать такой step в .props файл используемый для подключения ThirdParty библиотеки нецелесообразно, т.к. разные библиотеки могут его перекрывать друг у друга

Правильное копирование файлов

Очень часто встречающейся разновидностью build target является копирование каких-нибудь файлов из одного места в другое. Например копирование файлов ресурсов в папку с собранным проектом или копирование thirdparty DLL к собранному бинарнику. И очень часто эту операцию реализуют «в лоб» через запуск консольной утилиты xcopy в Post-Build Targets. К примеру,

Так делать не надо по тем же самым причинам по которым не надо пытаться запихивать в Post-build steps другие build targets. Вместо этого мы можем напрямую указать Студии что ей необходимо скопировать тот или иной файл. К примеру если файл напрямую входит в проект, то ему достаточно указать ItemType=Copy

После нажатия кнопки apply появится дополнительная вкладка на которой можно настроить куда и как следует копировать выбранный файл. В коде .vcxproj-файла это будет выглядеть примерно так:

Всё заработает «из коробки», включая правильную поддержку tlog-файлов. Внутри это реализовано по все тому же принципу «специальной стандартной таски для копирования файлов» что и Custom Build Step которую я критиковал буквально в предыдущем разделе, но поскольку копирование файлов — довольно тривиальная операция и мы не переопределяем саму операцию (копирование) а лишь меняем список входных и выходных файлов для нее то работает это неплохо.

Замечу что при формировании списков файлов CopyFileToFolder можно использовать wildcards. К примеру

Добавление файлов в список CopyFileToFolders — пожалуй самый простой способ реализовать копирование при сборке проекта, в том числе в .props-файлах подключающих thirdparty-библиотеки. Однако если хочется получить больше контроля над происходящим, то еще одним вариантом является добавление в свои build target специализированной таски Copy. К примеру

R сожалению таска Copy не поддерживает wildcards и не заполняет .tlog файлы. При желании это можно реализовать вручную,

Однако работа с стандартным CopyFileToFolders обычно будет намного проще.

Level 3: интегрируемся с GUI от Visual Studio

Все то чем мы до сих пор занимались со стороны может показаться довольно унылой попыткой реализовать в не слишком подходящем для этого инструменте функциональность нормального make. Ручная правка XML-файлов, неочевидные конструкции для решения простых задач, костыльные tlog-файлы… Однако у билд-системы Студии есть и плюсы — к примеру после первоначальной настройки она обеспечивает получившимуся билд-плану неплохой графический интерфейс. Для его реализации используется тэг PropertyPageSchema о котором мы сейчас и поговорим.

Вытаскиваем настройки из недр .vcxproj в Configuration Properties

Давайте попробуем сделать так чтобы мы могли бы редактировать свойство $(ProtobufOutputFolder) из «причесанной реализации protobuf.targets» не вручную в файле, а с комфортом прямо из IDE. Для этого нам потребуется написать специальный XAML-файл с описанием настроек. Открываем текстовый редактор и создаем файл с названием, к примеру, custom_settings.xml

Помимо собственно тэга StringProperty который указывает Студии на существование настройки «ProtobufOutputFolder» с типом String и Subtype=Folder и объясняет то как ее следует показывать в GUI, данный XML-ник указывает что хранить эту информацию следует в project file. Помимо ProjectFile можно использовать еще UserFile — тогда данные будут записаны в отдельный файлик .vcxproj.user который по задумке создателей Студии предназначается для приватных (не сохраняемых в VCS) настроек. Подключаем описанную нами схему к проекту, дописав в наш protobuf.targets тэг PropertyPageSchema

Для того чтобы наши правки вступили в силу перезапускаем Студию, загружаем наш проект, открываем project properties и видим…

Да! Появилась наша страничка с нашей настройкой и ее значение по умолчанию было верно прочитано Студией. Пробуем ее изменить, сохраняем проект, смотрим .vcxproj…

Как можно видеть по традиционному условию Condition, по умолчанию настройки ассоциированы с конкретной конфигурацией билда. Но при желании это можно перекрыть с помощью установки флага DataSource HasConfigurationCondition=«false». Правда в 2017 студии присутствует баг из-за которого настройки проекта могут не показываться если среди них нет хотя бы одной настройки ассоциированной с какой-то конфигурацией. К счастью эта настройка может быть невидимой.

<?xml version=»1.0″ encoding=»utf-8″?>
<Rule.DataSource>
/>
</Rule.DataSource>
<StringProperty Name=»ProtobufOutputFolder»
DisplayName=»Protobuf Output Directory»
Description=»Directory where Protobuf generated files are created.»
Subtype=»folder»>
<StringProperty.DataSource>
/>
</StringProperty.DataSource>

Настроек можно добавлять сколько угодно. Возможные типы включают BoolProperty, StringProperty (с опциональными подтипами «folder» и «file»), StringListProperty, IntProperty, EnumProperty и DynamicEnumProperty причем последний может заполняться на лету из любого списка доступного в .vcxproj. Подробнее об этом можно почитать здесь. Можно так же группировать настройки в разделы. Попробуем к примеру добавить еще одну настройку типа Bool

Редактируем настройку, сохраняем проект — все работает как ожидалось

Объясняем Студии про новые типы файлов

До сих пор чтобы добавить в проект protobuf-файл нам необходимо было вручную прописывать в .vcxproj что это . Это легко исправить дописав к упомянутому выше .xml три тэга

Перезапускаем студию, смотрим свойства у наших .proto файлов

Как легко видеть файлы теперь верно распознаются как «Google Protobuf Schema». К сожалению соответствующий пункт не добавляется автоматически в диалог «Add new item», но если мы добавим в проект уже существующий .proto-файл (контекстное меню проекта \ Add \ Existing item… ) то он распознается и добавится правильно. Кроме того наш новый «тип файлов» можно будет выбрать в выпадающем списке Item type:

Ассоциируем настройки с индивидуальными файлами

Помимо настроек «для проекта в целом» совершенно аналогичным образом можно сделать «настройки для отдельного файла». Достаточно указать в тэге DataSource аттрибут ItemType.

Сохраняем, смотрим содержимое .vcxproj

Все работает как ожидалось.

Level 4: расширяем функциональность MSBuild

У меня никогда не возникало необходимости залезать в процесс сборки настолько глубоко, но раз уж статья так и так получилась немаленькой, то коротенько упомяну о последней возможности для кастомизации: расширение самого MSBuild. Помимо довольно обширной коллекции «стандартных» тасков, в MSBuild таски можно «импортировать» из разных источников с помощью тэга UsingTask. К примеру мы можем написать свое расширение для MSBuild, скомпилировать его в DLL-библиотеку и импортировать как-то вот так:

Именно так реализовано большинство «стандартных» тасков предоставляемых Студией. Но таскать с собою кастомную DLL для сборки по очевидным причинам частенько неудобно. Поэтому в тэге UsingTask поддерживается штука которая называется TaskFactory. TaskFactory можно считать «компилятором для task-ов» — мы передаем ей на вход некий исходный «мета-код», а она по нему генерирует реализующий его объект типа Task. К примеру с помощью CodeTaskFactory можно воткнуть код написанной на C# таски прямо внутрь .props-файла.

Если кто-то подобной функциональностью пользовался — отпишитесь об интересных use-case в комментариях.

На этом всё. Надеюсь что мне удалось показать как при настройке MSBuild работу с крупным проектом в Visual Studio можно сделать простой и удобной. Если Вы соберетесь внедрять у себя что-то из описанного выше, то дам небольшой совет: для отладки .props, .targets и .vcxproj удобно выставить MSBuild «отладочный» уровень логгирования в котором он весьма подробно пошагово расписывает свои действия с входными и выходными файлами

Спасибо всем кто дочитал до конца, надеюсь что получилось интересно :).

Делитесь своими рецептами для msbuild в комментариях — я постараюсь обновлять пост чтобы он служил исчерпывающим гайдом по конфигурированию solution в Студии.

Что значит собрать решение в Visual Studio?

Visual Studio — это интегрированная среда разработки (IDE) от компании Microsoft, предназначенная для разработки программного обеспечения. Одной из важных функций Visual Studio является возможность сборки проектов в решение. Сборка — это процесс преобразования исходного кода в исполняемый файл, посредством компиляции, линковки и других операций.

Решение (Solution) в Visual Studio представляет собой контейнер, который объединяет один или несколько проектов. Оно содержит все файлы и настройки, необходимые для разработки программы. Внутри решения может быть несколько проектов, которые могут быть связаны между собой. Каждый проект может быть скомпилирован отдельно или включен в общую сборку решения.

Сборка решения в Visual Studio включает в себя проверку синтаксиса, компиляцию исходного кода, линковку объектных файлов и создание исполняемого файла или библиотеки. В процессе сборки Visual Studio выполняет множество действий в соответствии с настройками проекта. Если есть ошибки в коде, они обнаруживаются во время сборки и отображаются в окне «Ошибки».

Сборка решения в Visual Studio позволяет создать готовое программное решение, которое может быть запущено и использовано на целевом устройстве или передано другим разработчикам для дальнейшей работы.

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

Установка Visual Studio

Перед тем, как начать сборку решения в Visual Studio, необходимо установить саму среду разработки. Вот пошаговая инструкция по установке Visual Studio:

Скачайте установочный файл Visual Studio с официального сайта разработчика.
Запустите установочный файл и следуйте инструкциям мастера установки.
Выберите необходимые компоненты, которые будут установлены вместе с Visual Studio. Например, можно выбрать определенные языковые пакеты, дополнительные инструменты для разработки, расширения и т. д.
Выберите путь установки и настройте параметры установки, если это необходимо.
Дождитесь завершения процесса установки.

После установки Visual Studio вы можете запускать среду разработки и начинать работу над своим проектом.

Создание нового проекта

Visual Studio предоставляет удобную среду разработки для создания различных типов проектов. При создании нового проекта необходимо выполнить следующие шаги:

Откройте Visual Studio.
Выберите в меню «Файл» пункт «Создать» и затем выберите тип проекта, который хотите создать.
В открывшемся окне «Создание проекта» выберите настройки для вашего проекта, такие как язык программирования, платформу и шаблон проекта.
Назовите свой проект и выберите место для сохранения проекта на вашем компьютере.
Нажмите кнопку «Создать», чтобы создать проект.

После создания проекта вы увидите окно Visual Studio с открытым проектом. В этом окне вы можете добавлять и редактировать файлы проекта, настраивать настройки проекта, добавлять ссылки на другие библиотеки и многое другое.

Кроме того, в Visual Studio есть возможность управления версиями кода с использованием системы контроля версий, такой как Git. Вы можете создать репозиторий для вашего проекта и синхронизировать его с удаленным хранилищем, чтобы иметь возможность отслеживать изменения и совместно работать с другими разработчиками.

Добавление файлов в проект

При разработке программного решения в Visual Studio важно правильно организовать структуру проекта и добавлять необходимые файлы. Проект в Visual Studio представляет собой набор файлов и папок, которые связаны между собой.

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

Откройте проект в Visual Studio.
Щелкните правой кнопкой мыши на папке в Солюшен эксплорере, в которую вы хотите добавить файл.
В контекстном меню выберите пункт «Добавить», а затем «Существующий элемент».
В открывшемся диалоговом окне выберите нужный файл и нажмите кнопку «Добавить».

Также можно добавить файлы через интерфейс Visual Studio с помощью команды «Добавить новый элемент». Для этого выполните следующие действия:

Откройте проект в Visual Studio.
Щелкните правой кнопкой мыши на папке в Солюшен эксплорере, в которую вы хотите добавить файл.
В контекстном меню выберите пункт «Добавить», а затем «Новый элемент».
В открывшемся окне выберите тип добавляемого элемента (например, класс, форма или ресурс) и нажмите кнопку «Добавить».

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

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

Настройка компиляции и сборки

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

Компиляция

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

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

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

Сборка

Сборка — это процесс создания исполняемого файла или библиотеки, который может быть запущен или использован другими программами. Visual Studio предоставляет несколько вариантов сборки проекта.

Отладка (Debug): этот режим сборки используется во время разработки для выполнения и отладки кода. В этом режиме компилятор включает отладочную информацию в собранном файле, что позволяет использовать отладчик для поиска и исправления ошибок.

Релиз (Release): этот режим сборки используется для создания окончательной версии программы. В этом режиме компилятор оптимизирует код и исключает отладочную информацию, чтобы улучшить производительность и уменьшить размер собранного файла.

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

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

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

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

Обнаружение и исправление ошибок

При разработке программного обеспечения в Visual Studio неизбежно возникают ошибки. Ошибки могут возникать из-за неправильного синтаксиса, недостающих файлов, неправильных настроек и других причин. Они могут препятствовать компиляции и выполнению программы.

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

Одним из инструментов для обнаружения ошибок является «Подсказка IntelliSense». Этот инструмент предлагает автозаполнение кода и предлагает доступные методы, свойства и переменные, что упрощает написание кода без необходимости запоминать все функции и их имена.

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

Кроме того, в Visual Studio есть панель «Ошибка», которая отображает список всех ошибок в проекте. В этой панели вы можете увидеть описание проблемы, файл и строку, в которой возникла ошибка, и быстро перейти к месту ошибки для ее исправления.

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

В заключение, обнаружение и исправление ошибок в Visual Studio является важным этапом разработки программного обеспечения. Использование инструментов, таких как «Подсказка IntelliSense», панель «Ошибка» и отладчик, помогает обнаруживать и устранять ошибки более эффективно и повышать качество вашего кода.

Тестирование и отладка решения

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

Тестирование

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

Для создания модульных тестов вам понадобится использовать фреймворк для тестирования, такой как NUnit или Microsoft Unit Testing Framework. Вы можете создать новый проект для модульных тестов в своем решении и написать тесты, которые будут проверять правильность работы вашего кода. После запуска тестов, вы получите отчет о том, сколько тестов прошло успешно, а сколько завершилось неудачей.

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

Отладка

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

Отладчик также предоставляет ряд полезных инструментов, таких как окно «Точка останова», где вы можете увидеть все установленные точки останова и управлять ими, а также окно «Локальные переменные», где отображаются значения локальных переменных в текущем контексте выполнения.

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

Выгрузка готового решения

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

Первый способ — это использование инструментов сборки, предоставленных Visual Studio. В меню «Сборка» вы найдете опцию «Собрать решение». При выборе этой опции, Visual Studio выполнит компиляцию всех проектов в вашем решении и соберет готовые исполняемые файлы. Вы можете выбрать конфигурацию сборки, такую как «Debug» или «Release», в зависимости от ваших потребностей.

Если вы хотите передать только исполняемые файлы без исходного кода, вы можете воспользоваться опцией «Публиковать» в меню «Сборка». В результате этой операции Visual Studio соберет исполняемые файлы и все необходимые зависимости, упакует их в удобный для установки пакет и создаст инструкции по его развертыванию. Вы можете выбрать местоположение публикации и другие параметры в соответствии с вашими потребностями.

Еще один способ выгрузить готовое решение — это использование системы контроля версий, такой как Git или Subversion. Вы можете создать репозиторий для вашего проекта и слить последние изменения в основную ветку. Затем вы можете предоставить доступ к репозиторию вашим коллегам или скачать готовое решение с другого компьютера.

В зависимости от ваших потребностей и наличия различных инструментов, вы можете выбрать наиболее подходящий способ выгрузки готового решения из Visual Studio. Удостоверьтесь, что все зависимости и конфигурации включены в ваше решение, чтобы оно успешно запускалось на других компьютерах.