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

W tym temacie opisano, jak można rozpocząć tworzenie aplikacji cross platform na tym 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 znasz zestaw narzędzi interfejsu wiersza polecenia platformy .NET Core odczytu Omówienie zestawu SDK programu .NET Core.If you're unfamiliar with the .NET Core CLI toolset, read the .NET Core SDK overview.

Wymagania wstępnePrerequisites

Witaj, aplikacji konsoli!Hello, Console App!

Możesz wyświetlić lub pobrać przykładowy kod z repozytorium GitHub dotnet/próbek.You can view or download the sample code from the dotnet/samples GitHub repository. Instrukcje pobrania, 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 i wpisz następujące polecenie:Navigate to the folder you created and type the following:

$ dotnet new console
$ dotnet restore
$ dotnet run

Poznajmy Szybkie wskazówki:Let's do a quick walkthrough:

  1. $ dotnet new console

    dotnet new Tworzy aktualne Hello.csproj pliku projektu z zależnościami, które są niezbędne do tworzenia aplikacji konsoli.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, podstawowe 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>netcoreapp1.0</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 Określa tag tworzymy plik wykonywalny, innymi słowy aplikacji konsoli.The OutputType tag specifies that we're building an executable, in other words a console application.
    • TargetFramework Tag Określa, jakie implementacji .NET możemy docelowych.The TargetFramework tag specifies what .NET implementation we're targeting. Realizując bardziej zaawansowany scenariusz, można określić wiele platform docelowych i kompilacji 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 firma Microsoft będzie osadzania kompilowanie 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 podstawowe konstrukcji string, lub typy liczbowe.The System namespace includes basic constructs such as string, or numeric types.

    Następnie definicję przestrzeni nazw o nazwie Hello.We then define a namespace called Hello. Można to zmienić, do dowolnych znaków.You can change this to anything you want. Klasa o nazwie Program jest zdefiniowany w tej przestrzeni nazw z Main metody pobierającej tablicy ciągów jako jej argument.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 przekazana wywołanego skompilowany program.This array contains the list of arguments passed in when the compiled program is called. Ta tablica nie jest używany, jak: wszystkich zadań programu jest napisanie "Witaj świecie!"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 ona uruchamiana niejawnie przez wszystkie polecenia, które wymagają przywracania było, takich 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, w którym podczas przywracania jawne ma sens, takich jak kompilacje ciągłej integracji w programie Visual Studio Team Services lub w systemach kompilacji, które trzeba 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 Visual Studio Team Services or in build systems that need to explicitly control the time at which the restore occurs.

  2. $ dotnet restore

    dotnet restore Wywołano NuGet (.NET package manager) w celu przywrócenia drzewie 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 określone w pliku (lub grabs je z pamięci podręcznej na komputerze) i zapisuje obj/project.assets.json pliku.NuGet analyzes the Hello.csproj file, downloads the dependencies stated in the file (or grabs them from a cache on your machine), and writes the obj/project.assets.json file. Project.assets.json plik jest niezbędny można było skompilować i uruchomić.The project.assets.json file is necessary to be able to compile and run.

    Project.assets.json plik jest utrwalona i pełny zestaw wykres zależności NuGet i inne informacje opisujące aplikację.The project.assets.json file is a persisted and complete set of the graph of NuGet dependencies and other information describing an app. Ten plik jest odczytywany przez innych narzędzi, takich jak dotnet build i dotnet run , umożliwiając im procesu kodu źródłowego z poprawny zestaw zależności NuGet i powiązanie rozwiązania.This file is read by other tools, such as dotnet build and dotnet run, enabling them to process the source code with a correct set of NuGet dependencies and binding resolutions.

  3. $ dotnet run

    dotnet run wywołania dotnet build do upewnij się, że kompilacji są wbudowane elementy docelowe, a następnie wywołania dotnet <assembly.dll> do uruchomienia 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ż wykonywać dotnet build skompilować kod bez uruchamiania Kompilowanie aplikacji konsoli.Alternatively, you can also execute dotnet build to compile the code without running the build console applications. Powoduje to skompilowanej aplikacji jako plik DLL, który może być uruchamiane przy dotnet bin\Debug\netcoreapp1.0\Hello.dll w systemie Windows (Użyj / dla systemów z systemem innym niż Windows).This results in a compiled application as a DLL file that can be run with dotnet bin\Debug\netcoreapp1.0\Hello.dll on Windows (use / for non-Windows systems). Argumenty do aplikacji mogą określać również, jak można zauważyć później na temat.You may also specify arguments to the application as you'll see later on the topic.

    $ dotnet bin\Debug\netcoreapp1.0\Hello.dll
    Hello World!
    

    W ramach scenariusza zaawansowanego jest możliwe utworzenie aplikacji jako autonomiczny zestaw plików specyficzne dla platformy, które mogą być wdrożone i uruchom na komputerze, na którym nie muszą być .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 wdrażanie aplikacji .NET Core szczegółowe informacje.See .NET Core Application Deployment for details.

Rozbudować programAugmenting the program

Zmieńmy nieco program.Let's change the program a bit. Numery Fibonacci fun, więc Dodajmy oprócz Użyj argument greet osoby uruchomiona aplikacja.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ść z 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. Wykonanie dotnet build do kompilacji zmian.Execute dotnet build to compile the changes.

  3. Uruchom program przekazanie 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 już wszystko!And that's it! Można rozszerzyć Program.cs żadnym chcesz.You can augment Program.cs any way you like.

Praca z wieloma plikamiWorking with multiple files

Pojedynczych plików jest poprawna dla programów jednorazowe prostego, ale jeśli tworzysz złożonych aplikacji jest teraz zawierają wiele plików źródłowych w projekcie najczęściej kompilacji wylogowuje na poprzednim przykładzie Fibonacci przez buforowanie niektórych wartości Fibonacci i dodać niektóre 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. Zmień Main metody w Twojej Program.cs plik, aby utworzyć wystąpienia klasy nowy i Wywołaj 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. Wykonanie dotnet build do kompilacji zmian.Execute dotnet build to compile the changes.

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

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

I to już wszystko!And that's it! Teraz możesz rozpocząć używać, podstawowe koncepcje przedstawiono w tym miejscu do tworzenia własnych programów.Now, you can start using the basic concepts learned here to create your own programs.

Należy pamiętać, że poleceń i kroki opisane w tym samouczku do uruchamiania aplikacji są używane tylko w czasie tworzenia.Note that the commands and steps shown in this tutorial to run your application are used during development time only. Gdy wszystko jest gotowe do wdrożenia aplikacji, należy spojrzeć na różnych strategii wdrażania dla aplikacji .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

Organizowanie i testowanie projektów przy użyciu narzędzi interfejsu wiersza polecenia platformy .NET CoreOrganizing and testing projects with the .NET Core CLI tools