使用命令行开始你的netcore之路

321231255

在Windows/Linux/macOS 下使用命令行开始你的.netcore 之路

准备：

sdk工具:官方提供、最后的latest .NET Core CLI t工具：官方提供

hellow  控制台app

using System;
namespace ConsoleApplication
{
   public clss Program
   {
       public static void Main(string[] args)
       {
           Console.WriteLine("Hello World!");
       }
   }
}
$ dotnet new
$ dotnet restore
$ dotnet run

快速开始：
$ dotnet new
创建一个 project.json 文件以完成依赖关系和程序的入口点.

{
    "version": "1.0.0-*",
    "buildOptions": {
        "emitEntryPoint": true
    },
    "dependencies": {
        "Microsoft.NETCore.App": {
            "type": "platform",
            "version": "1.0.0"
        }
    },  
   "frameworks": {
        "netcoreapp1.0": {
            "imports": "dnxcore50"
        }
    }
}

Program.cs:

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

$ dotnet restore
分析 project.json 文件, 下载依赖并返回结果。 (或 从一个 cache 机器 grabs ), 写 project.lock.json 文件.
project.lock.json 文件：准许和完成NuGet的graph。 其他工具将读取它，如： dotnet build 和 dotnet run, 即保证用一个正确的方式处理原代码。即： NuGet 依赖和和绑定方案.
$ dotnet run
调用dotnet build 建造运行，调用dotnet来运行应用..

$ dotnet run
Hello, World!

可以用dotnet build 来编译代码：修改 project.json 文件来满足你的要求。
首先删除"type": "platform" 依赖元素. 这个项目仅依赖"Microsoft.NETCore.App".

"dependencies": {
   "Microsoft.NETCore.App": {
       "version": "1.0.0"
   }
},

接着指明一个目标环境的运行节点,.以下为：Windows 10  64 位版本 和 Mac OS X 的 10.1版本1

"runtimes": {
"win10-x64": {},
"osx.10.11-x64": {}


$ dotnet restore
$ dotnet build
$ .\bin\Debug\netcoreapp1.0\win10-x64\HelloNative.exe
Hello World!

您会注意到本地应用程序需要长时间build，但运行速度快一些。随着应用程序的增长，变得更加明显。
build 进程产生一些文件. 文件在 bin\Debug\netcoreapp1.0\中，RID 选项是.项目的hellonative.dll,有一个hellonative.exe，它完成运行库加载和启动应用程序。注意，所生成的应用程序的名称被更改，因为项目目录的名称已更改。
您可能希望将此应用程序包,放在网络运行时的机器上执行。请使用DotNet命令发布。 DotNet发布命令创建一个新的子目录。/bin/debug / netcoreapp1.0 / < >目录称为发布平台。它复制可执行文件，所有相关的DLL和框架，可以将该目录复制到另一台机器（或一个容器）并在那里执行应用程序。
以下为：第一个Hello World示例发布。程序是一个可移植的应用程序，默认类型的应用程序。一种便携式应用程序，在目标机器上安装了一个网络核心。便携式应用可以建立在一台机器上，并在任何地方执行。本地应用程序必须单独为每个目标机构建。DotNet发布创建一个目录，应用程序的dll，和任何相关的DLL，不是平台安装部分。
建议program
让我们改变文件一点点。斐波那契数列是有趣的：
Program.cs:

using static System.Console;
namespace ConsoleApplication
{
   public class Program
   {
       public 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;  
       }

       public static void Main(string[] args)
       {
           WriteLine("Hello World!");
           WriteLine("Fibonacci Numbers 1-15:");

           for (int i = 0; i < 15; i++)
           {
               WriteLine($"{i+1}: {FibonacciNumber(i)}");
           }
       }
   }
}

开始运行：假设在windows里，项目目录为： Fibonacci：

$ dotnet build
$ .\bin\Debug\netcoreapp1.0\win10-x64\Fibonacci.exe
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

单一的文件是简单的一次性程序，多个文件有多个组件。多个文件是一种好的方法。 创建一个新的文件，并给它一个唯一的命名空间：:

using System;
namespace NumberFun
{
   // code can go here
}
以下是 Program.cs文件:
using static System.Console;
using NumberFun;<< span="">

build它:
$ dotnet build
使新的文件做一些事情            
例如：一个斐波那契序列发生，比如说建立了以前的斐波那契，缓存一些斐波纳中间值和添加一些递归。更好的斐波那契的例子看起来像这样：

using System;
using System.Collections.Generic;

namespace NumberFun
{
   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 IEnumerableGenerate(int n)
       {
           for (int i = 0; i < n; i++)
           {
               yield return FibValue(i);
           }
       }
   }
}

注意，使用Dictionary< int，int，int>和IEnumerable均在System.Collections namespace< >系统中。microsoft.netcore.app包是一元软件包，包含了许多NET框架的核心组件。通过包括本元软件包，你已经有system.collections.dll组件作为项目的一部分。你可以通过运行验证这个模块发布和检查是安装包的一部分文件。你会看到列表中的system.collections.dll。

{
"version": "1.0.0-*",
"buildOptions": {
   "debugType": "portable",
   "emitEntryPoint": true
},
"dependencies": {},
"frameworks": {
   "netcoreapp1.0": {
     "dependencies": {
       "Microsoft.NETCore.App": {
         "version": "1.0.0"
       }
     },
     "imports": "dnxcore50"
   }
},
"runtimes": {
   "win10-x64": {},
   "osx.10.11-x64": {}
}
}

