Первая программа

Вы уже установили SDK и запустили первую лабораторию. Экран показал pine. Эта страница остаётся при той же форме программы и задаёт другой вопрос: какая строка внутри файла написала это слово, а какие строки ничего не написали. Вы снова не устанавливаете .NET. Строка версии с прошлой страницы может остаться как была. Сохраните открытый класс с именем Pine, сохраните Main и сохраните Console.WriteLine("pine");. Экран, который вы объясняете, всё ещё одна строка, и эта строка — pine.

В файле больше одной строки, поэтому первая догадка — что каждая строка файла становится строкой на экране. Эта догадка неверна, и остальная часть страницы показывает почему. Несколько строк что‑то называют. Пишет только одна. Фигурные скобки группируют эти строки. Они тоже не пишут. Когда вы можете указать на строку записи, держа файл перед собой, эта страница закончена. Следующая страница добавляет заметку, которую экран не показывает. Она не меняет pine.

using System готовит короткие имена

Первая полезная строка — using System;. Читайте её как строку подготовки, а не как предложение, которое экран напечатает. Она приводит имена из пространства имён System к короткой форме, чтобы Console мог появиться без длинного пути. Слово using на экране вы не видите. System на экране вы не видите. Удалите эту строку в неверном эксперименте — и короткое имя Console позже может не сработать: это история компиляции на другой день. На этой странице строка остаётся, и экран остаётся pine, потому что эта строка не пишет.

Строка класса именует тип

Следующая строка типа — public class Pine. Читайте её как три слова с работой, а не как текст экрана. public значит, что другой код может использовать этот тип. public на экране вы не видите. class значит, что этот файл определяет одну именованную единицу. class на экране вы не видите. Pine — имя этой единицы. В этой учебной форме основа имени файла совпадает с этим именем. Смените имя в этой строке — и привычка имени файла должна смениться вместе с ним. Это правило про тип и файл. Не про экран. Посмотрите на экран снова. Экран не показывает Pine. Он показывает pine. Большая P и маленькая p — не одно и то же слово. Строка класса никогда не пишет своё имя на экран.

Символ после той строки — открывающая фигурная скобка {. Парная закрывающая скобка позже в файле заканчивает тело класса. Всё между этими скобками принадлежит классу Pine. Скобки — ограды. Они говорят C#, где эта единица начинается и где заканчивается. Ограда — не текст для экрана. Рядом с pine вы не увидите { или }. Если удалить открывающую скобку, файл сломан, и компилятор пишет ошибку вместо тишины. Эта ошибка — не тема этой страницы. Эта страница сохраняет обе скобки, и экран остаётся pine.

Строка Main — где runtime начинает

Следующая строка — public static void Main(). На эту строку указывают, когда спрашивают, где программа начинается, и насчёт начала они правы. Они ошибаются, если потом говорят, что экран показывает Main. Runtime при запуске проекта ищет метод такой формы. Он начинает выполнение с этой строки. Начать — не то же самое, что писать. Слова на строке — инструкции о том, как начать. Это не слова для экрана.

Возьмите слова по одному и сверьте каждое с экраном. public снова значит, что метод можно запустить снаружи. static значит, что runtime может запустить этот метод, не создавая сначала объект. С объектами вы ещё не встречались, поэтому вам нужен только факт: в этой учебной форме static обязателен и не печатается. void значит, что этот метод не возвращает значение вызывающему. На этой странице нет истории вызывающего, и void на экране нет. Main — имя, которое runtime ищет в этой форме. Экран по‑прежнему не показывает эти четыре буквы. Круглые скобки отмечают список параметров. На этой странице список пуст. Пустые скобки тоже не печатаются.

Итак, строка Main может быть верна сразу в двух смыслах. Runtime действительно начал оттуда. Экран не получил ни одного слова от этой строки. Если глаз останавливается на Main, потому что он сидит в середине файла, сдвиньте взгляд. Слово, которое вы помните с экрана, — pine, и pine на этой строке не написан.

Внутренняя строка пишет pine

Внутри Main, между его собственными скобками, есть ещё одна строка. Эта строка — Console.WriteLine("pine");. Именно она пишет на экран. В файле она с отступом, чтобы было видно, что она сидит внутри Main. Отступ — это пробелы. Пробелы на экран тоже не пишутся. Runtime выполняет эту внутреннюю строку, потому что она внутри метода, с которого программа начинается. Экран использует то, что пишет эта внутренняя строка. Он не использует имя внешнего метода.

Читайте внутреннюю строку слева. Console — помощник экрана, который использует этот курс. WriteLine значит: напиши это, затем закончи строку. Часть в круглых скобках — то, что записывается. Внутри скобок слово pine стоит между двойными кавычками. Кавычки помечают pine как текст. Они не часть текста. Уберите их в уме — остаётся слово pine, и это весь экран. Оставьте кавычки в файле. Без кавычек компилятор не считает pine этим текстовым литералом. Точка с запятой в конце завершает оператор для C#. Точку с запятой на экране вы не видите. Вы видите pine, а затем строка заканчивается, потому что WriteLine её закончил.

Вот эта строка записи отдельно, чтобы другие строки её не прятали.

Ничто в команде dotnet run не выбирает слово pine. Команда только запускает проект. Слово приходит из кавычек. Если в кавычках было другое слово, экран показал бы то слово, а эта страница так не делает. Кавычки на этой странице держат pine, поэтому экран — pine. Одна строка. Без второй строки. Без кавычек на экране. Без слова Main. Без слова Pine.

Что люди читают неверно

Обычная ошибка — читать файл сверху и считать, что самое знакомое слово и есть вывод. Main выглядит важным, и он важен, потому что runtime не запустит эту форму без него. Важность — не вывод. Вы можете закрыть строку Main пальцем, и строка записи всё равно Console.WriteLine("pine");. Вы не можете закрыть строку записи и всё ещё объяснить экран. Другая ошибка — сказать, что экран показывает Pine, потому что класс назван Pine. Экран использует слово между кавычками, а это слово написано с маленькой p. Третья ошибка — считать строки. Файл показывает несколько строк и несколько скобок. Экран показывает одну. Скобки, слова public, static и void, имя Main, имя Pine и using System; после запуска всё ещё в файле. Запуск их не удаляет. Он их и не печатает.

Экран приходит из одной строки

Вы можете положить палец на Console.WriteLine("pine"); и сказать, что экран приходит из этой строки. Вы можете положить палец на public static void Main() и сказать, что runtime начинает там и что слово Main на экране нет. Вы можете положить палец на public class Pine и сказать, что это имя совпадает с учебным типом и не совпадает с экраном. Следующая страница кладёт в файл заметку. Заметка для человека, который читает файл. Экран всё равно будет pine, потому что заметка — не второй WriteLine.
Держите оставшиеся привычки Java с System.out.println("mint") в стороне от этой страницы, когда практикуете строку записи C#. Держите выдумывание маршрутов ASP.NET в стороне от этой страницы. Держите трактовку dotnet --version как слова экрана в стороне от этой страницы — строка версии была доказательством установки, а не выводом этой программы. Когда вы можете назвать строку записи и отвергнуть ложные догадки из Main и Pine, First Program сделал своё дело, и вы готовы к C# Comments, если продолжаете.