.NET Core - Kurzanleitung

.NET Core ist die neueste Allzweck-Entwicklungsplattform, die von Microsoft verwaltet wird. Es funktioniert plattformübergreifend und wurde so umgestaltet, dass .NET schnell, flexibel und modern ist. Dies ist einer der wichtigsten Beiträge von Microsoft. Entwickler können jetzt Android-, iOS-, Linux-, Mac- und Windows-Anwendungen mit .NET in Open Source erstellen.

In diesem Lernprogramm werden .NET Core und einige neue Innovationen behandelt, darunter die .NET Framework-Updates, .NET Standard- und Universal Windows Platform-Updates usw.

Eigenschaften von .NET Core

Im Folgenden sind die Hauptmerkmale von .NET Core aufgeführt:

Open Source

• .NET Core ist eine Open Source-Implementierung, die MIT- und Apache 2-Lizenzen verwendet.

• .NET Core ist ein .NET Foundation-Projekt und auf GitHub verfügbar.

• Als Open Source-Projekt fördert es einen transparenteren Entwicklungsprozess und eine aktive und engagierte Community.

Plattformübergreifend

• In .NET Core implementierte Anwendungen können ausgeführt und ihr Code unabhängig von Ihrem Plattformziel wiederverwendet werden.

• Derzeit werden drei Hauptbetriebssysteme (OS) unterstützt.

  • Windows

  • Linux

  • MacOS

• Die unterstützten Betriebssysteme, CPUs und Anwendungsszenarien werden im Laufe der Zeit von Microsoft, anderen Unternehmen und Einzelpersonen bereitgestellt.

Flexible Bereitstellung

• Es gibt zwei Arten von Bereitstellungen für .NET Core-Anwendungen:

  • Framework-abhängige Bereitstellung

  • Unabhängige Bereitstellung

• Bei der Framework-abhängigen Bereitstellung hängt Ihre App von einer systemweiten Version von .NET Core ab, auf der Ihre App und Abhängigkeiten von Drittanbietern installiert sind.

• Bei der eigenständigen Bereitstellung wird die zum Erstellen Ihrer Anwendung verwendete .NET Core-Version zusammen mit den Abhängigkeiten Ihrer App und von Drittanbietern bereitgestellt und kann neben anderen Versionen ausgeführt werden.

Befehlszeilentools

• Alle Produktszenarien können über die Befehlszeile ausgeführt werden.

kompatibel

• .NET Core ist über die .NET Standard Library mit .NET Framework, Xamarin und Mono kompatibel

Modular

• .NET Core wird über NuGet in kleineren Assembly-Paketen veröffentlicht.

• .NET Framework ist eine große Assembly, die die meisten Kernfunktionen enthält.

• .NET Core wird als kleinere funktionsorientierte Pakete zur Verfügung gestellt.

• Dieser modulare Ansatz ermöglicht es den Entwicklern, ihre App zu optimieren, indem nur die NuGet-Pakete, die sie benötigen, in ihre App aufgenommen werden.

• Zu den Vorteilen einer kleineren App-Oberfläche gehören eine strengere Sicherheit, ein geringerer Service, eine verbesserte Leistung und geringere Kosten in einem Pay-for-What-You-Use-Modell.

Die .NET Core-Plattform

Die .NET Core Platform enthält die folgenden Hauptteile:

• .NET Runtime - Es bietet ein Typsystem, Assembly-Laden, einen Garbage Collector, native Interop und andere grundlegende Dienste.

• Fundamental Libraries - Eine Reihe von Framework-Bibliotheken, die primitive Datentypen, App-Kompositionstypen und grundlegende Dienstprogramme bereitstellen.

• SDK & Compiler - Eine Reihe von SDK-Tools und Sprachcompilern, die die Basisentwicklererfahrung ermöglichen und im .NET Core SDK verfügbar sind.

• ‘dotnet’ app host- Es wird zum Starten von .NET Core-Apps verwendet. Es wählt die Laufzeit aus und hostet die Laufzeit, stellt eine Richtlinie zum Laden von Assemblys bereit und startet die App. Der gleiche Host wird auch verwendet, um SDK-Tools auf die gleiche Weise zu starten.

In diesem Kapitel werden die verschiedenen Abhängigkeiten erläutert, die Sie bereitstellen und ausführen müssen. Dazu gehören die .NET Core-Anwendungen auf Windows-Computern, die mit Visual Studio entwickelt wurden.

Unterstützte Windows-Versionen

.NET Core wird in den folgenden Windows-Versionen unterstützt:

• Windows 7 SP1
• Windows 8.1
• Windows 10
• Windows Server 2008 R2 SP1 (vollständiger Server oder Serverkern)
• Windows Server 2012 SP1 (vollständiger Server oder Serverkern)
• Windows Server 2012 R2 SP1 (vollständiger Server oder Serverkern)
• Windows Server 2016 (Vollserver, Server Core oder Nano Server)

Abhängigkeiten

• Wenn Sie Ihre .NET Core-Anwendung unter Windows-Versionen vor Windows 10 und Windows Server 2016 ausführen, ist außerdem Visual C ++ Redistributable erforderlich.

• Diese Abhängigkeit wird automatisch für Sie installiert, wenn Sie das .NET Core-Installationsprogramm verwenden.

• Sie müssen Visual C ++ Redistributable für Visual Studio 2015 manuell installieren, wenn Sie .NET Core über das Installationsskript installieren oder eine eigenständige .NET Core-Anwendung bereitstellen.

• Bei Windows 7- und Windows Server 2008-Computern müssen Sie sicherstellen, dass Ihre Windows-Installation auf dem neuesten Stand ist und auch den über Windows Update installierten Hotfix KB2533623 enthält.

Voraussetzungen für Visual Studio

• Zum Entwickeln von .NET Core-Anwendungen mit dem .NET Core SDK können Sie einen beliebigen Editor Ihrer Wahl verwenden.

• Wenn Sie jedoch .NET Core-Anwendungen unter Windows mit Visual Studio entwickeln möchten, können Sie die folgenden zwei Versionen verwenden:

  • Visual Studio 2015

  • Visual Studio 2017 RC

• Mit Visual Studio 2015 erstellte Projekte basieren standardmäßig auf project.json, während mit Visual Studio 2017 RC erstellte Projekte immer auf MSBuild basieren.

In diesem Kapitel werden wir das Umgebungs-Setup von .NET Core erläutern. Es ist eine bedeutende Neugestaltung von .NET Framework. Um .NET Core in Ihrer Anwendung zu verwenden, können Sie zwei Versionen verwenden:

• Visual Studio 2015
• Visual Studio 2017 RC

Visual Studio 2015

Um Visual Studio 2015 verwenden zu können, müssen Sie Folgendes installiert haben:

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

Microsoft bietet eine kostenlose Version von Visual Studio an, die auch den SQL Server enthält und von heruntergeladen werden kann https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx und Microsoft .NET Core 1.0.1 - VS 2015 Tooling Preview 2 kann von heruntergeladen werden https://www.visualstudio.com/downloads/

Sie können auch die Installationsrichtlinien in der folgenden URL befolgen https://www.microsoft.com/net/core/#windowsvs2017

Installation von Visual Studio 2015

Führen Sie die folgenden Schritte aus, um Visual Studio 2015 zu installieren -

Step 1- Führen Sie nach Abschluss des Downloads das Installationsprogramm aus. Das folgende Dialogfeld wird angezeigt.

Step 2 - Klicken Sie auf Install um den Installationsvorgang zu starten.

Step 3 - Nach Abschluss der Installation wird das folgende Dialogfeld angezeigt.

Step 4 - Schließen Sie diesen Dialog und starten Sie Ihren Computer bei Bedarf neu.

Step 5- Öffnen Sie Visual Studio über das Startmenü. Sie erhalten das folgende Dialogfeld. Das Laden und endgültige Verwenden kann einige Minuten dauern.

Step 6 - Sobald es geladen ist, sehen Sie den folgenden Bildschirm.

Step 7 - Schließen Sie nach Abschluss der Visual Studio-Installation Visual Studio und starten Sie Microsoft .NET Core - VS 2015 Tooling Preview 2.

Step 8 - Aktivieren Sie das Kontrollkästchen und klicken Sie auf Installieren.

Step 9 - Nach Abschluss der Installation wird das folgende Dialogfeld angezeigt.

Sie können jetzt Ihre Anwendung mit .NET Core starten.

Visual Studio 2017

In diesem Lernprogramm wird Visual Studio 2015 verwendet. Wenn Sie jedoch Visual Studio 2017 verwenden möchten, ist in Visual Studio 2017 RC eine experimentelle Version der .NET Core-Tools für Visual Studio enthalten. Die Installationsrichtlinien finden Sie hier https://www.microsoft.com/net/core/#windowsvs2017

Visual Studio 2015 bietet eine umfassende Entwicklungsumgebung für die Entwicklung von .NET Core-Anwendungen. In diesem Kapitel erstellen wir ein neues Projekt in Visual Studio. Nachdem Sie das Visual Studio 2015-Tool installiert haben, können Sie mit dem Erstellen einer neuen .NET Core-Anwendung beginnen.

In dem New Project Erweitern Sie im Dialogfeld in der Liste Vorlagen den Knoten Visual C # und wählen Sie .NET Core aus. Die folgenden drei neuen Projektvorlagen sollten angezeigt werden

• Klassenbibliothek (.NET Core)
• Konsolenanwendung (.NET Core)
• ASP.NET Core-Webanwendung (.NET Core)

Wählen Sie im mittleren Bereich des Dialogfelds Neues Projekt die Option Konsolenanwendung (.NET Core) aus, nennen Sie sie "FirstApp" und klicken Sie dann auf "OK".

Visual Studio öffnet das neu erstellte Projekt und Sie sehen im Projektmappen-Explorer alle Dateien, die sich in diesem Projekt befinden.

Fügen Sie die folgende Zeile hinzu, um zu testen, ob die .NET-Kernkonsolenanwendung funktioniert.

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!"); 
      } 
   } 
}

Führen Sie nun die Anwendung aus. Sie sollten die folgende Ausgabe sehen.

.NET Core unterstützt die standardmäßigen numerischen Integral- und Gleitkomma-Grundelemente. Es werden auch die folgenden Typen unterstützt:

• System.Numerics.BigInteger ist ein integraler Typ ohne Ober- oder Untergrenze.

• System.Numerics.Complex ist ein Typ, der komplexe Zahlen darstellt.

• Eine Reihe von SIMD-fähigen Vektortypen (Single Instruction Multiple Data) im System.Numerics-Namespace.

Integrale Typen

.NET Core unterstützt sowohl vorzeichenbehaftete als auch vorzeichenlose Ganzzahlen mit unterschiedlichen Bereichen von einem Byte bis zu acht Bytes. Alle Ganzzahlen sind Werttypen.

Die folgende Tabelle zeigt die Integraltypen und ihre Größe.

Art	Signiert / nicht signiert	Größe (Bytes)	Mindestwert	Höchster Wert
Byte	Ohne Vorzeichen	1	0	255
Int16	Unterzeichnet	2	-32.768	32.767
Int32	Unterzeichnet	4	-2.147.483.648	2,147,483,647
Int64	Unterzeichnet	8	-9.223.372.036.854.775.808	9,223,372,036,854,775,807
SByte	Unterzeichnet	1	-128	127
UInt16	Ohne Vorzeichen	2	0	65.535
UInt32	Ohne Vorzeichen	4	0	4,294,967,295
UInt64	Ohne Vorzeichen	8	0	18.446.744.073.709.551.615

Jeder Integraltyp unterstützt einen Standardsatz von Operatoren für Arithmetik, Vergleich, Gleichheit, explizite Konvertierung und implizite Konvertierung.

Sie können auch mit den einzelnen Bits in einem ganzzahligen Wert arbeiten, indem Sie die System.BitConverter-Klasse verwenden.

Gleitkommatypen

.NET Core enthält drei primitive Gleitkommatypen, die in der folgenden Tabelle aufgeführt sind.

Art	Größe (Bytes)	Mindestwert	Höchster Wert
Doppelt	8	−1.79769313486232e308	1.79769313486232e308
Single	4	−3.402823e38	3.402823e38
Dezimal	16	−79,228,162,514,264,337,593,5 43,950,335	79,228,162,514,264,337,593,543,9 50,335

• Jeder Gleitkommatyp unterstützt einen Standardsatz von Operatoren für Arithmetik, Vergleich, Gleichheit, explizite Konvertierung und implizite Konvertierung.

• Sie können auch mit den einzelnen Bits in Doppel- und Einzelwerten arbeiten, indem Sie die BitConverter-Klasse verwenden.

• Die Dezimalstruktur verfügt über eigene Methoden, Decimal.GetBits und Decimal.Decimal (Int32 ()), um mit den einzelnen Bits eines Dezimalwerts zu arbeiten, sowie über eigene Methoden zum Ausführen einiger zusätzlicher mathematischer Operationen.

BigInteger

• System.Numerics.BigInteger ist ein unveränderlicher Typ, der eine beliebig große Ganzzahl darstellt, deren Wert theoretisch keine oberen oder unteren Grenzen hat.

• Die Methoden des BigInteger-Typs sind eng parallel zu denen der anderen Integraltypen.

Komplex

• Der Typ System.Numerics.Complex repräsentiert eine komplexe Zahl, dh eine Zahl mit einem reellen Zahlenteil und einem imaginären Zahlenteil

• Es unterstützt einen Standardsatz von Operatoren für Arithmetik, Vergleich, Gleichheit, explizite Konvertierung und implizite Konvertierung sowie mathematische, algebraische und trigonometrische Methoden.

SIMD

• Der Numerics-Namespace enthält eine Reihe von SIMD-fähigen Vektortypen für .NET Core.

• Mit SIMD können einige Vorgänge auf Hardwareebene parallelisiert werden, was zu enormen Leistungsverbesserungen bei mathematischen, wissenschaftlichen und grafischen Apps führt, die Berechnungen über Vektoren durchführen.

• Die SIMD-fähigen Vektortypen in .NET Core umfassen Folgendes:

  • System.Numerics.Vector2-, System.Numerics.Vector3- und System.Numerics.Vector4-Typen, bei denen es sich um 2-, 3- und 4-dimensionale Vektoren vom Typ Single handelt.

  • Die Vektor <T> -Struktur, mit der Sie einen Vektor eines beliebigen primitiven numerischen Typs erstellen können. Die primitiven numerischen Typen enthalten alle numerischen Typen im System-Namespace mit Ausnahme von Decimal.

  • Zwei Matrixtypen, System.Numerics.Matrix3 × 2, die eine 3 × 2-Matrix darstellen; und System.Numerics.Matrix4 × 4, die eine 4 × 4-Matrix darstellt.

  • Der Typ System.Numerics.Plane, der eine dreidimensionale Ebene darstellt, und der Typ System.Numerics.Quaternion, der einen Vektor darstellt, der zum Codieren dreidimensionaler physikalischer Rotationen verwendet wird.

In diesem Kapitel werden wir das Konzept der Garbage Collection behandeln, eine der wichtigsten Funktionen der .NET Managed Code-Plattform. Der Garbage Collector (GC) verwaltet die Zuweisung und Freigabe von Speicher. Der Garbage Collector dient als automatischer Speichermanager.

• Sie müssen nicht wissen, wie Sie Speicher zuweisen und freigeben oder die Lebensdauer der Objekte verwalten, die diesen Speicher verwenden

• Eine Zuordnung erfolgt jedes Mal, wenn Sie ein Objekt mit einem "neuen" Schlüsselwort deklarieren oder ein Werttyp eingerahmt wird. Zuweisungen sind normalerweise sehr schnell

• Wenn nicht genügend Speicher zum Zuweisen eines Objekts vorhanden ist, muss der GC Speicherbereinigungen sammeln und entsorgen, um Speicher für neue Zuweisungen verfügbar zu machen.

• Dieser Vorgang ist bekannt als garbage collection.

Vorteile der Müllabfuhr

Garbage Collection bietet die folgenden Vorteile:

• Sie müssen während der Entwicklung Ihrer Anwendung nicht manuell Speicher freigeben.

• Außerdem werden Objekte auf dem verwalteten Heap effizient zugewiesen.

• Wenn Objekte nicht mehr verwendet werden, werden diese Objekte durch Löschen ihres Speichers zurückgefordert und der Speicher für zukünftige Zuordnungen verfügbar gehalten.

• Verwaltete Objekte erhalten zunächst automatisch sauberen Inhalt, sodass ihre Konstruktoren nicht jedes Datenfeld initialisieren müssen.

• Es bietet auch Speichersicherheit, indem sichergestellt wird, dass ein Objekt den Inhalt eines anderen Objekts nicht verwenden kann.

Bedingungen für die Müllabfuhr

Die Speicherbereinigung erfolgt, wenn eine der folgenden Bedingungen erfüllt ist.

• Das System hat wenig physischen Speicher.

• Der Speicher, der von zugewiesenen Objekten auf dem verwalteten Heap verwendet wird, überschreitet einen akzeptablen Schwellenwert. Dieser Schwellenwert wird während des Prozesses kontinuierlich angepasst.

• Das GC.CollectMethode wird aufgerufen und in fast allen Fällen müssen Sie diese Methode nicht aufrufen, da der Garbage Collector kontinuierlich ausgeführt wird. Diese Methode wird hauptsächlich für spezielle Situationen und Tests verwendet.

Generationen

Der .NET Garbage Collector verfügt über 3 Generationen und jede Generation verfügt über einen eigenen Heap, der zum Speichern der zugewiesenen Objekte verwendet wird. Es gibt ein Grundprinzip, dass die meisten Objekte entweder kurzlebig oder langlebig sind.

Generation First (0)

• In Generation 0 werden zuerst Objekte zugewiesen.

• In dieser Generation leben Objekte häufig nicht nach der ersten Generation, da sie zum Zeitpunkt der nächsten Speicherbereinigung nicht mehr verwendet werden (außerhalb des Gültigkeitsbereichs).

• Generation 0 lässt sich schnell erfassen, da der zugehörige Heap klein ist.

Zweite Generation (1)

• In Generation 1 haben Objekte einen Raum mit zweiter Chance.

• Objekte, die nur von kurzer Dauer sind, aber die Sammlung der Generation 0 überleben (häufig basierend auf zufälligem Timing), gehen zur Generation 1.

• Sammlungen der 1. Generation sind ebenfalls schnell, da der zugehörige Heap ebenfalls klein ist.

• Die ersten beiden Heaps bleiben klein, da Objekte entweder gesammelt oder zum Heap der nächsten Generation befördert werden.

Dritte Generation (2)

• In Generation 2 werden alle langen Objekte gelebt und sein Haufen kann sehr groß werden.

• Die Objekte in dieser Generation können lange überleben, und es gibt keinen Heap der nächsten Generation, um Objekte weiter zu fördern.

• Der Garbage Collector verfügt über einen zusätzlichen Heap für große Objekte, der als Large Object Heap (LOH) bezeichnet wird.

• Es ist für Objekte reserviert, die 85.000 Byte oder mehr umfassen.

• Große Objekte werden nicht den Generationshaufen zugeordnet, sondern direkt dem LOH

• Sammlungen der Generation 2 und LOH können für Programme, die lange ausgeführt wurden oder große Datenmengen verarbeiten, spürbare Zeit in Anspruch nehmen.

• Es ist bekannt, dass große Serverprogramme Haufen von 10 GB haben.

• Der GC verwendet eine Vielzahl von Techniken, um die Zeit zu reduzieren, die er die Programmausführung blockiert.

• Der primäre Ansatz besteht darin, so viel Garbage Collection-Arbeit wie möglich an einem Hintergrund-Thread so auszuführen, dass die Programmausführung nicht beeinträchtigt wird.

• Der GC bietet Entwicklern auch einige Möglichkeiten, sein Verhalten zu beeinflussen, was zur Verbesserung der Leistung sehr nützlich sein kann.

In diesem Kapitel werden wir den Ausführungsprozess von .NET Core verstehen und ihn mit .NET Framework vergleichen. Der verwaltete Ausführungsprozess umfasst die folgenden Schritte.

• Compiler auswählen
• Kompilieren Sie Ihren Code in MSIL
• Kompilieren von MSIL zu nativem Code
• Code ausführen

Compiler auswählen

• Es handelt sich um eine mehrsprachige Ausführungsumgebung. Die Laufzeit unterstützt eine Vielzahl von Datentypen und Sprachfunktionen.

• Um die Vorteile der Common Language Runtime zu nutzen, müssen Sie einen oder mehrere Sprachcompiler verwenden, die auf die Laufzeit abzielen.

Kompilieren Sie Ihren Code in MSIL

• Durch das Kompilieren wird Ihr Quellcode in Microsoft Intermediate Language (MSIL) übersetzt und die erforderlichen Metadaten generiert.

• Metadaten beschreiben die Typen in Ihrem Code, einschließlich der Definition jedes Typs, der Signaturen der Mitglieder jedes Typs, der Mitglieder, auf die Ihr Code verweist, und anderer Daten, die die Laufzeit zur Ausführungszeit verwendet.

• Die Laufzeit sucht und extrahiert die Metadaten aus der Datei sowie aus Framework-Klassenbibliotheken (FCL) nach Bedarf während der Ausführung.

Kompilieren von MSIL zu nativem Code

• Zur Ausführungszeit übersetzt ein Just-in-Time-Compiler (JIT) die MSIL in nativen Code.

• Während dieser Kompilierung muss der Code einen Überprüfungsprozess bestehen, der die MSIL und die Metadaten untersucht, um herauszufinden, ob der Code als typsicher bestimmt werden kann.

Code ausführen

• Die Common Language Runtime bietet die Infrastruktur, die die Ausführung ermöglicht, und Dienste, die während der Ausführung verwendet werden können.

• Während der Ausführung erhält verwalteter Code Dienste wie Speicherbereinigung, Sicherheit, Interoperabilität mit nicht verwaltetem Code, sprachübergreifende Debugging-Unterstützung sowie erweiterte Unterstützung für Bereitstellung und Versionierung.

Ausführungsprozess von .NET Core Code

Lassen Sie uns nun beschreiben, wie Code mit .NET Core im Vergleich zu .NET Framework ausgeführt wird. In .NET Core gibt es viele Ersetzungen dieser Komponenten, die Teil von .NET Framework sind.

• In .NET Core haben wir jetzt eine neue Reihe von Compilern, wie wir Roslyn für C # und VB haben.

• Sie können auch den neuen F # 4.1-Compiler verwenden, wenn Sie F # mit .NET Core verwenden möchten.

• Tatsächlich sind diese Tools unterschiedlich und wir können Roslyn auch mit .NET Framework verwenden, wenn wir C # 6 oder höher verwenden, da der C # -Compiler nur bis zu C # 5 unterstützen kann.

• In .NET Core haben wir keine Framework Class Libraries (FCL), daher werden andere Bibliotheken verwendet und wir haben jetzt CoreFx.

• CoreFx ist die Neuimplementierung der Klassenbibliotheken für .NET Core.

• Wir haben auch eine neue Laufzeit mit .NET Core, bekannt als CoreCLR, und nutzen einen JIT-Compiler.

• Die Frage ist nun, warum wir all diese Komponenten, die wir bereits in .NET Framework haben, erneut implementieren.

• Die Antwort ist also dieselbe wie die, warum Microsoft .NET Core implementiert hat.

Es ist eine weitere Überlegung von .NET Core, eine modulare Anwendung zu erstellen und zu implementieren. Anstatt das gesamte .NET Framework zu installieren, kann Ihre Anwendung jetzt nur das installieren, was erforderlich ist. Gehen wir ins visuelle Studio und sehen uns die Modularität an.

Hier ist unsere einfache .NET Core-Anwendung im Projektmappen-Explorer. Lassen Sie uns Referenzen erweitern und Sie werden Verweise auf .NETCoreApp sehen

In .NETCoreApp wird der Paketverweis auf NuGet angezeigt. Lassen Sie es uns erweitern.

Sie sehen die gesamte Reihe der NuGet-Paketreferenzen. Wenn Sie in .NET Framework gearbeitet haben, werden Ihnen viele dieser Namespaces bekannt vorkommen, da Sie in .NET Framework daran gewöhnt sind.

.NET Framework ist in viele verschiedene Teile unterteilt und wird mit CoreFx erneut implementiert. Diese Stücke werden weiter als Einzelverpackungen verteilt.

• Wenn Sie nun die NETStandard.Library erweitern, werden zusätzliche Referenzen angezeigt. Sie werden sogar System.Console bemerken, das wir in dieser Anwendung verwenden.

• Jetzt müssen Sie nicht mehr alles in .NET Framework einbringen, sondern nur das, was Sie für Ihre Anwendung benötigen.

• Es gibt noch einige andere Vorteile; Beispielsweise können diese Module bei Bedarf einzeln aktualisiert werden.

Modularität führt zu Leistungsvorteilen und Ihre Anwendung kann schneller ausgeführt werden, insbesondere die ASP.NET Core-Anwendung.

In diesem Kapitel werden wir uns mit .NET Core-Projektdateien und dem Hinzufügen vorhandener Dateien zu Ihrem Projekt befassen.

Lassen Sie uns ein einfaches Beispiel verstehen, in dem wir einige Dateien haben, die bereits erstellt wurden. Wir müssen diese Dateien in unser FirstApp-Projekt einfügen.

Hier ist die Implementierung des Student.cs Datei

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; } 
   } 
}

Hier ist die Implementierung des Course.cs Datei.

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; } 
   } 
}

Lassen Sie uns diese drei Dateien nun auf Ihrer Festplatte und im Quellordner Ihres Projekts speichern.

• Wenn Sie mit .NET vertraut sind und es sich um eine traditionelle .NET Framework-Konsolenanwendung handelt, ist es wichtig zu verstehen, wie Sie diese Dateien in Visual Studio zu Ihrem Projekt hinzufügen.

• Sie müssen die Dateien zuerst in den Lösungs-Explorer ziehen, um sie in Ihren Projektordner zu kopieren, da Ihr Projekt auf diese Dateien verweisen muss.

• Einer der Vorteile von .NET Core ist der Ansatz der Projektdatei (project.json). Wir können einfach Dateien in das Stammverzeichnis unseres Projekts ablegen und diese werden dann automatisch in unser Projekt aufgenommen.

• Wir müssen nicht manuell auf Dateien verweisen, wie wir es in der Vergangenheit für herkömmliche .NET Framework-Anwendungen in Visual Studio getan haben.

Lassen Sie uns jetzt die Wurzel Ihres Projekts öffnen.

Lassen Sie uns nun alle drei Dateien in das Stammverzeichnis Ihres Projekts kopieren.

Sie können jetzt alle Dateien sehen, die in den Stammordner kopiert wurden.

Gehen wir jetzt zu Visual Studio. Sie erhalten das folgende Dialogfeld.

Klicken Yes to All um Ihr Projekt neu zu laden.

Sie werden nun feststellen, dass Dateien automatisch in Ihr Projekt aufgenommen werden.

In diesem Kapitel wird erläutert, wie Sie Pakete in Ihre .NET Core-Anwendung einfügen und wie Sie ein bestimmtes Paket finden. Wir können direkt zu NuGet gehen und ein Paket hinzufügen, aber hier werden wir einige andere Orte sehen.

Gehen wir nun zum Quellcode von .NET Core, der sich hier befindet - https://github.com/dotnet/corefx

Öffnen Sie im CoreFx-Repo das src Ordner -

Und Sie sehen die gesamte Liste der Ordner, die verschiedenen Paketen entsprechen. Lassen Sie uns jetzt Json suchen -

Es gibt eine andere Möglichkeit, Ihr Paket zu finden. Sie kennen wahrscheinlich verschiedene Typen, wenn Sie mit .NET Framework vertraut sind, aber das Zusammenstellen von Paketen in .NET Core ist völlig anders und Sie wissen nicht, wo sich diese Pakete befinden.

Wenn Sie den Typ kennen, können Sie mithilfe von suchen, um die Paketsuche umzukehren https://packagesearch.azurewebsites.net/

Hier können Sie jede Art von Paket eingeben, die Sie finden möchten. Anschließend scannt diese Site NuGet und findet die relevanten Pakete für Sie.

Lassen Sie uns jetzt suchen DataContractJson.

Sie werden jetzt sehen, dass wir das gleiche Paket erhalten; Lassen Sie uns auf das Paket klicken.

Sie sehen nun die NuGet-Seite. Sie müssen bestätigen, dass Sie dieses Paket benötigen. Sie können dies mit einigen Methoden in Ihre Anwendung einfügen.

Öffnen wir die Datei project.json.

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

Dies ist das neue Projektformat. In dieser Datei sehen Sie den Abschnitt Abhängigkeiten. Fügen wir eine neue Abhängigkeit hinzu, wie unten gezeigt.

{ 
   "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" 
      } 
   } 
}

Wenn Sie sich nun Ihre Referenzen ansehen, werden Sie das sehen System.Runtime.Serialization.Json Paket wird Ihrem Projekt hinzugefügt.

Eine andere Möglichkeit besteht darin, zum NuGet Manager zu wechseln und das Paket zu durchsuchen, das Sie hinzufügen möchten.

In diesem Kapitel wird erläutert, wie Sie eine UWP-Anwendung mit .NET Core erstellen. UWP wird auch als Windows 10 UWP-Anwendung bezeichnet. Diese Anwendung wird nicht unter früheren Windows-Versionen ausgeführt, sondern nur unter zukünftigen Windows-Versionen.

Es folgen einige Ausnahmen, bei denen UWP reibungslos funktioniert.

• Wenn Sie es lokal ausführen möchten, müssen Sie über Windows 10 verfügen. Sie können es auch unter Windows 8 entwickeln. Anschließend müssen Sie es unter Emulator ausführen. Es wird jedoch empfohlen, Windows 10 zu verwenden.

• Für UWP-Anwendungen benötigen Sie außerdem das Windows 10 SDK. Öffnen Sie das Visual Studio 2015-Setup und ändern Sie dann Visual Studio.

• Scrollen Sie auf der Seite "Ausgewählte Funktionen" nach unten, und Sie sehen die universellen Windows App-Entwicklungstools. Aktivieren Sie diese Option wie unten gezeigt.

Hier sehen Sie die verschiedenen Versionen des SDK und das neueste Update der Tools. Klicken Sie auf Weiter.

Klicken Sie nun auf Install Taste.

Nach Abschluss der Installation müssen Sie Ihr System neu starten.

Lassen Sie uns nun das UWP implementieren, indem Sie diese Schritte ausführen.

• Starten Sie zunächst Visual Studio 2015.

• Klicken Sie auf das Menü Datei und wählen Sie Neu → Projekt; Ein Dialogfeld "Neues Projekt" wird angezeigt. Sie können die verschiedenen Arten von Vorlagen im linken Bereich des Dialogfelds sehen.

• Im linken Bereich sehen Sie die Baumansicht. Wählen Sie nun unter Vorlagen → Visual C # → Windows die Option Universelle Vorlage aus.

• Wählen Sie im mittleren Bereich die Vorlage für die leere App (Universal Windows) aus.

• Geben Sie dem Projekt einen Namen, indem Sie eingeben UWPFirstApp Klicken Sie im Feld Name auf OK.

• Das Dialogfeld Zielversion / Mindestversion wird angezeigt. Die Standardeinstellungen für dieses Lernprogramm sind in Ordnung. Wählen Sie daher OK, um das Projekt zu erstellen.

• Hier haben wir ein einziges Projekt, das auf alle Windows 10-Geräte abzielen kann, und Sie werden feststellen, dass sowohl .NET Core als auch UWP das Multi-Targeting vereinfachen.

• Wenn ein neues Projekt geöffnet wird, werden seine Dateien auf der rechten Seite des Projektmappen-Explorers angezeigt. Möglicherweise müssen Sie die Registerkarte Projektmappen-Explorer anstelle der Registerkarte Eigenschaften auswählen, um Ihre Dateien anzuzeigen.

• Obwohl die leere App (Universal Window) eine minimale Vorlage ist, enthält sie immer noch viele Dateien. Diese Dateien sind für alle UWP-Apps, die C # verwenden, unerlässlich. Jedes Projekt, das Sie in Visual Studio erstellen, enthält die Dateien.

• Um das laufende Beispiel zu sehen, öffnen wir MainPage.XAML und fügen den folgenden Code hinzu.

<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>

Unten ist das Klickereignis der Schaltfläche in 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"; 
      } 
   } 
}

Lassen Sie uns nun den obigen Code auf dem lokalen Computer ausführen und Sie werden das folgende Fenster sehen. Geben Sie nun einen beliebigen Namen in das Textfeld ein und drücken Sie die TasteClick Me Taste.

In diesem Kapitel werden wir diskutieren, was MSBuild ist und wie es mit .NET Core funktioniert. MSBuild ist die Build-Plattform für Microsoft und Visual Studio. Wenn Sie in der UWP-Anwendung den Projektordner öffnen, werden sowohl die Dateien project.json als auch * .csproj angezeigt.

Wenn Sie jedoch unsere vorherige .NET Core Console-App öffnen, werden die Dateien project.json und * .xproj angezeigt.

• Das .NET Core-Buildsystem oder das project.json-Buildsystem reichen für UWP-Anforderungen nicht aus. Aus diesem Grund verwendet UWP immer noch das Build-System * .csproj (MSBuild).

• Aber project.json wird sich in Bezug auf das Build-System weiterentwickeln.

• Wenn Sie Ihrer UWP-Anwendung einige vorhandene Dateien hinzufügen möchten, wie wir sie in der Konsolen-App hinzugefügt haben, müssen Sie diese Dateien im Projektordner hinzufügen. Darüber hinaus müssen Sie Ihr Projekt auch in den Projektmappen-Explorer aufnehmen.

Betrachten wir nun die folgenden Dateien; Kopieren Sie diese Dateien in Ihren Projektordner.

Kehren wir zu Visual Studio zurück und öffnen Sie den Projektmappen-Explorer.

• Sie können jetzt sehen, dass das Kopieren von Dateien bei UWP-Anwendungen nicht ausreicht, da diese Dateien im Projektmappen-Explorer nicht angezeigt werden.

• Jetzt müssen wir auch diese Dateien einschließen, indem wir auf klicken Show All Files Symbol wie im obigen Screenshot hervorgehoben und Sie sehen jetzt alle Dateien im Projektordner.

Diese beiden Dateien sind immer noch nicht in unserem Projekt enthalten. Um diese Dateien einzuschließen, wählen Sie diese Dateien aus, klicken Sie mit der rechten Maustaste auf eine beliebige Datei und wählen Sie dannInclude in Project.

Jetzt sind diese Dateien auch enthalten. Eine gute Sache, die vorhergesehen werden kann, ist der project.json-Ansatz, Dateien für * .csproj in der zukünftigen Version der SKD-Tools und auch für Visual Studio abzulegen.

In diesem Kapitel werden die Referenzen zwischen unserer Konsolen-App und unserer UWP-App erläutert. Wenn Sie sich die Referenzen im Projektmappen-Explorer Ihrer Konsolenanwendung ansehen, wird die .NETCoreApp wie unten gezeigt angezeigt.

.NETCoreApp ist ein neues Framework für .NET Core-Anwendungen. Wenn Sie nun unter den Referenzen der UWP-Anwendung nachsehen, sieht es etwas anders aus, wie unten gezeigt.

• Der Hauptgrund dafür ist, dass wir hier in UWP die * .csproj haben, also kehren wir zum alten Referenzstil zurück und können mit diesem Projekttyp nur auf ein Framework abzielen.

• Die Referenzen sind jedoch ähnlich. Sie können jetzt sehen, dass in der UWP-Anwendung die Referenz für das NuGet-Paket Miscrosoft.NETCore.UniversalWindowsPlatform der NuGet-Referenz für Microsoft.NETCore.App in der Konsolenanwendung ähnlich ist.

• Sowohl Miscrosoft.NETCore.UniversalWindowsPlatform als auch Microsoft.NETCore.App sind Metapakete, dh sie bestehen aus anderen Paketen.

• In der Konsolenanwendung können wir andere Pakete in Microsoft.NETCore.App durchsuchen und anzeigen, aber wir können nicht dieselbe Miscrosoft.NETCore.UniversalWindowsPlatform im Projektmappen-Explorer ausführen.

• Wir können jedoch ein anderes Tool verwenden, den NuGet Package Explorer, um dies zu überprüfen. Lassen Sie uns jetzt diese URL im Browser öffnen -https://npe.codeplex.com/downloads/get/clickOnce/NuGetPackageExplorer.application und Sie werden sehen, wie ein kleines Dienstprogramm heruntergeladen wird.

• Doppelklicken Sie nach Abschluss des Downloads auf diese Datei.

• Klicken Install um die Installation im NuGet Package Explorer zu starten.

• Nach Abschluss der Installation wird das folgende Dialogfeld angezeigt.

• Klicken wir jetzt auf die Open a package from online feed Möglichkeit.

• Standardmäßig wird nach dem Feed nuget.org gesucht. Lassen Sie uns nun im Suchfeld nach Microsoft.NETCore.UniversalWindowsPlatform suchen, und Sie sehen 1 Ergebnis, wie unten gezeigt.

• Drücke den open Link und es werden die Abhängigkeiten der obersten Ebene dieses Metapakets geöffnet.

• Lassen Sie uns nun das .NETCore-Metapaket für die .NETCore-Anwendung und das Metapaket für die UWP-Anwendung nebeneinander öffnen.

• Sie können jetzt sehen, dass jedes Metapaket aus verschiedenen Paketen besteht.

• .NET Core ist eine Teilmenge der Klassen, die zumindest zu diesem Zeitpunkt in .NET Framework verfügbar sind, wächst jedoch und entspricht den Basisklassen von .NET Framework.

• Das UWP basiert auf .NET Core und ist eine Obermenge der APIs, die für die Windows Store-Entwicklung verfügbar sind.

Aufgrund von .NET Core stehen jetzt mehr APIs für die Entwicklung zur Verfügung.

Windows Runtime-Komponenten sind in sich geschlossene Objekte, die Sie in jeder Sprache instanziieren und verwenden können, einschließlich C #, Visual Basic, JavaScript und C ++. Zusätzlich zu dem im vorherigen Kapitel gezeigten .NET Core-Metapaket enthält die UWP-App standardmäßig einen Verweis auf ein universelles Windows SDK.

Universal Windows ist der Verweis auf Windows Runtime und wurde in eine Reihe von API-Verträgen einbezogen.

Der Satz von APIs innerhalb einer Gerätefamilie ist in Unterteilungen unterteilt, die als API-Verträge bezeichnet werden. Eine Liste der verschiedenen API-Verträge finden Sie hierhttps://msdn.microsoft.com/en-us/library/windows/apps/dn706135.aspx

Die meisten dieser APIs innerhalb der Windows-Laufzeit werden in einem einzigen Vertrag zusammengefasst. Lassen Sie uns nun auf der Seite API-Verträge nach dem Schlüsselwort Universal suchen.

Sie können Links zu verschiedenen APIs sehen und Sie können auch sehen, dass die Universal-Familie so groß ist, dass sie 12 Seiten Dokumentation enthält.

Sie können auf dieser Seite auch nach Telefon-API-Verträgen suchen.

Klicken wir jetzt auf die Windows.Phone.PhoneContractund nach unten scrollen; Sie sehen nun die Akkuinformationen des Telefons oder des Mobilgeräts.

Wenn Sie diese Informationen zusätzlich zu den bereits vorhandenen hinzufügen möchten, sollten Sie die Referenzen manuell hinzufügen. Gehen wir jetzt zu Visual Studio und klicken Sie mit der rechten Maustaste auf die Referenzen im Projektmappen-Explorer.

Wählen Add References…

Sie können jetzt die neue Referenzkategorie für Universal Windows anzeigen. Unter dieser Kategorie befindet sich Core, der sich auf die universellen Universal Windows API-Verträge bezieht

• Mit den Erweiterungen können wir die Funktionalität erweitern, und Sie sehen verschiedene Referenzen für Mobilgeräte, Desktops und andere Erweiterungen.

• Es gibt verschiedene SKD-Erweiterungen, die Sie hinzufügen können, um weitere APIs zu erhalten.

• Sie können auch verschiedene Versionen sehen. Stellen Sie also sicher, dass Sie die neueste Version erhalten, um die aktualisierten APIs zu erhalten, und klicken Sie dann auf OK.

Das können Sie jetzt sehen Windows Mobile Extensions for the UWP wird als Referenz hinzugefügt.

Eine Klassenbibliothek definiert die Typen und Methoden, die von jeder Anwendung aufgerufen werden können.

• Eine mit .NET Core entwickelte Klassenbibliothek unterstützt die .NET Standard Library, mit der Ihre Bibliothek von jeder .NET-Plattform aufgerufen werden kann, die diese Version der .NET Standard Library unterstützt.

• Wenn Sie Ihre Klassenbibliothek fertiggestellt haben, können Sie entscheiden, ob Sie sie als Komponente eines Drittanbieters verteilen oder als Komponente einbinden möchten, die mit einer oder mehreren Anwendungen gebündelt ist.

Beginnen wir mit dem Hinzufügen eines Klassenbibliotheksprojekts in unserer Konsolenanwendung. Klicken Sie mit der rechten Maustaste aufsrc Ordner im Projektmappen-Explorer und wählen Sie Add → New Project…

In dem Add New Project Wählen Sie im Dialogfeld den .NET Core-Knoten und anschließend die Projektvorlage für die Klassenbibliothek (.NET Core).

Geben Sie im Textfeld Name "UtilityLibrary" als Namen des Projekts ein, wie die folgende Abbildung zeigt.

Klicken Sie auf OK, um das Klassenbibliotheksprojekt zu erstellen. Sobald das Projekt erstellt ist, fügen wir eine neue Klasse hinzu. Klicken Sie mit der rechten Maustaste aufproject im Projektmappen-Explorer und wählen Sie Add → Class...

Wählen Sie im mittleren Bereich die Klasse aus, geben Sie StringLib.cs in den Namen und das Feld ein und klicken Sie dann auf Add. Ersetzen Sie nach dem Hinzufügen der Klasse den folgenden Code in der Datei 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); 
      } 
   } 
}

• Die Klassenbibliothek, UtilityLibrary.StringLib, enthält einige Methoden wie, StartsWithUpper, StartsWithLower, und StartsWithNumber Dies gibt einen booleschen Wert zurück, der angibt, ob die aktuelle Zeichenfolgeninstanz mit Groß-, Klein- und Kleinbuchstaben beginnt.

• In .NET Core wird die Char.IsUpper Die Methode gibt true zurück, wenn ein Zeichen in Großbuchstaben geschrieben ist, die Char.IsLower-Methode gibt true zurück, wenn ein Zeichen in Kleinbuchstaben geschrieben ist, und die Char.IsNumber-Methode gibt true zurück, wenn ein Zeichen eine Zahl ist.

• Wählen Sie in der Menüleiste Build, Build Solution. Das Projekt sollte fehlerfrei kompiliert werden.

• Unser .NET Core-Konsolenprojekt hat keinen Zugriff auf unsere Klassenbibliothek.

• Um diese Klassenbibliothek zu nutzen, müssen wir in unserem Konsolenprojekt einen Verweis auf diese Klassenbibliothek hinzufügen.

Erweitern Sie dazu FirstApp, klicken Sie mit der rechten Maustaste auf Referenzen und wählen Sie Add Reference…

Wählen Sie im Dialogfeld Referenzmanager UtilityLibrary, unser Klassenbibliotheksprojekt, aus und klicken Sie dann auf OK.

Öffnen wir nun die Datei Program.cs des Konsolenprojekts und ersetzen den gesamten Code durch den folgenden Code.

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); 
      } 
   } 
}

Lassen Sie uns jetzt Ihre Anwendung ausführen und Sie werden die folgende Ausgabe sehen.

Lassen Sie uns zum besseren Verständnis die anderen Erweiterungsmethoden Ihrer Klassenbibliothek in Ihrem Projekt verwenden.

In diesem Kapitel werden wir diskutieren, was PCL (Portable Class Library) ist und warum wir PCL benötigen. Um dieses Konzept zu verstehen, öffnen wir den Klassenordner-Projektordner, den wir im vorherigen Kapitel erstellt haben.

In diesem Ordner können Sie sehen, dass wir neben den Dateien project.json und CS auch die Datei * .xproj haben. Dies liegt daran, dass Visual Studio den .NET Core-Projekttyp als * .xproj anstelle von * .csproj einrichtet.

Wie von Microsoft erwähnt, wird * .xproj verschwinden, aber es ist immer noch hier in der Vorschau 2. Wie wir bereits erwähnt haben, verwendet die UWP-Anwendung die * .csproj.

Jetzt ist es tatsächlich nicht möglich, * .csproj als Referenz und * .xproj zu erhalten, und diese Funktionalität wird nicht implementiert, da * .xproj ausgezogen wird.

Stattdessen benötigen wir eine Klassenbibliothek, die von der Konsolen-App und der UWP-App gemeinsam genutzt werden kann. Hier kommt PCL.

Was ist PCL?

Lassen Sie uns jetzt verstehen, was PCL ist -

• Mit dem Projekt Portable Class Library können Sie verwaltete Assemblys schreiben und erstellen, die auf mehr als einer .NET Framework-Plattform funktionieren.

• Sie können Klassen erstellen, die Code enthalten, den Sie für viele Projekte freigeben möchten, z. B. gemeinsam genutzte Geschäftslogik, und dann auf diese Klassen aus verschiedenen Projekttypen verweisen.

• Sie können damit auch schnell und einfach plattformübergreifende Apps und Bibliotheken für Microsoft-Plattformen erstellen.

• Mit tragbaren Klassenbibliotheken können Sie Zeit und Kosten für die Entwicklung und das Testen von Code reduzieren.

• Verwenden Sie diesen Projekttyp, um tragbare .NET Framework-Assemblys zu schreiben und zu erstellen, und verweisen Sie dann auf diese Assemblys aus Apps, die auf mehrere Plattformen wie Windows und Windows Phone usw. abzielen.

Entfernen wir nun die von uns erstellte Klassenbibliothek aus dem Projektmappen-Explorer. Löschen Sie es gleichzeitig aus dem Ordner "Lösung" und fügen Sie ein neues Projektelement hinzu.

Wähle aus Visual C# → Windows Vorlage im linken Bereich und wählen Sie im mittleren Bereich die Option Klassenbibliothek (tragbar).

Geben Sie StringLibrary in das Namensfeld ein und klicken Sie auf OK um dieses Projekt zu erstellen.

Jetzt müssen wir die Ziel-Frameworks auswählen, auf die verwiesen werden soll. Lassen Sie uns für einen Moment Windows Universal und ASP.NET Core auswählen, dann werden wir es neu ausrichten. KlickenOK.

Sie können sehen, dass ein neues Projekt im PCF-Format erstellt wurde. Klicken Sie jetzt im Projektmappen-Explorer mit der rechten Maustaste auf das StringLibrary-Projekt und wählen Sie Eigenschaften.

Klicken Sie auf den Target .NET Platform Standard.

Klicken Sie auf Ja. Es ist jetzt dieselbe Klassenbibliothek mit einem kleinen Unterschied. Der Unterschied besteht darin, dass es auch von UWP verwendet werden kann, da es die Datei * .csproj anstelle von * .xproj enthält.

Fügen wir nun eine neue Klasse hinzu. Dazu müssen Sie im Projektmappen-Explorer mit der rechten Maustaste auf Projekt klicken und auswählenAdd → Class...

Wählen Sie im mittleren Bereich die Klasse aus und geben Sie ein StringLib.cs in das Namensfeld und dann auf klicken Add. Ersetzen Sie nach dem Hinzufügen der Klasse den folgenden Code in der Datei 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); 
      } 
   } 
}

Lassen Sie uns dieses tragbare Klassenbibliotheksprojekt erstellen und es sollte fehlerfrei kompiliert werden. Jetzt müssen wir in unserem Konsolenprojekt einen Verweis auf diese tragbare Klassenbibliothek hinzufügen. Erweitern Sie also FirstApp, klicken Sie mit der rechten Maustaste auf Referenzen und wählen SieAdd Reference…

Wählen Sie im Dialogfeld Referenzmanager die Option StringLibrary aus, bei der es sich um unser portables Klassenbibliotheksprojekt handelt, und klicken Sie dann auf OK.

Sie können sehen, dass die StringLibrary-Referenz zum Konsolenprojekt hinzugefügt wird und auch in der Datei project.json angezeigt wird.

Sie können die Anwendung jetzt erneut ausführen und sehen dieselbe Ausgabe.

Lassen Sie uns jetzt die anderen Erweiterungsmethoden Ihrer tragbaren Klassenbibliothek in Ihrem Projekt verwenden. Dieselbe tragbare Bibliothek wird auch in Ihrer UWP-Anwendung verwendet.

In diesem Kapitel wird erläutert, wie Sie Ihrer Bibliothek Verweise hinzufügen. Das Hinzufügen von Verweisen zur Bibliothek entspricht dem Hinzufügen von Verweisen auf andere Projekte wie Konsolenprojekte und UWP-Projekte.

Sie können jetzt sehen, dass das PCL-Projekt standardmäßig einige Referenzen enthält. Sie können auch andere Referenzen gemäß Ihren Anwendungsanforderungen hinzufügen.

In der PCL-Bibliothek sehen Sie auch die Datei project.json.

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

Eine Methode zum Hinzufügen von Verweisen zu Ihrer Bibliothek besteht darin, sie direkt in die Datei project.json einzugeben. Wie Sie sehen, haben wir im Abschnitt Abhängigkeiten einige Verweise hinzugefügt, wie im folgenden Code gezeigt.

{ 
   "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": {} 
   } 
}

Lassen Sie uns diese Datei jetzt speichern und Sie werden sehen, dass jetzt Referenzen zu Ihrer Bibliothek hinzugefügt werden.

Die andere Methode zum Hinzufügen von Verweisen zu Ihrer Bibliothek ist der NuGet Package Manager. Klicken Sie jetzt mit der rechten Maustaste aufStringLibrary (Portable) projizieren und auswählen Mange NuGet Packages…

Auf der Registerkarte Durchsuchen können Sie jedes NuGet-Paket durchsuchen. Angenommen, wir möchten das Paket "System.Runtime.Serialization.Primitives" hinzufügen.

Drücke den Install Schaltfläche, die den folgenden Bildschirm anzeigt.

Klicken Sie nun auf OK Taste.

Klicken Sie abschließend auf I AcceptKlicken Sie auf die Schaltfläche, um die Installation dieses NuGet-Pakets zu starten. Sobald die Installation abgeschlossen ist, wird das NuGet-Paket "System.Runtime.Serialization.Primitives" zu Ihrer Bibliothek hinzugefügt.

In diesem Kapitel wird erläutert, wie Sie Ihre Bibliothek als freigeben können NuGet Packagedamit es in einem anderen Projekt verbraucht werden kann. Das Erstellen eines Pakets beginnt mit dem Code, den Sie verpacken und mit anderen teilen möchten, entweder über die öffentliche Galerie nuget.org oder eine private Galerie in Ihrer Organisation. Das Paket kann auch zusätzliche Dateien enthalten, zreadme Dies wird angezeigt, wenn das Paket installiert wird, und kann Transformationen in bestimmte Projektdateien enthalten.

Betrachten wir nun ein einfaches Beispiel, in dem wir ein NuGet-Paket aus unserer Bibliothek erstellen. Öffnen Sie dazu die Eingabeaufforderung und wechseln Sie in den Ordner, in dem sich die Datei project.json Ihres Bibliotheksprojekts befindet.

Lassen Sie uns nun den folgenden Befehl ausführen.

dotnet help

Am Ende sehen Sie verschiedene Befehle wie Neu, Wiederherstellen und Erstellen usw.

Der letzte Befehl ist pack;Dadurch wird ein NuGet-Paket erstellt. Lassen Sie uns nun den folgenden Befehl ausführen.

dotnet pack

Sie können jetzt sehen, dass die NuGet-Pakete im Ordner bin erstellt werden. Lassen Sie uns den Ordner bin \ Debug öffnen.

Die Frage ist nun, was sich in den NuGet-Paketen befindet, um zu sehen, dass wir NuGet Package Explorer verwenden können. Öffnen wir nun den NuGet Package Explorer.

Wählen Sie die erste Option Open a local package.

Wähle aus StringLibrary.1.0.0.nupkg und klicken Sie auf Open.

Sie können sehen, dass wir im Abschnitt Paketinhalt nur StringLibrary.dll haben. Im Abschnitt Paketmetadaten sehen Sie einige Informationen zu dieser Bibliothek wie ID, Versionen und alle Abhängigkeiten.

Lassen Sie uns jetzt die öffnen StringLibrary.1.0.0.symbols.nupkg.

In diesem NuGet-Paket sehen Sie die Quelldateien und die *.pdbDatei auch. Wenn Sie auf das doppelklickenStringLib.cs Datei sehen Sie auch den Quellcode.

Hier stellt sich die Frage, wie die Metadaten wie Version, Autoren und Beschreibung usw. konfiguriert werden können.

Die Datei project.json wird in .NET Core-Projekten verwendet, um Projektmetadaten, Kompilierungsinformationen und Abhängigkeiten zu definieren. Öffnen wir nun die Datei project.json und fügen die folgenden zusätzlichen Informationen hinzu.

{ 
   "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": {} 
   } 
}

Hier können Sie zusätzliche Informationen wie Autorenname, Beschreibung und Version sehen. Speichern Sie diese Datei, erstellen Sie das Bibliotheksprojekt und führen Sie den Befehl „dotnet pack“ erneut aus.

Im Ordner bin \ Debug können Sie sehen, dass die StringLibrary NuGet-Pakete mit Version 1.0.1 erstellt wurden. Lassen Sie es uns im NuGet Package Explorer öffnen.

Sie sehen die aktualisierten Metadaten. Die Frage ist nun, wie wir es in einem anderen Paket verwenden können.

Wir müssen zunächst irgendwo im NuGet-Feed veröffentlichen und können ihn dann in einem anderen Projekt verwenden.

Es gibt zwei Möglichkeiten, die aktualisierten Metadaten zu veröffentlichen:

• Veröffentlichen Sie es auf nuget.org
• Verschieben Sie die Metadaten in einen privaten NuGet-Feed

Hier werden wir den privaten NuGet-Feed verwenden, da es viel einfacher ist, ein Konto auf nuget.org einzurichten. Um zu erfahren, wie Sie Ihr Paket auf nuget.org veröffentlichen, können Sie alle hier angegebenen Richtlinien befolgenhttps://docs.microsoft.com/en-us/nuget/create-packages/publish-a-package.

Befolgen Sie diese Schritte, um die aktualisierten Metadaten in einen privaten NuGet-Feed zu übertragen.

Step 1- Zunächst benötigen wir das Nuget-Befehlszeilenprogramm und müssen es installieren. Öffnen wir nun den NuGet Package Manager und suchen nach nuget.commandline.

Step 2 - Wählen Sie Nuget.Commandline und klicken Sie auf Install.

Step 3 - Klicken Sie auf OKum Nuget.Commandline zu installieren. Sie können es auch manuell installieren, indem Sie es von der folgenden URL herunterladenhttps://dist.nuget.org/index.html und richten Sie dann die Umgebungsvariable ein.

Step 4 - Lassen Sie uns nach Abschluss der Installation die Eingabeaufforderung erneut öffnen und gehen Sie zu bin\Debug Ordner, in dem sich die NuGet-Pakete befinden, und geben Sie den folgenden Befehl an:

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

Step 5 - Im obigen Befehl fügen wir das Paket StringLibrary.1.0.1.nupkg zu unserem privaten Feed hinzu und der Speicherort ist D:\PrivateNugetPackages, -Source gibt die Paketquelle an.

Step 6 - Sie können sehen, dass die StringLibraryist installiert; dasStringLibrary kann weiter zum privaten Feed hinzugefügt werden.

Step 7 - Lass uns zu diesem Ordner gehen.

Step 8 - In der stringlibrary Ordner, sehen Sie einen anderen Ordner mit dem Versionsnamen und hier ist es 1.0.1.

Das NuGet-Paket befindet sich hier.

In diesem Kapitel wird erläutert, wie Sie das von uns erstellte und in einem privaten NuGet-Feed veröffentlichte NuGet-Paket verwenden. Also werden wir zuerst ein Xamarin.Forms-Projekt erstellen. Wir müssen zuerst verstehen, was Xamarin.Forms ist.

• Xamarin.Forms ist ein Framework, mit dem Entwickler schnell plattformübergreifende Benutzeroberflächen erstellen können.

• Xamarin.Forms ist eine plattformübergreifende, nativ unterstützte UI-Toolkit-Abstraktion, mit der Entwickler auf einfache Weise Benutzeroberflächen erstellen können, die für Android, iOS, Windows und Windows Phone gemeinsam genutzt werden können.

• Die Benutzeroberflächen werden mithilfe der nativen Steuerelemente der Zielplattform gerendert, sodass Xamarin.Forms-Anwendungen für jede Plattform das entsprechende Erscheinungsbild beibehalten können.

Um Xamarin.Forms zu starten, benötigen wir einige zusätzliche Funktionen in Visual Studio 2015. Lassen Sie uns Ihr Visual Studio 2015 ändern und sicherstellen, dass die folgende plattformübergreifende mobile Entwicklungsoption ausgewählt ist.

Lassen Sie uns nach Abschluss der Installation den Xamarin durch Auswahl aktualisieren Tools → Options…

Scrollen Sie nach unten und erweitern Sie Xamarin im linken Bereich. Wählen Sie dann aus Other. Klicken Sie oben rechts im Dialogfeld aufCheck Now um zu sehen, ob Updates verfügbar sind.

Sie können sehen, dass Updates verfügbar sind. Lassen Sie uns auf klicken DownloadSchaltfläche zum Starten des Downloads. Sobald der Download abgeschlossen ist, werden Sie benachrichtigt, um die Updates zu installieren.

Lassen Sie uns nun das Visual Studio erneut öffnen und das auswählen File → New → Project… Menüoption.

Wählen Sie im linken Bereich die Option aus Visual C# → Cross-Platform Vorlage und wählen Sie im mittleren Bereich Blank Xaml App (Xamarin.Forms Portable). Geben Sie den Namen in das Feld Name ein und klicken Sie auf OK.

Wählen Sie die Zielversion und die Mindestversion aus und klicken Sie auf OK.

Sie werden eine Reihe von Projekten sehen; Oben haben wir die PCL-Bibliothek, die von allen Plattformen wie Android, iOS, UWP, Windows 8.1 und Windows Phone 8.1 gemeinsam genutzt wird.

Hier konzentrieren wir uns auf die PCL-Bibliothek und bringen hier Code. Lassen Sie uns den Code erweitern.

In dieser Xamarin.Forms-Vorlage sehen Sie die generische App.xaml und MainPage.xaml, die das Xamarin.Forms XAML-Framework verwendet, das auf diesen Plattformen funktioniert.

Wir müssen unsere Codes importieren und wir brauchen auch den privaten NuGet-Feed, den wir im letzten Kapitel eingerichtet haben.

Öffnen wir nun den NuGet Package Manager. Klicken Sie auf das Rad neben der Dropdown-Liste Paketquelle.

Wir müssen hier unseren privaten Feed hinzufügen, lassen Sie uns auf klicken plus (+) button.

Sie werden sehen, dass ein weiteres Kontrollkästchen in der hinzugefügt wird Available package sources Geben Sie im Abschnitt einen Namen und einen Quellpfad an und klicken Sie auf OK.

Gehen wir jetzt zur Registerkarte Durchsuchen und wählen Sie PrivateSource aus der Dropdown-Liste Paketquelle aus. Daraufhin wird das StringLibrary NuGet-Paket angezeigt. Wählen Sie StringLibrary und klicken Sie aufInstall.

Klicken Sie auf OK und Sie sehen einen Fehler.

Wir können die Bibliothek nicht mit .NETPortable-Profilversion 259 verwenden. Wir werden diesen Fehler im nächsten Kapitel beheben.

In diesem Kapitel werden wir den Fehler beheben, den wir bei der Installation des NuGet-Pakets aus unserem privaten Feed im Xamarin.Forms-Projekt erhalten haben.

Wir werden das Problem in Kürze weiter verstehen. Klicken Sie zunächst mit der rechten Maustaste auf die PCL-Bibliothek und wählen Sie Eigenschaften.

Auf dieser Seite sehen Sie die gesamte Reihe der Frameworks, auf die abgezielt wird. Anhand des Fehlers können Sie erkennen, dass das .NETPortable-Profil 259 nicht mit unserer StringLibrary 1.0.1 kompatibel ist. Es wird jedoch versucht, auf die .NET Standard 1.1-Bibliothek zu verweisen.

Lassen Sie uns nun die .NET-Standardbibliothek anzeigen und feststellen, welche Plattform nicht mit unserer Bibliothek kompatibel ist.

Sie können sehen, dass Windows Phone Silverlight 8 mit .NET Standard 1.0 kompatibel ist. Wenn Sie die folgende Webseite öffnen, werden Sie feststellen, dass Profile259 nur .NET Standard 1.0 unterstützen kann.

Deaktivieren Sie jetzt Windows Phone Silverlight 8.

Drücke den OK Taste.

Um dieses Problem zu beheben, klicken Sie auf OK und brechen Sie das Dialogfeld "Ziele ändern" ab. Öffnen Sie dann die Package Manager-Konsole und führen Sie den folgenden Befehl aus.

PM > Uninstall-Package Xamarin.Forms

Gehen wir nun zu den Eigenschaften der PCL-Bibliothek. Klicken Sie auf die Schaltfläche Ändern.

Deaktivieren Sie Windows Phone Silverlight 8 und klicken Sie auf OK.

Sie können jetzt sehen, dass Windows Phone Silverlight 8 im Targeted Framework nicht mehr verfügbar ist. Sie können jetzt auch das Profil sehen, das das Ziel ist. Um dies zu sehen, entladen wir die PCL-Bibliothek und bearbeiten die Datei XamarinApp.csproj.

Sie können jetzt sehen, dass TargetFrameworkProfile jetzt Profile111 ist.

Wenn Sie die Dokumentation öffnen, sehen Sie, dass Profile111 .NET Standard 1.1 unterstützt.

Laden Sie nun die PCL erneut, öffnen Sie den NuGet Package Manager und versuchen Sie, das StringLibrary-Paket aus einem privaten Feed zu installieren.

Wählen Sie in der Dropdown-Liste Abhängigkeitsverhalten die Option Abhängigkeiten ignorieren aus und klicken Sie dann auf Install.

Sie können sehen, dass das StringLibrary-Paket jetzt über den privaten Feed installiert ist. Wenn Sie die Referenzen von PCL erweitern, werden Sie sehen, dass die StringLibrary-Referenz auch wie unten gezeigt hinzugefügt wird.

Wir hatten Xamarin.Forms für das Windows Phone Silverlight 8-Problem deinstalliert. Die Xamarin.Forms müssen erneut installiert werden. Es wird empfohlen, dieselbe Version zu installieren.

Lassen Sie uns nach Abschluss der Installation die StringLibrary-Funktionalität in Ihrer Anwendung verwenden.

In diesem Kapitel wird erläutert, wie Sie ein Testprojekt mit .NET Core erstellen. Unit Testing ist ein Entwicklungsprozess für die Software, die die kleinsten testbaren Teile einer Anwendung enthält, die als Einheiten bezeichnet werden. Sie werden einzeln und unabhängig auf ordnungsgemäßen Betrieb geprüft. Unit-Tests können entweder automatisiert oder auch manuell durchgeführt werden.

Lassen Sie uns nun das Dialogfeld Neues Projekt öffnen und auswählen Visual C# → .NET Core Vorlage.

