.NETCore-クイックガイド

.NET Coreは、Microsoftが管理する最新の汎用開発プラットフォームです。さまざまなプラットフォームで機能し、.NETを高速、柔軟、最新の状態にするように再設計されています。これは、Microsoftによる主要な貢献の1つです。開発者は、.NETを使用してAndroid、iOS、Linux、Mac、およびWindowsアプリケーションをすべてオープンソースで構築できるようになりました。

このチュートリアルでは、.NET Coreと、.NET Frameworkの更新、.NET Standard、ユニバーサルWindowsプラットフォームの更新などのいくつかの新しいイノベーションについて説明します。

.NETCoreの特徴

.NETCoreの主な特徴は次のとおりです。

オープンソース

  • .NET Coreは、MITおよびApache2ライセンスを使用したオープンソースの実装です。

  • .NETCoreは.NETFoundationプロジェクトであり、GitHubで入手できます。

  • オープンソースプロジェクトとして、より透明性の高い開発プロセスを促進し、活発で熱心なコミュニティを促進します。

クロスプラットフォーム

  • .NET Coreに実装されたアプリケーションを実行でき、プラットフォームのターゲットに関係なくそのコードを再利用できます。

  • 現在、3つの主要なオペレーティングシステム（OS）をサポートしています

    • Windows

    • Linux

    • MacOS

  • サポートされているオペレーティングシステム（OS）、CPU、およびアプリケーションシナリオは、Microsoft、他の企業、および個人によって提供され、時間の経過とともに成長します。

柔軟な展開

  • .NETCoreアプリケーションの展開には2つのタイプがあります-

    • フレームワークに依存する展開

    • 自己完結型の展開

  • フレームワークに依存する展開では、アプリは、アプリとサードパーティの依存関係がインストールされているシステム全体のバージョンの.NETCoreに依存します。

  • 自己完結型のデプロイメントでは、アプリケーションの構築に使用される.NET Coreバージョンも、アプリおよびサードパーティの依存関係とともにデプロイされ、他のバージョンと並行して実行できます。

コマンドラインツール

  • すべての製品シナリオは、コマンドラインで実行できます。

互換性があります

  • .NET Coreは、.NET Standard Libraryを介して、.NET Framework、Xamarin、Monoと互換性があります。

基本単位

  • .NET Coreは、NuGetを介して小さなアセンブリパッケージでリリースされます。

  • .NET Frameworkは、ほとんどのコア機能を含む1つの大きなアセンブリです。

  • .NET Coreは、より小さな機能中心のパッケージとして提供されます。

  • このモジュラーアプローチにより、開発者はアプリに必要なNuGetパッケージだけを含めることでアプリを最適化できます。

  • アプリの表面積を小さくすることの利点には、セキュリティの強化、サービスの削減、パフォーマンスの向上、従量課金モデルのコストの削減などがあります。

.NETCoreプラットフォーム

.NET Core Platformには、次の主要部分が含まれています-

  • .NET Runtime −型システム、アセンブリのロード、ガベージコレクタ、ネイティブ相互運用、およびその他の基本的なサービスを提供します。

  • Fundamental Libraries −プリミティブデータ型、アプリ構成タイプ、および基本的なユーティリティを提供するフレームワークライブラリのセット。

  • SDK & Compiler − .NET Core SDKで利用可能な、基本的な開発者エクスペリエンスを可能にするSDKツールと言語コンパイラのセット。

  • ‘dotnet’ app host− .NETCoreアプリの起動に使用されます。ランタイムを選択してランタイムをホストし、アセンブリの読み込みポリシーを提供してアプリを起動します。同じホストを使用して、SDKツールをほぼ同じ方法で起動します。

この章では、デプロイして実行する必要のあるさまざまな依存関係について説明します。これには、VisualStudioを使用して開発されたWindowsマシン上の.NETCoreアプリケーションが含まれます。

サポートされているWindowsバージョン

.NET Coreは、次のバージョンのWindowsでサポートされています-

  • Windows 7 SP1
  • Windows 8.1
  • ウィンドウズ10
  • Windows Server 2008 R2 SP1（フルサーバーまたはサーバーコア）
  • Windows Server 2012 SP1（フルサーバーまたはサーバーコア）
  • Windows Server 2012 R2 SP1（フルサーバーまたはサーバーコア）
  • Windows Server 2016（フルサーバー、サーバーコアまたはナノサーバー）

依存関係

  • .NETCoreアプリケーションをWindows10およびWindowsServer 2016より前のバージョンのWindowsで実行している場合は、Visual C ++再頒布可能パッケージも必要になります。

  • .NET Coreインストーラーを使用すると、この依存関係が自動的にインストールされます。

  • インストーラースクリプトを介して.NETCoreをインストールする場合、または自己完結型の.NET Coreアプリケーションを展開する場合は、Visual Studio2015用のVisualC ++再頒布可能パッケージを手動でインストールする必要があります。

  • Windows7およびWindowsServer 2008マシンの場合、Windowsのインストールが最新であり、WindowsUpdateを通じてインストールされた修正プログラムKB2533623が含まれていることを確認する必要があります。

VisualStudioの前提条件

  • .NET CoreSDKを使用して.NETCoreアプリケーションを開発するには、任意のエディターを使用できます。

  • ただし、VisualStudioを使用してWindowsで.NETCoreアプリケーションを開発する場合は、次の2つのバージョンを使用できます。

    • Visual Studio 2015

    • Visual Studio 2017 RC

  • Visual Studio 2015で作成されたプロジェクトはデフォルトでproject.jsonベースになりますが、Visual Studio 2017RCで作成されたプロジェクトは常にMSBuildベースになります。

この章では、.NETCoreの環境設定について説明します。これは、.NETFrameworkの大幅な再設計です。アプリケーションで.NETCoreを使用するには、2つのバージョンを使用できます-

  • Visual Studio 2015
  • Visual Studio 2017 RC

Visual Studio 2015

Visual Studio 2015を使用するには、次のものをインストールしておく必要があります-

  • Microsoft Visual Studio 2015 Update 3
  • Microsoft .NET Core 1.0.1-VS 2015 Tooling Preview 2

Microsoftは、SQL Serverも含み、からダウンロードできるVisualStudioの無料バージョンを提供しています。 https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx およびMicrosoft.NET Core 1.0.1-VS 2015 Tooling Preview2はからダウンロードできます。 https://www.visualstudio.com/downloads/

次のURLのインストールガイドラインに従うこともできます https://www.microsoft.com/net/core/#windowsvs2017

Visual Studio2015のインストール

次の手順に従って、Visual Studio2015をインストールします-

Step 1−ダウンロードが完了したら、インストーラーを実行します。以下のダイアログボックスが表示されます。

Step 2 −クリック Install インストールプロセスを開始します。

Step 3 −インストールが完了すると、次のダイアログボックスが表示されます。

Step 4 −このダイアログを閉じ、必要に応じてコンピュータを再起動します。

Step 5−スタートメニューからVisualStudioを開きます。次のダイアログボックスが表示されます。ロードして最終的に初めて使用するまでに数分かかる場合があります。

Step 6 −ロードされると、次の画面が表示されます。

Step 7 − Visual Studioのインストールが完了したら、Visual Studioを閉じて、Microsoft .NETCoreを起動します-VS2015 Tooling Preview2。

Step 8 −チェックボックスをオンにして、[インストール]をクリックします。

Step 9 −インストールが完了すると、次のダイアログボックスが表示されます。

これで、.NETCoreを使用してアプリケーションを起動する準備が整いました。

Visual Studio 2017

このチュートリアルでは、Visual Studio 2015を使用しますが、Visual Studio 2017を使用する場合は、VisualStudio用の.NETCoreツールの実験的なリリースがVisualStudio 2017 RCに含まれており、インストールのガイドラインをここで確認できます。 https://www.microsoft.com/net/core/#windowsvs2017

Visual Studio 2015は、.NETCoreアプリケーションを開発するためのフル機能の開発環境を提供します。この章では、VisualStudio内に新しいプロジェクトを作成します。Visual Studio 2015ツールをインストールしたら、新しい.NETCoreアプリケーションの構築を開始できます。

の中に New Project ダイアログボックスの[テンプレート]リストで、[Visual C＃]ノードを展開し、[。NET Core]を選択すると、次の3つの新しいプロジェクトテンプレートが表示されます。

  • クラスライブラリ（.NET Core）
  • コンソールアプリケーション（.NET Core）
  • ASP.NET Core Webアプリケーション（.NET Core）

[新しいプロジェクト]ダイアログボックスの中央のウィンドウで、[コンソールアプリケーション（.NET Core）]を選択し、「FirstApp」という名前を付けて、[OK]をクリックします。

Visual Studioは新しく作成されたプロジェクトを開き、ソリューションエクスプローラーウィンドウにこのプロジェクトにあるすべてのファイルが表示されます。

.NETコアコンソールアプリケーションが機能していることをテストするために、次の行を追加しましょう。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace FirstApp { 
   public class Program { 
      public static void Main(string[] args) { 
         Console.WriteLine("Hello guys, welcome to .NET Core world!"); 
      } 
   } 
}

次に、アプリケーションを実行します。次の出力が表示されます。

.NET Coreは、標準の数値積分および浮動小数点プリミティブをサポートしています。次のタイプもサポートします-

  • System.Numerics.BigIntegerは、上限または下限のない整数型です。

  • System.Numerics.Complexは、複素数を表す型です。

  • System.Numerics名前空間内の単一命令複数データ（SIMD）対応のベクタータイプのセット。

整数型

.NET Coreは、長さが1バイトから8バイトまでのさまざまな範囲の符号付き整数と符号なし整数の両方をサポートします。すべての整数は値型です。

次の表は、整数型とそのサイズを表しています。

タイプ 署名済み/署名なし サイズ（バイト） 最小値 最大値
バイト 署名なし 1 0 255
Int16 署名済み 2 −32,768 32,767
Int32 署名済み 4 −2,147,483,648 2,147,483,647
Int64 署名済み 8 −9,223,372,036,854,775,808 9,223,372,036,854,775,807
SByte 署名済み 1 -128 127
UInt16 署名なし 2 0 65,535
UInt32 署名なし 4 0 4,294,967,295
UInt64 署名なし 8 0 18,446,744,073,709,551,615

各整数型は、算術、比較、等式、明示的変換、および暗黙的変換演算子の標準セットをサポートします。

System.BitConverterクラスを使用して、整数値の個々のビットを操作することもできます。

浮動小数点型

.NET Coreには、次の表に示す3つのプリミティブ浮動小数点型が含まれています。

タイプ サイズ（バイト） 最小値 最大値
ダブル 8 −1.79769313486232e308 1.79769313486232e308
シングル 4 −3.402823e38 3.402823e38
10進数 16 −79,228,162,514,264,337,593,5 43,950,335 79,228,162,514,264,337,593,543,9 50,335

  • 各浮動小数点型は、算術、比較、等式、明示的変換、および暗黙的変換演算子の標準セットをサポートします。

  • BitConverterクラスを使用して、Double値とSingle値の個々のビットを操作することもできます。

  • Decimal構造には、10進値の個々のビットを操作するための独自のメソッドDecimal.GetBitsおよびDecimal.Decimal（Int32（））と、いくつかの追加の数学演算を実行するための独自のメソッドセットがあります。

BigInteger

  • System.Numerics.BigIntegerは、理論上値に上限または下限がない任意の大きさの整数を表す不変の型です。

  • BigIntegerタイプのメソッドは、他の整数タイプのメソッドとほぼ同じです。

繁雑

  • System.Numerics.Complexタイプは、複素数、つまり実数部分と虚数部分を持つ数を表します。

  • 算術、比較、等式、明示的変換、暗黙的変換演算子の標準セット、および数学、代数、三角法をサポートしています。

SIMD

  • Numerics名前空間には、.NETCore用のSIMD対応のベクタータイプのセットが含まれています。

  • SIMDを使用すると、一部の操作をハードウェアレベルで並列化できます。これにより、ベクトルに対して計算を実行する数学、科学、およびグラフィックスアプリのパフォーマンスが大幅に向上します。

  • .NET CoreのSIMD対応のベクタータイプには、次のものがあります。

    • System.Numerics.Vector2、System.Numerics.Vector3、およびSystem.Numerics.Vector4タイプ。これらは、シングルタイプの2、3、および4次元ベクトルです。

    • 任意のプリミティブ数値型のベクトルを作成できるようにするVector <T>構造。プリミティブ数値タイプには、Decimalを除くSystem名前空間のすべての数値タイプが含まれます。

    • 2つのマトリックスタイプ、System.Numerics.Matrix3×2。これは3×2マトリックスを表します。System.Numerics.Matrix4×4は、4×4の行列を表します。

    • 3次元平面を表すSystem.Numerics.Planeタイプと、3次元の物理的回転をエンコードするために使用されるベクトルを表すSystem.Numerics.Quaternionタイプ。

この章では、.NETマネージコードプラットフォームの最も重要な機能の1つであるガベージコレクションの概念について説明します。ガベージコレクタ（GC）は、メモリの割り当てと解放を管理します。ガベージコレクタは、自動メモリマネージャとして機能します。

  • メモリを割り当てて解放する方法や、そのメモリを使用するオブジェクトの存続期間を管理する方法を知る必要はありません。

  • 「new」キーワードを使用してオブジェクトを宣言するか、値タイプがボックス化されるたびに、割り当てが行われます。通常、割り当ては非常に高速です

  • オブジェクトを割り当てるのに十分なメモリがない場合、GCはガベージメモリを収集して破棄し、メモリを新しい割り当てに使用できるようにする必要があります。

  • このプロセスは、 garbage collection。

ガベージコレクションの利点

ガベージコレクションには次の利点があります-

  • アプリケーションの開発中に手動でメモリを解放する必要はありません。

  • また、マネージヒープにオブジェクトを効率的に割り当てます。

  • オブジェクトが使用されなくなると、メモリをクリアしてそれらのオブジェクトを再利用し、将来の割り当てに使用できるようにメモリを保持します。

  • 管理対象オブジェクトは、最初から自動的にクリーンなコンテンツを取得するため、コンストラクターがすべてのデータフィールドを初期化する必要はありません。

  • また、オブジェクトが別のオブジェクトのコンテンツを使用できないようにすることで、メモリの安全性も提供します。

ガベージコレクションの条件

ガベージコレクションは、次のいずれかの条件が当てはまる場合に発生します。

  • システムの物理メモリが少なくなっています。

  • 管理対象ヒープに割り当てられたオブジェクトによって使用されるメモリが、許容可能なしきい値を超えています。このしきい値は、プロセスの実行時に継続的に調整されます。

  • ザ・ GC.Collectメソッドが呼び出され、ガベージコレクターが継続的に実行されるため、ほとんどの場合、このメソッドを呼び出す必要はありません。この方法は、主に固有の状況とテストに使用されます。

世代

.NETガベージコレクタには3つの世代があり、各世代には、割り当てられたオブジェクトのストレージに使用される独自のヒープがあります。ほとんどのオブジェクトは短命または長命であるという基本原則があります。

ジェネレーションファースト（0）

  • ジェネレーション0では、オブジェクトが最初に割り当てられます。

  • この世代では、オブジェクトは、次のガベージコレクションが発生するまでに使用されなくなった（スコープ外）ため、多くの場合、最初の世代を超えて存続しません。

  • ジェネレーション0は、関連するヒープが小さいため、すばやく収集できます。

ジェネレーションセカンド（1）

  • 第1世代では、オブジェクトには2番目のチャンススペースがあります。

  • 寿命は短いが、第0世代のコレクション（多くの場合、偶然のタイミングに基づく）を生き残ったオブジェクトは、第1世代に移動します。

  • 関連するヒープも小さいため、第1世代のコレクションも高速です。

  • オブジェクトが収集されるか、次世代ヒープにプロモートされるため、最初の2つのヒープは小さいままです。

ジェネレーションサード（2）

  • 第2世代では、すべての長いオブジェクトが存続し、そのヒープが非常に大きくなる可能性があります。

  • この世代のオブジェクトは長期間存続することができ、オブジェクトをさらに促進する次世代のヒープはありません。

  • ガベージコレクタには、ラージオブジェクトヒープ（LOH）と呼ばれるラージオブジェクト用の追加のヒープがあります。

  • 85,000バイト以上のオブジェクト用に予約されています。

  • ラージオブジェクトは世代別ヒープに割り当てられませんが、LOHに直接割り当てられます

  • 第2世代およびLOHコレクションは、長時間実行されたプログラムや大量のデータを処理するプログラムでは、かなりの時間がかかる場合があります。

  • 大規模なサーバープログラムは、数十GBのヒープを持つことが知られています。

  • GCは、さまざまな手法を使用して、プログラムの実行をブロックする時間を短縮します。

  • 主なアプローチは、プログラムの実行を妨げない方法で、バックグラウンドスレッドで可能な限り多くのガベージコレクション作業を行うことです。

  • GCは、開発者がその動作に影響を与えるためのいくつかの方法も公開します。これは、パフォーマンスを向上させるのに非常に役立ちます。

この章では、.NET Coreの実行プロセスを理解し、.NETFrameworkと比較します。管理実行プロセスには、次の手順が含まれます。

  • コンパイラの選択
  • コードをMSILにコンパイルする
  • MSILをネイティブコードにコンパイルする
  • 実行中のコード

コンパイラの選択

  • これは多言語実行環境であり、ランタイムはさまざまなデータ型と言語機能をサポートします。

  • 共通言語ランタイムによって提供される利点を得るには、ランタイムを対象とする1つ以上の言語コンパイラーを使用する必要があります。

コードをMSILにコンパイルする

  • コンパイルすると、ソースコードがMicrosoft中間言語（MSIL）に変換され、必要なメタデータが生成されます。

  • メタデータは、各タイプの定義、各タイプのメンバーの署名、コードが参照するメンバー、およびランタイムが実行時に使用するその他のデータを含む、コード内のタイプを記述します。

  • ランタイムは、実行中に必要に応じて、ファイルおよびフレームワーククラスライブラリ（FCL）からメタデータを見つけて抽出します。

MSILをネイティブコードにコンパイルする

  • 実行時に、ジャストインタイム（JIT）コンパイラーがMSILをネイティブコードに変換します。

  • このコンパイル中に、コードはMSILとメタデータを調べて、コードがタイプセーフであると判断できるかどうかを確認する検証プロセスに合格する必要があります。

実行中のコード

  • 共通言語ランタイムは、実行を可能にするインフラストラクチャと、実行中に使用できるサービスを提供します。

  • 実行中、マネージコードは、ガベージコレクション、セキュリティ、アンマネージコードとの相互運用性、言語間のデバッグサポート、拡張された展開とバージョン管理のサポートなどのサービスを受け取ります。

.NETCoreコード実行プロセス

次に、.NETFrameworkと比較して.NETCoreでコードがどのように実行されるかを関連付けましょう。.NET Coreには、.NETFrameworkの一部であるこれらのコンポーネントの多くの置き換えがあります。

  • .NET Coreには、C＃およびVB用のRoslynのように、新しい一連のコンパイラがあります。

  • .NET CoreでF＃を使用する場合は、新しいF＃4.1コンパイラを使用することもできます。

  • 実際、これらのツールは異なり、C＃コンパイラはC＃5までしかサポートできないため、C＃6以降を使用している場合は.NETFrameworkでRoslynを使用することもできます。

  • .NET Coreには、フレームワーククラスライブラリ（FCL）がないため、別のライブラリセットが使用され、CoreFxが作成されました。

  • CoreFxは、.NETCoreのクラスライブラリを再実装したものです。

  • また、CoreCLRと呼ばれる.NET Coreの新しいランタイムがあり、JITコンパイラを活用しています。

  • ここで問題となるのは、.NETFrameworkにすでにあるこれらすべてのコンポーネントを再実装する理由です。

  • したがって、答えは、Microsoftが.NETCoreを実装した理由と同じです。

モジュール式のアプリケーションを構築および実装することは、.NETCoreのもう1つの考慮事項です。.NET Framework全体をインストールする代わりに、アプリケーションは必要なものだけをインストールできるようになりました。Visual Studioにアクセスして、モジュール性を確認しましょう。

これが、ソリューションエクスプローラーの単純な.NETCoreアプリケーションです。Referencesを展開すると、.NETCoreAppへの参照が表示されます。

.NETCoreApp内には、NuGetへのパッケージ参照が表示されます。それを拡張しましょう。

NuGetパッケージの一連の参照全体が表示されます。.NET Frameworkで作業したことがある場合は、.NET Frameworkでの使用に慣れているため、これらの名前空間の多くは見覚えがあります。

.NET Frameworkは多くの異なる部分に分割され、CoreFxで再実装されます。これらのピースは、個別のパッケージとしてさらに配布されます。

  • ここで、NETStandard.Libraryを展開すると、追加の参照が表示されます。このアプリケーションで使用しているSystem.Consoleにも気付くでしょう。

  • これで、.NET Framework内にすべてを取り込む必要はありませんが、アプリケーションに必要なものを取り込むだけです。

  • 他にもいくつかの利点があります。たとえば、これらのモジュールは必要に応じて個別に更新できます。

モジュール性はパフォーマンスの向上につながり、アプリケーション、特にASP.NETCoreアプリケーションをより高速に実行できます。

この章では、.NET Coreプロジェクトファイルと、プロジェクトに既存のファイルを追加する方法について説明します。

すでに作成されているファイルがある簡単な例を理解しましょう。これらのファイルをFirstAppプロジェクトに追加する必要があります。

これがの実装です Student.cs ファイル

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace FirstApp { 
   public class Student { 
      public int ID { get; set; } 
      public string LastName { get; set; } 
      public string FirstMidName { get; set; } 
      public DateTime EnrollmentDate { get; set; } 
   } 
}

これがの実装です Course.cs ファイル。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace FirstApp { 
   public class Course { 
      public int CourseID { get; set; } 
      public string Title { get; set; } 
      public int Credits { get; set; } 
   } 
}

これらの3つのファイルをディスクとプロジェクトのソースフォルダーに保存しましょう。

  • .NETに精通していて、これが従来の.NET Frameworkコンソールアプリケーションであった場合は、VisualStudioのプロジェクトにこれらのファイルを追加する方法を理解することが重要です。

  • プロジェクトではこれらのファイルを参照する必要があるため、最初にファイルをソリューションエクスプローラーにドラッグして、プロジェクトフォルダーにコピーする必要があります。

  • .NET Coreの利点の1つは、プロジェクトファイル（project.json）で採用されているアプローチです。ファイルをプロジェクトのルートにドロップするだけで、これらは自動的にプロジェクトに含まれます。

  • VisualStudioの従来の.NETFrameworkアプリケーションでこれまで行ったように、ファイルを手動で参照する必要はありません。

プロジェクトのルートを開きましょう。

3つのファイルすべてをプロジェクトのルートにコピーしましょう。

これで、ルートフォルダにコピーされたすべてのファイルを確認できます。

VisualStudioに行きましょう。次のダイアログボックスが表示されます。

クリック Yes to All プロジェクトをリロードします。

これで、ファイルがプロジェクトに自動的に含まれるようになります。

この章では、.NET Coreアプリケーションにパッケージを追加する方法と、特定のパッケージを見つける方法について説明します。NuGetに直接アクセスしてパッケージを追加できますが、ここでは他の場所もいくつか表示されます。

ここにある.NETCoreのソースコードに行きましょう- https://github.com/dotnet/corefx

CoreFxリポジトリで、 src フォルダ-

また、さまざまなパッケージに対応するフォルダの全リストが表示されます。Jsonを検索してみましょう-

パッケージを見つける別の方法があります。.NETFrameworkに精通していれば、おそらくさまざまなタイプを知っていますが、.NET Coreでのパッケージの組み立てはまったく異なり、そのパッケージがどこにあるのかわかりません。

タイプがわかっている場合は、を使用してパッケージ検索を逆に検索できます。 https://packagesearch.azurewebsites.net/

ここでは、検索したい任意のタイプのパッケージを入力できます。次に、このサイトはNuGetをスキャンして、関連するパッケージを見つけます。

今から検索してみましょう DataContractJson。

これで、同じパッケージを取得することがわかります。パッケージをクリックしてみましょう。

NuGetページが表示されます。このパッケージが必要であることを確認する必要があります。いくつかの方法を使用して、これをアプリケーションに追加できます。

project.jsonファイルを開きましょう。

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

これは新しいプロジェクト形式であり、このファイル内に依存関係セクションが表示されます。以下に示すように、新しい依存関係を追加しましょう。

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

今、あなたがあなたの参照を見るならば、あなたはそれを見るでしょう System.Runtime.Serialization.Json パッケージがプロジェクトに追加されます。

もう1つの方法は、NuGetマネージャーに移動して、追加するパッケージを参照することです。

この章では、.NETCoreを使用してUWPアプリケーションを作成する方法について説明します。UWPは、Windows 10UWPアプリケーションとも呼ばれます。このアプリケーションは、以前のバージョンのWindowsでは実行されませんが、将来のバージョンのWindowsでのみ実行されます。

以下は、UWPがスムーズに実行されるいくつかの例外です。

  • ローカルで実行する場合は、Windows 10が必要です。Windows8で開発してから、エミュレーターで実行する必要がありますが、Windows10を使用することをお勧めします。

  • UWPアプリケーションの場合、Windows 10SDKも必要になります。Visual Studio 2015セットアップを開いてから、VisualStudioを変更してみましょう。

  • [機能の選択]ページで下にスクロールすると、ユニバーサルWindowsアプリ開発ツールが表示されます。以下に示すようにそのオプションをオンにします。

ここでは、SDKのさまざまなバージョンとツールの最新の更新を確認できます。[次へ]をクリックします。

次に、をクリックします Install ボタン。

インストールが完了したら、システムを再起動する必要があります。

次の手順に従って、UWPを実装しましょう。

  • まず、Visual Studio2015を起動します。

  • [ファイル]メニューをクリックして、[新規]→[プロジェクト]を選択します。[新しいプロジェクト]ダイアログが表示されます。ダイアログボックスの左側のペインに、さまざまな種類のテンプレートが表示されます。

  • 左側のペインにツリービューが表示されます。次に、[テンプレート]→[ビジュアルC＃]→[ウィンドウ]から[ユニバーサルテンプレート]を選択します。

  • 中央のペインから、Blank App（Universal Windows）テンプレートを選択します。

  • 次のように入力して、プロジェクトに名前を付けます UWPFirstApp [名前]フィールドで、[OK]をクリックします。

  • ターゲットバージョン/最小バージョンダイアログが表示されます。このチュートリアルではデフォルト設定で問題ないため、[OK]を選択してプロジェクトを作成します。

  • ここでは、すべてのWindows 10デバイスをターゲットにできる単一のプロジェクトがあり、.NETCoreとUWPの両方がマルチターゲットを単純化したことに気付くでしょう。

  • 新しいプロジェクトを開くと、そのファイルがソリューションエクスプローラーペインの右側に表示されます。ファイルを表示するには、[プロパティ]タブではなく[ソリューションエクスプローラー]タブを選択する必要がある場合があります。

  • 空白のアプリ（ユニバーサルウィンドウ）は最小限のテンプレートですが、それでも多くのファイルが含まれています。これらのファイルは、C＃を使用するすべてのUWPアプリに不可欠です。Visual Studioで作成するすべてのプロジェクトには、ファイルが含まれています。

  • 実行例を確認するには、MainPage.XAMLを開いて、次のコードを追加します。

<Page 
   x:Class = "UWPFirstApp.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPFirstApp" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <StackPanel HorizontalAlignment = "Center"> 
         <TextBlock Text = "Hello, world!"  
            Margin = "20" 
            Width = "200" 
            HorizontalAlignment = "Left"/> 
         <TextBlock Text = "Write your name." 
            Margin = "20" 
            Width = "200" 
            HorizontalAlignment = "Left"/> 
         <TextBox x:Name = "txtbox"  
            Width = "280" 
            Margin = "20" 
            HorizontalAlignment = "Left"/> 
         <Button x:Name = "button" Content = "Click Me" 
            Margin = "20" 
            Click = "button_Click"/> 
         <TextBlock x:Name = "txtblock"  
            HorizontalAlignment = "Left" 
            Margin = "20"/> 
      </StackPanel> 
   </Grid> 

</Page>

以下は、C＃のボタンのクリックイベントです。

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using System.Runtime.InteropServices.WindowsRuntime; 

using Windows.Foundation; 
using Windows.Foundation.Collections; 

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Controls.Primitives; 
using Windows.UI.Xaml.Data; 
using Windows.UI.Xaml.Input; 
using Windows.UI.Xaml.Media; 
using Windows.UI.Xaml.Navigation;  

// The Blank Page item template is documented at 
// http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace UWPHellowWorld { 
   /// <summary> 
   /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
   public sealed partial class MainPage : Page { 
      public MainPage() { 
         this.InitializeComponent(); 
      }  
      private void button_Click(object sender, RoutedEventArgs e) { 
         if (txtbox.Text != "") 
            txtblock.Text = "Hello: " + txtbox.Text; 
         else 
            txtblock.Text = "You have not write your name"; 
      } 
   } 
}

上記のコードをローカルマシンで実行すると、次のウィンドウが表示されます。テキストボックスに任意の名前を入力して、Click Me ボタン。

この章では、MSBuildとは何か、およびMSBuildが.NETCoreでどのように機能するかについて説明します。MSBuildは、MicrosoftおよびVisualStudioのビルドプラットフォームです。UWPアプリケーションでプロジェクトフォルダーを開くと、project.jsonファイルと* .csprojファイルの両方が表示されます。

ただし、以前の.NET Core Consoleアプリを開くと、project.jsonファイルと* .xprojファイルが表示されます。

  • .NET Coreビルドシステムまたはproject.jsonビルドシステムは、UWPのニーズには不十分です。これが、UWPがまだ* .csproj（MSBuild）ビルドシステムを使用している理由です。

  • ただし、project.jsonは、ビルドシステムに関する限り移動します。

  • ここで、コンソールアプリで追加したように、いくつかの既存のファイルをUWPアプリケーションに追加する場合は、それらのファイルをプロジェクトフォルダーに追加する必要があります。さらに、ソリューションエクスプローラーのプロジェクトにも含める必要があります。

次のファイルについて考えてみましょう。これらのファイルをプロジェクトフォルダにコピーします。

Visual Studioに戻り、ソリューションエクスプローラーを開きます。

  • ソリューションエクスプローラーではこれらのファイルを表示できないため、UWPアプリケーションの場合はファイルのコピーだけでは不十分であることがわかります。

  • 次に、をクリックしてこれらのファイルも含める必要があります。 Show All Files 上のスクリーンショットで強調表示されているアイコンをクリックすると、プロジェクトフォルダ内のすべてのファイルが表示されます。

これらの2つのファイルはまだプロジェクトに含まれていません。これらのファイルを含めるには、これらのファイルを選択し、任意のファイルを右クリックして、Include in Project。

現在、これらのファイルも含まれています。予測できる良い点の1つは、SKDツールの将来のバージョンおよびVisualStudioに* .csprojのファイルをドロップするproject.jsonアプローチです。

この章では、コンソールアプリとUWPアプリの間の参照について説明します。コンソールアプリケーションのソリューションエクスプローラーで参照を見ると、次のように.NETCoreAppが表示されます。

.NETCoreAppは、.NETCoreアプリケーションを対象とした新しいフレームワークです。ここで、UWPアプリケーションの参照を見ると、以下に示すように少し異なって見えます。

  • これの主な理由は、ここUWPに* .csprojがあるため、古いスタイルの参照に戻り、このプロジェクトタイプで1つのフレームワークのみをターゲットにできるためです。

  • ただし、参照は似ています。これで、UWPアプリケーションでは、Miscrosoft.NETCore.UniversalWindowsPlatformNuGetパッケージ参照がコンソールアプリケーションのMicrosoft.NETCore.AppNuGet参照に類似していることがわかります。

  • Miscrosoft.NETCore.UniversalWindowsPlatformとMicrosoft.NETCore.Appはどちらもメタパッケージであり、他のパッケージで構成されていることを意味します。

  • コンソールアプリケーションでは、Microsoft.NETCore.App内の他のパッケージをドリルインして表示できますが、ソリューションエクスプローラーで同じMiscrosoft.NETCore.UniversalWindowsPlatformを実行することはできません。

  • ただし、別のツールであるNuGetパッケージエクスプローラーを使用してこれを確認できます。このURLをブラウザで開きましょう-https://npe.codeplex.com/downloads/get/clickOnce/NuGetPackageExplorer.application 小さなユーティリティがダウンロードされます。

  • ダウンロードが完了したら、そのファイルをダブルクリックします。

  • クリック Install NuGetパッケージエクスプローラーでインストールを開始します。

  • インストールが完了すると、次のダイアログボックスが表示されます。

  • をクリックしてみましょう Open a package from online feed オプション。

  • デフォルトでは、nuget.orgフィードを検索します。検索ボックスでMicrosoft.NETCore.UniversalWindowsPlatformを検索すると、次のような1つの結果が表示されます。

  • クリック open リンクすると、このメタパッケージの最上位の依存関係が開きます。

  • ここで、.NETCoreアプリケーションの.NETCoreメタパッケージとUWPアプリケーションのメタパッケージを並べて開きます。

  • これで、各メタパッケージが異なるパッケージのセットで構成されていることがわかります。

  • .NET Coreは、少なくとも現時点では.NET Frameworkで使用可能なクラスのサブセットですが、成長しており、.NETFrameworkの基本クラスと同じようになります。

  • UWPは.NETCoreに基づいており、Windowsストアの開発に使用できるAPIのスーパーセットです。

.NET Coreにより、開発に利用できるAPIが増えました。

Windowsランタイムコンポーネントは、C＃、Visual Basic、JavaScript、C ++など、任意の言語からインスタンス化して使用できる自己完結型のオブジェクトです。前の章で見た.NETCoreメタパッケージに加えて、UWPアプリにはデフォルトでユニバーサルWindowsSDKへの参照もあります。

ユニバーサルWindowsはWindowsランタイムへの参照であり、一連のAPIコントラクトに組み込まれています。

デバイスファミリ内のAPIのセットは、APIコントラクトと呼ばれるサブディビジョンに分類されます。さまざまなAPIコントラクトのリストはここにありますhttps://msdn.microsoft.com/en-us/library/windows/apps/dn706135.aspx

Windowsランタイム内のこれらのAPIのほとんどは、単一のコントラクトに組み込まれています。APIコントラクトページでUniversalキーワードを検索してみましょう。

さまざまなAPIへのリンクを見ることができます。また、Universalファミリーは非常に大きく、12ページのドキュメントがあることもわかります。

このページで電話API契約を検索することもできます。

をクリックしてみましょう Windows.Phone.PhoneContract下にスクロールします。これで、電話またはモバイルデバイスのバッテリー情報が表示されます。

すでに持っているものに加えてこの情報を追加したい場合は、参照を手動で追加する必要があります。Visual Studioに移動し、ソリューションエクスプローラーで[参照]を右クリックします。

選択する Add References…

これで、UniversalWindowsの新しい参照カテゴリが表示されます。このカテゴリの下には、コアユニバーサルWindowsAPIコントラクトを参照するコアがあります

  • 拡張機能を使用すると、機能を拡張でき、モバイル、デスクトップ、その他の拡張機能のさまざまな参照が表示されます。

  • さまざまなSKD拡張機能があり、さらにAPIを取得するために上に追加できます。

  • また、さまざまなバージョンを見ることができます。したがって、最新バージョンを取得して更新されたAPIを取得していることを確認してから、[OK]をクリックしてください。

あなたは今それを見ることができます Windows Mobile Extensions for the UWP 参考として追加しました。

クラスライブラリは、任意のアプリケーションから呼び出すことができるタイプとメソッドを定義します。

  • .NET Coreを使用して開発されたクラスライブラリは、.NET標準ライブラリをサポートします。これにより、そのバージョンの.NET標準ライブラリをサポートする任意の.NETプラットフォームからライブラリを呼び出すことができます。

  • クラスライブラリが完成したら、サードパーティコンポーネントとして配布するか、1つ以上のアプリケーションにバンドルされているコンポーネントとして含めるかを決定できます。

コンソールアプリケーションにクラスライブラリプロジェクトを追加することから始めましょう。を右クリックしますsrc ソリューションエクスプローラーでフォルダーを選択し、 Add → New Project…

の中に Add New Project ダイアログボックスで、.NET Coreノードを選択してから、クラスライブラリ（.NET Core）プロジェクトテンプレートを選択します。

次の図に示すように、[名前]テキストボックスに、プロジェクトの名前として「UtilityLibrary」と入力します。

[OK]をクリックして、クラスライブラリプロジェクトを作成します。プロジェクトが作成されたら、新しいクラスを追加しましょう。右クリックproject ソリューションエクスプローラーで、 Add → Class...

中央のペインでクラスを選択し、名前とフィールドにStringLib.csと入力して、[ Add。クラスが追加されたら、StringLib.csファイルの次のコードを置き換えます。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace UtilityLibrary { 
   public static class StringLib { 
      public static bool StartsWithUpper(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
         return false; 
         Char ch = str[0]; 
         return Char.IsUpper(ch); 
      } 
      public static bool StartsWithLower(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
         return false; 
         Char ch = str[0]; 
         return Char.IsLower(ch); 
      } 
      public static bool StartsWithNumber(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
         return false;  
         Char ch = str[0]; 
         return Char.IsNumber(ch); 
      } 
   } 
}

  • クラスライブラリ、 UtilityLibrary.StringLib、のようないくつかのメソッドが含まれています StartsWithUpper、 StartsWithLower、および StartsWithNumber これは、現在の文字列インスタンスがそれぞれ大文字、小文字、数値で始まるかどうかを示すブール値を返します。

  • .NET Coreでは、 Char.IsUpper メソッドは文字が大文字の場合はtrueを返し、Char.IsLowerメソッドは文字が小文字の場合はtrueを返し、同様にChar.IsNumberメソッドは文字が数値の場合はtrueを返します。

  • メニューバーで、[ビルド]、[ソリューションのビルド]を選択します。プロジェクトはエラーなしでコンパイルされます。

  • .NET Coreコンソールプロジェクトは、クラスライブラリにアクセスできません。

  • このクラスライブラリを使用するには、コンソールプロジェクトにこのクラスライブラリの参照を追加する必要があります。

これを行うには、FirstAppを展開し、[参照]を右クリックして[参照]を選択します。 Add Reference…

[参照マネージャー]ダイアログボックスで、クラスライブラリプロジェクトであるUtilityLibraryを選択し、[ OK。

コンソールプロジェクトのProgram.csファイルを開いて、すべてのコードを次のコードに置き換えてみましょう。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
using UtilityLibrary; 

namespace FirstApp { 
   public class Program { 
      public static void Main(string[] args) { 
         int rows = Console.WindowHeight; 
         Console.Clear(); 
         do { 
            if (Console.CursorTop >= rows || Console.CursorTop == 0) { 
               Console.Clear(); 
               Console.WriteLine("\nPress <Enter> only to exit; otherwise, enter a string and press <Enter>:\n"); 
            } 
            string input = Console.ReadLine(); 
            
            if (String.IsNullOrEmpty(input)) break; 
            Console.WriteLine("Input: {0} {1,30}: {2}\n", input, "Begins with uppercase? ", 
            input.StartsWithUpper() ? "Yes" : "No"); 
         } while (true); 
      } 
   } 
}

アプリケーションを実行すると、次の出力が表示されます。

理解を深めるために、プロジェクトでクラスライブラリの他の拡張メソッドを利用しましょう。

この章では、PCL（Portable Class Library）とは何か、およびPCLが必要な理由についても説明します。この概念を理解するために、前の章で作成したクラスライブラリプロジェクトフォルダを開いてみましょう。

このフォルダーには、project.jsonファイルとCSファイルに加えて、*。xprojファイルもあることがわかります。これは、VisualStudioが.NETCoreプロジェクトタイプを* .csprojではなく* .xprojとしてセットアップしたためです。

Microsoftが述べたように、*。xprojは廃止されますが、プレビュー2ツールではまだここにあります。すでに説明したように、UWPアプリケーションは* .csprojを使用します。

現在、*。csprojを参照および* .xprojに取得することは実際には不可能であり、*。xprojが移動するため、その機能は実装されません。

その代わりに、コンソールアプリとUWPアプリの間で共有できるクラスライブラリが必要です。PCLが登場します。

PCLとは

PCLとは何かを理解しましょう-

  • Portable Class Libraryプロジェクトを使用すると、複数の.NETFrameworkプラットフォームで動作するマネージアセンブリを作成および構築できます。

  • 共有ビジネスロジックなど、多くのプロジェクト間で共有したいコードを含むクラスを作成し、さまざまなタイプのプロジェクトからそれらのクラスを参照できます。

  • また、Microsoftプラットフォーム用のクロスプラットフォームアプリやライブラリをすばやく簡単に構築するのにも役立ちます。

  • ポータブルクラスライブラリは、コードの開発とテストの時間とコストを削減するのに役立ちます。

  • このプロジェクトタイプを使用して、ポータブル.NET Frameworkアセンブリを作成および構築し、WindowsやWindowsPhoneなどの複数のプラットフォームを対象とするアプリからそれらのアセンブリを参照します。

次に、作成したクラスライブラリをソリューションエクスプローラーから削除します。同時に、Solutionフォルダーから削除し、さらに新しいプロジェクトアイテムを追加します。

を選択 Visual C# → Windows 左側のペインでテンプレートを選択し、中央のペインで[クラスライブラリ（ポータブル）]を選択します。

名前フィールドにStringLibraryと入力し、[ OK このプロジェクトを作成します。

次に、参照するターゲットフレームワークを選択する必要があります。少しの間、WindowsUniversalとASP.NETCoreを選択してから、ターゲットを変更します。クリックOK。

PCF形式で新しいプロジェクトが作成されたことがわかります。ソリューションエクスプローラーでStringLibraryプロジェクトを右クリックし、[プロパティ]を選択します。

Target .NET PlatformStandardをクリックします。

[はい]をクリックします。これで同じクラスライブラリになりましたが、わずかな違いが1つあります。違いは、*。xprojの代わりに* .csprojファイルが含まれているため、UWPでも使用できることです。

新しいクラスを追加しましょう。このためには、ソリューションエクスプローラーでプロジェクトを右クリックして、を選択する必要があります。Add → Class...

中央のペインでクラスを選択し、 StringLib.cs 名前フィールドでクリックします Add。クラスが追加されたら、StringLib.csファイルの次のコードを置き換えます。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
  
namespace StringLibrary { 
   public static class StringLib { 
      public static bool StartsWithUpper(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
            return false; 
         Char ch = str[0]; 
         return Char.IsUpper(ch); 
      } 
      public static bool StartsWithLower(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
            return false; 
         Char ch = str[0]; 
         return Char.IsLower(ch); 
      } 
      public static bool StartsWithNumber(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
            return false; 
         Char ch = str[0]; 
         return Char.IsNumber(ch); 
      } 
   } 
}

このポータブルクラスライブラリプロジェクトをビルドしてみましょう。エラーなしでコンパイルできます。次に、このポータブルクラスライブラリの参照をコンソールプロジェクトに追加する必要があります。したがって、FirstAppを展開し、[参照]を右クリックして、[参照]を選択します。Add Reference…

[参照マネージャー]ダイアログボックスで、ポータブルクラスライブラリプロジェクトであるStringLibraryを選択し、[ OK。

StringLibrary参照がコンソールプロジェクトに追加され、project.jsonファイルでも確認できることがわかります。

これでアプリケーションを再度実行でき、同じ出力が表示されます。

ここで、プロジェクトでポータブルクラスライブラリの他の拡張メソッドを使用しましょう。同じポータブルライブラリがUWPアプリケーションでも使用されます。

この章では、ライブラリに参照を追加する方法について説明します。ライブラリへの参照の追加は、コンソールプロジェクトやUWPプロジェクトなどの他のプロジェクトへの参照の追加に似ています。

これで、PCLプロジェクトにデフォルトでいくつかの参照があることがわかります。アプリケーションのニーズに応じて、他の参照を追加することもできます。

PCLライブラリには、project.jsonファイルも表示されます。

{ 
   "supports": {}, 
   "dependencies": { 
      "NETStandard.Library": "1.6.0", 
      "Microsoft.NETCore.Portable.Compatibility": "1.0.1" 
   }, 
   "frameworks": { 
      "netstandard1.3": {} 
   } 
}

ライブラリへの参照を追加する1つの方法は、project.jsonファイルに直接入力することです。ご覧のとおり、次のコードに示すように、依存関係セクションの下にいくつかの参照を追加しました。

{ 
   "supports": {}, 
   "dependencies": { 
      "NETStandard.Library": "1.6.0", 
      "Microsoft.NETCore.Portable.Compatibility": "1.0.1", 
      "System.Runtime.Serialization.Json": "4.0.3", 
      "Microsoft.EntityFrameworkCore": "1.1.0" 
   }, 
   "frameworks": { 
      "netstandard1.3": {} 
   } 
}

このファイルを保存すると、参照がライブラリに追加されていることがわかります。

ライブラリに参照を追加するもう1つの方法は、NuGetパッケージマネージャーです。右クリックしてみましょうStringLibrary (Portable) プロジェクトして選択 Mange NuGet Packages…

[参照]タブでは、任意のNuGetパッケージを検索できます。「System.Runtime.Serialization.Primitives」パッケージを追加するとします。

クリック Install ボタンをクリックすると、次の画面が表示されます。

次に、をクリックします OK ボタン。

最後に、をクリックします I AcceptこのNuGetパッケージのインストールを開始するボタン。インストールが完了すると、「System.Runtime.Serialization.Primitives」NuGetパッケージがライブラリに追加されていることがわかります。

この章では、ライブラリを次のように共有する方法について説明します。 NuGet Package別のプロジェクト内で使用できるようにします。パッケージの作成は、組織内のパブリックnuget.orgギャラリーまたはプライベートギャラリーを介して、パッケージ化して他のユーザーと共有するコードから始まります。パッケージには、次のような追加のファイルを含めることもできます。readme これは、パッケージのインストール時に表示され、特定のプロジェクトファイルへの変換を含めることができます。

ここで、ライブラリからNuGetパッケージを作成する簡単な例を考えてみましょう。これを行うには、コマンドプロンプトを開き、ライブラリプロジェクトのproject.jsonファイルが配置されているフォルダーに移動します。

次のコマンドを実行してみましょう。

dotnet help

最後に、new、restore、buildなどのさまざまなコマンドを確認できます。

最後のコマンドは pack;これにより、NuGetパッケージが作成されます。次のコマンドを実行してみましょう。

dotnet pack

これで、NuGetパッケージがbinフォルダーに作成されていることがわかります。bin \ Debugフォルダーを開きます。

ここで問題となるのは、NuGetパッケージエクスプローラーを使用できることを確認するために、NuGetパッケージの内容です。ここで、NuGetパッケージエクスプローラーを開きます。

最初のオプションを選択します Open a local package。

を選択 StringLibrary.1.0.0.nupkg をクリックします Open。

[パッケージの内容]セクションには、StringLibrary.dllのみがあることがわかります。[パッケージメタデータ]セクションには、ID、バージョン、すべての依存関係など、このライブラリに関する情報が少し表示されます。

開いてみましょう StringLibrary.1.0.0.symbols.nupkg。

このNuGetパッケージには、ソースファイルと *.pdbファイルも。をダブルクリックするとStringLib.cs ファイルには、ソースコードも表示されます。

ここで問題となるのは、バージョン、作成者、説明などのメタデータをどのように構成できるかです。

project.jsonファイルは.NETCoreプロジェクトで使用され、プロジェクトメタデータ、コンパイル情報、および依存関係を定義します。ここで、project.jsonファイルを開き、次の追加情報を追加しましょう。

{ 
   "authors": [ "Mark Junior" ], 
   "description": "String Library API", 
   "version" : "1.0.1-*", 
   "supports": {}, 
   
   "dependencies": { 
      "Microsoft.EntityFrameworkCore": "1.1.0", 
      "Microsoft.NETCore.Portable.Compatibility": "1.0.1", 
      "NETStandard.Library": "1.6.0", 
      "System.Runtime.Serialization.Json": "4.0.3", 
      "System.Runtime.Serialization.Primitives": "4.3.0" 
   }, 
   "frameworks": { 
      "netstandard1.3": {} 
   } 
}

ここに追加された作成者名、説明、バージョンなどの追加情報を確認できるようになりました。このファイルを保存し、ライブラリプロジェクトをビルドしてから、「dotnetpack」コマンドを再度実行してみましょう。

bin \ Debugフォルダー内で、StringLibraryNuGetパッケージがバージョン1.0.1で作成されていることがわかります。NuGetパッケージエクスプローラーで開きます。

更新されたメタデータが表示されます。問題は、別のパッケージでどのように使用できるかということです。

NuGetフィードのどこかに公開することから始めて、それを別のプロジェクトで使用できるようにする必要があります。

更新されたメタデータを公開するには、2つのオプションがあります-

  • nuget.orgに公開します
  • メタデータをプライベートNuGetフィードにプッシュします

ここでは、nuget.orgでアカウントを設定するよりもはるかに簡単なため、プライベートNuGetフィードを使用します。パッケージをnuget.orgに公開する方法については、ここで指定されているすべてのガイドラインに従うことができます。https://docs.microsoft.com/en-us/nuget/create-packages/publish-a-package。

次の手順に従って、更新されたメタデータをプライベートNuGetフィードにプッシュします。

Step 1−まず、nugetコマンドラインユーティリティが必要であり、それをインストールする必要があります。次に、NuGetパッケージマネージャーを開いて、nuget.commandlineを検索します。

Step 2 − Nuget.Commandlineを選択し、 Install。

Step 3 −クリック OKNuget.Commandlineをインストールします。次のURLからダウンロードして手動でインストールすることもできますhttps://dist.nuget.org/index.html 次に、環境変数を設定します。

Step 4 −インストールが完了したら、コマンドプロンプトをもう一度開いて、 bin\Debug NuGetパッケージが配置されているフォルダーで、次のコマンドを指定します-

nuget add StringLibrary.1.0.1.nupkg -Source D:\PrivateNugetPackages

Step 5 −上記のコマンドでは、StringLibrary.1.0.1.nupkgパッケージをプライベートフィードに追加します。場所は次のとおりです。 D:\PrivateNugetPackages、-Sourceはパッケージソースを指定します。

Step 6 −あなたはそれを見ることができます StringLibraryインストールされています。インクルードStringLibrary さらにプライベートフィードに追加することができます。

Step 7 −そのフォルダに移動しましょう。

Step 8 −内部 stringlibrary フォルダには、バージョン名が付いた別のフォルダが表示されます。ここでは1.0.1です。

NuGetパッケージはここにあります。

この章では、作成してプライベートNuGetフィードに公開したNuGetパッケージを使用する方法について説明します。したがって、最初にXamarin.Formsプロジェクトを作成します。まず、Xamarin.Formsとは何かを理解する必要があります。

  • Xamarin.Formsは、開発者がクロスプラットフォームのユーザーインターフェイスを迅速に作成できるようにするフレームワークです。

  • Xamarin.Formsは、クロスプラットフォームのネイティブにサポートされたUIツールキットの抽象化であり、開発者はAndroid、iOS、Windows、およびWindowsPhone間で共有できるユーザーインターフェイスを簡単に作成できます。

  • ユーザーインターフェイスは、ターゲットプラットフォームのネイティブコントロールを使用してレンダリングされるため、Xamarin.Formsアプリケーションは各プラットフォームの適切なルックアンドフィールを維持できます。

Xamarin.Formsを起動するには、Visual Studio2015にいくつかの追加機能が必要です。VisualStudio2015を変更して、次のクロスプラットフォームモバイル開発オプションが選択されていることを確認してください。

インストールが完了したら、[Xamarin]を選択して更新します。 Tools → Options…

下にスクロールして左側のペインでXamarinを展開し、[ Other。ダイアログボックスの右上隅にあるをクリックしますCheck Now アップデートが利用可能かどうかを確認します。

アップデートが利用可能であることがわかります。クリックしてみましょう。 Downloadボタンをクリックしてダウンロードを開始します。ダウンロードが完了すると、アップデートをインストールするように通知されます。

Visual Studioをもう一度開いて、 File → New → Project… メニューオプション。

左側のペインで、 Visual C# → Cross-Platform テンプレートと中央のペインで、 Blank Xaml App (Xamarin.Forms Portable)。「名前」フィールドに名前を入力して、「OK」をクリックします。

ターゲットバージョンと最小バージョンを選択し、[OK]をクリックします。

一連のプロジェクトが表示されます。上部には、Android、iOS、UWP、Windows 8.1、Windows Phone8.1などのすべてのプラットフォーム間で共有されるPCLライブラリがあります。

ここでは、PCLライブラリに焦点を当て、ここにいくつかのコードを示します。コードを展開してみましょう。

このXamarin.Formsテンプレートでは、汎用のApp.xamlとMainPage.xamlが表示され、これらのプラットフォーム間で機能するXamarin.FormsXAMLフレームワークを使用しています。

コードをインポートする必要があります。また、前の章で設定したプライベートNuGetフィードも必要です。

ここで、NuGetパッケージマネージャーを開きます。[パッケージソース]ドロップダウンリストの横にあるホイールをクリックします。

ここにプライベートフィードを追加する必要があります。 plus (+) button。

別のチェックボックスがに追加されていることがわかります Available package sources セクションで、名前とソースパスを指定してクリックします OK。

次に、[参照]タブに移動し、[パッケージソース]ドロップダウンリストから[PrivateSource]を選択すると、StringLibraryNuGetパッケージが表示されます。StringLibraryを選択し、Install。

[OK]をクリックすると、1つのエラーが表示されます。

.NETPortableプロファイルバージョン259ではライブラリを使用できません。次の章でこのエラーを修正します。

この章では、Xamarin.FormsプロジェクトのプライベートフィードからNuGetパッケージをインストールするときに発生したエラーを修正します。

問題を簡単にさらに理解します。まず、PCLライブラリを右クリックして、[プロパティ]を選択します。

このページでは、対象となる一連のフレームワーク全体を確認できます。エラーから、.NETPortableプロファイル259がStringLibrary1.0.1と互換性がないことがわかります。ただし、.NET Standard1.1ライブラリから参照を取得しようとしています。

ここで、.NET標準ライブラリを確認し、ライブラリと互換性のないプラットフォームを特定しましょう。

Windows Phone Silverlight8が.NETStandard1.0と互換性があることがわかります。次のWebページを開くと、Profile259が.NET Standard1.0のみをサポートできることがわかります。

Windows Phone Silverlight8のチェックを外してみましょう。

クリック OK ボタン。

この問題を修正するには、[OK]をクリックして[ターゲットの変更]ダイアログをキャンセルし、パッケージマネージャーコンソールを開いて次のコマンドを実行します。

PM > Uninstall-Package Xamarin.Forms

PCLライブラリのプロパティに移動しましょう。[変更]ボタンをクリックします。

Windows Phone Silverlight 8のチェックを外し、[OK]をクリックします。

これで、Windows Phone Silverlight8がターゲットフレームワークで使用できなくなったことがわかります。現在ターゲットとなっているプロファイルも表示されます。これを確認するには、PCLライブラリをアンロードして、XamarinApp.csprojファイルを編集します。

これで、TargetFrameworkProfileがProfile111になっていることがわかります。

ドキュメントを開くと、Profile111が.NET Standard1.1をサポートしていることがわかります。

PCLを再度リロードし、NuGetパッケージマネージャーを開いて、プライベートフィードからStringLibraryパッケージをインストールしてみましょう。

[依存関係の動作]ドロップダウンリストから、[依存関係を無視]を選択し、[ Install。

StringLibraryパッケージがプライベートフィードからインストールされていることがわかります。PCLの参照を展開すると、次のようにStringLibrary参照も追加されていることがわかります。

Windows Phone Silverlight8の問題のXamarin.Formsをアンインストールしました。Xamarin.Formsを再度インストールする必要があります。同じバージョンをインストールすることをお勧めします。

インストールが完了したら、アプリケーションでStringLibrary機能を使用しましょう。

この章では、.NETCoreを使用してテストプロジェクトを作成する方法について説明します。ユニットテストは、ユニットと呼ばれる、アプリケーションのテスト可能な最小部分を持つソフトウェアの開発プロセスです。それらは、適切な操作のために個別にそして独立して精査されます。ユニットテストは自動化することも、手動で行うこともできます。

[新しいプロジェクト]ダイアログボックスを開いて、[ Visual C# → .NET Core テンプレート。

このダイアログボックスでは、単体テスト用のプロジェクトテンプレートがないことがわかります。単体テストプロジェクトを作成するには、コマンドラインユーティリティを使用する必要があります。作成したSolutionフォルダーに移動しましょう。テストフォルダーを作成し、テストフォルダー内に別のフォルダーを作成して呼び出しますStringLibraryTests。

次に、dotnetコマンドラインユーティリティを使用して、次のコマンドを実行して新しいテストプロジェクトを作成しましょう。

dotnet new -t xunittest

これで、新しいC＃プロジェクトが作成されたことがわかります。を実行してフォルダを調べてみましょうv コマンドとあなたが見るでしょう project.json そして Tests.cs 以下に示すようなファイル。

これがproject.jsonファイルのコードです。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "debugType": "portable" 
   }, 
   "dependencies": { 
      "System.Runtime.Serialization.Primitives": "4.1.1", 
      "xunit": "2.1.0", 
      "dotnet-test-xunit": "1.0.0-rc2-192208-24" 
   }, 
   "testRunner": "xunit", 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { 
            "Microsoft.NETCore.App": { 
               "type": "platform", 
               "version": "1.0.1" 
            } 
         }, 
         "imports": [ 
            "dotnet5.4", 
            "portable-net451+win8" 
         ] 
      } 
   } 
}

以下は、Test.csファイルのコードです。

using System; 
using Xunit; 
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void Test1() { 
         Assert.True(true); 
      } 
   } 
}

NuGetから必要な依存関係を取得するには、次のコマンドを実行します-

dotnet restore

必要な依存関係が復元されたら、テストを実行できます。

コンパイルが成功したことがわかります。下に行くと、実行されたテストに関する情報が表示されます。

現在、1つのテストが実行され、0がエラー、0が失敗、0がスキップされ、実行プロセスにかかった時間も情報として示されています。

この章では、VisualStudioでテストを実行する方法について説明します。.NET Coreはテスト容易性を念頭に置いて設計されているため、アプリケーションの単体テストの作成がこれまでになく簡単になります。この章では、VisualStudioでテストプロジェクトを実行して実行します。

VisualStudioでFirstAppソリューションを開きましょう。

プロジェクトが2つしかないことがわかります。また、ソリューションにそのプロジェクトを追加していないため、テストプロジェクトを表示することはできません。

最初にフォルダを追加して呼び出しましょう test。

を右クリックします test フォルダ。

選択する project.json ファイルをクリックします Open。

次のスクリーンショットは、のコードを示しています Tests.cs 出力としてファイル。

これはデフォルトの実装であり、Trueがtrueに等しいことをテストしているだけです。これはxUnitテストフレームワークであり、テストメソッドに注釈を付けて示すFact属性が表示されます。

using System; 
using Xunit; 
  
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void Test1() { 
         Assert.True(true); 
      } 
   } 
}

以下はの実装です project.json ファイル。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "debugType": "portable" 
   }, 
   "dependencies": { 
      "System.Runtime.Serialization.Primitives": "4.1.1", 
      "xunit": "2.1.0", 
      "dotnet-test-xunit": "1.0.0-rc2-192208-24" 
   }, 
   "testRunner": "xunit", 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { 
            "Microsoft.NETCore.App": { 
               "type": "platform", 
               "version": "1.0.1" 
            }
         }, 
         "imports": [ 
            "dotnet5.4", 
            "portable-net451+win8" 
         ] 
      } 
   } 
}

に project.jsonファイルの場合、テストフレームワークへの最も重要な依存関係はxunitであり、これはFact属性をもたらします。xunitでテストするためのテストフレームワークとAPIを取り入れています。

また、 dotnet-test-xunit、これは、xunitが.NET Core、特に dotnet testコマンドラインユーティリティ。次に、testRunner これはxunitを実行し、 netcoreapp1.0 フレームワーク。

以下に.NETCore.Appの依存関係が表示されます。

Visual Studioでテストを実行するには、からテストエクスプローラーを開きます。 Test → Window → Test Explorer メニューオプション。

また、VisualStudioがテストを自動的に検出していることがわかります。テストの名前はで構成されていますnamespace.className.TestMethodName。クリックしてみましょうRun All button in Test Explorer。

最初にコードをビルドしてテストを実行すると、テストにかかった合計時間が表示されます。テストが失敗したときに出力が表示されるように、テスト方法を変更してみましょう。

using System; 
using Xunit; 
  
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void Test1() { 
         Assert.True(false); 
      } 
   } 
}

をクリックして、テストを再度実行しましょう。 Run All ボタンリンク。

あなたは今見ることができます test 失敗。

この章では、StringLibraryをテストします。そのためには、デフォルトの規則に従うことができるようにプロジェクトを再配置する必要があります。

開いてみましょう global.json ファイル。

{ 
   "projects": [ "src", "test" ], 
   "sdk": { 
      "version": "1.0.0-preview2-003131" 
   } 
}

このファイルの上部にプロジェクト設定が表示され、次のようなフォルダが設定されます。 src そして test デフォルトでは。

慣例により、これらのフォルダーにプロジェクトを配置する必要があるため、これは新しい規則であり、.NETCoreの一部として使用されます。

ソリューションエクスプローラーでは、コンソールプロジェクトとライブラリプロジェクトの両方が内部にあることがわかります。 src テストプロジェクトが内部にある間のフォルダ test フォルダ。

また、ソリューションエクスプローラーのプロジェクト構造は、プロジェクトがディスク上の物理的に存在する場所を表していません。Solutionフォルダーを開くと、次のように表示されます。StringLibrary プロジェクトは内部にありません src フォルダ。

あなたは両方を見ることができます src そして test フォルダは、で指定された規則にマップされます global.jsonファイル。ただし、慣例に反する1つのプロジェクトStringLibraryがあります。ここで追加しましょうStringLibrary 内部のプロジェクト src フォルダ。

srcフォルダーには2つのプロジェクトがあり、すべてのプロジェクトを適切に使用できるように問題を修正する必要があります。Visual Studioに戻り、StringLibraryプロジェクトを右クリックして、[削除]オプションを選択します。削除はしませんが、プロジェクトを削除するだけです。

次に、srcフォルダーを右クリックして、 Add → Existing Project…

現在内部にあるStringLibraryプロジェクトを参照します src フォルダ、を選択します StringLibrary.csproj ファイルをクリックします Open。

ここで、の参照を削除する必要があります StringLibrary から project.json コンソールアプリのファイル。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      }, 
      "NuGet.CommandLine": "3.5.0", 
      "System.Runtime.Serialization.Json": "4.0.3" 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { }, 
         "imports": "dnxcore50" 
      } 
   } 
}

変更を保存してから、の参照を追加します StringLibrary 再びコンソールプロジェクトで。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      }, 
   "NuGet.CommandLine": "3.5.0", 
      "System.Runtime.Serialization.Json": "4.0.3" 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { 
            "StringLibrary": { 
               "target": "project" 
            } 
         }, 
         "imports": "dnxcore50" 
      } 
   } 
}

これですべてが再び機能するはずで、ビルドできます StringLibrary その後 FirstApp（コンソールプロジェクト）エラーなし。xunitを使用してStringLibrary機能をテストしてみましょう。StringLibraryの参照をテストプロジェクトに追加する必要があります。StringLibraryTestsプロジェクトの参照を右クリックし、[参照の追加…]を選択します。

クリック OK の参照を追加します StringLibrary私たちのテストプロジェクトに。ここで、次のコードを置き換えましょう。Tests.cs ファイル。

using System; 
using Xunit; 
using StringLibrary; 
  
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void StartsWithUpperCaseTest() { 
         string input = "Mark"; 
         Assert.True(input.StartsWithUpper()); 
      } 
      [Fact] 
      public void StartsWithLowerCaseTest() { 
         string input = "mark"; 
         Assert.True(input.StartsWithLower()); 
      } 
      [Fact] 
      public void StartsWithNumberCaseTest() { 
         string input = "123"; 
         Assert.True(input.StartsWithNumber()); 
      } 
   } 
}

StringLibraryの機能をテストする3つのテストメソッドがあることがわかります。クリックしてみましょうRun All リンクをクリックすると、テストエクスプローラーに次の出力が表示されます。

コマンドラインからテストを実行することもできます。コマンドプロンプトを開いて、dotnet test コマンド。

この章では、Managed Extensibility Framework（MEF）について説明します。MEFは、サードパーティのプラグインの拡張性に使用できます。または、疎結合のプラグインのようなアーキテクチャの利点を通常のアプリケーションにもたらすことができます。

  • MEFは、軽量で拡張可能なアプリケーションを作成するためのライブラリです。

  • これにより、アプリケーション開発者は、構成を必要とせずに拡張機能を検出して使用できます。

  • MEFは.NETFramework 4の不可欠な部分であり、大規模なアプリケーションの柔軟性、保守性、およびテスト性を向上させる.NETFrameworkが使用されている場所ならどこでも利用できます。

  • MEFは、Windowsフォーム、WPF、その他のテクノロジを使用しているかどうかに関係なく、クライアントアプリケーション、またはASP.NETを使用するサーバーアプリケーションで使用できます。

  • MEFはとして移植されました Microsoft.Composition .NET Coreにも、部分的に。

  • のみ System.Composition 移植され、 System.ComponentModel.Compositionまだ利用できません。つまり、ディレクトリ内のアセンブリからタイプをロードできるカタログがありません。

この章では、.NETCoreアプリケーションでMEFを使用する方法についてのみ学習します。

.NETCoreコンソールアプリケーションでMEFを使用する簡単な例を理解しましょう。ここで、新しい.NETCoreコンソールプロジェクトを作成しましょう。

左側のペインで、 Templates → Visual C# → .NET Coreを選択し、中央のペインで[コンソールアプリケーション（.NET Core）]を選択します。

「名前」フィールドにプロジェクトの名前を入力し、「OK」をクリックします。

プロジェクトが作成されたら、MEFを使用できるように、Microsoft.Compositionの参照を追加する必要があります。これを行うには、ソリューションエクスプローラーでプロジェクトを右クリックし、Manage NuGet Packages…

検索する Microsoft.Composition をクリックします Install。

クリック OK ボタン。

クリック I Accept ボタン。

インストールが完了すると、リファレンスにエラーが表示されます。

開いてみましょう project.json ファイル。

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

あなたはそれを見ることができます Microsoft.Composition 依存関係が追加されますが、問題はこのパッケージがと互換性がないことです dnxcore50。だから私たちはインポートする必要がありますportablenet45+win8+wp8+wpa81。今すぐ交換しましょうproject.json 次のコードでファイルします。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.Composition": "1.0.30", 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1"
      } 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "imports": "portable-net45+win8+wp8+wpa81" 
      } 
   } 
}

このファイルを保存すると、エラーが修正されたことがわかります。

参照を展開すると、の参照が表示されます Microsoft.Composition。

まず、エクスポートするインターフェイスを作成してそのインターフェイスを実装し、クラスをexport属性で装飾する必要があります。新しいクラスを追加しましょう。

