Abou Chleih

{the magic lies between the brackets}

Menü Schließen

Schlagwort: C

ASP.NET Core App via Apache bereitstellen #1 – Compiling & Vorbereitung

Mit .NET Core ist es seit einiger Zeit problemlos möglich cross-plattform Applikationen zu erstellen.
Darunter fallen auch ASP.NET Core Web-Anwendungen.
Um diese Anwendungen allerdings allgemein bereitzustellen, müssen wir diese zuerst für den allgemeinen Zugriff aus dem Internet freigeben.
Dies geschieht auf Grund der Plattformunabhängigkeit natürlich ohne Microsoft IIS. In diesem Beispiel wird ein Apache2 Webserver in der Standardkonfiguration genutzt.
Voraussetzung sind daher ein installierter Server mit funktionaler Apache2 Installation und natürlich eine ASP.NET Core Anwendung.

Was werden wir hier nun genau machen?

  • Compilen der ASP.NET Core Anwendung
  • Konfigurieren einer eigenen Apache Instanz, die als Reverse Proxy fungiert
  • Bereitstellen der Applikation

Um die ASP.NET Anwendung bereitzustellen, müssen wir diese zuerst compilen, dies mache ich bevorzugt auf meiner Entwicklungsmaschine (hier: Windows).
Wir gehen als in das Projektverzeichnis ({Solutionpath}\src\{Projectpath}) und öffnen dort eine Kommandozeile oder PowerShell.

Mit dem Befehl dotnet publish -c Release (-c = –configuration) starten wir nun den Build Prozess (im Release Modus).
Sollten nun Fehler kommen, dass „bower“ nicht gefunden werden kann, so kann dies an zwei Dingen liegen.

  • Bower nicht installiert
  • Path-Variable nicht korrekt

Um Bower zu installieren, geben wir in der PowerShell einfach npm install bower ein, das entsprechende Node.js Projekt wird dann geladen und installiert.
Anschließend installieren wir noch Gulp via npm install gulp, eine weitere Abhängigkeit.

Sollte der Fehler immer noch erscheinen, so müssen wir die Path-Variable auf das Web Verzeichnis unserer Visual Studio Installation verweisen lassen:
PowerShell: $env:path = $env:path + ";C:\Program Files (x86)\Microsoft Visual Studio 14.0\Web\External"
Die VS Version entsprechend anpassen (hier: VS 2015).

Nun sollte das Projekt compilen und die lauffähige Version unter {Solutionpath}\src\{Projectpath}\bin\Release zu finden sein.

Diesen Ordner jetzt auf den Linux Server laden.

Um die Applikation jetzt ausführen zu können, benötigen wir die .NET Core Runtime auf dem Server (hier: Debian).
Um diese zu installieren, laden wir uns das Archiv (tar.gz) herunter und entpacken es:
Die Befehle dazu finden sich auf der entsprechenden Microsoft-Website:

Für v1.0.3:
sudo apt-get install curl libunwind8 gettext
curl -sSL -o dotnet.tar.gz https://go.microsoft.com/fwlink/?linkid=847105
sudo mkdir -p /opt/dotnet && sudo tar zxf dotnet.tar.gz -C /opt/dotnet
sudo ln -s /opt/dotnet/dotnet /usr/local/bin

Für v2.0.0:
deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main" > /etc/apt/sources.list.d/dotnetdev.list
apt-get update
apt-get install dotnet-sdk-2.0.0

Anschließend sollte man das Projekt starten können, zum Testen reicht hier: dotnet {Projektname}.dll im Pfad {App}\publish\.

Programmiertechnisch Windows Forms-Anwendungen erstellen

In C# gibt es verschiedene Techniken, GUIs zu erzeugen:

  • winforms
  • wpf

In Windows Forms (kurz meist winforms) ist das relativ einfach, da man hier komplett in C# arbeiten muss und nicht im „Backend-Code“ (C#) und im „Frontend-Code“ (XAML), wie in WPF.

Zu Beginn müssen wir zuerst einen Frame (hier: Form), der alle Controls (Textboxen, Labels, etc.) hält, erstellen und soweit vorbereiten.
Dazu legen wir eine Klasse MyForm an, welche von Form erbt:

 public partial class MyForm:Form 

Nun müssen wir noch die Attribute, wie bspw. Größe und Art des Rahmens anpassen. Dazu greifen wir auf die Properties der Klasse zu und setzen diese:

this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; //Setzt den Rahmen auf einen nicht vergrößerbaren, schmalen Rahmen ohne Min./Max-Boxen
this.ClientSize = new Size(Breite, Höhe);
this.Name = "Meine Form"; //Setzt den Namen der Form
this.ResumeLayout(false); //Unterdrückt Änderungen an der GUI
this.PerformLayout(); //Lässt Änderungen an der GUI zu und lädt diese 

Nun erstellen wir ein Objekt dieser Form:

 MyForm myFrmObj = new MyForm(); 

Um jetzt Controls (hier werden wir eine Textbox hinzufügen) zur Form hinzuzufügen, müssen wir ein Objekt dieses Controls erstellen:

 TextBox txtContent = new TextBox(); 

Anschließend greifen wir wieder auf die Attribute zu und ändern diese zu unseren Wünschen ab.

 txtContent.Size = new Size(Width, Height);
txtContent.Location = new Point(X,Y); 

Achtung die Position (Location) ist relativ, d.h. X = 0, Y = 0 sind im linken oberen Eck der Form, nicht des Bildschirms.

Nun fügen wir das Control zu unserer Form hinzu:

myFrmObj.Controls.Add(txtContent);

Natürlich kann man auch andere Attribute setzen, hier verweise ich auf das MSDN von Microsoft, in dem die Attribute von Klassen erklärt sind.
Aber auch IntelliSense hilft hier weiter.

Was jetzt noch wichtig ist, ist die Option

txtContent.AutoSize = true;

. Diese lässt Controls automatisch abhängig vom Content wachsen.

Um nun noch Events hinzuzufügen, erstellen wir die entsprechende Methode private void myMethod(object sender, EventArgs e) und fügen den Handler diesem Event zu:

this.txtContent.Click += new System.EventHandler(this.myMethod);

Zu guter letzt muss man die Controls beim Aufruf der Form initialisieren lassen, sodass man Zugriff während der Laufzeit bekommt.
Hierzu fügt man im Konstruktor der Form den Befehl InitializeComponent(); ein:

public MyForm()
{
     InitializeComponent();
}

Mehr Informationen zum Handlern und Events findet man im MSDN.

Generelle Infos findet man auf der Supportseite von Microsoft.

© 2018 Abou Chleih. Alle Rechte vorbehalten.

Thema von Anders Norén.