通过命令行开始在 Windows/Linux/macOS 上使用 .NET CoreGet started with .NET Core on Windows/Linux/macOS using the command line

本文内容

本主题将演示如何使用 .NET Core CLI 工具开始在计算机上开发跨平台应用。

如果熟悉 .NET Core CLI 工具集，请阅读 .NET Core SDK 概述。

系统必备Prerequisites

  • .NET Core SDK 2.1 或更高版本。
  • 按需选择的文本编辑器或代码编辑器。

Hello，控制台应用！Hello, Console App!

若要查看或下载示例代码，可以访问 dotnet/samples GitHub 存储库。有关下载说明，请参阅示例和教程。

打开命令提示符，创建一个名为“Hello” 的文件夹。导航到创建的文件夹，键入下列内容：

  1. dotnet new console
  2. dotnet run

让我们进行快速演练：

  • dotnet new console

dotnet new 会创建一个最新的 Hello.csproj 项目文件，其中包含生成控制台应用所必需的依赖项。它还将创建 Program.cs，这是包含应用程序的入口点的基本文件。

Hello.csproj：

  1. <Project Sdk="Microsoft.NET.Sdk">
  3.   <PropertyGroup>
  4.     <OutputType>Exe</OutputType>
  5.     <TargetFramework>netcoreapp2.2</TargetFramework>
  6.   </PropertyGroup>
  8. </Project>

项目文件指定还原依赖项和生成程序所需的一切。

  • OutputType 标记指定我们要生成的可执行文件，即控制台应用程序。
  • TargetFramework 标记指定要定位的 .NET 实现代码。在高级方案中，可以指定多个目标框架，并在单个操作中生成所有目标框架。在本教程中，我们将仅针对 .NET Core 2.1 进行生成。Program.cs：
  1. using System;
  3. namespace Hello
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             Console.WriteLine("Hello World!");
  10.         }
  11.     }
  12. }

该程序从 using System 开始，这意味着“将 System 命名空间中的所有内容都纳入此文件的作用域”。System 命名空间包括基本结构，如 string 或数值类型。

接着定义一个名为 Hello 的命名空间。你可以将其更改为任何你喜欢的名称。在该命名空间中定义了一个名为 Program 的类，其中 Main 方法将字符串数组作为其参数。此数组包含在调用编译的程序时所传递的参数列表。按照这样，不使用此数组：程序所进行的全部操作就是编写“Hello World!”“Hello World!”。稍后将对使用此参数的代码进行更改。

备注

从 .NET Core 2.0 SDK 开始，无需运行 dotnet restore，因为它由所有需要还原的命令隐式运行，如 dotnet new、dotnet build 和 dotnet run。在执行显式还原有意义的某些情况下，例如 Azure DevOps Services 中的持续集成生成中，或在需要显式控制还原发生时间的生成系统中，它仍然是有效的命令。

dotnet new 隐式调用 dotnet restore。dotnet restore 调用到 NuGet（.NET 包管理器）以还原依赖项树。NuGet 分析 Hello.csproj 文件、下载文件中定义的依赖项（或从计算机缓存中获取）并编写 obj/project.assets.json 文件，在编译和运行示例时需要使用该文件。

重要

如果你使用的是 .NET Core 1.x 版本的 SDK，在调用 dotnet new 后，必须自行调用 dotnet restore。

  • dotnet run

dotnet run 调用 dotnet build 来确保已生成要生成的目标，然后调用 dotnet <assembly.dll> 运行目标应用程序。

  1. $ dotnet run
  2. Hello World!

或者，还可以执行 dotnet build 来编译代码，无需运行已生成的控制台应用程序。这使得编译的应用程序（作为 DLL 文件）可以在 Windows 上使用 dotnet bin\Debug\netcoreapp2.1\Hello.dll 运行（将 / 用于非 Windows 系统）。还可以对应用程序指定参数，相关操作将在本主题稍后部分进行介绍。

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

在高级方案中，可以将应用程序作为独立的特定于平台的文件集生成，该应用程序可以在未安装 .NET Core 的计算机上部署或运行。请参阅 .NET Core 应用程序部署了解详细信息。

扩充程序Augmenting the program

让我们稍微更改一下程序。Fibonacci 数字很有意思，那么除了使用参数，让我们也来添加 Fibonacci 数字，让运行应用的用户开心一下。

  • 将 Program.cs 文件的内容替换为以下代码：
  1. using System;
  3. namespace Hello
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             if (args.Length > 0)
  10.             {
  11.                 Console.WriteLine($"Hello {args[0]}!");
  12.             }
  13.             else
  14.             {
  15.                 Console.WriteLine("Hello!");
  16.             }
  18.             Console.WriteLine("Fibonacci Numbers 1-15:");
  20.             for (int i = 0; i < 15; i++)
  21.             {
  22.                 Console.WriteLine($"{i + 1}: {FibonacciNumber(i)}");
  23.             }
  24.         }
  26.         static int FibonacciNumber(int n)
  27.         {
  28.             int a = 0;
  29.             int b = 1;
  30.             int tmp;
  32.             for (int i = 0; i < n; i++)
  33.             {
  34.                 tmp = a;
  35.                 a = b;
  36.                 b += tmp;
  37.             }
  39.             return a;
  40.         }
  42.     }
  43. }

  • 执行 dotnet build 以编译更改。

  • 运行向应用传递参数的程序：

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

就是这么简单！可以按任意喜欢的方式扩充 Program.cs。

使用多个文件Working with multiple files

单个文件适用于简单的一次性程序，但如果要构建较为复杂的应用，则项目中可能会有多个源文件。我们通过缓存一些 Fibonacci 值并添加一些递归特性来基于之前的 Fibonacci 示例进行构建。

  • 使用以下代码将新文件添加到名为 FibonacciGenerator.cs 的 Hello 目录：
  1. using System;
  2. using System.Collections.Generic;
  4. namespace Hello
  5. {
  6.     public class FibonacciGenerator
  7.     {
  8.         private Dictionary<int, int> _cache = new Dictionary<int, int>();
  10.         private int Fib(int n) => n < 2 ? n : FibValue(n - 1) + FibValue(n - 2);
  12.         private int FibValue(int n)
  13.         {
  14.             if (!_cache.ContainsKey(n))
  15.             {
  16.                 _cache.Add(n, Fib(n));
  17.             }
  19.             return _cache[n];
  20.         }
  22.         public IEnumerable<int> Generate(int n)
  23.         {
  24.             for (int i = 0; i < n; i++)
  25.             {
  26.                 yield return FibValue(i);
  27.             }
  28.         }
  29.     }
  30. }
  • 更改 Program.cs 文件中的 Main 方法，以实例化新的类并调用其方法，如下例所示：
  1. using System;
  3. namespace Hello
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             var generator = new FibonacciGenerator();
  10.             foreach (var digit in generator.Generate(15))
  11.             {
  12.                 Console.WriteLine(digit);
  13.             }
  14.         }
  15.     }
  16. }
  1. $ dotnet run
  2. 0
  3. 1
  4. 1
  5. 2
  6. 3
  7. 5
  8. 8
  9. 13
  10. 21
  11. 34
  12. 55
  13. 89
  14. 144
  15. 233
  16. 377

发布你的应用Publish your app

准备好分发应用后，使用 dotnet publish 命令在 bin\debug\netcoreapp2.1\publish\ （非 Windows 系统使用 /）处生成 publish 文件夹。可以将 publish 文件夹的内容分发到其他平台，只要这些平台安装了 dotnet 运行时即可。

可以使用 dotnet 命令运行已发布的应用：

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

结束语Conclusion

就是这么简单！现在，可以开始使用此处学到的基本概念来创建自己的程序了。

请参阅See also