[名前]フィールドにクラスの名前を入力し、[ Add。

次のコードをに追加しましょう PrintData.cs ファイル。

using System; 
using System.Collections.Generic; 
using System.Composition; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace MEFDemo { 
   public interface IPrintData { 
      void Send(string message); 
   } 
   [Export(typeof(IPrintData))] 
   public class PrintData : IPrintData { 
      public void Send(string message) { 
         Console.WriteLine(message); 
      } 
   } 
}

上記のように、カタログはMicrosoft.Composition名前空間では使用できません。そのため、Program.csファイルのComposeメソッドに示されているように、エクスポート属性を使用してアセンブリからすべてのタイプをロードし、インポート属性にアタッチします。

using System; 
using System.Collections.Generic; 
using System.Composition; 
using System.Composition.Hosting; 
using System.Linq; 
using System.Reflection; 
using System.Threading.Tasks; 
  
namespace MEFDemo { 
   public class Program { 
      public static void Main(string[] args) { 
         Program p = new Program(); 
         p.Run(); 
      } 
      public void Run() { 
         Compose(); 
         PrintData.Send("Hello,this is MEF demo"); 
      } 
      [Import] 
      public IPrintData PrintData { get; set; } 
      
      private void Compose() { 
         var assemblies = new[] { typeof(Program).GetTypeInfo().Assembly }; 
         var configuration = new ContainerConfiguration() 
            .WithAssembly(typeof(Program).GetTypeInfo().Assembly); 
         
         using (var container = configuration.CreateContainer()) { 
            PrintData = container.GetExport<IPrintData>(); 
         } 
      } 
   } 
}

アプリケーションを実行してみましょう。インスタンス化することで、アプリケーションが実行されていることがわかります。 PrintData クラス。

MEFの詳細については、次のURLにアクセスしてください。 https://msdn.microsoft.com/en-us/library/dd460648%28v=vs.110%29.aspx 詳細については。

この章では、.NETCoreの今後の機能について説明します。ブラウザで次のURLを開いて、.NETコマンドラインツールから始めます。https://github.com/dotnet/cli

進行状況の詳細については、下にスクロールして.NET Core SDKの最新バージョンをダウンロードすると、[インストーラーとバイナリ]セクションが表示されます。

さまざまなオペレーティングシステム用のプレビューツールの最新バージョンを確認できます。オペレーティングシステムに応じてインストーラーを選択しましょう。

.NET Core2.0のプレビュー1に取り組んでいます。

コマンドプロンプトを開いて次のコマンドを実行することにより、現在のツールを見てみましょう。

dotnet --info

以下に示すように、システムに現在インストールされているバージョンの.NETコマンドラインツールに関する情報が表示されます。

現在、プレビュー2のツールがあることがわかります。次のコマンドを実行して、new コマンド。

dotnet help new

プロジェクトの新しいコマンド言語については、C＃やF＃、プロジェクトの種類などを選択できます。

ここで、最新バージョンの.NETCoreでの変更点を見てみましょう。インストーラーがダウンロードされたら、それをダブルクリックしてインストールします。[インストール]をクリックします。

次のスクリーンショットは、インストールプロセスを示しています。

インストールプロセスが開始されます。インストールが完了したら、このダイアログを閉じます。

コマンドプロンプトを開き、次のコマンドを実行します。

dotnet --info

以下に示すように、システムに現在インストールされているバージョンの.NETコマンドラインツールの情報が表示されます。

これで、.NET Core 2のpreview1ツールがあることがわかります。コマンドプロンプトで次のコードを実行して、.NET Core 2preview1の新しいコマンドについて確認します。

dotnet help new

このコマンドは、パッケージをパッケージキャッシュにダウンロードするのにも役立ちます。

このコマンドは、.NET Core 2preview1の新しいコマンドに関する情報を含む次のWebページを開きます。

下にスクロールすると、より多くのテンプレートを使用して.NETCoreアプリケーションを作成できることがわかります。

これで作成できます mstest, web, mvc そして webapi コマンドラインを使用してプロジェクトも行います。

.NET Coreは、project.jsonを削除し、MSBuildと* .csprojに戻ることを決定しました。これは、リリースされたばかりの.Net Core 2.0preview1ツールですでに発生していることです。project.jsonは新鮮な空気の息吹だったので、これはかなり残念です。しかし、それは理解でき、多くの利点もあります。

ここで、変更がもたらす利点について説明しましょう。

  • これにより、既存のVisualStudioソリューションから.NETCoreへの移行が簡単になります。

  • これは大きな変更であり、MSBuildをベースにしたCI / RMへの既存の投資を活用することもできます。

  • MSBuildでのビルド中に、インクリメンタルコンパイル、ビルド時の依存関係の解決、構成管理などを考えることができます。

  • dotnet cliは、ASP.NET Coreだけでなく、コンソールアプリ、UWPアプリなどでもあるため、時間どおりに出荷するには多くの作業が必要です。

以下は、MSBuildと* .csprojの変更点です。

  • Project.jsonファイル（* .xproj）はMSBuild（* .csproj）に置き換えられます。

  • project.jsonの機能は、*。csprojにマージされ始めます。

  • 彼らがパッケージリストについて何をしようとしているのかはまだ明確ではありませんが、彼らはそれをjsonの下に保つかもしれないと言われました nuget.json またはそれをにマージします *.csproj。

  • Visual Studioを使用している場合、移行はスムーズで、潜在的に自動である必要があります。

MSBuildの利点

  • MSBuildはオープンソースであり、GitHubで入手でき、完全にクロスプラットフォームになるはずです。

  • MSBuildは、構造を劇的に簡素化およびトリミングします。 *.csproj。

  • マイクロソフトはまた、Visual Studioを必要とせずに多くのシナリオを可能にする新しいプロジェクトシステムを導入しています。詳細は、このURLに記載されています。 https://github.com/dotnet/roslyn-project-system/。

  • 目標は、MSBuildをセットアップした場合でも、ビルドとプロジェクトの操作がVisual StudioIDEの外部と同じようにシームレスになることです。

MSBuildとproject.json

次のコマンドを実行して、.NET Corepreview2ツールを使用して新しいコンソールプロジェクトを作成しましょう。

dotnet new -t console

このプロジェクト内で作成されたすべてのファイルを表示するには、 dir コマンド。

2つのファイルが作成されていることがわかります。 Program.cs そして project.json ファイル。

次のコマンドを実行して、.NET Core 2preview1ツールを使用してコンソールアプリを作成しましょう。

dotnet new console

このプロジェクト内で作成されたすべてのファイルを表示するには、 dirコマンド。3つのファイルが作成されていることがわかります。Program.cs, NuGet.config そして MSBuild.csproj project.jsonファイルの代わりに。

比較してみましょう project.json そして MSBuild.csproj ファイルを並べて表示します。

左側にはjson形式のファイルがあり、右側にはXML形式のファイルがあります。project.jsonファイルの依存関係セクション内にあることがわかりますnetcoreapp1.0、MSBuild.csprojファイルにある間、次のように表示されます。 netcoreapp2.0。

この章では、コマンドラインユーティリティを使用してMSBuild（* .csproj）ファイルを復元およびビルドする方法について説明します。.NET Core 2.0プレビュー1で使用できるコマンドを確認するには、次のコマンドを実行してみましょう。

dotnet help

new、restore、buildなどのすべてのコマンドが表示されます。

以下は、のデフォルトの実装です。 Program.cs ファイル。

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

次のコマンドを実行して、進行状況を確認しましょう。

dotnet build

多くのエラーが表示されます。これらのエラーは修正する必要があります。

次のコマンドを実行してみましょう。

dotnet restore

すべてのパッケージが復元されていることがわかります。いくつかの新しいフォルダとファイルも生成されました。

ディレクトリ構造を確認するには、次のコマンドを実行します。

tree /f

以下はディレクトリ構造です-

次のコマンドを実行して、プロジェクトを再構築しましょう。

dotnet build

これで、プロジェクトはエラーなしで正常にビルドされ、MSBuild.dllも作成されます。

出力を確認するには、次のコマンドを実行します-

dotnet run

コンソールに次の出力が表示されます。

この章では、を含むコンソールアプリケーションを移行します project.json 代わりにファイルビルドシステム MSBuild (*.csproj)。したがって、次のファイルを含む古いプロジェクトがあります。

問題は、なぜ移行が必要なのかということです。このプロジェクトは、.NET Core 1.0プレビュー2ツールを使用して作成され、.NET Core2.0プレビュー1ツールがインストールされました。これで、.NET Core 2.0コマンドラインユーティリティを使用してこのアプリケーションをビルドすると、次のエラーが表示されます。

これは、 project.jsonビルドシステムは.NETCore 2.0で使用できなくなったため、正しく機能するように移行する必要があります。使用可能なコマンドを確認するには、次のコマンドを実行してみましょう。

dotnet help

コマンドセクションでは、さまざまなコマンドを確認できます。また、 migrate project.jsonベースのプロジェクトをMSBuildベースのプロジェクトに移行するコマンド。

次のコマンドを実行してみましょう。

dotnet migrate

移行プロセスの概要が表示されます。ここでは、プロジェクトが正常に移行されたことも確認できます。

次のコマンドを使用して、ディレクトリ構造を確認しましょう。

tree /f

これで、*。csprojファイルとProgram.csファイルがプロジェクトのルートディレクトリに表示され、project.jsonがバックアップフォルダーに移動されます。

開いてみましょう console.csprojファイル。これで、次のコマンドを実行して、MSBuildシステムを使用してこのプロジェクトを復元およびビルドできます。

dotnet restore

これで、すべてのパッケージが復元されたことがわかります。

これで、次のコマンドを使用してプロジェクトをビルドできます。

dotnet build

これで、プロジェクトがMSBuildを使用して正常にビルドされ、console.dllもで生成されていることがわかります。 ..\bin\Debug\netcoreapp1.0 フォルダ。

次のスクリーンショットは、ディレクトリ構造とファイルを示しています。

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved