Команды visual studio c

Обновлено: 06.07.2024

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

Начнем с самого простого, что бывает нужно начинающему программисту:
cw + 2 раза Tab = Console.WriteLine();

Далее материалы статьи с Хабра, где-то с моими дополнениями, но в основном в чистом виде:

Комментирование

Ctrl+K,C — закомментировать выбранные линии в коде.
Ctrl+K,U — раскомментировать выбранные линии в коде.

Если перед именем метода набрать /// — автоматически будут добавлены XML комментарии, которые потом можно использовать для создания документации. Туда можно вписать название метода, описание переменных и т.п. Далее при использовании данного метода будут всплывать подсказки как раз с этой информацией.

Поиск

Ctrl+F — открывается стандартное окно поиска, если в буфер недавно было скопирован текст, то он автоматически подставиться.
Ctrl+F3 — поиск «активного» текста вниз (который выделен или слово на котором стоит курсор), без копирования в буфер обмена.
Ctrl+Shift+F3 — поиск «активного» текста вверх.
Ctrl+I — и начинаете печатать текст, этакий runtime поиск.

Вызов базового джина

Вам лень писать текст полностью?! Скорость выпадающего Intellisence не устраивает несущуюся впереди вас вашу мысль?!
Тогда самое время применить следующии комбинации:
Ctrl+Space — вызов Intellisence с показом «слов»
Ctrl+J — если вы подзабыли название метода класса или его свойсто, то эта комбинация вам поможет. Можно применять и предыдущую, но эта более «умная».
Ctrl+K, X — показ всех сниппетов, которые у вас есть, в виде выпадающего списка, использование интуитивно понятно 🙂
короткое_имя_снипета+Tab — использовать сниппет в коде.

Навигация по коду

Если обратите внимание то студия, по своей природе MDI, значит должна быть возможность перемещаться, между окнами:
Ctrl+Tab — аналог Alt+Tab в Windows, только применимо к студии.

Очень удобным инструментом в студии являются закладки, да-да, по аналогии с книжными. Можно отметить код чтобы потом перейти к нему:
Ctrl+B, T — поставить/снять закладку.
Ctrl+B, Ctrl+C — удалить все закладки.
Ctrl+B, N — перейти к следующей закладке.
Ctrl+B, P — перейти к предыдущей закладке.

Форматирование и редактирование

Многие знают и используют Ctrl+C и Ctrl+V, но студия обладает ещё рядом удобным комбинаций:
Ctrl+Shift+V — не отпуская Ctrl+Shift и нажимая на V, вы сможете вставить один из 10 последних кусков текста, скопированных в буфер обмена.
Tab — увеличить отступ.
Shift+Tab — уменьшить отступ.

Мне иногда не хватало вертикального выделения текста, бывает полезно. Оказывается и такая возможность есть! Стоит нажать Alt, и не отпуская, выделять мышкой текст. Но есть минус — меню и стрелочки клавиатуры :). Это решаемо, нажимаете Shift+Alt и используете стрелочки Left или Right

Если код доставшийся вам «грязен», не только по структуре, но и по внешнему оформлению, используйте:
Ctrl+E+D — форматирование всего документа, позволяет привести документ в более удобоваримый вид.
Ctrl+E+F — форматирование выбранной части текста

Иногда в целях рефакторинга или ещё каких-то благих начинаниях, есть смысл перевести все буквы в верхний или нижний регистр:
Ctrl+Shift+U — перевести выделенный блок в верхний регистр
Ctrl+U — перевести выделенный блок в нижний регистр

Небольшой экскурс в сборку и отладку

Конечно же со стороны хоткеев 🙂
Начнём со «сборки»:
Ctrl+Shift+B или F6 — собрать solution.
Shift+F6 — собрать активный проект.
Если честно, тут я немного пошаманил, заточив под себя, иногда бывает удобно пересобрать проект RebuildSolution, но почему-то хоткей для этого не предусмотрен, я поступил следующий образом:
F6 — собрать solution
Ctrl+Shift+B — пересобрать solution
Поступил я так из-за соображения, что иногда студия не выполняет пересборку проекта, а пишет «up-to-date», а мне нужно именно пересобрать.

Если появились ошибки, это плохо, но никто от них не застрахован:
F5 — запустить программу, с возможностью отладки. Или продолжить выполнение программы, после точки останова.
Ctrl+F5 — запустить программу без отладки
F9 — поставить/убрать точку останова — breakpoint
Ctrl+Shift+F9 — удалить все точки останова.
F10 — выполнить код, без захода внутрь
F11 — выполнить код, с заходом внутрь

В режиме отладки есть два типа просмотра — Watch и QuickWatch.
Вызвать QuickWatch вы можете нажав Ctrl+D, Q. Просто Watch — Ctrl+D, W.

Командное окно используется для выполнения команд или их псевдонимов непосредственно в интегрированной среде разработки (IDE) Visual Studio. Можно выполнять команды меню и команды, которые не отображаются в меню. Для вывода командного окна в меню Вид выберите Другие окна, а затем Командное окно.

Отображение значений переменных

Для проверки значения переменной varA используйте команду Print:

Вопросительный знак (?) является псевдонимом для команды Debug.Print , поэтому можно также написать такую команду:

Обе версии этой команды возвращают значение переменной varA .

Ввод команд

Символ "больше чем" ( > ) отображается в левой части окна командной строки для запроса новых строк. Используйте клавиши со стрелками ВВЕРХ и ВНИЗ для прокрутки ранее выполненных команд.

Задача	Решение	Пример
Вычисление выражения	Установите перед выражением знак вопроса ( ? ).	? myvar
Переключение в окно интерпретации	Введите в окне immed без знака "больше чем" (>).	immed
Возврат в командное окно из окна интерпретации	Введите в окне cmd .	>cmd

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

Действие	Положение курсора	Настраиваемое сочетание клавиш
Пролистать список ранее введенных команд	Строка ввода	СТРЕЛКА ВВЕРХ и СТРЕЛКА ВНИЗ
Прокрутка окна вверх	Содержимое командного окна	CTRL+СТРЕЛКА ВВЕРХ
Прокрутка окна вниз	Содержимое командного окна	СТРЕЛКА ВНИЗ или CTRL + СТРЕЛКА ВНИЗ

Всю предыдущую команду или ее часть можно скопировать в строку ввода: перейдите к команде с помощью прокрутки, выделите всю команду или ее часть и нажмите клавишу ВВОД.

Режим пометки

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

Знак равенства (=)

Окно, используемое для ввода команды EvaluateStatement , определяет, интерпретируется ли знак равенства (=) как оператор сравнения или оператор присваивания.

В командном окне знак равенства (=) интерпретируется как оператор сравнения. Операторы присваивания нельзя использовать в командном окне. Например, если значения переменных varA и varB различаются, то команда >Debug.EvaluateStatement(varA=varB) вернет значение False .

В окне интерпретации, напротив, знак равенства (=) интерпретируется как оператор присваивания. Например, команда >Debug.EvaluateStatement(varA=varB) присвоит переменной varA значение переменной varB .

Параметры, аргументы и значения

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

Edit.ReplaceInFiles — это команда;

/case и /pattern:regex — это параметры командной строки (начинаются с символа косой черты [/]);

regex — это значение параметра командной строки /pattern (параметр /case не имеет значения);

var2+ и oldpar — это параметры.

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

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

Почти все параметры, поддерживаемые командой, имеют две формы: краткую (один символ) и длинную. Несколько параметров в краткой форме можно объединять в группы. Например, значение /p /g /m можно также представить как /pgm .

Если параметры в краткой форме будут объединены в группу, и ей будет присвоено значение, это значение присваивается каждому параметру. Например, /pgm:123 соответствует /p:123 /g:123 /m:123 . Если какой-либо из параметров в группе не принимает значение, возникает ошибка.

Escape-символы

Символ "крышки" (^) в командной строке означает, что следующий за ним символ интерпретируется буквально, а не как управляющий символ. Благодаря этому в значение параметра можно внедрить прямые кавычки ("), пробелы, начальные символы косой черты, крышки или другие знаки, за исключением имен параметров. Например,

Крышка действует одинаково как внутри кавычек, так и за их пределами. Если крышка является последним символом в строке, она игнорируется. В следующем примере показано, как выполнить поиск шаблона "^t".

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

Например, если вы хотите открыть файл, путь к которому содержит пробелы, необходимо заключить путь или сегмент пути, содержащий пробелы, в двойные кавычки: C:\"Program Files" или "C:\Program Files".

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

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

Введение

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

Модуль-расширение PVS-Studio для IDE в качестве одного их своих основных UI компонентов (другим таким компонентом является инструментальное окно) интегрирует в главное меню Visual Studio несколько собственных подгрупп команд, позволяя пользователю контролировать все аспекты использования статического анализа как из самой среды, так и через прямой вызов команд из командной строки.

Использование команд

Любая IDE команда, независимо от формы её представления (или отсутствия такового) в интерфейсе IDE, может быть исполнена напрямую через окна Command Window и Immediate Window, а также с помощью аргумента командной строки devenv.exe /command при запуске приложения из консоли.

Команды могут принимать дополнительные аргументы, передаваемые через пробел. Приведём пример вызова стандартной системной команды меню File -> New -> File, с передачей ей дополнительных параметров, через окно среды Command Window:

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

Имя команды и её аргументы разделяются пробелом
Содержащие пробелы значения аргументов оборачиваются в кавычки
Знак вставки (^) используется для экранирования символов
Односимвольные сокращения имён аргументов можно сочетать, например /case (/c) и /word (/w) могут быть записаны как /cw

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

Для быстрого вызова команде может быть назначен псевдоним с помощью команды alias:

Команды, добавляемые в главное меню IDE модулем-расширением PVS-Studio, могут также быть использованы и через вызов /command, в частности, например, для решения задачи интеграции статического анализа в автоматизированный сборочный процесс проекта. Здесь заметим, что непосредственно сам статический анализатор PVS-Studio.exe представляет собой как раз консольное приложение, работающее по схожему с компилятором принципу, т.е. он получает на вход путь до файла с исходным кодом и параметры компиляции этого файла, выдавая результаты своего анализа в потоки stdout/strerr. Понятно и то, что анализатор может быть относительно легко интегрирован непосредственно в сборочную систему (например, основанную на том же MSBuild, NMake или даже GNU Make) на одном уровне с вызовом C/C++ компилятора. Подобная система уже сама по определению будет реализовывать обход всех исходных файлов с предоставлением параметров компиляции для каждого из них, что фактически позволяет подменять (или скорее дополнять) вызов компилятора вызовом анализатора. И хотя такой режим работы полностью поддерживается анализатором PVS-Studio.exe, подобная интеграция анализа в сборочный процесс требует достаточно близкого знакомства непосредственно со сборочной системой, ровно как и собственно возможности для такой её модификации, что может быть как затруднительно, так и вовсе не доступно.

В случае запуска Visual Studio из командной строки с аргументом /command, команда будет выполнена сразу после загрузки среды. При этом среда разработки будет запущена как обычное UI приложение, соответственно, и без перенаправления в запускающую её консоль стандартных потоков ввода/вывода. Стоит заметить, что в общем случае Visual Studio является именно UI средой разработки и не предназначена для работы в режиме командной строки. Так, например, для компиляции проектов в системах автоматизации сборок рекомендуется напрямую вызывать сборочную утилиту Microsoft MSBuild, поддерживающую все стандартные типы проектов Visual Studio.

С осторожностью следует применять вызов команд Visual Studio через /command при работе в неинтерактивном режиме рабочего стола (например, при запуске из службы Windows). Например, проверяя возможность интегрировать статический анализ PVS-Studio в сборочные процессы Microsoft Team Foundation, мы столкнулись с несколькими интересными моментами, т.к. по умолчанию Team Foundation работает именно как Windows служба. Сам наш плагин был не готов работать в неинтерактивном режиме рабочего стола, неправильно управляя своими дочерними окнами и диалогами, что в свою очередь приводило к аварийному падению. У Visual Studio таких проблем не обнаружилось, а точнее практически не обнаружилось. После первого запуска среды, для каждого пользователя Visual Studio выдаёт диалог, предлагающий выбрать одну из стандартных конфигураций интерфейса. Этот же диалог она выдала и для пользователя LocalSystem, которому принадлежал сервис Team Foundation. Оказалось, что данный диалог Visual Studio генерирует и в неинтерактивном режиме при вызове /command, блокируя всё дальнейшее исполнение. А так как пользователь не имеет интерактивного рабочего стола, то и закрыть этот диалог оказалось затруднительно. В итоге мы всё же смогли это сделать, запустив Visual Studio для LocalSystem в интерактивном режиме с помощью утилиты psexec из набора PSTools.

Создание и обработка команд в VSPackage. Vsct файлы

Для создания и управления интегрируемыми IDE командами в VSPackage используются таблицы команд (Visual Studio Command Table, vsct файлы). Таблицы команд — это текстовые конфигурационные файлы в формате XML, компилируемые VSCT-компилятором в бинарные cto-файлы (command table output). CTO файлы включаются затем в качестве ресурса в финальную сборку модуля-расширения IDE. С помощью VCST команды могут быть назначены на пункты главного меню IDE или кнопки панелей инструментов. Поддержка VSCT файлов доступна начиная с Visual Studio 2005, в предыдущих версиях IDE для описания команд использовались CTC (command table compiler) файлы, в рамках данной статьи они рассматриваться не будут.

Каждой команде в vsct файле присваивается уникальный идентификатор — CommandID, имя и группа, определяется сочетание для быстрого вызова. С помощью различных флагов задаётся её внешний вид в интерфейсе (в меню или на панели инструментов), определяются параметры её видимости и т.д.

Рассмотрим базовую структуру VSCT файла. Корневой элемент таблицы команд CommandTable должен содержать под-узел Commands, в котором будут определены все пользовательские команды, группы, меню, панели инструментов и т.д. Узел Commands должен также иметь атрибут Package со значением, соответствующим идентификатору разрабатываемого пакета расширения. Под-узел корневого узла Symbols должен содержать определения для всех используемых в VSCT файле идентификаторов. Под-узел корневого узла KeyBindings содержит задаваемые по умолчания сочетания для быстрого вызова команд.

Элемент Buttons задаёт непосредственно сами IDE команды, задавая их внешний вид и привязывая их к группам команд.

Элемент Menus описывает структуру UI элементов главного меню и панели инструментов, и связывает их с группами команд элемента Groups. Группа команд, связанная с элементом Menu, будет отображена на заданном здесь меню или панели инструментов.

Элемент Groups формирует группы пользовательских команд среды.

Для добавления vsct файла в MSBuild проект VSPackage необходимо сначала вставить следующий узел для вызова VSCT компилятора в csproj файл (в автогенерируемом проекте SDK шаблона VSPackage vsct файл будет уже добавлен в проект):

И затем указать на него с помощью атрибута ProvideMenuResource у вашего наследника класса Package:

Назначение обработчиков для команд, определённых в VSCT файле, возможно с помощью службы, доступной через интерфейс IMenuCommandService. Получить ссылку на него можно с помощью метода GetService класса Package:

Приведём пример назначения обработчика на команду меню (команда должна быть определена в vsct файле заранее):

Для получения аргументов команды во время обработки её вызова можно преобразовать получаемое обработчиком значение EventArgs в OleMenuCmdEventArgs:

Работа с командами через интерфейс EnvDTE.DTE

Использование объектной модели автоматизации для вызова, модификации и создания IDE команд, в отличие от механизма VSCT, доступного только для VSPackage, позволяет взаимодействовать с командами из модулей-расширений Visual Studio типа Add-In.

При этом добавленная подобным образом команда будет сохранена в IDE и появится в меню после перезапуска среды, даже если создавшее её расширение не будет загружено. Поэтому вызывать данный метод стоит только при самом первом подключении Add-In модуля после его установки (подробно этот момент описан в разделе, посвященном объектной модели автоматизации Visual Studio). Для метода OnConnection Add-In модулей доступен вариант первичной загрузки (при самой первой инициализации), вызываемый только один раз за всю жизнь модуля, который также можно использовать для интеграции UI элементов в IDE.

Интерфейс EnvDTE.Command абстрагирует в себе отдельную команду IDE. Его можно использовать для модификации связанной с ним команды. Данный интерфейс позволяет работать с командами среды как из VSPackage, так и из Add-In модулей. Получим ссылку на объект автоматизации EnvDTE.Command для нашей пользовательской команды MyCommand1 и используем данный интерфейс для назначения ей "горячей клавиши" быстрого вызова:

Назначенное для команды MyGroup.MyCommand1 сочетание быстрого вызова теперь будет видно в настройках среды в диалоге Keyboard, Environment.

Стоит помнить, что команда Visual Studio не является по умолчанию элементом интерфейса IDE. Метод интерфейса Commands.AddCommandBar позволяет создавать такие элементы UI среды, как пункты главного меню, инструментальные панели, контекстные меню, и назначать на них пользовательские команды.

Для удаления команды или командной панели из IDE можно воспользоваться методом Delete интерфейсов Command/ CommandBar:

В общем случае не рекомендуется создавать команды каждый раз при загрузке Add-In модуля и удалять их при его выгрузке, т.к. это может замедлить загрузку самой IDE, а в случае некорректно отработавшего метода OnDisconnect пользовательские команды не будут полностью очищены до следующего запуска модуля. Поэтому, добавление и удаление команд среды рекомендуется осуществлять в процессе инсталляции/деинсталляции модуля, используя, например, получение ссылки на интерфейс DTE из стороннего приложения, в данном случае инсталлятора. Подробно инициализация Add-Inn модулей и получение доступа к объекту DTE из внешних приложений описаны в разделе, посвящённом модели объектной автоматизации EnvDTE.

Любая команда среды (как пользовательская, так и встроенная) может быть вызвана с помощью с помощью метода ExecuteCommand. Приведём пример вызова пользовательской команды MyCommand1:

Для обработки команды основной класс Add-In модуля должен наследоваться от интерфейса IDTCommandTarget и реализовывать метод обработки Exec:

По мере углубления ваших знаний о системе Visual Studio 2013 вы будете проводить все меньше времени в поисках функциональных свойств и чаще будете использовать комбинации клавиш, чтобы перемещаться в интегрированной среде разработки и выполнять определенные действия. Одно из инструментальных окон, которое открывается чаще других, - окно Command (View --> Other Windows --> Command Window <Ctrl+Alt+A> ). Когда открыто это окно, можете выполнить любую существующую команду или макрос, а также любой дополнительный макрос, который можете написать и сохранить. На рисунке ниже показано, как с помощью технологии IntelliSense открыть список команд, которые можно выбрать в окне Command. Этот список будет содержать все макросы, определенные в текущем решении.

Полный список команд системы Visual Studio можно открыть с помощью узла Environments Keyboard, содержащегося в диалоговом окне Options (Tools --> Options). Все команды имеют одинаковый синтаксис, основанный на области интегрированной среды разработки, для которой они созданы. Например, можете открыть окно отладки (Debug --> Windows --> Output), набрав команду Debug. Output в окне Command.

Все команды разделяются на три группы. Одни являются просто методами быстрого открытия инструментальных или диалоговых окон (которые открываются, если до этого были закрыты). Например, команда File.NewFile открывает новое диалоговое окно. Другие команды запрашивают информацию о текущем решении или отладчике. Команда Debug.ListThreads позволяет получить список текущих потоков, а команда Debug.Threads открывает инструментальное окно Threads. К третьему типу принадлежат команды, которые выполняют действия без открытия диалогового окна. К ним относится большинство макросов и команд, принимающих аргументы (полный список этих команд, включая аргументы, которые они принимают, можно найти в документации MSDN). Между этими группами существуют пересечения: например, команда Edit.Find может выполняться как с аргументами, так и без них. Если эта команда выполняется без аргументов, то открывается диалоговое окно Find and Replace. В качестве альтернативы следующая команда найдет все вхождения строки MyVariable в текущем документе (/d) и поставит маркер на границе окна кода напротив соответствующих строк (/m):

Несмотря на то что в окне Command применяется технология IntelliSense, набор часто используемых команд может показаться утомительным. В системе Visual Studio 2013 существует возможность присваивать некоторым командам альтернативные имена, или псевдонимы. Например, для присваивания псевдонима можно использовать команду alias, а для поиска команды, использованной ранее, команду e?:

Определив этот псевдоним, можно легко выполнить эту команду в любом месте интегрированной среды разработки: нажмите комбинацию клавиш <Ctrl+Alt+A> , чтобы установить фокус на окно Command, затем наберите команду "e?", чтобы выполнить команду "найти и пометить".

В начале работы с системой Visual Studio 2013 будет импортировано большое количество псевдонимов, заданных по умолчанию и относящихся к настройкам среды. Перечислить их можно с помощью команды alias без аргументов. В качестве альтернативы при желании найти, какие именно команды относятся к конкретному псевдониму, можете выполнить команду alias, задав в качестве аргумента соответствующий псевдоним. Например, выполнив запрос к предыдущем псевдониму "e?", будет получено следующее:

К псевдонимам можно применять два дополнительных переключателя. Переключатель /delete вместе с псевдонимом удаляет ранее определенный псевдоним. Если вы хотите удалить все ранее определенные вами псевдонимы и вернуться к предыдущим именам, можно использовать переключатель /reset.

Окно Immediate

Довольно часто при создании кода или отладке программы возникает необходимость вычислить простое выражение либо для того, чтобы проверить часть кода, либо для того, чтобы вспомнить, как работает тот или иной его фрагмент. В таких ситуациях удобно использовать окно Immediate, позволяющее вычислять инструкции сразу после их ввода. На рисунке ниже показано много инструкций - от простого присваивания и операций вывода на печать до создания объекта и сложных манипуляций.

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

Открыть окно Immediate можно с помощью команды Debug --> Windows --> Immediate или комбинации клавиш <Ctrl+Alt+I> , но, если вы работаете, поочередно переключаясь между окнами Command и Immediate, то, вероятно, захотите использовать заранее установленные псевдонимы cmd и immed соответственно.

Обратите внимание на то, что для того чтобы выполнить команду в окне Immediate, необходимо добавить префикс ">" (например, для того, чтобы перейти к окну Command, надо выполнить команду >cmd); в противном случае система Visual Studio попытается вычислить команду. Кроме того, вы должны быть уверены, что язык, используемый в окне Immediate, совпадает с языком, на котором создается активный проект. Примеры, приведенные на рисунке выше, работают, только если текущий активный проект создан на языке Visual Basic.

Все элементы, необходимые для создания первого приложения, объединены в специальной программе IDE (англ. Integrated Development Environment), а именно:

Кодовый редактор
Транслятор (компилятор и/или интерпретатор)
Средства автоматизированной сборки
Отладчик

Community – полнофункциональная, расширяемая и бесплатная версия интегрированной среды разработки для создания современных приложений Android, iOS и Windows, а также веб-приложений и облачных служб.
Professional – платная версия, содержащая профессиональные инструменты и службы для индивидуальных разработчиков или небольших команд.
Enterprise – платная версия, представляющая интегрированное комплексное решение для команд любого размера с высокими требованиями к качеству и масштабу.

Установка Visual Studio

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

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

Откройте Visual Studio и на стартовом экране выберите пункт «Создание проекта».

В следующем окне зададим название проекта. Пусть будет HelloWorld. На этом этапе также можно указать папку, где будет располагаться проект. После этого нажмите кнопку «Создать».

Visual Studio создаст и откроет проект. Окно будет выглядеть так:

Hello world

Под узлом «Зависимости» расположен непосредственно сам файл кода программы — Program.cs. Как раз он и открыт в центральном окне. Вначале разберёмся, что весь этот код собой представляет:

Пространство имён может включать другие пространства или классы. В нашем случае по умолчанию сгенерирован один класс — Program. Классы объявляются похожим способом: сначала идёт ключевое слово class, а потом название класса, и далее блок самого класса в фигурных скобках.

Слово static указывает, что метод Main статический, а слово void — что он не возвращает никакого значения. Далее в скобках у нас идут параметры метода. string[] args — это массив с именем args, который хранит значения типа string, то есть строки. В данном случае они нам пока не нужны, но в реальной программе это те параметры, которые передаются при запуске программы из консоли.

Внутри метода располагаются действия, которые этот метод выполняет. По умолчанию он содержит одно действие: Console.WriteLine("Hello World!"); - выводит в консоль строку "Hello World!".

Теперь мы можем запустить программу на выполнение с помощью клавиши F5 или с панели инструментов, нажав на зелёную стрелку. И если вы все сделали правильно, то при запуске приложения увидите заветную строку.

Теперь сделаем всё поинтересней — изменим код на следующий:

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

Класс Console, метод которого мы вызываем, находится в пространстве имён System. Это пространство подключено в начале с помощью директивы using. Без подключения пространства имён System невозможно было бы использовать класс Console.

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

Во второй строке определяется строковая переменная name (тип string), в которую пользователь вводит информацию с консоли:

Мы обозначили, что помощью метода ReadLine() можем считать с консоли строку.

Затем введённое имя выводится на консоль:

Чтобы задать вывод значения переменной name в выводимой на консоль строке, применяются фигурные скобки <>. При выводе строки на консоль выражение будет заменяться на значение переменной name — введённое имя.

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

Читайте также: