.NET Core-概要

NET Core is the latest general purpose development platform maintained by Microsoft. It works across different platforms and has been redesigned in a way that makes .NET fast, flexible and modern. This happens to be one of the major contributions by Microsoft. Developers can now build Android, iOS, Linux, Mac, and Windows applications with .NET, all in Open Source..

このチュートリアルでは、.NET Coreと、.NET Frameworkの更新、.NET Standard、およびUniversal Windows Platformの更新など、いくつかの新しい技術革新について説明します。

.NET Coreの特徴

以下は、.NET Coreの主な特徴です-

オープンソース

.NET Coreは、MITおよびApache 2ライセンスを使用したオープンソース実装です。
.NET Coreは.NET Foundationプロジェクトであり、GitHubで入手できます。
オープンソースプロジェクトとして、より透明な開発プロセスを促進し、活発で熱心なコミュニティを促進します。

クロスプラットフォーム

.NET Coreに実装されたアプリケーションは実行でき、プラットフォームのターゲットに関係なくそのコードを再利用できます。
現在、3つの主要なオペレーティングシステム（OS）をサポートしています。
Windows
Linux
マックOS
サポートされるオペレーティングシステム（OS）、CPU、およびアプリケーションシナリオは、Microsoft、他の企業、および個人が提供する時間とともに成長します。

柔軟な展開

.NET Coreアプリケーションの展開には2つのタイプがあります-
フレームワークに依存した展開
自己完結型の展開
フレームワーク依存の展開では、アプリは、アプリとサードパーティの依存関係がインストールされているシステム全体のバージョンの.NET Coreに依存します。
自己完結型の展開では、アプリケーションのビルドに使用される.NET Coreバージョンもアプリおよびサードパーティの依存関係と共に展開され、他のバージョンと並行して実行できます。

コマンドラインツール

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

互換性あり

.NET Coreは、.NETフレームワーク、XamarinおよびMonoと、.NET標準ライブラリを介して互換性があります。

モジュラー

.NET Coreは、NuGetを通じて小さなアセンブリパッケージでリリースされます。
.NET Frameworkは、ほとんどのコア機能を含む1つの大きなアセンブリです。
.NET Coreは、より小さな機能中心のパッケージとして利用できます。
このモジュラーアプローチにより、開発者はアプリに必要なNuGetパッケージのみを含めることでアプリを最適化できます。
アプリの表面積を小さくすることの利点には、セキュリティの強化、サービスの削減、パフォーマンスの向上、使用量に応じた使用モデルのコストの削減などがあります。

.NET Coreプラットフォーム

* .NETランタイム*-型システム、アセンブリの読み込み、ガベージコレクター、ネイティブ相互運用、およびその他の基本サービスを提供します。
基本ライブラリ-プリミティブデータ型、アプリ構成型、および基本ユーティリティを提供するフレームワークライブラリのセット。
* SDKおよびコンパイラ*-基本的な開発者エクスペリエンスを可能にするSDKツールと言語コンパイラのセット。.NETCore SDKで利用できます。
「ドットネット」アプリホスト-.NET Coreアプリの起動に使用されます。ランタイムを選択してランタイムをホストし、アセンブリ読み込みポリシーを提供してアプリを起動します。同じホストを使用して、SDKツールをほぼ同じ方法で起動します。

.NET Core-前提条件

この章では、デプロイして実行する必要があるさまざまな依存関係について説明します。これらには、Visual Studioを使用して開発された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（フルサーバー、サーバーコアまたはナノサーバー）

依存関係

Windows 10およびWindows Server 2016より前のWindowsバージョンで.NET Coreアプリケーションを実行している場合は、Visual C ++再頒布可能パッケージも必要です。
.NET Coreインストーラーを使用する場合、この依存関係は自動的にインストールされます。
インストーラースクリプトを使用して.NET Coreをインストールする場合、または自己完結型の.NET Coreアプリケーションを展開する場合は、Visual Studio 2015用のVisual C ++ Redistributableを手動でインストールする必要があります。
Windows 7およびWindows Server 2008マシンの場合、Windowsインストールが最新であり、Windows Updateを通じてインストールされたホットフィックスKB2533623も含まれていることを確認する必要があります。

Visual Studioの前提条件

.NET Core SDKを使用して.NET Coreアプリケーションを開発するには、任意のエディターを使用できます。
ただし、Visual Studioを使用してWindows上で.NET Coreアプリケーションを開発する場合は、次の2つのバージョンを使用できます-
Visual Studio 2015
Visual Studio 2017 RC
Visual Studio 2015で作成されたプロジェクトはデフォルトでproject.jsonベースになり、Visual Studio 2017 RCで作成されたプロジェクトは常にMSBuildベースになります。

.NET Core-環境のセットアップ

この章では、.NET Coreの環境設定について説明します。 .NET Frameworkの大幅な再設計です。アプリケーションで.NET Coreを使用するには、使用できる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を含むVisual Studioの無料バージョンを提供しています。https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspxおよびMicrosoft .NET Core 1.0からダウンロードできます。 .1-VS 2015 Tooling Preview 2はhttps://www.visualstudio.com/downloads/からダウンロードできます