调整在Program.cs文件下main()方法、如下所示。假设cs使用System；声明，有一个使用using static System.Console。

public static void Main(string[] args)
{
   var generator = new FibonacciGenerator();
   foreach (var digit in generator.Generate(15))
   {
       WriteLine(digit);
   }
}
完成运行
$ dotnet run
0
1
1
2
3
5
8
13
21
34
55
89
144
233
377

使用文件夹组织代码，通过添加多个文件，确保给他们的命名空间.
/MyProject
|__Program.cs
|__AccountInformation.cs
|__MonthlyReportRecords.cs
|__project.json
当你的项目的规模相对较小，这是伟大的作品。然而，如果你有一个更大的应用程序，有许多不同的数据类型和潜在的多个层，这是文件夹的发挥。你可以创建自己的文件和文件夹。            
/NewTypes
|__/Model
|__Program.cs
|__project.json
增加新的类型到文件夹:
/NewTypes
|__/Model
  |__AccountInformation.cs
  |__MonthlyReportRecords.cs
|__Program.cs
|__project.json
同一个目录使用同一个明媚空间
Program.cs.
Example: Pet Types
以下为创建两个新类型例子.
Folder Structure:
/NewTypes
|__/Pets
  |__Dog.cs
  |__Cat.cs
  |__IPet.cs
|__Program.cs
|__project.json

IPet.cs：
using System;
namespace Pets
{
   public interface IPet
   {
       string TalkToOwner();
   }
}
Dog.cs:
using System;
namespace Pets
{
   public class Dog : IPet
   {
       public string TalkToOwner() => "Woof!";
   }
}
Cat.cs:
using System;
namespace Pets
{
   public class Cat : IPet
   {
       public string TalkToOwner() => "Meow!";
   }
}
Program.cs:
using System;
using Pets;
using System.Collections.Generic;
namespace ConsoleApplication
{
   public class Program
   {
       public static void Main(string[] args)
       {
           Listpets = new List
           {
               new Dog(),
               new Cat()  
           };

           foreach (var pet in pets)
           {
               Console.WriteLine(pet.TalkToOwner());
           }
       }
   }
}
project.json:
{
"version": "1.0.0-*",
"buildOptions": {
   "emitEntryPoint": true
},
"dependencies": {
   "Microsoft.NETCore.App": {
     "type": "platform",
     "version": "1.0.0"
   }
},
"frameworks": {
   "netcoreapp1.0": {
     "imports": "dnxcore50"
   }
}
}

开始运行

$ dotnet restore
$ dotnet run<< span="">

Woof!
Meow!

新的宠物类型可以添加（如鸟），扩展这个项目。
这里有一个很好的方法来做：动源你现有的项目进入了一个新的SRC文件夹。

/Project
|__/src
1.Create a /test directory.
/Project
|__/src
|__/test
2，Create a new global.json file:
/Project
|__/src
|__/test
|__global.json
3.global.json:
{
  "projects": [
     "src", "test"
  ]
}

该文件告诉构建系统，这是一个多项目系统，它允许寻找依赖关系，而不仅仅是当前文件夹中的执行情况。这是很重要的，因为它允许您将依赖于测试项目中的代码放在测试中。 例如：扩展新项目 现在项目系统已就位，您可以创建测试项目并开始编写测试项目！从这里开始，本指南将使用和扩展示例类型项目。此外，它将使用xUnit测试框架。随时按照或创建自己的多项目系统测试。
整个项目结构应该是这样的：   
/NewTypes
|__/src
  |__/NewTypes
     |__/Pets
        |__Dog.cs
        |__Cat.cs
        |__IPet.cs
     |__Program.cs
     |__project.json
|__/test
  |__NewTypesTests
     |__PetTests.cs
     |__project.json
|__global.json

有两个新的东西，以确保你在你的测试项目：
一个正确的project.json
参考xUnit
参考模块测试xUnit
在测试中对应于代码的命名空间的引用
XUnit测试类。
newtypestests / project.json： :

{
"version": "1.0.0-*",
"testRunner": "xunit",

"dependencies": {
   "Microsoft.NETCore.App": {
     "type":"platform",
     "version": "1.0.0"
   },
   "xunit":"2.2.0-beta2-build3300",
   "dotnet-test-xunit": "2.2.0-preview2-build1029",
   "NewTypes": "1.0.0"
},
"frameworks": {
   "netcoreapp1.0": {
     "imports": [
       "dnxcore50",
       "portable-net45+win8"
     ]
   }
}

PetTests.cs:

using System;
using Xunit;
using Pets;
public class PetTests
{
   [Fact]
   public void DogTalkToOwnerTest()
   {
       string expected = "Woof!";
       string actual = new Dog().TalkToOwner();

       Assert.Equal(expected, actual);
   }

   [Fact]
   public void CatTalkToOwnerTest()
   {
       string expected = "Meow!";
       string actual = new Cat().TalkToOwner();

       Assert.Equal(expected, actual);
   }
}}

现在开始测试，请确保在顶级目录
$ dotnet restore
$ cd test/NewTypesTests
$ dotnet test
输出:
xUnit.net .NET CLI test runner (64-bit win10-x64)
Discovering: NewTypesTests
Discovered:  NewTypesTests
Starting:    NewTypesTests
Finished:    NewTypesTests
=== TEST EXECUTION SUMMARY ===
  NewTypesTests  Total: 2, Errors: 0, Failed: 0, Skipped: 0, Time: 0.144s
SUMMARY: Total: 1 targets, Passed: 1, Failed: 0.