ASP.NET für PHP-Entwickler

German (Deutsch) translation by Nikol Angelowa (you can also view the original English article)

Dieses Tutorial für PHP-Entwickler bietet Ihnen eine Einführung in ASP.NET in der Sprache C#. Wenn Sie sich gefragt haben, worum es bei ASP.NET geht, wird in diesem Lernprogramm versucht, zumindest einige Ihrer Fragen zu beantworten. Selbst wenn Sie ein begeisterter Open-Source-Fan sind, enthält ASP.NET einige Techniken und Funktionen, die Sie kennen sollten. Und wie manche vielleicht sagen, ist es gut, einen Feind zu kennen!

Bevor wir anfangen

ASP.NET ist keine reine Microsoft-Technologie mehr. Dank der harten Arbeit der Mono-Projektmitarbeiter kann ASP.NET auf Linux- und Mac-Plattformen sowie unter Windows verwendet werden.

Sie haben sogar eine IDE erstellt, in der Sie Ihre Web- und Desktopanwendungen schreiben können. Laden Sie eine Kopie von MonoDevelop herunter und installieren Sie sie. Wir werden diese IDE für dieses Tutorial verwenden, da sie einige nützliche Funktionen bietet, um die Entwicklungszeit zu verkürzen. Genau wie PHP können ASP.NET-Anwendungen jedoch in nichts Komplexerem als einem Texteditor geschrieben werden.

ASP.NET und C# auf einen Blick

ASP.NET ist das Webentwicklungstechnologie-Framework von Microsoft und wurde ursprünglich als Ersatz für eine alte Active Server Pages-Technologie entwickelt. Wenn Sie klassisches ASP verwendet haben (normalerweise mit VBScript), sind Teile von ASP.NET sehr vertraut. ASP.NET kann mit einer Vielzahl von Programmiersprachen verwendet werden, darunter VB.NET (die neue Version von Visual Basic), J# und C#. In diesem Tutorial wird C# verwendet.

ASP.NET ist in zwei Varianten erhältlich:

ASP.NET WebForms: Das ursprüngliche Framework, mit dem Entwickler Webanwendungen mit vielen der in .NET Windows-Desktopanwendungen verwendeten Techniken erstellen können
ASP.NET MVC: Ein neueres Framework, das eine Model-View-Controller-Architektur und mehr Kontrolle über clientseitigen Code bietet

Da sich dieses Tutorial an PHP-Entwickler richtet, die es oft vorziehen, "näher an das Metall heranzukommen", werde ich keines von beiden verwenden. Stattdessen werde ich meine eigene Anwendung basierend auf den Funktionen der .NET-Laufzeit- und C# -Sprachen mit ASP.NET als Wrapper und nicht als beabsichtigtes Framework rollen. Machen Sie sich keine Sorgen, wenn das keinen Sinn ergibt. Fahren Sie einfach mit dem Tutorial fort und Sie werden sehen, was ich meine.

Ich verwende MonoDevelop auch unter Xubuntu Linux, aber es sollte auf anderen Plattformen genauso funktionieren.

Wichtig: ASP.NET basiert stark auf objektorientierter Programmierung (OOP). Wenn Sie keine Erfahrung mit OOP haben, empfehle ich Ihnen dringend, diese Einführung in OOP in PHP zu lesen. Sie müssen Wörter wie "class", "instance", "method", "property" und "inherit" verstehen.

Fünf Dinge, auf die Sie achten sollten

C# kann PHP-Entwickler verwirren, insbesondere wenn Sie regelmäßig zwischen den beiden Sprachen wechseln. Hier sind meine fünf besten Fallstricke.

String-Verkettung

In C# erfolgt die Verkettung von Zeichenfolgen eher mit "+" als mit ".".

1	// PHP
2	"This is part 1 " . "and this is part 2!";
3	// C#
4	"This is part 1 " + "and this is part 2!";

Referenzieren von Klassenmethoden und -eigenschaften