次のURL [[1]]

Visual Studio 2015のインストール

Visual Studio 2015をインストールするには、次の手順に従います−

ステップ1 *-ダウンロードが完了したら、インストーラーを実行します。次のダイアログボックスが表示されます。

ダウンロード

ステップ2 *-[インストール]をクリックして、インストールプロセスを開始します。

インストール

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

完全

ステップ4 *-このダイアログを閉じて、必要に応じてコンピューターを再起動します。

ステップ5 *-[スタート]メニューからVisual Studioを開きます。次のダイアログボックスが表示されます。ロードに数分かかり、最終的に初めて使用される場合があります。

開く

ステップ6 *-ロードされると、次の画面が表示されます。

読み込み中

ステップ7 *-Visual Studioのインストールが完了したら、Visual Studioを閉じてMicrosoft .NET Core-VS 2015 Tooling Preview 2を起動します。

起動

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

チェックボックス

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

アプリケーション準備完了

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

ビジュアルスタジオ2017

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

.NET Core-はじめに

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

コアアプリケーション

[新しいプロジェクト]ダイアログボックスの[テンプレート]リストで、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（Single Instruction Multiple Data）対応ベクタータイプのセット。

積分型

NET Core supports both signed and unsigned integers of different ranges from one byte to eight bytes in length. All integers are value types..

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

Type	Signed/Unsigned	Size (bytes)	Minimum Value	Maximum Value
Byte	Unsigned	1	0	255
Int16	Signed	2	−32,768	32,767
Int32	Signed	4	−2,147,483,648	2,147,483,647
Int64	Signed	8	−9,223,372,036,854,775,808	9,223,372,036,854,775,807
SByte	Signed	1	-128	127
UInt16	Unsigned	2	0	65,535
UInt32	Unsigned	4	0	4,294,967,295
UInt64	Unsigned	8	0	18,446,744,073,709,551,615

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

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

浮動小数点型

NET Core includes three primitive floating point types, which are shown in the following table.
Type	Size (bytes)	Minimum Value	Maximum Value
Double	8	−1.79769313486232e308	1.79769313486232e308
Single	4	−3.402823e38	3.402823e38
Decimal	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名前空間には、.NET Core用のSIMD対応ベクタータイプのセットが含まれています。
SIMDを使用すると、一部の操作をハードウェアレベルで並列化できるため、ベクターで計算を実行する数学、科学、およびグラフィックアプリのパフォーマンスが大幅に向上します。
.NET CoreのSIMD対応ベクタータイプには、次のものが含まれます-
System.Numerics.Vector2、System.Numerics.Vector3、およびSystem.Numerics.Vector4タイプは、Singleタイプの2、3、および4次元ベクトルです。
任意のプリミティブ数値型のベクトルを作成できるVector <T>構造。プリミティブ数値型には、Decimalを除くSystem名前空間のすべての数値型が含まれます。
2つのマトリックスタイプ、System.Numerics.Matrix3×2。3×2マトリックスを表します。 System.Numerics.Matrix4×4は、4×4マトリックスを表します。
System.Numerics.Planeタイプは3次元平面を表し、System.Numerics.Quaternionタイプは3次元の物理的回転のエンコードに使用されるベクトルを表します。

.NET Core-ガベージコレクション

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

メモリの割り当てと解放、またはそのメモリを使用するオブジェクトの有効期間の管理方法を知る必要はありません。
「新しい」キーワードを使用してオブジェクトを宣言するか、値タイプがボックス化されるたびに、割り当てが行われます。通常、割り当ては非常に高速です
オブジェクトを割り当てるのに十分なメモリがない場合、GCはガベージメモリを収集して廃棄し、メモリを新しい割り当てに使用できるようにする必要があります。
このプロセスは*ガーベッジコレクション*と呼ばれます。

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

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

アプリケーションの開発中にメモリを手動で解放する必要はありません。
また、管理ヒープ上のオブジェクトを効率的に割り当てます。
オブジェクトが使用されなくなった場合、メモリをクリアすることでそれらのオブジェクトを再利用し、将来の割り当てに使用可能なメモリを保持します。
管理対象オブジェクトは最初からクリーンなコンテンツを自動的に取得するため、コンストラクターはすべてのデータフィールドを初期化する必要はありません。
また、オブジェクトが別のオブジェクトのコンテンツを使用できないようにすることで、メモリの安全性も提供します。

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

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

システムの物理メモリが不足しています。
マネージヒープ上の割り当てられたオブジェクトによって使用されるメモリは、許容可能なしきい値を超えています。このしきい値は、プロセスの実行中に継続的に調整されます。
GC.Collect メソッドが呼び出されます。ほとんどの場合、ガベージコレクターは継続的に実行されるため、このメソッドを呼び出す必要はありません。この方法は、主に固有の状況およびテストに使用されます。

世代

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

Generation 0では、オブジェクトが最初に割り当てられます。
この世代では、オブジェクトは次のガベージコレクションが発生するまでに（スコープ外で）使用されなくなっているため、多くの場合、第1世代を超えて生きることはありません。
ジェネレーション0は、関連するヒープが小さいため、すばやく収集できます。

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

ジェネレーション1では、オブジェクトにセカンドチャンススペースがあります。
短命ですが、世代0のコレクション（多くの場合、偶然のタイミングに基づいて）を生き延びたオブジェクトは、世代1に移動します。
関連付けられたヒープも小さいため、ジェネレーション1のコレクションも高速です。
オブジェクトが収集されるか、次世代ヒープに昇格されるため、最初の2つのヒープは小さいままです。

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

ジェネレーション2では、すべての長いオブジェクトが存続し、そのヒープが非常に大きくなる可能性があります。
この世代のオブジェクトは長期間存続でき、オブジェクトをさらに昇格させる次世代のヒープはありません。
ガベージコレクターには、ラージオブジェクトヒープ（LOH）と呼ばれるラージオブジェクト用の追加のヒープがあります。
85,000バイト以上のオブジェクト用に予約されています。
ラージオブジェクトは世代ヒープに割り当てられませんが、LOHに直接割り当てられます
ジェネレーション2およびLOHのコレクションは、長時間実行されたプログラムや大量のデータを処理するプログラムでは、かなりの時間がかかる場合があります。
大規模なサーバープログラムは、数十GBのヒープを持つことが知られています。
GCはさまざまな手法を使用して、プログラムの実行をブロックする時間を短縮します。
第一のアプローチは、プログラムの実行を妨げない方法で、バックグラウンドスレッドで可能な限り多くのガベージコレクションを行うことです。
また、GCは、開発者がその動作に影響を与えるいくつかの方法を公開します。これは、パフォーマンスを改善するのに非常に役立ちます。

.NET Core-コード実行

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

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

コード実行

コンパイラの選択

これは多言語実行環境であり、ランタイムはさまざまなデータ型と言語機能をサポートしています。
共通言語ランタイムによって提供される利点を得るには、ランタイムを対象とする1つ以上の言語コンパイラを使用する必要があります。

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

コンパイルすると、ソースコードがMicrosoft Intermediate Language（MSIL）に変換され、必要なメタデータが生成されます。
メタデータは、各タイプの定義、各タイプのメンバーの署名、コードが参照するメンバー、ランタイムが実行時に使用するその他のデータなど、コード内のタイプを記述します。
ランタイムは、実行中に必要に応じて、ファイルおよびフレームワーククラスライブラリ（FCL）からメタデータを見つけて抽出します。

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

実行時に、ジャストインタイム（JIT）コンパイラーがMSILをネイティブコードに変換します。
このコンパイル中に、コードは、MSILとメタデータを調べる検証プロセスに合格して、コードがタイプセーフであると判断できるかどうかを調べる必要があります。

実行中のコード

共通言語ランタイムは、実行を可能にするインフラストラクチャと、実行中に使用できるサービスを提供します。
実行中に、マネージコードは、ガベージコレクション、セキュリティ、アンマネージコードとの相互運用性、言語間のデバッグサポート、強化された展開およびバージョン管理サポートなどのサービスを受け取ります。

.NET Coreコード実行プロセス

次に、.NET Frameworkと比較して、.NET Coreを使用してコードを実行する方法を関連付けます。 .NET Coreには、.NET Frameworkの一部であるこれらのコンポーネントの多くの置き換えがあります。

.NET Core Code Execution

.NET Coreには、C＃およびVB用のRoslynのような新しいシリーズのコンパイラがあります。
.NET CoreでF＃を使用する場合は、新しいF＃4.1コンパイラを使用することもできます。
実際、これらのツールは異なり、C＃コンパイラはC＃5までしかサポートできないため、C＃6以降を使用している場合は、.NET FrameworkでもRoslynを使用できます。
.NET Coreには、フレームワーククラスライブラリ（FCL）がないため、異なるライブラリセットが使用され、現在はCoreFxがあります。
CoreFxは、.NET Coreのクラスライブラリの再実装です。
また、CoreCLRと呼ばれる.NET Coreを使用した新しいランタイムがあり、JITコンパイラーを活用しています。
ここで問題は、.NETフレームワークにすでにあるこれらすべてのコンポーネントを再実装する理由です。
その答えは、Microsoftが.NET Coreを実装した理由と同じです。

.NET Core-モジュール性

NET Coreのもう1つの考慮事項は、モジュール化されたアプリケーションを構築および実装することです。 .NET Framework全体をインストールする代わりに、アプリケーションは必要なものだけをインストールできるようになりました。ビジュアルスタジオに行って、モジュール性を見てみましょう。.

ソリューションエクスプローラーのシンプルな.NET Coreアプリケーションを次に示します。 Referencesを展開すると、.NETCoreAppへの参照が表示されます。

.Net Core App

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

NuGet

NuGetパッケージリファレンスのシリーズ全体が表示されます。 .NET Frameworkで作業したことがある場合、これらの名前空間の多くは、.NET Frameworkで使用して慣れているため、見慣れたものになります。

NET Framework is split into many different pieces and re-implemented with CoreFx; these pieces are further distributed as individual packages..

フレームワーク

NETStandard.Libraryを展開すると、追加の参照が表示されます。このアプリケーションで使用しているSystem.Consoleにも気付くでしょう。
これで、すべてを.NET Framework内に取り込む必要はなく、アプリケーションに必要なものを取り込むだけです。
他にもいくつかの利点があります。たとえば、これらのモジュールは必要に応じて個別に更新できます。

モジュール化によりパフォーマンスが向上し、アプリケーション、特にASP.NET Coreアプリケーションをより高速に実行できます。

.NET Core-プロジェクトファイル

この章では、.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フレームワークコンソールアプリケーションであった場合、Visual Studioのプロジェクトにこれらのファイルを追加する方法を理解することが重要です。
プロジェクトではこれらのファイルを参照する必要があるため、最初にファイルをソリューションエクスプローラーにドラッグしてプロジェクトフォルダーにコピーする必要があります。
.NET Coreの利点の1つは、プロジェクトファイル（project.json）を使用したアプローチです。プロジェクトのルートにファイルをドロップするだけで、これらはプロジェクトに自動的に含まれます。
Visual Studioの従来の.NET Frameworkアプリケーションの場合のように、手動でファイルを参照する必要はありません。

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

ルート

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

プロジェクト

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

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

ビジュアル

[すべてはい]をクリックして、プロジェクトをリロードします。

すべてはい

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

.NET Core-パッケージ参照

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

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

ソースコード

CoreFxリポジトリで、 src フォルダーを開きます-

CoreFx

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

Json

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

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

Reverse Package

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

*DataContractJson* を検索してみましょう。

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 パッケージが追加されていることがわかります。

実行

別の方法は、NuGet Managerに移動して、追加するパッケージを参照することです。

パッケージの参照

.NET Core-UWPアプリの作成

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

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

ローカルで実行する場合は、Windows 10が必要です。Windows8でも開発できます。その後、エミュレータで実行する必要がありますが、Windows 10を使用することをお勧めします。
UWPアプリケーションには、Windows 10 SDKも必要です。 Visual Studio 2015セットアップを開き、Visual Studioを変更します。
[機能の選択]ページで下にスクロールすると、ユニバーサルWindowsアプリ開発ツールが表示されます。以下に示すように、そのオプションをチェックします。

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

Professional 2015

次に、[インストール]ボタンをクリックします。

インストールボタン

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

セットアップ完了

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

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

ファイルメニュー

左側のペインにツリービューが表示されます。テンプレート→Visual C＃→Windowsからユニバーサルテンプレートを選択してください。
中央のペインから、Blank App（Universal Windows）テンプレートを選択します。
[名前]フィールドに UWPFirstApp と入力してプロジェクトに名前を付け、[OK]をクリックします。

UWPFirstApp

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

デフォルト設定

ここでは、すべてのWindows 10デバイスをターゲットにできる単一のプロジェクトがあり、.NET CoreとUWPの両方がマルチターゲットの簡素化であることがわかります。
新しいプロジェクトが開くと、そのファイルがソリューションエクスプローラーペインの右側に表示されます。ファイルを表示するには、[プロパティ]タブではなく[ソリューションエクスプローラー]タブを選択する必要がある場合があります。
Blank App（Universal Window）は最小限のテンプレートですが、まだ多くのファイルが含まれています。これらのファイルは、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

.NET Core-MSBuild

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

project.json

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

ファイル

.NET Coreビルドシステムまたはproject.jsonビルドシステムは、UWPのニーズには不十分です。これが、UWPがまだ* .csproj（MSBuild）ビルドシステムを使用している理由です。
ただし、project.jsonはビルドシステムに関する限り移動します。
コンソールアプリで追加したように、いくつかの既存のファイルをUWPアプリケーションに追加する場合は、それらのファイルをプロジェクトフォルダーに追加する必要があります。さらに、ソリューションエクスプローラーのプロジェクトにも含める必要があります。

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

プロジェクトフォルダ

プロジェクト

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

ソリューションエクスプローラー

UWPアプリケーションの場合、ファイルをコピーするだけでは不十分であることがわかります。ソリューションエクスプローラーでは、これらのファイルを表示できないためです。
上記のスクリーンショットで強調表示されている Show All Files アイコンをクリックして、これらのファイルも含める必要があります。プロジェクトフォルダー内のすべてのファイルが表示されます。

すべてのファイルを表示

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

プロジェクトに含める

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

.NET Core-メタパッケージ

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

コンソールアプリケーション

NETCoreApp is a new framework that targeted .NET Core application. Now if you look under the References of UWP application, it will look a bit different as shown below..

UWPアプリケーション

この主な理由は、ここUWPに* .csprojがあるため、参照の古いスタイルに戻り、このプロジェクトタイプで1つのフレームワークのみをターゲットにできるためです。
参照は似ていますが。 UWPアプリケーションでは、Miscrosoft.NETCore.UniversalWindowsPlatform NuGetパッケージの参照は、コンソールアプリケーションのMicrosoft.NETCore.App NuGetの参照に似ていることがわかります。
Miscrosoft.NETCore.UniversalWindowsPlatformとMicrosoft.NETCore.Appはどちらもメタパッケージです。つまり、他のパッケージで構成されています。
コンソールアプリケーションでは、Microsoft.NETCore.App内の他のパッケージをドリルして表示できますが、ソリューションエクスプローラーで同じMiscrosoft.NETCore.UniversalWindowsPlatformを実行することはできません。
ただし、別のツールであるNuGetパッケージエクスプローラーを使用してこれを確認できます。ブラウザでこのURLを開きます-https://npe.codeplex.com/downloads/get/clickOnce/NuGetPackageExplorer.applicationをダウンロードすると、小さなユーティリティがダウンロードされます。
ダウンロードが完了したら、そのファイルをダブルクリックします。

ファイルを開く

[*インストール]をクリックして、NuGetパッケージエクスプローラーでインストールを開始します。

NuGetパッケージエクスプローラー

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

完了

[オンラインフィードからパッケージを開く]オプションをクリックします。

オンラインフィード

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

Nuget Org feed

open リンクをクリックすると、このメタパッケージのトップレベルの依存関係が開きます。

リンクを開く

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

メタパッケージ

これで、各メタパッケージが異なるパッケージのセットで構成されていることがわかります。
.NET Coreは、少なくとも現時点では.NET Frameworkで使用可能なクラスのサブセットですが、成長し続けており、.NET Frameworkの基本クラスに従っています。
UWPは.NET Coreに基づいており、Windowsストア開発に使用できるAPIのスーパーセットです。

Windowsランタイムおよび拡張SDK

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

ユニバーサルWindows SDK

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

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

API

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

API契約ページ

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

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

phone API

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

バッテリー情報

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

[参照の追加…*]を選択します

参照の追加

これで、ユニバーサルWindowsの新しい参照カテゴリを確認できます。このカテゴリの下には、コアユニバーサルWindows APIコントラクトを指すコアがあります

APIコントラクト

拡張機能を使用すると、機能を拡張でき、モバイル、デスクトップ、その他の拡張機能のさまざまな参照が表示されます。
さまざまなSKD拡張があり、さらに追加してAPIを取得できます。
また、異なるバージョンを見ることができます。そのため、必ず最新バージョンを入手して更新されたAPIを入手し、[OK]をクリックしてください。

更新されたAPI

UWP用の Windows Mobile Extensions が参照として追加されていることがわかります。

.NET Core-.NET標準ライブラリの作成

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

.NET Coreを使用して開発されたクラスライブラリは、.NET標準ライブラリをサポートします。これにより、そのバージョンの.NET標準ライブラリをサポートする任意の.NETプラットフォームからライブラリを呼び出すことができます。
クラスライブラリを完成したら、サードパーティコンポーネントとして配布するか、1つ以上のアプリケーションにバンドルされているコンポーネントとして含めるかを決定できます。

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

新しいプロジェクト

[新しいプロジェクトの追加]ダイアログボックスで、.NET Coreノードを選択してから、クラスライブラリ（.NET Core）プロジェクトテンプレートを選択します。

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

UtilityLibrary

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

クラス

中央のペインでクラスを選択し、名前とフィールドにStringLib.csを入力して、[追加]をクリックします。クラスを追加したら、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を展開して[参照設定]を右クリックし、[参照の追加…*]を選択します

FirstApp

[参照マネージャー]ダイアログボックスで、クラスライブラリプロジェクトの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);
      }
   }
}

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

アプリケーション

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

.NET Core-ポータブルクラスライブラリ

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

PCL

このフォルダーには、project.jsonファイルとCSファイルに加えて* .xprojファイルもあります。これは、Visual Studioが.NET Coreプロジェクトタイプを* .csprojではなく* .xprojに設定しているためです。

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

ツーリング

.csprojを参照して* .xprojを取得することは実際には不可能であり、*。xprojがなくなるため、その機能は実装されません。

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

PCLとは

ここで、PCLが何であるかを理解しましょう-

Portable Class Libraryプロジェクトを使用すると、複数の.NET Frameworkプラットフォームで動作するマネージアセンブリを記述およびビルドできます。
共有ビジネスロジックなど、多くのプロジェクトで共有するコードを含むクラスを作成し、さまざまなタイプのプロジェクトからそれらのクラスを参照できます。
また、Microsoftプラットフォーム用のクロスプラットフォームアプリとライブラリをすばやく簡単に構築するのにも役立ちます。
ポータブルクラスライブラリは、コードの開発とテストの時間とコストを削減するのに役立ちます。
このプロジェクトタイプを使用して、ポータブル.NET Frameworkアセンブリを記述およびビルドし、WindowsやWindows Phoneなどの複数のプラットフォームを対象とするアプリからそれらのアセンブリを参照します。

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

削除

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

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

StringLibrary

次に、参照するターゲットフレームワークを選択する必要があります。しばらくの間、Windows UniversalとASP.NET Coreを選択してから、ターゲットを変更します。 OK をクリックしてください。

retarget

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

プロパティ

Target .NET Platform Standardをクリックします。

ターゲット

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

クラスライブラリ

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

新しいクラスを追加

中央のペインでクラスを選択し、名前フィールドに StringLib.cs と入力して、[追加]をクリックします。クラスを追加したら、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を展開して[参照設定]を右クリックし、[参照の追加…]を選択します

参照

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

ライブラリプロジェクト

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

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

アプリケーションの実行

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

.NET Core-ライブラリへの参照の追加

この章では、ライブラリに参照を追加する方法について説明します。ライブラリへの参照の追加は、コンソールプロジェクトや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」パッケージを追加したいとしましょう。

参照タブ

[インストール]ボタンをクリックすると、次の画面が表示されます。

プレスインストール

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

ボタン

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

インストール

.NETコア共有ライブラリ

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

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

例

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

dotnet help

コマンド

最後に、new、restore、buildなどのさまざまなコマンドが表示されます。

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

dotnet pack

実行

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

デバッグフォルダー

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

Open NuGet

最初のオプション*ローカルパッケージを開く*を選択します。

最初のオプション

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

OKをクリック

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

*StringLibrary.1.0.0.symbols.nupkg* を開きましょう。

シンボル

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

StringLib.cs

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

project.jsonファイルは、プロジェクトのメタデータ、コンパイル情報、依存関係を定義するために.NET Coreプロジェクトで使用されます。ここで、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": {}
   }
}

ここで、著者名、説明、バージョンなどの追加情報を確認できます。このファイルを保存し、ライブラリプロジェクトをビルドしてから、「dotnet pack」コマンドを再度実行します。

.Net Pack

bin \ Debugフォルダー内で、StringLibrary NuGetパッケージがバージョン1.0.1で作成されていることがわかります。 NuGet Package Explorerで開きます。

バージョン

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

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

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

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

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

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

ステップ1 *-開始するには、nugetコマンドラインユーティリティが必要であり、インストールする必要があります。 NuGetパッケージマネージャーを開き、nuget.commandlineを検索します。

ステップ2 *-Nuget.Commandlineを選択し、*インストール*をクリックします。

コマンドライン

ステップ3 *- *OK をクリックしてNuget.Commandlineをインストールします。次のURL [[2]]

手動インストール

ステップ4 *-インストールが完了したら、コマンドプロンプトを再度開いて、NuGetパッケージがある *bin \ Debug フォルダーに移動し、次のコマンドを指定します-

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

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

ステップ6 *- *StringLibrary がインストールされていることがわかります。 StringLibrary をプライベートフィードにさらに追加できます。

プライベートフィード

ステップ7 *-そのフォルダに移動しましょう。

フォルダー

ステップ8 *- *stringlibrary フォルダー内に、バージョン名が付いた別のフォルダーが表示されます。ここでは1.0.1です。

バージョン名

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

Xamarin.Formsプロジェクトの作成

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

Xamarin.Formsは、開発者がクロスプラットフォームユーザーインターフェイスを迅速に作成できるようにするフレームワークです。
Xamarin.Formsは、開発者がAndroid、iOS、Windows、およびWindows Phoneで共有できるユーザーインターフェイスを簡単に作成できる、クロスプラットフォームのネイティブバックアップUIツールキットの抽象化です。
ユーザーインターフェイスは、ターゲットプラットフォームのネイティブコントロールを使用してレンダリングされるため、Xamarin.Formsアプリケーションは各プラットフォームに適切なルックアンドフィールを保持できます。

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

クロスプラットフォーム

インストールが完了したら、*ツール→オプション…*を選択して、Xamarinを更新します。

ツール

左ペインでスクロールダウンしてXamarinを展開し、その他*を選択します。ダイアログボックスの右上にある[*今すぐ確認]をクリックして、更新プログラムが利用可能かどうかを確認します。

今すぐチェック

更新が利用可能であることを確認できます。ダウンロードを開始するには、*ダウンロード*ボタンをクリックしてください。ダウンロードが完了すると、更新をインストールするよう通知されます。

Visual Studioを再度開き、[*ファイル]→[新規]→[プロジェクト…]メニューオプションを選択します。

更新

左側のペインで Visual C＃→Cross-Platform テンプレートを選択し、中央のペインで* Blank Xaml App（Xamarin.Forms Portable）*を選択します。 [名前]フィールドに名前を入力し、[OK]をクリックします。

ブランクXamlアプリ

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

対象バージョン

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

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

コードを展開する

このXamarin.Formsテンプレートでは、汎用のApp.xamlおよびMainPage.xamlを見ることができ、これらのプラットフォームで機能するXamarin.Forms XAMLフレームワークを使用しています。

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

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

ソース

ここにプライベートフィードを追加する必要があります。*プラス（+）ボタン*をクリックします。

プラス

プラスボタン

[利用可能なパッケージソース]セクションに別のチェックボックスが追加されていることがわかります。名前とソースパスを指定して[OK]をクリックします。

ソースパス

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

Select StringLibrary

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

エラー

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

修正

.NET Core-PCLのトラブルシューティング

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

修正エラー

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

このページでは、対象となるフレームワークのシリーズ全体が表示されます。エラーから、.NETPortableプロファイル259がStringLibrary 1.0.1と互換性がないことがわかります。ただし、.NET Standard 1.1ライブラリから参照を取得しようとしています。

互換

NET標準ライブラリを見て、どのプラットフォームがライブラリと互換性がないかを特定しましょう。.

プラットフォーム

Windows Phone Silverlight 8は.NET Standard 1.0と互換性があることがわかります。次のWebページを開くと、Profile259は.NET Standard 1.0のみをサポートできることがわかります。

Profile259

Windows Phone Silverlight 8のチェックを外しましょう。

Silverlight

[OK]ボタンをクリックします。

OKボタン

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

PM > Uninstall-Package Xamarin.Forms

コマンドの実行

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

PCLライブラリ

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

チェック解除

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

アンロード

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

TargetFrameworkProfile

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

ドキュメント

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

パッケージプライベートフィード

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

依存関係

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

PCLリファレンス

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

同じバージョン

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

.NET Core-テストプロジェクトを作成する

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

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

Visual C＃

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

StringLibraryTests

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

dotnet new -t xunittest

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

DIRコマンド

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のスキップ、実行プロセスにかかる時間も情報として記載されています。

.NET Core-Visual Studioでのテストの実行

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

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

FirstAppソリューション

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

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

テスト

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

テストフォルダー

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

プロジェクトJsonファイル

次のスクリーンショットは、 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 コマンドラインユーティリティと連携できるようにするためのアダプターです。次に、xunitを実行する testRunner が表示され、 netcoreapp1.0 フレームワークも表示されます。

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

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

テストエクスプローラー

そして、Visual Studioがテストを自動的に検出することがわかります。テストの名前は namespace.className.TestMethodName で構成されます。ここで、テストエクスプローラーの[すべて実行]ボタンをクリックします。

すべてのボタンを実行

最初にコードをビルドし、テストを実行すると、テストにかかった合計時間が表示されます。テストが失敗したときに出力を確認できるように、テストメソッドを変更します。

using System;
using Xunit;

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

[すべて実行]ボタンリンクをクリックして、テストを再度実行します。

すべて実行

これで、 test の失敗を確認できます。

.NET Core-テストライブラリ

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

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

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

このファイルの上部にプロジェクト設定が表示され、デフォルトで src や test などのフォルダーが設定されます。

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

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

SRCフォルダー

また、ソリューションエクスプローラーのプロジェクト構造は、プロジェクトがディスク上の物理的に存在する場所を表していません。ソリューションフォルダーを開いてみましょう。 StringLibrary プロジェクトが src フォルダー内にないことがわかります。

StringLibraryプロジェクト

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

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

プロジェクトの削除

srcフォルダーを右クリックして、[追加]→[既存のプロジェクト…]を選択します。

SRC

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

StringLibrary.csproj

コンソールアプリの project.json ファイルから 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": { },
         "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つのテストメソッドがあることがわかります。 [すべて実行]リンクをクリックすると、テストエクスプローラーに次の出力が表示されます。

すべてのリンクを実行

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

.Net Test

管理された拡張性フレームワーク

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

MEFは、軽量で拡張可能なアプリケーションを作成するためのライブラリです。
アプリケーション開発者は、構成を必要とせずに拡張機能を検出して使用できます。
MEFは.NET Framework 4に不可欠な部分であり、.NET Frameworkが使用されている場合はいつでも利用でき、大規模アプリケーションの柔軟性、保守性、およびテスト容易性を向上させます。
MEFは、Windows Forms、WPF、またはその他のテクノロジを使用するかどうかにかかわらず、クライアントアプリケーションで、またはASP.NETを使用するサーバーアプリケーションで使用できます。
MEFは Microsoft.Composition として.NET Coreにも移植されていますが、部分的に移植されています。
System.Composition のみが移植され、 System.ComponentModel.Composition はまだ使用できません。つまり、ディレクトリ内のアセンブリから型をロードできるカタログはありません。

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

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

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

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

名前フィールド

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

*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 の参照が表示されます。

Microsoft.Composition

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

[名前]フィールドにクラスの名前を入力し、[追加]をクリックします。

追加をクリック

*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 クラスをインスタンス化することで、アプリケーションが実行されていることがわかります。

PrintData

MEFの詳細については、次のURL [[3]]

.NET Core-SDK

この章では、.NET Coreの今後の機能について理解します。ブラウザーhttps://github.com/dotnet/cliで次のUrlを開くことにより、.NETコマンドラインツールから始めます。

Url

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

バイナリセクション

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

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

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

dotnet --info

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

コマンドラインツール

現在、プレビュー2ツールがあります。次のコマンドを実行して、 new コマンドについて確認しましょう。

dotnet help new

プロジェクトの新しいコマンド言語の場合、C＃やF＃などのプロジェクトやプロジェクトのタイプなどを選択できます。

プロジェクトタイプ

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

インストーラー

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

プロセス

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

インストール完了

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

dotnet --info

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

システム上のツール

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

dotnet help new

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

パッケージキャッシュ

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

Preview1

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

テンプレート

コマンドラインを使用して mstest、web、mvc および webapi プロジェクトを作成できるようになりました。

.NET Core-MSBuildおよびproject.json

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

私たちは今、変更がもたらす利点を議論しましょう-

既存のVisual Studioソリューションから.NET Coreへの移行が簡単になります。
これは大きな変化であり、MSBuildに基づいたCI/RMへの既存の投資を活用することもできます。
MSBuildでのビルド中に、インクリメンタルコンパイル、ビルド時の依存関係の解決、構成管理などを考えることができます。
dotnet cliを時間通りに出荷するには、ASP.NET Coreだけでなく、コンソールアプリ、UWPアプリなども含まれるため、多くの作業が必要です。

MSBuildおよび* .csprojの変更点は次のとおりです-

Project.jsonファイル（* .xproj）はMSBuild（* .csproj）に置き換えられます。
project.jsonの機能は、*。csprojに再びマージされ始めます。
パッケージリストについて何をするのかはまだ明確ではありませんが、 nuget.json の下にjsonのままにしておくか、**。csproj *にマージするかについて言及しました。
おそらく、その移行はスムーズであり、Visual Studioを使用している場合は潜在的に自動でなければなりません。

MSBuildの利点

MSBuildはオープンソースであり、GitHubで利用でき、完全にクロスプラットフォームになる予定です。
MSBuildは、**。csproj *の構造を劇的に単純化し、トリミングします。
マイクロソフトはまた、Visual Studioを必要とせずに多くのシナリオを可能にする新しいプロジェクトシステムを導入しています。詳細は、このURL [[4]]
目標は、MSBuildセットアップを使用しても、ビルドおよびプロジェクトの操作がVisual Studio IDEの外部と同様にシームレスになることです。

MSBuild vs project.json

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

dotnet new -t console

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

実行ディレクトリ

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

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

dotnet new console

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

コンソール

*project.json* ファイルと *MSBuild.csproj* ファイルを並べて比較してみましょう。

比較

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

MSBuildを使用した復元と構築

この章では、コマンドラインユーティリティを使用して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も作成されます。

MSBuild.dll

出力を表示するには、次のコマンドを実行してみましょう-

dotnet run

コンソールで次の出力を確認できます。

コンソール出力

.NET Core-移行

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

次のファイル

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

次のエラー

これは、 project.json ビルドシステムが.NET Core 2.0で使用できなくなったため、適切に機能するために移行が必要だからです。利用可能なコマンドを確認するには、次のコマンドを実行します。

dotnet help

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

移行

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

dotnet migrate

移行プロセスの概要が表示され、ここでプロジェクトが正常に移行されたことがわかります。

Migrate Sucessfull

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

tree/f

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

バックアップフォルダ

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

dotnet restore

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

Dotnet Restore

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

dotnet build

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

MSBuild

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

screenshot

Dotnet-core-quick-guide

.NET Core-概要

.NET Coreの特徴

オープンソース

クロスプラットフォーム

柔軟な展開

コマンドラインツール

互換性あり

モジュラー

.NET Coreプラットフォーム

.NET Core-前提条件

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

依存関係

Visual Studioの前提条件

.NET Core-環境のセットアップ

Visual Studio 2015

Visual Studio 2015のインストール

ビジュアルスタジオ2017

.NET Core-はじめに

.NET Core-数値

積分型

浮動小数点型

BigInteger

複雑な

SIMD

.NET Core-ガベージコレクション

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

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

世代

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

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

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

.NET Core-コード実行

コンパイラの選択

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

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

実行中のコード

.NET Coreコード実行プロセス

.NET Core-モジュール性

.NET Core-プロジェクトファイル

.NET Core-パッケージ参照

.NET Core-UWPアプリの作成

.NET Core-MSBuild

.NET Core-メタパッケージ

Windowsランタイムおよび拡張SDK

.NET Core-.NET標準ライブラリの作成

.NET Core-ポータブルクラスライブラリ

PCLとは

.NET Core-ライブラリへの参照の追加

.NETコア共有ライブラリ

Xamarin.Formsプロジェクトの作成

.NET Core-PCLのトラブルシューティング

.NET Core-テストプロジェクトを作成する

.NET Core-Visual Studioでのテストの実行

.NET Core-テストライブラリ

管理された拡張性フレームワーク

.NET Core-SDK

.NET Core-MSBuildおよびproject.json

MSBuildの利点

MSBuild vs project.json

MSBuildを使用した復元と構築

.NET Core-移行