In diesem Dialogfeld sehen Sie, dass es keine Projektvorlage für Unit-Tests gibt. Um ein Unit-Test-Projekt zu erstellen, sollten Sie das Befehlszeilenprogramm verwenden. Gehen wir zu dem von uns erstellten Lösungsordner. Erstellen Sie einen Testordner und erstellen Sie innerhalb des Testordners einen anderen Ordner und rufen Sie ihn aufStringLibraryTests.

Verwenden Sie jetzt das Befehlszeilenprogramm dotnet, um ein neues Testprojekt zu erstellen, indem Sie den folgenden Befehl ausführen:

dotnet new -t xunittest

Sie können jetzt sehen, dass ein neues C # -Projekt erstellt wird. Lassen Sie uns in den Ordner schauen, indem Sie das ausführenv Befehl und Sie werden sehen project.json und Tests.cs Dateien wie unten gezeigt.

Hier ist der Code in der Datei 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" 
         ] 
      } 
   } 
}

Es folgt der Code in der Datei Test.cs.

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

Um die erforderlichen Abhängigkeiten von NuGet abzurufen, führen Sie den folgenden Befehl aus:

dotnet restore

Wir können den Test ausführen, wenn die erforderlichen Abhängigkeiten wiederhergestellt sind.

Sie können sehen, dass die Kompilierung erfolgreich war. Während Sie nach unten gehen, sehen Sie einige Informationen über den ausgeführten Test.

Derzeit haben wir 1 Test ausgeführt, 0 Fehler, 0 fehlgeschlagen, 0 übersprungen und die Zeit, die der Ausführungsprozess benötigt, wird ebenfalls als Information erwähnt.

In diesem Kapitel wird erläutert, wie Sie Tests in Visual Studio ausführen. Der .NET Core wurde unter Berücksichtigung der Testbarkeit entwickelt, sodass das Erstellen von Komponententests für Ihre Anwendungen einfacher als je zuvor ist. In diesem Kapitel führen wir unser Testprojekt in Visual Studio aus und führen es aus.

Öffnen wir die FirstApp-Lösung in Visual Studio.

Sie können sehen, dass es nur zwei Projekte gibt und Sie das Testprojekt nicht sehen können, da wir dieses Projekt nicht zu unserer Lösung hinzugefügt haben.

Fügen wir zuerst einen Ordner hinzu und rufen Sie ihn auf test.

Klicken Sie mit der rechten Maustaste auf test Mappe.

Wählen project.json Datei und klicken Open.

Der folgende Screenshot zeigt den Code in Tests.cs Datei als Ausgabe.

Es ist die Standardimplementierung und es wird nur getestet, ob True gleich true ist. Es ist das xUnit-Testframework, und Sie sehen das Attribut Fact, das die Testmethode mit Anmerkungen versehen und bezeichnet.

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

Es folgt die Implementierung von project.json Datei.

{ 
   "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" 
         ] 
      } 
   } 
}

Im project.jsonDatei, die wichtigste Abhängigkeit vom Test-Framework ist die xunit, die das Fact-Attribut einbringt. Es enthält das Testframework und APIs zum Testen mit xunit.

Wir haben auch die dotnet-test-xunitDies ist ein Adopter, damit xunit mit .NET Core arbeiten kann, insbesondere mit dotnet testBefehlszeilenprogramm. Dann sehen Sie dietestRunner welches xunit laufen lässt und du kannst auch das sehen netcoreapp1.0 Rahmen.

Unten sehen Sie die .NETCore.App-Abhängigkeit.

Um den Test in Visual Studio auszuführen, öffnen Sie den Test Explorer über das Test → Window → Test Explorer Menüoption.

Und Sie können sehen, dass Visual Studio den Test automatisch erkennt. Der Name des Tests besteht ausnamespace.className.TestMethodName. Lassen Sie uns jetzt auf klickenRun All button in Test Explorer.

Zuerst wird der Code erstellt und der Test ausgeführt, und Sie sehen die Gesamtzeit, die der Test benötigt. Lassen Sie uns die Testmethode so ändern, dass wir die Ausgabe sehen können, wenn der Test fehlschlägt.

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

Lassen Sie uns den Test erneut ausführen, indem Sie auf klicken Run All Button Link.

Sie können jetzt die sehen test Fehler.

In diesem Kapitel werden wir unsere StringLibrary testen. Dazu müssen wir unsere Projekte neu anordnen, damit wir der Standardkonvention folgen können.

Lassen Sie uns die öffnen global.json Datei.

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

Oben in dieser Datei sehen Sie die Projekteinstellungen und es wird ein Ordner wie z src und test standardmäßig.

Da wir laut Konvention Projekte in diesen Ordnern haben müssen, ist dies die neue Konvention, die als Teil von .NET Core verwendet wird.

Im Projektmappen-Explorer können Sie sehen, dass sich sowohl das Konsolenprojekt als auch das Bibliotheksprojekt im befinden src Ordner, während sich das Testprojekt im Inneren befindet test Mappe.

Die Projektstruktur im Projektmappen-Explorer stellt nicht dar, wo die Projekte physisch auf der Festplatte vorhanden sind. Lassen Sie uns jetzt den Lösungsordner öffnen und Sie werden das sehenStringLibrary Projekt ist nicht in der src Mappe.

Sie können das beides sehen src und test Ordner werden der Konvention zugeordnet, die in der global.jsonDatei. Wir haben jedoch ein Projekt StringLibrary, das nicht den Konventionen entspricht. Fügen wir nun die hinzuStringLibrary Projekt innerhalb der src Mappe.

Im src-Ordner befinden sich zwei Projekte, und wir müssen das Problem beheben, damit wir alle Projekte ordnungsgemäß verwenden können. Kehren wir zu Visual Studio zurück, klicken Sie mit der rechten Maustaste auf das StringLibrary-Projekt und wählen Sie die Option Entfernen. Es wird nicht gelöscht, sondern nur das Projekt entfernt.

Klicken Sie nun mit der rechten Maustaste auf den Ordner src und wählen Sie Add → Existing Project…

Navigieren Sie zum StringLibrary-Projekt, das sich jetzt im befindet src Ordner, wählen Sie die StringLibrary.csproj Datei und klicken Open.

Wir müssen jetzt den Verweis von entfernen StringLibrary von dem project.json Datei der Konsolen-App.

{ 
   "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" 
      } 
   } 
}

Speichern Sie die Änderungen und fügen Sie eine Referenz von hinzu StringLibrary wieder in Ihrem Konsolenprojekt.

{ 
   "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" 
      } 
   } 
}

Jetzt sollte alles wieder funktionieren und Sie können bauen StringLibrary und dann FirstApp(Konsolenprojekt) ohne Fehler. Testen wir nun die StringLibrary-Funktionalität mit xunit. Wir müssen unserem Testprojekt eine Referenz von StringLibrary hinzufügen. Klicken Sie mit der rechten Maustaste auf das Projekt "Referenzen von StringLibraryTests" und wählen Sie "Referenz hinzufügen".

Klicken OK das wird eine Referenz von hinzufügen StringLibraryzu unserem Testprojekt. Lassen Sie uns nun den folgenden Code in der ersetzenTests.cs Datei.

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()); 
      } 
   } 
}

Sie können sehen, dass wir drei Testmethoden haben, die die Funktionalität von StringLibrary testen. Klicken wir aufRun All Link und Sie sehen die folgende Ausgabe im Test Explorer.

Sie können die Tests auch über die Befehlszeile ausführen. Lassen Sie uns die Eingabeaufforderung öffnen und die ausführendotnet test Befehl.

In diesem Kapitel werden wir das Managed Extensibility Framework (MEF) diskutieren. MEF kann für die Erweiterbarkeit von Plugins von Drittanbietern verwendet werden oder die Vorteile einer lose gekoppelten Plugin-ähnlichen Architektur für reguläre Anwendungen nutzen.

• MEF ist eine Bibliothek zum Erstellen leichter, erweiterbarer Anwendungen.

• Anwendungsentwickler können Erweiterungen erkennen und verwenden, ohne dass eine Konfiguration erforderlich ist.

• MEF ist ein integraler Bestandteil von .NET Framework 4 und überall dort verfügbar, wo .NET Framework verwendet wird, um die Flexibilität, Wartbarkeit und Testbarkeit großer Anwendungen zu verbessern.

• Sie können MEF in Ihren Clientanwendungen verwenden, unabhängig davon, ob sie Windows Forms, WPF oder eine andere Technologie verwenden, oder in Serveranwendungen, die ASP.NET verwenden.

• MEF wurde portiert als Microsoft.Composition auch zu .NET Core, aber teilweise.

• Nur System.Composition ist portiert, und System.ComponentModel.Compositionist noch nicht verfügbar. Dies bedeutet, dass wir nicht über die Kataloge verfügen, mit denen Typen aus Assemblys in einem Verzeichnis geladen werden können.

In diesem Kapitel erfahren Sie nur, wie wir MEF in .NET Core-Anwendungen verwenden können.

Lassen Sie uns ein einfaches Beispiel verstehen, in dem wir MEF in der .NET Core-Konsolenanwendung verwenden. Lassen Sie uns jetzt ein neues .NET Core-Konsolenprojekt erstellen.

Wählen Sie im linken Bereich aus Templates → Visual C# → .NET Core und wählen Sie dann im mittleren Bereich Konsolenanwendung (.NET Core) aus.

Geben Sie den Namen des Projekts in das Feld Name ein und klicken Sie auf OK.

Sobald das Projekt erstellt ist, müssen wir eine Referenz von Microsoft.Composition hinzufügen, damit wir MEF verwenden können. Klicken Sie dazu im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt undManage NuGet Packages…

Suchen nach Microsoft.Composition und klicken Sie auf Install.

Drücke den OK Taste.

Drücke den I Accept Taste.

Nach Abschluss der Installation wird in den Referenzen ein Fehler angezeigt.

Lassen Sie uns die öffnen project.json Datei.

{ 
   "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" 
      } 
   } 
}

Sie können sehen, dass die Microsoft.Composition Abhängigkeit wird hinzugefügt, aber das Problem ist, dass dieses Paket nicht kompatibel ist dnxcore50. Also müssen wir importierenportablenet45+win8+wp8+wpa81. Lassen Sie uns jetzt Ihre ersetzenproject.json Datei mit dem folgenden Code.

{ 
   "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" 
      } 
   } 
}

Speichern Sie diese Datei und Sie werden sehen, dass der Fehler behoben ist.

Wenn Sie die Referenzen erweitern, wird eine Referenz von angezeigt Microsoft.Composition.

Zuerst müssen wir eine Schnittstelle erstellen, die exportiert werden soll, die Schnittstelle implementieren und die Klasse mit dem Exportattribut dekorieren. Fügen wir nun eine neue Klasse hinzu.

Geben Sie den Namen Ihrer Klasse in das Feld Name ein und klicken Sie auf Add.

Fügen wir den folgenden Code in die PrintData.cs Datei.

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); 
      } 
   } 
}

