Sourcecode: Screenshot

2: Ein neues dotNet Projekt auf dem Mac starten (Einrichtung)

Inhalt (Teil2)

Einleitung

Die Fortsetzung von Teil 1. Ich zeige das Anlegen und Verlinken einer Solution und den zugehörigen Projekten.

Den Großteil der Arbeit erledigen ich zu "Fuß" an der Kommandozeile und am Ende starte ich noch Visual Studio Code mit dem Projekt und empfehle ein paar Erweiterungen.

Ich bin hier wirklich sehr ausführlich, erkläre so viel wie möglich und gehe schon auf die ein oder andere Abhängigkeit und Bedeutung ein.

Wenn Fragen entstehen, bin ich übrigens auf Mastodon (Verweis im Hauptmenü) erreichbar. Zu Mastodon habe ich auch einen kleinen Artikel verfasst.

Die ganzen Kommandos sind übrigens genauso unter Windows und Linux ausführbar. Mit kleinen Anpassungen auf der Windowsseite läuft das dann sogar dort ohne Probleme.

Das Projekt

Ich brauche zum Zeigen natürlich ein schönes Beispiel. Die Demonstration soll

  • ein Webprojekt
  • eine Bibliothek für die Daten
  • ein Kommandozeilenwerkzeug dazu
  • und - um die Sache spannender zu machen - ein paar schöne Unittests

enthalten. Wie in VisualStudio (der große Bruder) üblich fasse ich mehrere Einzelprojekte in einer Solution zusammen. Damit kann die Software dann mit VisualStudio (Community, Professional, Enterprise oder for Mac) und VisualStudio Code geöffnet werden.

Natürlich kann auch jeder andere Texteditor seines Vertrauens zum Bearbeiten der Dateien benutzt werden.

Die Befehle, die in diesem Beitrag verwendet werden habe ich hier gleich zum Download (DemoProjekt.sh) zusammengefasst.

Das Kommandozeilenwerkzeug "dotnet"

Am Mac nutze ich iTerm2 als Terminalanwendung (brew install iterm2)

Das dotNet core SDK enthält ein Konsolenkommando (dotnet), mit dem so gut wie alle Verwaltungsoperationen, die das Projekt betreffen, durchgeführt werden können.

Neu in der Version 2.1 des SDK sind auch globale Kommandozeilenwerkzeuge, wie es auch bei npm gibt.

Es werden für die unterschiedlichsten Typen Projektvorlagen (Konsolenanwendung, Klassenbibliothek, Unittestprojekt, ASP.NET Core leer, uvm.) mitgeliefert.

Ein einfaches dotnet new <templateName> legt im aktuellen Verzeichnis ein neues Projekt an.

Die offizielle Dokumentation ist übrigens auch sehr gut und hilft oft weiter.

Verzeichnisse und Projekte erzeugen

In der Einleitung habe ich ja schon geschrieben, dass ich eine Solution anlege und darin die einzelnen Projekte zusammenfasse.

Projektverzeichnisse anlegen

Im ersten Schritt lege ich die Verzeichnisse an. Benötigt wird ein Terminal (oder der Finder) und ich erstelle alle Verzeichnisse auf einmal.

mkdir DemoProjekt
cd DemoProjekt

mkdir DemoProjekt.Lib
mkdir DemoProjekt.Cli
mkdir DemoProjekt.Web
mkdir DemoProjekt.Tests

Solution erzeugen

Die Solution wird der Rahmen unserer Software. Dort werden wir alle Komponenten registrieren. Zudem werden in dieser Datei die verschiedenen Konfigurationen (Debug, Release, ...) und Zielsysteme (x86, x64, Any CPU) definiert.

Für dotNet core sind die Zielsysteme (in der Regel) uninteressant, die Konfigurationen sind aber recht nützlich. Evtl. schreibe ich noch einen Beitrag drüber.

Der Befehl zur Anlage einer neuen Solution lautet:

dotnet new sln

Nach der Ausführung wurde eine einzige neue Datei DemoProjekt.sln im Verzeichnis erzeugt. Die Befehlsausgabe war auch recht knapp:

Wird vorbereitet...
Die Vorlage "Solution File" wurde erfolgreich installiert.
dotnet sln

Der Standardname der Solution entspricht dem Verzeichnis. Wer möchte, kann bei dotnet new sln -n <SOLUTIONNAME> noch einen alternativen Namen übergeben und damit alles nach seinen Wünschen anpassen.

Die neu angelegte Solution kann dann mit dotnet sln verwaltet werden.

Hilfe gibt es zu jedem Kommando mit dem Hilfeparameter -h oder --help

Beispiel (dotnet sln --help):

Nutzung: dotnet sln [Optionen] <<SLN_FILE>> [Befehl]

Argumente:
<<SLN_FILE>> Die zu verwendende Projektmappendatei. Wenn keine
Projektmappendatei angegeben ist, sucht der Befehl im aktuellen
Verzeichnis nach einer Datei.


Optionen:
-h, --help Hiermit wird die Hilfe zur Befehlszeile angezeigt.

Befehle:
add <PROJECT_PATH> Fügt einer Projektmappendatei ein oder mehrere
Projekte hinzu.
list Listet alle Projekte in einer Projektmappendatei auf.
remove <PROJECT_PATH> Entfernt ein oder mehrere Projekte von einer
Projektmappendatei.

Datenmodellprojekt anlegen und zur Solution hinzufügen

In unserem Projekt trenne ich die Funktionalität von den verschiedenen Benutzeroberflächen und lagere diese in eine eigene Bibliothek aus.

Ein neues Klassenbibliotheksprojekt wird im Zielverzeichnis mit

cd DemoProjekt.Lib
dotnet new classlib
rm Class1.cs

erstellt. Die Vorlage legt immer eine leere und unnütze Klasse mit an, die ich gleich wieder lösche.

Hier landen dann später alle Objekte, die von den anderen Projekten verwendet werden (Repositories, Datenmodelle, usw.).

In dieser Befehlsausgabe passiert schon ein bisschen mehr. Es wird die Projektdatei (DemoProjekt.Lib.csproj) erzeugt, die benötigten Referenzen zum dotnet core SDK angelegt und dafür gesorgt, dass die entsprechenden Bibliotheken auch wirklich auf dem Rechner vorhanden sind (Wiederherstellung). Sollten diese fehlen, dann werden diese von den Microsoft Paketservern (nuget.org) nachgeladen.

Die Vorlage "Class library" wurde erfolgreich installiert.

Aktionen nach der Erstellung werden verarbeitet...
Ausführen von 'dotnet restore' für /DemoProjekt/DemoProjekt.Lib/DemoProjekt.Lib.csproj...
Pakete für "/DemoProjekt/DemoProjekt.Lib/DemoProjekt.Lib.csproj" werden wiederhergestellt...
Die MSBuild-Datei "/DemoProjekt/DemoProjekt.Lib/obj/DemoProjekt.Lib.csproj.nuget.g.props" wird generiert.
Die MSBuild-Datei "/DemoProjekt/DemoProjekt.Lib/obj/DemoProjekt.Lib.csproj.nuget.g.targets" wird generiert.
Wiederherstellung in "290,1 ms" für "/DemoProjekt/DemoProjekt.Lib/DemoProjekt.Lib.csproj" abgeschlossen.

Wiederherstellung erfolgreich.
DemoProjekt.Lib.csproj

Die neue Projektdatei ist, im Vergleich zu früher(tm) sehr übersichtlicht und sogar lesbar. Im Laufe von größeren Projekten bearbeitet man diese auch und fügt Einträge hinzu.

Hier die komplette Datei:

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework>
</PropertyGroup>
</Project>

Hier steht nur noch drin: Das ist ein Projekt vom Microsoft.NET.Sdk und das Zielframework ist netstandard2.0.

Der Standard steht für portable Bibliotheken und definiert die Auswahl von APIs, die vorhanden sein müssen, damit die Bibliothek in anderen Projekten verwendet werden kann. Damit ist es dann egal, ob die Bibliothek im richtigen, vollen .NET-Framework oder mit dotnet core ausgeführt wird.

Registrieren des Projektes

Jetzt registriere ich noch das Projekt in der Solution.

cd ..
dotnet sln add DemoProjekt.Lib/DemoProjekt.Lib.csproj

Die Befehlsausgabe ist dann noch ein kurzes und erfreuliches:

Das Projekt "DemoProjekt.Lib/DemoProjekt.Lib.csproj" wurde der Projektmappe hinzugefügt.

Kommandozeilenprojekt

Die erste Benutzeroberfläche wird der Kommandozeilenclient. Dieser verwendet die Bibliothek, die wir einen Schritt vorher angelegt haben.

Hier der komplette Code dieses Abschnitts:

#
# 4. Kommandozeilenprojekt anlegen, die Bibliothek verknüpfen
# und in Solution einfügen
#
cd DemoProjekt.Cli

dotnet new console
dotnet add reference ../DemoProjekt.Lib/DemoProjekt.Lib.csproj

cd ..
dotnet sln add DemoProjekt.Cli/DemoProjekt.Cli.csproj

Neu bei dieser Befehlszeilenfolge ist der dotnet add reference-Befehl, der den Bezug zwischen den Projekten herstellt.

In der Datei DemoProject.Cli.csproj wird die Referenz mit

<ItemGroup>
<ProjectReferenceInclude="..\DemoProjekt.Lib\DemoProjekt.Lib.csproj"/>
</ItemGroup>

abgespeichert.

Webprojekt anlegen

Das Webprojekt wird genauso, wie das Kommandozeilen erzeugt. In diesem Beispiel wähle ich die leere web Vorlage.

#
# 5. Webprojekt anlegen, die Bibliothek verknüpfen
# und in Solution einfügen
#

cd DemoProjekt.Web
dotnet new web
dotnet add reference ../DemoProjekt.Lib/DemoProjekt.Lib.csproj

cd ..
dotnet sln add DemoProjekt.Web/DemoProjekt.Web.csproj

Testprojekt anlegen

Im den Unittests möchte ich sowohl die Bibliothek, als auch die Webanwendung testen. Daher füge ich Referenzen zu beiden Projekten mit ein.

#
# 6. Testprojekt anlegen, das Webprojekt und die Bibliothek
# verknüpfen und in Solution einfügen
#

cd DemoProjekt.Tests
dotnet new xunit
dotnet add reference ../DemoProjekt.Lib/DemoProjekt.Lib.csproj
dotnet add reference ../DemoProjekt.Web/DemoProjekt.Web.csproj

rm UnitTest1.cs
cd ..
dotnet sln add DemoProjekt.Tests/DemoProjekt.Tests.csproj

Damit sind dann alle Bausteine an ihrem Platz.

VisualStudio Code

Wenn man den Ordner jetzt in VisualStudio Code öffnet. Kann man mit dem Bearbeiten der Quellcodedateien anfangen.

Datei ... Öffnen ... <Order auswählen>

  Frisches Projekt in VisualStudio Code geöffnet

Erweiterungen

Der Editor lässt sich durch Erweiterungen sehr gut anpassen. Ich kann folgende Erweiterungen für den Alltagsgebrauch empfehlen:

  • .NET Core Test Explorer: formulahendry.dotnet-test-explorer.
    Unterstützung von Unittests.
  • Bracket Pair Colorizer: coenraads.bracket-pair-colorizer.
    Färbt Klammern ein.
  • EditorConfig for VS Code: editorconfig.editorconfig.
    Unterstützung von Textformatierungsvorgaben.
  • gitignore: codezombiech.gitignore.
    Erstellen von gitignore-Dateien anhand von Vorlagen.
  • GitLens — Git supercharged: eamodio.gitlens.
    Erweitertes Git.
  • Polacode: pnp.polacode.
    Schöne Quellcodescreenshots.
  • REST Client: humao.rest-client.
    Erstellen, Testen und Entwickeln von HTTP-Restanfragen.
  • TODO Highlight: wayou.vscode-todo-highlight.
    Hervorheben von TODO, FIXME, ... Kommentaren.
  • vscode-icons: robertohuertasm.vscode-icons.
    Schönere Dateiicons.
  • XML Tools: dotjoshjohnson.xml.
    XML Formatierung, XML Treeview, und vieles mehr.

Inhalt

  1. Vorbereitung
  2. Einrichtung (hier)

Aktualisiert am: 2018-09-14