Rozpoczęcie pracy z platformą .NET Core w Windows/Linux/macOS przy użyciu wiersza poleceniaGetting started with .NET Core on Windows/Linux/macOS using the command line

W tym temacie pokazują sposób rozpoczęcia tworzenia aplikacji dla wielu platform, na komputerze przy użyciu narzędzi interfejsu wiersza polecenia platformy .NET Core.This topic will show you how to start developing cross-platforms apps in your machine using the .NET Core CLI tools.

Jeśli jesteś zaznajomiony z zestawu narzędzi interfejsu wiersza polecenia platformy .NET Core, zapoznaj się z Omówienie zestawu .NET Core SDK.If you're unfamiliar with the .NET Core CLI toolset, read the .NET Core SDK overview.

Wymagania wstępnePrerequisites

Witaj, aplikacja Konsolowa!Hello, Console App!

Możesz wyświetlić lub pobrać przykładowy kod z repozytorium dotnet/samples w witrynie GitHub.You can view or download the sample code from the dotnet/samples GitHub repository. Aby uzyskać instrukcje pobierania, zobacz przykłady i samouczki.For download instructions, see Samples and Tutorials.

Otwórz wiersz polecenia i Utwórz folder o nazwie Hello.Open a command prompt and create a folder named Hello. Przejdź do folderu, który został utworzony, a następnie wpisz następujące polecenie:Navigate to the folder you created and type the following:

$ dotnet new console
$ dotnet run

Zróbmy szybkiego przewodnika:Let's do a quick walkthrough:

  1. $ dotnet new console

    dotnet new Tworzy aktualnej Hello.csproj pliku projektu z zależnościami, które są niezbędne do tworzenia aplikacji konsolowej.dotnet new creates an up-to-date Hello.csproj project file with the dependencies necessary to build a console app. Tworzy również Program.cs, podstawowy plik zawierający punkt wejścia dla aplikacji.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.1</TargetFramework>
      </PropertyGroup>
    
    </Project>
    

    Plik projektu określa wszystko, co jest potrzebne do przywrócenia zależności i kompilacji programu.The project file specifies everything that's needed to restore dependencies and build the program.

    • OutputType Tag Określa, czy tworzymy plik wykonywalny, innymi słowy aplikację konsolową w języku.The OutputType tag specifies that we're building an executable, in other words a console application.
    • TargetFramework Tagów Określa, jakie firma Microsoft objęci implementacja programu .NET.The TargetFramework tag specifies what .NET implementation we're targeting. W zaawansowanym scenariuszu można określić wielu platform docelowych i kompilacja — przejście do wszystkich tych w ramach jednej operacji.In an advanced scenario, you can specify multiple target frameworks and build to all those in a single operation. W tym samouczku używany będzie tworzenie tylko dla platformy .NET Core 1.0.In this tutorial, we'll stick to building only for .NET Core 1.0.

    Program.cs:Program.cs:

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

    Program, który rozpoczyna się od using System, co oznacza, że "Przenieś wszystko System przestrzeni nazw do zakresu dla tego pliku".The program starts by using System, which means "bring everything in the System namespace into scope for this file". System Przestrzeń nazw zawiera podstawowymi konstrukcjami string, lub typów liczbowych.The System namespace includes basic constructs such as string, or numeric types.

    Następnie definiujemy przestrzeń nazwy wywołaną Hello.We then define a namespace called Hello. Można to zmienić, do żadnego elementu, który ma.You can change this to anything you want. Klasa o nazwie Program jest zdefiniowana w ramach tej przestrzeni nazw za pomocą Main metody, która przyjmuje tablicę ciągów, jako argumentem.A class named Program is defined within that namespace, with a Main method that takes an array of strings as its argument. Ta tablica zawiera listę argumentów przekazywanych do wywołanego skompilowanego programu.This array contains the list of arguments passed in when the compiled program is called. I nie jest używana ta tablica: wszystkie działania programu służy do zapisania "Hello World!"As it is, this array is not used: all the program is doing is to write "Hello World!" w konsoli.to the console. Później, wybierzemy zmiany do kodu, który będzie używać tego argumentu.Later, we'll make changes to the code that will make use of this argument.

    Uwaga

    Począwszy od programu .NET Core 2.0, nie trzeba uruchamiać dotnet restore , ponieważ jest uruchamiane domyślnie przez wszystkie polecenia, które wymagają Przywracanie wystąpienia, takie jak dotnet new, dotnet build i dotnet run.Starting with .NET Core 2.0, 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. Nadal jest prawidłowe polecenie, w niektórych scenariuszach, gdzie wykonując jawne przywracanie ma sens, takich jak kompilacje ciągłej integracji w usługach Azure DevOps Services lub w systemach kompilacji, które wymagają, aby jawnie kontrolować czas, w którym występuje, przywracania.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 wywołania dotnet restore niejawnie.dotnet new calls dotnet restore implicitly. dotnet restore wywoła NuGet (.NET package manager) w celu przywrócenia drzewo zależności.dotnet restore calls into NuGet (.NET package manager) to restore the tree of dependencies. Analizuje NuGet Hello.csproj plików, pliki do pobrania zależności zdefiniowane w pliku (lub bierze ich z pamięci podręcznej na komputerze) i zapisuje obj/project.assets.json pliku, który jest konieczny do Skompiluj i uruchom aplikację przykładową.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.

    Ważne

    Jeśli używasz wersji 1.x platformy .NET Core SDK, musisz wywołać dotnet restore samodzielnie po wywołaniu 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 wywołania dotnet build do upewnij się, że kompilacji, utworzone elementy docelowe, a następnie wywołania dotnet <assembly.dll> do uruchamiania aplikacji docelowej.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!
    

    Alternatywnie można również wykonać dotnet build skompilować kod bez konieczności uruchamiania kompilacji aplikacji konsoli.Alternatively, you can also execute dotnet build to compile the code without running the build console applications. Skutkuje to skompilowaną aplikację jako plik DLL, który można uruchomić z dotnet bin\Debug\netcoreapp2.1\Hello.dll na Windows (Użyj / systemów innych niż 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). Jak zobaczysz później tematu można też określić argumenty do aplikacji.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!
    

    W ramach scenariusza zaawansowanego jest możliwe utworzenie aplikacji jako autonomiczny zestaw plików specyficznych dla platformy, które można wdrożyć i uruchomić na komputerze, na którym nie musi koniecznie mieć platformy .NET Core zainstalowane.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. Zobacz wdrożenie aplikacji programu .NET Core Aby uzyskać szczegółowe informacje.See .NET Core Application Deployment for details.