Wie oben erwähnt, sind Kataloge im Microsoft.Composition-Namespace nicht verfügbar. Daher werden alle Typen aus der Assembly mit dem Exportattribut geladen und an das Importattribut angehängt, wie in der Compose-Methode in der Datei Program.cs gezeigt.

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>(); 
         } 
      } 
   } 
}

Lassen Sie uns jetzt Ihre Anwendung ausführen und Sie werden sehen, dass sie ausgeführt wird, indem Sie die PrintData Klasse.

Um mehr über MEF zu erfahren, besuchen Sie die folgende URL https://msdn.microsoft.com/en-us/library/dd460648%28v=vs.110%29.aspx für mehr Details.

In diesem Kapitel werden die bevorstehenden Funktionen in .NET Core erläutert. Wir beginnen mit den .NET-Befehlszeilentools, indem wir die folgende URL im Browser öffnenhttps://github.com/dotnet/cli

Um mehr über den Fortschritt zu erfahren, können Sie die neueste Version von .NET Core SDK herunterladen, indem Sie nach unten scrollen. Der Abschnitt Installer und Binärdateien wird angezeigt.

Sie können die neueste Version der Vorschau-Tools für verschiedene Betriebssysteme anzeigen. Lassen Sie uns das Installationsprogramm gemäß Ihrem Betriebssystem auswählen.

Wir arbeiten an Vorschau 1 von .NET Core 2.0.

Lassen Sie uns nun unser aktuelles Werkzeug betrachten, indem Sie die Eingabeaufforderung öffnen und den folgenden Befehl ausführen.

dotnet --info

Sie sehen Informationen zur aktuell installierten Version der .NET-Befehlszeilentools auf Ihrem System (siehe unten).

Sie können sehen, dass wir derzeit Preview 2-Tools haben. Lassen Sie uns nun den folgenden Befehl ausführen, um mehr über das zu erfahrennew Befehl.

dotnet help new

Für die neue Befehlssprache des Projekts können Sie wie C # und F # und den Projekttyp usw. auswählen.

Lassen Sie uns nun die Änderungen in der neuesten Version von .NET Core sehen. Doppelklicken Sie nach dem Herunterladen des Installationsprogramms darauf, um es zu installieren. Klicken Sie auf Installieren.

Der folgende Screenshot zeigt den Installationsprozess.

Der Installationsvorgang wird gestartet. Wenn die Installation abgeschlossen ist, schließen Sie diesen Dialog.

Öffnen Sie die Eingabeaufforderung und führen Sie den folgenden Befehl aus.

dotnet --info

Sie sehen Informationen zur aktuell installierten Version von .NET Command Line Tools auf Ihrem System, wie unten gezeigt.

Sie können jetzt sehen, dass wir ein Vorschau1-Tool von .NET Core 2 haben. Lassen Sie uns nun den folgenden Code in der Eingabeaufforderung ausführen, um Informationen zum neuen Befehl in .NET Core 2 Vorschau1 zu erhalten.

dotnet help new

Mit dem Befehl können Sie auch Pakete in den Paketcache herunterladen.

Der Befehl öffnet die folgende Webseite, die Informationen zum neuen Befehl in .NET Core 2 Vorschau1 enthält.

Lassen Sie uns nach unten scrollen. Sie können jetzt sehen, dass wir die .NET Core-Anwendung mit mehr Vorlagen erstellen können.

Wir können jetzt erstellen mstest, web, mvc und webapi Projekte auch über die Kommandozeile.

Der .NET Core hat beschlossen, project.json zu löschen und zu MSBuild und * .csproj zurückzukehren. Dies ist bereits in den gerade veröffentlichten .Net Core 2.0 Preview1-Tools geschehen. Das ist ziemlich enttäuschend, denn das project.json war ein Hauch frischer Luft. Es ist jedoch verständlich und hat auch viele Vorteile.

Lassen Sie uns nun die Vorteile diskutieren, die die Änderung mit sich bringt -

• Dies würde den Übergang der vorhandenen Visual Studio-Lösungen zu .NET Core unkompliziert machen.

• Dies ist eine enorme Veränderung und wird es auch ermöglichen, bestehende Investitionen in CI / RM basierend auf MSBuild zu nutzen.

• Während des Builds in MSBuild können wir an inkrementelle Kompilierung, das Auflösen von Buildtime-Abhängigkeiten, Konfigurationsmanagement usw. denken.

• Es ist viel Arbeit erforderlich, um dotnet cli pünktlich zu versenden, da es nicht mehr nur um ASP.NET Core geht, sondern auch um Konsolen-Apps, UWP-Apps usw.

Es folgen die Änderungen in MSBuild und * .csproj -

• Die Datei Project.json (* .xproj) wird durch MSBuild (* .csproj) ersetzt.

• Die Funktionen in project.json werden wieder in die * .csproj integriert.

• Es ist noch nicht klar, was sie mit der Paketliste machen werden, aber es wurde erwähnt, dass sie es als json unter behalten könnten nuget.json oder verschmelzen Sie es in die *.csproj.

• Angeblich sollte dieser Übergang reibungslos und möglicherweise automatisch erfolgen, wenn Visual Studio verwendet wird.

Vorteile von MSBuild

• MSBuild ist Open Source und auf GitHub verfügbar. Es wird zwangsläufig vollständig plattformübergreifend.

• MSBuild wird die Struktur des MSBuild dramatisch vereinfachen und kürzen *.csproj.

• Microsoft führt außerdem ein neues Projektsystem ein, das viele Szenarien ohne Visual Studio ermöglicht. Die Details finden Sie in dieser URL https://github.com/dotnet/roslyn-project-system/.

• Das Ziel ist, dass die Arbeit mit Builds und Projekten auch mit dem MSBuild-Setup in Visual Studio IDE so nahtlos ist wie außerhalb.

MSBuild vs project.json

Lassen Sie uns nun ein neues Konsolenprojekt mit dem .NET Core Preview2-Tool erstellen, indem Sie den folgenden Befehl ausführen.

dotnet new -t console

Führen Sie die Datei aus, um alle in diesem Projekt erstellten Dateien anzuzeigen dir Befehl.

Sie können sehen, dass zwei Dateien erstellt werden, Program.cs und project.json Datei.

Lassen Sie uns nun eine Konsolen-App mit dem Tool .NET Core 2 Preview1 erstellen, indem Sie den folgenden Befehl ausführen.

dotnet new console

Führen Sie die Datei aus, um alle in diesem Projekt erstellten Dateien anzuzeigen dirBefehl. Sie können sehen, dass drei Dateien erstellt werden:Program.cs, NuGet.config und MSBuild.csproj anstelle der Datei project.json.

Vergleichen wir jetzt project.json und MSBuild.csproj Dateien nebeneinander.

Links haben wir die Datei im JSON-Format, während rechts die Datei im XML-Format ist. Sie können dies in der Datei project.json im Abschnitt Abhängigkeiten sehennetcoreapp1.0Während Sie sich in der Datei MSBuild.csproj befinden, sehen Sie die netcoreapp2.0.

In diesem Kapitel wird erläutert, wie Sie Ihre MSBuild-Datei (* .csproj) mithilfe des Befehlszeilenprogramms wiederherstellen und erstellen. Führen Sie den folgenden Befehl aus, um zu sehen, welche Befehle in .NET Core 2.0 Preview 1 verfügbar sind.

dotnet help

Sie sehen alle Befehle wie neu, wiederherstellen, erstellen usw.

Es folgt die Standardimplementierung in Program.cs Datei.

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

Lassen Sie uns nun den folgenden Befehl ausführen, um den Fortschritt zu sehen.

dotnet build

Sie werden viele Fehler sehen. Diese Fehler müssen behoben werden.

Lassen Sie uns nun den folgenden Befehl ausführen.

dotnet restore

Sie können sehen, dass alle Pakete wiederhergestellt sind. Einige neue Ordner und Dateien wurden ebenfalls generiert.

Führen Sie den folgenden Befehl aus, um die Verzeichnisstruktur anzuzeigen.

tree /f

Es folgt die Verzeichnisstruktur -

Lassen Sie uns nun das Projekt neu erstellen, indem Sie den folgenden Befehl erneut ausführen.

dotnet build

Jetzt wird Ihr Projekt ohne Fehler erfolgreich erstellt und MSBuild.dll wird ebenfalls erstellt.

Führen Sie den folgenden Befehl aus, um die Ausgabe anzuzeigen:

dotnet run

Sie können die folgende Ausgabe auf Ihrer Konsole sehen.

In diesem Kapitel werden wir die Konsolenanwendung migrieren, die das enthält project.json Dateierstellungssystem anstelle von MSBuild (*.csproj). Wir haben also ein altes Projekt, das die folgenden Dateien enthält.

Die Frage ist nun, warum wir Migration brauchen. Dieses Projekt wurde mit dem Tool .NET Core 1.0 Preview 2 erstellt. Jetzt haben wir das Tool .NET Core 2.0 Preview 1 installiert. Wenn Sie diese Anwendung jetzt mit dem Befehlszeilenprogramm .NET Core 2.0 erstellen, wird der folgende Fehler angezeigt.

Das liegt daran, dass die project.jsonDas Build-System ist in .NET Core 2.0 nicht mehr verfügbar, daher benötigen wir eine Migration, damit es ordnungsgemäß funktioniert. Führen Sie den folgenden Befehl aus, um die verfügbaren Befehle anzuzeigen.

dotnet help

Im Befehlsbereich sehen Sie die verschiedenen Befehle und auch die migrate Befehl, der ein project.json-basiertes Projekt in ein MSBuild-basiertes Projekt migriert.

Lassen Sie uns nun den folgenden Befehl ausführen.

dotnet migrate

Sie sehen eine Zusammenfassung des Migrationsprozesses und hier können Sie auch sehen, dass ein Projekt erfolgreich migriert wurde.

Lassen Sie uns nun die Verzeichnisstruktur mit dem folgenden Befehl sehen.

tree /f

Sie sehen nun die Datei * .csproj zusammen mit der Datei Program.cs im Projektstammverzeichnis und project.json wird in den Sicherungsordner verschoben.

Lassen Sie uns die öffnen console.csprojDatei. Jetzt können Sie dieses Projekt mithilfe des MSBuild-Systems wiederherstellen und erstellen, indem Sie den folgenden Befehl ausführen.

dotnet restore

Sie können jetzt sehen, dass alle Pakete wiederhergestellt sind.

Sie können Ihr Projekt jetzt mit dem folgenden Befehl erstellen.

dotnet build

Sie können jetzt sehen, dass das Projekt erfolgreich mit MSBuild erstellt wurde und console.dll auch in generiert wird ..\bin\Debug\netcoreapp1.0 Mappe.

Der folgende Screenshot zeigt die Verzeichnisstruktur und die Dateien.