Начало работы с .NET Core в Windows, Linux и Mac OS с помощью командной строкиGet started with .NET Core on Windows/Linux/macOS using the command line

В этом разделе показано, как приступить к разработке кроссплатформенных приложений с помощью средств интерфейса командной строки (CLI) .NET Core.This topic will show you how to start developing cross-platforms apps in your machine using the .NET Core CLI tools.

Если вы не знакомы с набором средств CLI .NET Core, прочитайте обзор пакета SDK для .NET Core.If you're unfamiliar with the .NET Core CLI toolset, read the .NET Core SDK overview.

Предварительные требованияPrerequisites

Первое консольное приложениеHello, Console App!

Просмотреть или скачать пример кода можно в репозитории dotnet/samples на сайте GitHub.You can view or download the sample code from the dotnet/samples GitHub repository. Инструкции по загрузке см. в разделе Просмотр и скачивание примеров.For download instructions, see Samples and Tutorials.

Откройте командную строку и создайте папку с именем Hello.Open a command prompt and create a folder named Hello. Перейдите в созданную папку и введите следующую команду:Navigate to the folder you created and type the following:

dotnet new console
dotnet run

Вкратце рассмотрим эти команды.Let's do a quick walkthrough:

  1. dotnet new console

    dotnet new создает актуальный файл проекта Hello.csproj с зависимостями, необходимыми для создания консольного приложения.dotnet new creates an up-to-date Hello.csproj project file with the dependencies necessary to build a console app. Эта команда также создает Program.cs — простой файл, содержащий точку входа для приложения.It also creates a Program.cs, a basic file containing the entry point for the application.

    Hello.csproj:Hello.csproj:

    <Project Sdk="Microsoft.NET.Sdk">
    
      <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>netcoreapp2.2</TargetFramework>
      </PropertyGroup>
    
    </Project>
    

    В файле проекта указываются все данные, необходимые для восстановления зависимостей и создания программы.The project file specifies everything that's needed to restore dependencies and build the program.

    • Тег OutputType указывает, что мы создаем исполняемый файл — другими словами, консольное приложение.The OutputType tag specifies that we're building an executable, in other words a console application.
    • Тег TargetFramework указывает, какая реализация.NET является целевой.The TargetFramework tag specifies what .NET implementation we're targeting. В расширенном сценарии обработки можно указать несколько целевых платформ и выполнить сборку во всех средах за одну операцию.In an advanced scenario, you can specify multiple target frameworks and build to all those in a single operation. В этом руководстве рассматривается сборка только для платформы .NET Core 2.1.In this tutorial, we'll stick to building only for .NET Core 2.1.

    Program.cs:Program.cs:

    using System;
    
    namespace Hello
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("Hello World!");
            }
        }
    }
    

    Программа начинается с команды using System, что означает "добавить все данные пространства имен System в область видимости для этого файла".The program starts by using System, which means "bring everything in the System namespace into scope for this file". Пространство имен System содержит основные конструкции, такие как string, или числовые типы.The System namespace includes basic constructs such as string, or numeric types.

    Затем мы определяем пространство имен с именем Hello.We then define a namespace called Hello. Вы можете сменить это имя на любое другое.You can change this to anything you want. Класс Program определяется в этом пространстве имен с использованием метода Main, который принимает массив строк в качестве аргумента.A class named Program is defined within that namespace, with a Main method that takes an array of strings as its argument. Этот массив содержит список аргументов, передаваемых при вызове скомпилированной программы.This array contains the list of arguments passed in when the compiled program is called. В такой форме программа не использует этот массив. Единственное ее действие — вывод надписи "Hello World!"As it is, this array is not used: all the program is doing is to write "Hello World!" в консоль.to the console. Позднее мы внесем в код изменения, использующие этот аргумент.Later, we'll make changes to the code that will make use of this argument.

    Примечание

    Начиная с пакета SDK для .NET Core 2.0 нет необходимости выполнять команду dotnet restore, так как она выполняется неявно всеми командами, которые требуют восстановления, например dotnet new, dotnet build и dotnet run.Starting with .NET Core 2.0 SDK, you don't have to run dotnet restore because it's run implicitly by all commands that require a restore to occur, such as dotnet new, dotnet build and dotnet run. Эту команду по-прежнему можно использовать в некоторых сценариях, где необходимо явное восстановление, например в сборках с использованием непрерывной интеграции в Azure DevOps Services или системах сборки, где требуется явно контролировать время восстановления.It's still a valid command in certain scenarios where doing an explicit restore makes sense, such as continuous integration builds in Azure DevOps Services or in build systems that need to explicitly control the time at which the restore occurs.

    dotnet new неявно вызывает dotnet restore.dotnet new calls dotnet restore implicitly. dotnet restore вызывает NuGet (диспетчер пакетов .NET) для восстановления дерева зависимостей.dotnet restore calls into NuGet (.NET package manager) to restore the tree of dependencies. NuGet анализирует файл Hello.csproj, скачивает указанные в нем зависимости (или извлекает их из кэша на вашем компьютере) и записывает файл obj/project.assets.json, который требуется для компиляции и запуска примера.NuGet analyzes the Hello.csproj file, downloads the dependencies defined in the file (or grabs them from a cache on your machine), and writes the obj/project.assets.json file, which is necessary to compile and run the sample.

    Важно!

    Если вы используете пакет SDK для .NET Core 1.x, необходимо самому вызвать dotnet restore после вызова dotnet new.If you're using a .NET Core 1.x version of the SDK, you'll have to call dotnet restore yourself after calling dotnet new.

  2. dotnet run

    dotnet run вызывает dotnet build для проверки того, выполнена ли сборка целевых объектов, а затем вызывает dotnet <assembly.dll> для запуска целевого приложения.dotnet run calls dotnet build to ensure that the build targets have been built, and then calls dotnet <assembly.dll> to run the target application.

    $ dotnet run
    Hello World!
    

    Кроме того, вы можете выполнить dotnet build, чтобы скомпилировать код, не запуская консольные приложения сборки.Alternatively, you can also execute dotnet build to compile the code without running the build console applications. В результате мы получаем скомпилированное приложение в виде файла DLL, которое можно выполнить с помощью dotnet bin\Debug\netcoreapp2.1\Hello.dll в Windows или / в других операционных системах.This results in a compiled application as a DLL file that can be run with dotnet bin\Debug\netcoreapp2.1\Hello.dll on Windows (use / for non-Windows systems). Вы также можете указать аргументы для приложения, как описано ниже.You may also specify arguments to the application as you'll see later on the topic.

    $ dotnet bin\Debug\netcoreapp2.1\Hello.dll
    Hello World!
    

    В расширенном сценарии можно собрать приложение в качестве автономного набора файлов для определенной платформы, которые можно развернуть и запустить на компьютере без .NET Core.As an advanced scenario, it's possible to build the application as a self-contained set of platform-specific files that can be deployed and run to a machine that doesn't necessarily have .NET Core installed. Чтобы получить подробные сведения, см. статью .NET Core Application Deployment (Развертывание приложений .NET Core).See .NET Core Application Deployment for details.

Расширение программыAugmenting the program

Давайте немного изменим программу.Let's change the program a bit. С числами Фибоначчи интересно работать, поэтому давайте добавим следующее в дополнение к использованию аргумента для приветствия пользователя приложения.Fibonacci numbers are fun, so let's add that in addition to use the argument to greet the person running the app.

  1. Замените содержимое файла Program.cs следующим кодом:Replace the contents of your Program.cs file with the following code:

    using System;
    
    namespace Hello
    {
        class Program
        {
            static void Main(string[] args)
            {
                if (args.Length > 0)
                {
                    Console.WriteLine($"Hello {args[0]}!");
                }
                else
                {
                    Console.WriteLine("Hello!");
                }
    
                Console.WriteLine("Fibonacci Numbers 1-15:");
    
                for (int i = 0; i < 15; i++)
                {
                    Console.WriteLine($"{i + 1}: {FibonacciNumber(i)}");
                }
            }
    
            static int FibonacciNumber(int n)
            {
                int a = 0;
                int b = 1;
                int tmp;
    
                for (int i = 0; i < n; i++)
                {
                    tmp = a;
                    a = b;
                    b += tmp;
                }
    
                return a;
            }
    
        }
    }
    
  2. Выполните dotnet build для компиляции изменений.Execute dotnet build to compile the changes.

  3. Запустите программу, передав параметр в приложение:Run the program passing a parameter to the app:

    $ dotnet run -- John
    Hello John!
    Fibonacci Numbers 1-15:
    1: 0
    2: 1
    3: 1
    4: 2
    5: 3
    6: 5
    7: 8
    8: 13
    9: 21
    10: 34
    11: 55
    12: 89
    13: 144
    14: 233
    15: 377
    

Вот и все!And that's it! Вы можете расширять файл Program.cs по своему усмотрению.You can augment Program.cs any way you like.

Работа с несколькими файламиWorking with multiple files

Отдельные файлы хороши для простых одиночных программ, но при создании более сложных приложений, возможно, в проекте будет несколько исходных файлов.Single files are fine for simple one-off programs, but if you're building a more complex app, you're probably going to have multiple source files on your project. Используем в качестве основы предыдущий пример, реализовав в нем кэширование значений Фибоначчи и рекурсию.Let's build off of the previous Fibonacci example by caching some Fibonacci values and add some recursive features.

  1. Добавьте в каталог Hello новый файл FibonacciGenerator.cs со следующим кодом:Add a new file inside the Hello directory named FibonacciGenerator.cs with the following code:

    using System;
    using System.Collections.Generic;
    
    namespace Hello
    {
        public class FibonacciGenerator
        {
            private Dictionary<int, int> _cache = new Dictionary<int, int>();
            
            private int Fib(int n) => n < 2 ? n : FibValue(n - 1) + FibValue(n - 2);
            
            private int FibValue(int n)
            {
                if (!_cache.ContainsKey(n))
                {
                    _cache.Add(n, Fib(n));
                }
                
                return _cache[n];
            }
            
            public IEnumerable<int> Generate(int n)
            {
                for (int i = 0; i < n; i++)
                {
                    yield return FibValue(i);
                }
            }
        }
    }
    
  2. Измените метод Main в своем файле Program.cs, чтобы создать экземпляр класса new и вызвать его метод, как показано в следующем примере:Change the Main method in your Program.cs file to instantiate the new class and call its method as in the following example:

    using System;
    
    namespace Hello
    {
        class Program
        {
            static void Main(string[] args)
            {
                var generator = new FibonacciGenerator();
                foreach (var digit in generator.Generate(15))
                {
                    Console.WriteLine(digit);
                }
            }
        }
    }
    
  3. Выполните dotnet build для компиляции изменений.Execute dotnet build to compile the changes.

  4. Запустите приложение, выполнив dotnet run.Run your app by executing dotnet run. Ниже приведены выходные данные программы:The following shows the program output:

    $ dotnet run
    0
    1
    1
    2
    3
    5
    8
    13
    21
    34
    55
    89
    144
    233
    377
    

Публикация приложенияPublish your app

Когда вы будете готовы к распространению приложения, используйте команду dotnet publish для создания папки publish в bin\debug\netcoreapp 2.1.\publish\ (используйте / для систем, отличных от Windows).Once you're ready to distribute your app, use the dotnet publish command to generate the publish folder at bin\debug\netcoreapp2.1\publish\ (use / for non-Windows systems). Содержимое папки publish можно распространить на другие платформы, если на них установлена среда выполнения .NET.You can distribute the contents of the publish folder to other platforms as long as they've already installed the dotnet runtime.

Запустить опубликованное приложение можно с помощью команды dotnet:You can run your published app with the dotnet command:

$ dotnet bin\Debug\netcoreapp2.1\publish\Hello.dll
Hello World!

ЗаключениеConclusion

Вот и все!And that's it! Теперь вы можете воспользоваться изученными здесь основными концепциями, чтобы создавать собственные программы.Now, you can start using the basic concepts learned here to create your own programs.

См. такжеSee also