So rufen Sie eine Methode oder Eigenschaft in PHP auf:

1	$myclass = new MyClass();
2	$var = $myclass->var;
3	$myclass->doMethod();

In C# verwenden Sie ein "." anstelle von "->" wie hier:

1	MyClass myclass = new MyClass();
2	string var = myclass.var;
3	myclass.doMethod();

Starkes Tippen

C# ist eine stark typisierte Sprache, sodass Sie beispielsweise Zeichenfolgen nicht wie in PHP als Ganzzahlen behandeln können. In PHP ist dies wahr:

"1" == 1

In C# würde dies einen Fehler verursachen. Sie müssen eines der Elemente konvertieren:

1	Convert.ToInt32("1") == 1

Oder:

1	"1" == 1.ToString()

Sie werden feststellen, dass Sie diese .ToString() -Methode häufig verwenden...

Methoden geben Typen zurück

Bei PHP spielt der Typ des Rückgabewerts einer Funktion oder Methode keine Rolle. In C# müssen Methoden den Werttyp deklarieren, den sie zurückgeben:

protected string MyStringMethod()
{
	return "I am a string";
}
protected int MyIntMethod()
{
	// return an int
	return 100;
}

Methoden, die nichts zurückgeben, müssen das Schlüsselwort void haben:

1	protected void MyMethod() { }

Umfang

Achten Sie auf den Umfang der Methoden und Eigenschaften. Die drei wichtigen Schlüsselwörter sind "public", "protected" und "private". Diese funktionieren genauso wie in PHP.

// this is public, can be called from anywhere
public int MyInt;
// this is protected, can only be called by the declaring class and any descendents
protected int MyInt;
// this is private, can only be called by the declaring class
private int MyInt;

Erstellen Ihrer ersten ASP.NET-Seite

Öffnen Sie MonoDevelop.

Wählen Sie im Hauptbildschirm "Neue Lösung/Solution starten". "solution" ist eine Sammlung eines oder mehrerer verwandter Projekte. Dies können Projekte verschiedener Typen sein, z.B. eine Webanwendung und eine Desktopanwendung, die damit arbeitet, und möglicherweise auch ein Webdienst.

Wählen Sie C# ASP.NET-Webanwendung aus, geben Sie einen Namen für Ihre Anwendung ein (ich verwende "WebApplication1") und wählen Sie einen Speicherort für Ihre Lösung aus. Klicken Sie dann auf "Weiterleiten". Wenn Sie die Optionen auf der nächsten Seite ignorieren, klicken Sie auf "OK". An dem von Ihnen angegebenen Speicherort wird eine neue ASP.NET-Anwendung erstellt.

Die IDE öffnet die Standardseite mit dem Namen "Default.aspx" und Sie sehen den folgenden Code:

<%@ Page Language="C#" Inherits="WebApplication1.Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head runat="server">
	<title>Default</title>
</head>
<body>
	<form id="form1" runat="server">
		<asp:Button id="button1" runat="server" Text="Click me!" OnClick="button1Clicked" />
	</form>
</body>
</html>

Sie werden sehen, dass es sich hauptsächlich um Standard-HTML handelt, mit ein paar zusätzlichen Bits. Es gibt bereits ein <form> -Element mit einem seltsamen <asp:Button> -Element. Versuchen wir, die Anwendung auszuführen.

Ausführen Ihrer Anwendung im Debug-Modus

MonoDevelop kann Ihre ASP.NET-Anwendung mit einer Schaltfläche ausführen. Anstatt einen lokalen Entwicklungsserver einzurichten und Ihre App zu konfigurieren, drücken Sie einfach F5. Ein Entwicklungsserver wird an einem nicht standardmäßigen Port gestartet und Ihre Anwendung wird in einem Browser geöffnet. Beachten Sie Port 8080 in den folgenden URLs.

Hinweis: In Xubuntu musste ich den Mono-Webserver mit dem Namen XSP2 manuell mit folgendem Befehl installieren: sudo apt-get install mono-xsp2.

Drücken Sie also F5, um die Anwendung auszuführen. Hoffentlich wird ein Browserfenster geöffnet, das so aussieht.

Das Klicken auf die Schaltfläche, wie hier.

Was Sie gerade getan haben, ist ein ASP.NET-Button angeklickt, der Ereignisse automatisch mit serverseitigem Code verbindet. Mit anderen Worten, wenn auf die Schaltfläche geklickt wird, weiß die Seite davon - dies ist einer der Hauptvorteile des WebForms-Frameworks. Es funktioniert ähnlich wie die Entwicklung von Desktopanwendungen. Wir werden diese Funktion jedoch nicht verwenden, da sie zu einer Welt voller Schmerzen führt (die in Teil 2 dieses Tutorials erläutert wird). Stattdessen werden wir die Dinge etwas mehr manuell erledigen. Es ist der PHP-Weg.

Daher werden wir diesen Code geringfügig ändern, da wir das WebForms-Framework nicht verwenden möchten. Bearbeiten Sie die geöffnete "Default.aspx", indem Sie das <form> -Element entfernen und ein <h1> -Element hinzufügen, sodass der Code lautet:

<%@ Page Language="C#" Inherits="WebApplication1.Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head runat="server">
	<title>Default</title>
</head>
<body>
	<h1>This is the text</h1>
</body>
</html>

Durchsuchen Ihrer Lösung

Auf der linken Seite der IDE befinden sich drei Ansichten der Anwendung. Die erste Ansicht ist Klassen und zeigt das Klassendiagramm der Anwendung.

Die zweite Ansicht ist Lösung und zeigt die Projekte und Dateien, aus denen die gesamte Lösung besteht (Sie können mehrere Projekte in einer Lösung haben).

Außerdem gibt es eine Dateiansicht, in der alle Verzeichnisse und Dateien der Lösung angezeigt werden, einschließlich der Datei "WebApplication1.csproj", die die C# -Projektdatei für unsere Anwendung ist.

Wählen Sie die Lösungsansicht. Sie haben bereits "Default.aspx" geöffnet. Dies ist die Seite, die Sie gerade bearbeitet haben. Doppelklicken Sie auf die Datei "Default.aspx.cs", um sie in der IDE zu öffnen. Hier ist die erste wichtige Lektion.

Code-Behind-Dateien

Die Datei "Default.aspx.cs" ist eine CodeBehind-Datei. Anstatt Ihre .html- (oder in diesem Fall .aspx- und für PHP-Anwendungen .php-) Dateien mit serverseitigem Code zu versehen, ist es in ASP.NET möglich, Ihren gesamten serverseitigen Code in einer CodeBehind-Datei abzulegen. Auf die gleiche Weise müssen Sie nicht Ihr gesamtes CSS und JavaScript in jede HTML-Seite einfügen, sondern können sie in separate Dateien einfügen, die enthalten sind. Dies können Sie mit ASP.NET-Code tun.

Das Schöne ist, dass diese CodeBehind-Dateien automatisch in Ihre ASPX-Seite aufgenommen werden. (Aus diesem Grund heißt der Code-Behind "Default.aspx.cs" und ist daher der Datei "Default.aspx" zugeordnet.) Der Code von "Default.aspx.cs" ist ziemlich kurz. Hier ist eine Erklärung, Zeile für Zeile:

// reference the System namespace
using System;
// reference the System.Web namespace
using System.Web;
// reference the System.Web.UI namespace
using System.Web.UI;
// put this class in the WebApplication1 namespace
namespace WebApplication1
{
	// declare a new partial class called "Default" which inherits (":") from System.Web.UI.Page
	public partial class Default : System.Web.UI.Page
	{
		// NOTE: we're going to delete this method
		// declare a public void method which is called when button1 is clicked
		public virtual void button1Clicked (object sender, EventArgs args)
		{
			// set the text 
			button1.Text = "You clicked me";
		}
	}
}

Ein Hinweis zu Namesraum

Wikipedia definiert einen Namesraum als:

Ein Namesraum ist ein abstrakter Container, der den Kontext für die darin enthaltenen Elemente (Namen oder Fachbegriffe oder Wörter) bereitstellt und die Disambiguierung von gleichnamigen Homonymelementen ermöglicht (die sich in verschiedenen Namesräume befinden).

Welches ist ziemlich kompliziert. Ich meine, Homonym? Ich sehe Namesraum als virtuelle Verzeichnisse für Klassen. Genau wie in einem Dateisystem können Sie nicht zwei Dateien mit dem Namen "test.txt" im selben Ordner haben, Sie können nicht zwei Klassen mit demselben Namen in einem einzigen Namesraum haben. Namesraum können wie Verzeichnisse verschachtelt werden (daher die Verweise auf System, System.Web, System.Web.UI im obigen Code) und müssen aus Ihren ASP.NET-CodeBehind-Dateien referenziert werden, damit Sie die in enthaltenen Klassen verwenden können Sie.

Sie haben auch bemerkt, dass sich unsere Anwendung im Namesraum WebApplication1 befindet. Dies bedeutet, dass sich jeder von uns geschriebene Code in diesem Namesraum befindet. Wir werden das später zu unserem Vorteil nutzen.

Ein Hinweis zu Seiten

In ASP.NET ist eine Webseite tatsächlich eine Klasse. Es gehört in einen Namesraum in einem Projekt und erbt von der System.Web.UI.Page-Klasse. In der CodeBehind-Datei wird dies ausgedrückt als:

1	public partial class Default : System.Web.UI.Page { ... }

(Das Schlüsselwort "Partial" bedeutet, dass sich ein Teil dieser Klasse auch in einer anderen Datei befindet, nämlich in der Datei "Default.aspx.designer.cs". Da diese Datei automatisch erstellt und verwaltet wird, müssen wir uns darüber keine Gedanken machen. )

Ihre "Default.aspx" erbt von der gerade erstellten Seite mit folgendem Code:

1	<%@ Page Language="C#" Inherits="WebApplication1.Default" %>

In der Deklaration "Seite" legen wir die Sprache für die Seite und die Klasse fest, von der sie erbt, in diesem Fall WebApplication1.Default. Das heißt, wenn wir eine andere Seite erstellen, zum Beispiel "Contact.aspx", lautet die Deklaration "Seite" und die CodeBehind-Datei wie gezeigt ist:

1	// code-behind file
2	public partial class Contact : System.Web.UI.Page { ... }

1	// .aspx page
2	<%@ Page Language="C#" Inherits="WebApplication1.Contact" %>

Es kann schwierig sein, sich zunächst ein Bild zu machen, aber wenn Sie ein paar Seiten erstellt haben, ist dies eine Selbstverständlichkeit.

Benutzerdefinierte Funktionen erstellen

Wir sind jetzt bereit, selbst etwas zu schreiben. Entfernen Sie die Methode "button1Clicked" und fügen Sie stattdessen den folgenden Code hinzu:

1	protected void Page_Load(object sender, EventArgs e)
2	{
3
4	}

Die Methode "Page_Load" ist eines von mehreren Lebenszyklusereignissen, die automatisch aufgerufen werden, wenn das Load-Ereignis der Seite ausgelöst wird. Es gibt einige Ereignisse im Lebenszyklus einer ASP.NET-Seite. Die vollständige Liste finden Sie hier. Im Allgemeinen geben Sie bei der Methode "Page_Load" alles ein, was beim Laden dieser Seite passieren soll (Sicherheitsüberprüfungen, Abrufen von Daten aus einer Datenbank zur Anzeige, Laden einer Anzeige usw.). Wir werden eine neue Methode für die Seite mit dem Namen "SetText" deklarieren, die von der Methode "Page_Load" aufgerufen wird.

protected void Page_Load(object sender, EventArgs e)
{
	SetText();
}

protected void SetText()
{
	headertext.InnerHtml = "This is the changed text";
}

Sie können davon ausgehen, dass die Eigenschaft "InnerHtml" für das Element "headertext" auf "Dies ist der geänderte Text" gesetzt wird. Aber was ist "Headertext"? Gehen Sie zurück zu "Default.aspx" und ändern Sie das <h1> -Element:

1	<h1 id="headertext" runat="server">This is the header</h1>

Drücken Sie dann F5, um die Anwendung auszuführen. Wenn alles in Ordnung ist, sollten Sie Folgendes sehen:

Überprüfen Sie die Quelle der Seite. Sie werden sehen, dass das Attribut runat="server" verschwunden ist. Was ist gerade passiert? Wir haben ein HTML-Steuerelement in ein serverseitiges Steuerelement umgewandelt.

Serverseitige Steuerelemente

Meine Lieblingsfunktion von ASP.NET ist bei weitem die Möglichkeit, fast jedes Standard-HTML-Steuerelement (Elemente werden auch als Steuerelemente bezeichnet) in ein serverseitiges Steuerelement umzuwandeln. Dies bedeutet, dass ASP.NET das Steuerelement kennt und seine Eigenschaften ändern und Methoden auf der CodeBehind-Seite ausführen kann. In unserem obigen Beispiel wurden dem <h1> -Element zwei Attribute hinzugefügt:

1	<h1 id="headertext" runat="server">This is the text</h1>

Jetzt können wir in unserer CodeBehind-Datei ("Default.aspx.cs") auf das Steuerelement zugreifen und dessen Eigenschaften ändern.

1	headertext.InnerHtml = "This is the changed text";

Eine der besten Funktionen bei der Verwendung einer IDE wie MonoDevelop anstelle eines Texteditors ist Intellisense, mit dem Sie während der Eingabe ein Menü mit Optionen erhalten. Eigenschaften von Objekten, Systemklassen und -methoden, benutzerdefinierten Klassen und Methoden - alles ist da:

(Ich glaube, "Intellisense" ist möglicherweise eine Marke von Microsoft, aber ich bin mir nicht sicher, wie MonoDevelop es nennt!)

Für verschiedene Steuerelemente stehen zahlreiche andere Eigenschaften zur Verfügung (z. B. ein Steuerelement vom Typ input="text" hat die Eigenschaft "value"), die alle während der Eingabe in einer Liste angezeigt werden. Es gibt auch eine äußerst nützliche Eigenschaft namens Visible. Hiermit wird festgelegt, ob das Steuerelement in der Quelle sichtbar ist. Schauen Sie sich dieses Beispiel an:

<div id="notloggedin" runat="server">
	<h1>You are not logged in</h1>
	<p>Please <a href="/login">log in to the site here</a>.</p>
</div>

<div id="loggedin" runat="server" visible="false">
	<h1>Thanks, you've logged in</h1>
	<p>Welcome back, user!</p>
</div>

Beachten Sie, dass ich das visible="false" für das loggedin Element manuell hinzugefügt habe. Bei Verwendung mit diesem serverseitigen Code können wir jedes <div> -Steuerelement sichtbar oder unsichtbar machen.

protected void Page_Load(object sender, EventArgs e)
{
	User currentuser = new User();
	currentuser.CheckSecurity();
	if (currentuser.IsLoggedIn)
	{
		notloggedin.Visible = false;
		loggedin.Visible = true;
	}
}

Sie können sich vorstellen, wie einfach die Konfiguration von Seiten ist und wie viel sauberer Ihr Code sein kann.

Wie wäre es mit Formularelementen? Lassen Sie uns eine <select> -Server-Serverseite erstellen:

<select name="genre" id="genre" runat="server">
	<option value="1">Jazz</option>
	<option value="2">Blues</option>
	<option value="3">Rock</option>
	<option value="4">Pop</option>
	<option value="5">Classical</option>
</select>

Die Auswahl einer bestimmten Option ist so einfach:

1	int chosengenre = 4;
2	genre.Items.FindByValue(chosengenre.ToString()).Selected = true;

Ich habe dir gesagt, dass du die ToString() -Methode häufig verwenden würdest. Die Eigenschaft <select> control Items verfügt auch über eine nützliche Methode namens FindByText(), die Folgendes ausführt:

1	string chosengenre = "Blues";
2	genre.Items.FindByText(chosengenre).Selected = true;

Intellisense gibt Ihnen sogar eine Liste der gefundenen Steuerelemente, sodass Sie sich nicht einmal daran erinnern müssen, wie Sie all diese verschiedenen Textfelder genannt haben. Da wir normale HTML-Steuerelemente verwenden, die serverseitig konvertiert wurden (anstelle von echten ASP.NET-Steuerelementen), verlieren wir einige Funktionen, aber nichts, ohne das wir nicht leben können. In Teil 2 des Tutorials verwenden wir ein echtes ASP.NET-Steuerelement. Aber zuerst ein Wort zur Konfiguration.

Die Web.config-Datei

In Ihren PHP-Anwendungen hatten Sie zweifellos eine Konfigurationsdatei mit dem Namen "config.php" oder ähnlichem. ASP.NET verfügt über einen speziellen Dateityp für Konfigurationsdateien mit dem Namen ".config", die in der öffentlichen Ansicht automatisch deaktiviert werden. Ihre ASP.NET-Anwendung verfügt bereits über eine "Web.config" -Datei. Öffnen Sie diese in der Lösungsansicht in MonoDevelop.

Sie werden sehen, dass es sich um eine Standard-XML-Datei handelt. Wir werden einige anwendungsweite Einstellungen hinzufügen. Bearbeiten Sie also die Datei, indem Sie diesen Code direkt über </configuration> hinzufügen

1	<appSettings>
2	<add key="ApplicationName" value="My first ASP.NET Application"/>
3	<add key="Developer" value="Chris Taylor"/>
4	</appSettings>

Zurück zu unserer Datei "Default.aspx.cs" verweisen wir auf den System.Configuration-Namesraum

1	using System;
2	using System.Web;
3	using System.Web.UI;
4	using System.Configuration;

Und wir können jetzt auf unsere Einstellung "Anwendungsname" zugreifen, indem wir:

1	ConfigurationSettings.AppSettings["ApplicationName"];

Lassen Sie uns versuchen, die Dinge ein wenig aufzupeppen:

1	headertext.InnerHtml = "Welcome to " + ConfigurationSettings.AppSettings["ApplicationName"] + " by " + ConfigurationSettings.AppSettings["Developer"];

F5, um die Anwendung auszuführen, und Sie werden sehen:

Wie Sie zu schätzen wissen, erhalten Sie dadurch eine enorme Leistung über die standortweiten Einstellungen.

Sitzungen, Cookies und Post / Get-Parameter

Sie können nicht sehr weit kommen, um Webanwendungen zu entwickeln, ohne sich mit Sessions, Cookies und Post- oder Get-Parametern zu befassen. ASP.NET handhabt diese ziemlich gut, mit ein paar Fallstricken.

Sitzungen

Verwenden Sie zum Abrufen der Sitzungs-ID: Session.SessionID. Warnung: Wenn Sie in der Sitzung nichts speichern, kann sich die SessionID-Eigenschaft * bei jeder Seitenanforderung * ändern. Ja, ich weiß, es ist Wahnsinn. Das Update besteht darin, etwas in der Sitzung zu speichern.

Um etwas in der Sitzung zu speichern, verwenden Sie: Session["var"] = "value";.

Um etwas aus der Sitzung abzurufen, verwenden Sie: string value = Session["var"];.

Cookies

Um etwas in einem Cookie zu speichern, verwenden Sie: Response.Cookies["name"].Value = "value";.

Um etwas aus einem Cookie abzurufen, verwenden Sie: string value = Request.Cookies["name"].Value;.

Beachten Sie die unterschiedliche Verwendung von Request and Response und die Tatsache, dass Sie die Value-Eigenschaft festlegen müssen. Sie können auch andere Eigenschaften für jedes Cookie festlegen (weitere Informationen finden Sie unter Intellisense):

1	Request.Cookies[0].Domain = "http://domain.com";
2	Request.Cookies[0].Expires = DateTime.Now.AddMonths(1);
3	Request.Cookies[0].Secure = true;

In diesem letzten Beispiel haben Sie Ihren ersten Blick auf die DateTime-Klasse geworfen. Mit einem Wort, das ist fantastisch. Obwohl es an der "Anzahl" der PHPs-Funktion time() mangelt, bietet es eine Vielzahl von verkettbaren Methoden zum Erstellen und Ändern von Datenzeiten. Dies ist ein guter Einführungsartikel.

Parameter post/get

Diese sind wie Cookies im Request-Objekt enthalten. Dieses Objekt enthält viele nützliche Informationen für Anwendungsentwickler und kann grob mit der Variablen PHP $_SERVER verglichen werden. Hier sind einige andere nützliche Dinge:

NameValueCollection headers = Request.Headers;
bool issecure = Request.IsSecureConnection;
string url = Request.RawUrl;
string scriptname = Request.ServerVariables["SCRIPT_NAME"];
string useragent = Request.ServerVariables["HTTP_USER_AGENT"];

Für eine vollständige Liste von Request.ServerVariables ist dies eine gute Ressource.

Zurück zum Punkt; Um etwas von einem Post-Parameter abzurufen (der von einem Formular gesendet wurde), verwenden Sie: string value = Request.Form["param"];.

Und um etwas aus einem get-Parameter (im Querystring) abzurufen, verwenden Sie: string value = Request.QueryString["param"];.

Überprüfen Sie bei Sitzungsvariablen, Cookies und Post-and-Get-Eigenschaften immer, ob der Parameter nicht null ist, bevor Sie versuchen, darauf zuzugreifen. Dies entspricht der Funktion isset() von PHP. C# ist sehr unversöhnlich, wenn es um Nullobjekte geht. Daher lohnt es sich im Allgemeinen immer, zu überprüfen, ob etwas vorhanden ist, bevor Sie versuchen, es zu verwenden.

// session variable
if (Session["var"] != null) { ... }
// cookie
if (Request.Cookies["cookiename"] != null) { ... }
// post parameter
if (Request.Form["param"] != null) { ... }
// get parameter
if (Request.QueryString["param"] != null) { ... }

Sie können auch mehrere Teile in eine if-Anweisung einfügen. Um zu überprüfen, ob der Benutzer ein Cookie mit dem Namen "loggedin" und dem Wert "true" hat, funktioniert dies:

1	if (Request.Cookies["loggedin"] != null && Request.Cookies["loggedin"].Value == "true") { ... }

Genau wie bei PHP wird der zweite nicht ausgeführt, wenn der erste Teil der if-Anweisung fehlschlägt.

Kurzübersicht

Hier ist eine Tabelle allgemeiner Codefragmente in PHP mit ihren Entsprechungen in C#.

Klicken Sie auf das Bild, um es in voller Größe anzuzeigen.

Zu ihnen...

Sie haben jetzt das Wissen, grundlegende ASP.NET-Seiten zu erstellen und mithilfe der MonoDevelop-IDE einfache Websites zu erstellen. In Teil zwei dieses Tutorials werden Ihnen einige der erweiterten Funktionen von ASP.NET gezeigt, darunter:

MasterPages: Seitenlayouts für Steroide
Datenquellen und Datenbindung
Benutzerdefinierte Klassen: Alles objektorientiert auf einen Arsch
Benutzerdefinierte Steuerelemente: Maximale Wiederverwendung, Baby!

Folgen Sie uns auf Twitter oder abonnieren Sie den Nettuts+ RSS-Feed, um die besten Webentwicklungs-Tutorials im Web zu erhalten.