Rozszerzając programAugmenting the program

Zmieńmy nieco program.Let's change the program a bit. Numery Fibonacci zabawy, Dodajmy oprócz Użyj argumentu w celu powitania osoby uruchamiania aplikacji.Fibonacci numbers are fun, so let's add that in addition to use the argument to greet the person running the app.

  1. Zastąp zawartość swojej Program.cs pliku następującym kodem: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. Wykonaj dotnet build skompilować zmiany.Execute dotnet build to compile the changes.

  3. Uruchom program przekazywania parametru do aplikacji: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
    

I to wszystko!And that's it! Można rozszerzyć Program.cs sposób chcesz.You can augment Program.cs any way you like.

Praca z wieloma plikamiWorking with multiple files

Pojedynczych plików są w dobrym stanie, proste, jednorazowe programów, ale jeśli tworzysz bardziej złożonych aplikacji są teraz zawierają wiele plików źródłowych w projekcie najczęściej kompilacji zniżki w stosunku do poprzedniego przykładu Fibonacci przez buforowanie niektórych wartości Fibonacci i dodaj kilka cykliczne funkcje.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. Dodaj nowy plik wewnątrz Hello katalog o nazwie FibonacciGenerator.cs następującym kodem: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. Zmiana Main method in Class metoda swoje Program.cs plik, aby utworzyć nowe wystąpienie klasy i wywołać jej metodę jak w poniższym przykładzie: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. Wykonaj dotnet build skompilować zmiany.Execute dotnet build to compile the changes.

  4. Uruchom aplikację, wykonując dotnet run .Run your app by executing dotnet run. Poniżej przedstawiono dane wyjściowe programu:The following shows the program output:

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

I to wszystko!And that's it! Teraz można uruchomić przy użyciu podstawowych pojęć w tym miejscu przedstawiono tworzenie własnych programów.Now, you can start using the basic concepts learned here to create your own programs.

Należy pamiętać, że polecenia i kroki opisane w tym samouczku do uruchamiania aplikacji są używane tylko w czasie projektowania.Note that the commands and steps shown in this tutorial to run your application are used during development time only. Gdy wszystko będzie gotowe do wdrożenia aplikacji, należy spojrzeć na poszczególne strategie wdrażania dla aplikacji platformy .NET Core i dotnet publish polecenia.Once you're ready to deploy your app, you'll want to take a look at the different deployment strategies for .NET Core apps and the dotnet publish command.

Zobacz takżeSee also