~~~TUTORIAL HTTPWEBREQUESTS~~~
~~~ByEasysurfer~~~
1. Einleitung:
Hier mein versprochenes Tut über HttpWebRequests in C# und VB.NET. Ich werde den Code jeweils in beide Sprachen “übersetzen”, das C# Coder, sowie VB.NET wissende beide was davon haben. Aber genug geredet, fangen wir an:
2. Warum HttpWebRequests?
Viele (meistens Anfänger) sehen in der Toolbox das WebBrowser Control und fangen an, mit diesem zu Arbeiten. Danach folgen Fragen wie “Wie klicke ich eineRadiobox an”, es folgen unsaubere Lösung und schlechter Code. Aber dieses ist nich der Hauptgrund, ich werde euch kurz ein paar Sachen aufzählen:
- Das WebBrowser Control verwendet die IE6 Engine, das heist:
- – Exploits können ausgeführt werden
- – Seiten können zum Teil nicht richtig dargestellt werden
- – Sehr langsamer Seitenaufbau
- Das Laden von Bildern kostet ca. das 5 – 6 fache an Ladezeit
- Multithreading nicht möglich
- Keine Kontrolle über Abläufe was der Browser macht (auser die Document_Loaded Events)
- Schwer Formulare auszufülllen
Das sind eigentlich die Hauptgründe, ich denke ich würde noch mehr finden 
Dazu schauen wir uns kurz die Pro’s von HttpWebRequests an:
- Wir senden direkt die Request, kein laden der Site und ausfüllen nötig
- Schneller als das WebBrowser Control
- Theoretisch ist es möglich, alles zu machen was der normale Browser auch kann (Ajax senden etc)
- Multithreading (rulez <3 )
- Genaue Kontrolle der Request (UserAgent, Cookies etc)
Der einzigste große Nachteil an HttpWebRequests ist eigentlich, das kein Javascript ausgeführt werden kann. Dieses kann man aber “simulieren” indem man den JS Code in C# umschreibt und da dann diverse Berechnungen etc durchführt.
3. WebClient und HttpWebRequest
Ich werde hier erst auf die WebClient Klasse eingehen, damit der Einstieg nicht all zu schwierig wird.
Der WebClient ist in der Lage jede beliebige Site herrunter zu laden (wenn auch ohne Cookies, wobei wenn man die Funktion überschreibt etc, sind da Sachen möglich ). Des weitern kann super einfach Dateien heruntergeladen werden, sowie Dateien hochgeladen werden. Aber ein Beispiel sagtmehr wie tausend Worte:
System.Net.WebClient Client = new WebClient();
// Neue Inztanz
String GoogleSite =
Client.DownloadString("http://www.google.de");
// Wir laden die Google Mainpage
Client.DownloadFile("http://www.google.com/
intl/images/logo.gif",
"googleLogo.gif");
// wir laden das Google logo runter und speichern es unter
//[ExecutePath]/googleLogo.gifDim Client As System.Net.WebClient = New WebClient()
' Neue Inztanz
Dim GoogleSite As String =
Client.DownloadString("http://www.google.de")
' Wir laden die Google Mainpage
Client.DownloadFile("http://www.google.com/
intl/images/logo.gif",
"googleLogo.gif")
' wir laden das Google logo runter und speichern es unter
' [ExecutePath]/googleLogo.gifMit dem WebClient kann man schöne Sachen machen (Asyncron Datein runterladen, Proxy verwenden etc), aber wir wollen ja mehr ins Detail gehen. Also Weiter zu HttpWebRequest:
Ich werde erst auf die einfache Methode ohne POST eingehen (laden einer normalen Site), dann mit POST.
Der Aufbau einer HttpWebRequest sieht immer folgendermasen aus:
- Neue Inztanz
- Parameter Setzen (Cookies, UserAgent, Proxy etc)
- [POST String schreiben]
- Die Request abschicken und eine Response erhalten
- Mit den Cookies / Seiteninhalt von der Response weiterarbeiten
Ich werde im folgenden Beispiel genau diese Reihnfolge einhalten.
Die Inztanz erstellen
HttpWebRequest Request =
(HttpWebRequest)WebRequest.Create("http://google.de");Dim Request As HttpWebRequest =
DirectCast(WebRequest.Create("http://google.de"),
HttpWebRequest)Hier wird eine Request Variable von Typ HttpWebRequest erzeugt. Diese wird zu einer HttpWebRequest von Typ WebRequest gecastet, dieses müsst ihr einfach so hin nehmen. Es gibt noch andre Typen von Requests (FTPRequest) etc, daher ist WebRequest die Basisklasse von dem.
Parameter setzen
request.CookieContainer = Cookies;
// Siehe Unten
request.UserAgent = "Mozilla/5.0
(Windows; U; Windows NT 5.1; de; rv:1.9.0.10)
Gecko/2009042316 Firefox/3.0.5
(.NET CLR 4.0.20506)";
// Wir benutzen "Firefox"
Request.Accept = "text/html,application
/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
// solche Infos sendet der Browser normalerweise mit
Request.KeepAlive = true;
Request.Method = "GET";
// es wird GET verwendet (beim normalen Laden)
Request.Timeout = 10000;
// nach 10 Sek wird abgebrochen
Request.Referer = "http://google.de/";
// wir kommen (anscheinded) bereits von Google :D
Request.ContentType = "application
/x-www-form-urlencoded";
// das ist eine normale HTTPRequest
Request.CookieContainer = Cookies;
Request.Accept = "text/html,application
/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
Request.KeepAlive = True
Request.Method = "GET"
Request.Timeout = 10000
Request.UserAgent = "Mozilla/5.0
(Windows; U; Windows NT 5.1; de; rv:1.9.0.10)
Gecko/2009042316 Firefox/3.0.5
(.NET CLR 4.0.20506)"
Request.Referer = "http://google.de/"
Request.ContentType = "application/
x-www-form-urlencoded"
Zu dem Cookie Container komme ich später, nehmt das einfach mal so hin ^^ Die restlichen Angaben könnten sich so oder so ähnlich in einem Header einer Http-Request befinden, wie sie Firefox abschicken würde. Sollte euch das weiter interessieren, rate ich Euch zu einer Dokumentation zum HTTP Protokol 
Post string “schreiben”
Jetzt kommt der komplizierteste Teil des ganzen Tutorials. In der Thoerie schreibt man diesen POST String folgendermasen:
- wir fordern einen Stream an um die Post daten zu schreiben
- wir schreiben in den Stream unsere Daten
- wir schliesen den Stream und setzten die ContentLength
Dann mal zum Source:
string Post = "username=XXX&password=XXX2";
// das wird gesendet
byte[] byteArray = Encoding.UTF8.GetBytes(Post);
// Die Post daten werden in ein Byte Array umgewandelt
Stream DataStream = Request.GetRequestStream();
// der Steam wird angefordert ;)
DataStream.Write(byteArray, 0, byteArray.Length);
// wir schrieben in den Stream unsere Post daten
DataStream.Close(); // immer schön zumachen
Request.ContentLength = byteArray.Length;
// wir setzen die ContentLengh auf die Anzahl
// der Zeichen in dem PostString
Dim Post As String = "username=XXX&password=XXX2"
' das wird gesendet
Dim byteArray As Byte() = Encoding.UTF8.GetBytes(Post)
' Die Post daten werden in ein Byte Array umgewandelt
Dim DataStream As Stream = Request.GetRequestStream()
' der Steam wird angefordert ;)
DataStream.Write(byteArray, 0, byteArray.Length)
' wir schrieben in den Stream unsere Post daten
DataStream.Close() ' immer schön zumachen
Request.ContentLength = byteArray.Length
' wir setzen die ContentLengh auf die Anzahl
' der Zeichen in dem PostString
Wichtig ist noch bei der POST Request, in der Request.Method “POST” zu verwenden
Die Request abschicken und eine Response erhalten
Da wir nun unsere schöne HttpWebRequest “gebaut” haben, schicken wir sie doch mal ab. Das geht im Prenzip so, das wir einfach eine Antwort anfordern(eine HttpWebResponse). Dann mal los:
HttpWebResponse Response =
(HttpWebResponse)Request.GetResponse();
// Wir müssen wieder casten ^^
DataStream = Response.GetResponseStream();
// hier wird der "Empfangsstream" angefordert
StreamReader reader = new StreamReader(DataStream);
// Mit einem StreamReader wird aus dem Empfangsstream gelesen
string ServerResponse = reader.ReadToEnd();
// Es wird alles gelesen, was der Webserver zurückgegeben hat
// (den Quelltext quasi)
reader.Close();
DataStream.Close();
Response.Close();
// alles Closen ^^
Dim Response As HttpWebResponse =
DirectCast(Request.GetResponse(), HttpWebResponse)
' Wir müssen wieder casten ^^
DataStream = Response.GetResponseStream()
' hier wird der "Empfangsstream" angefordert
Dim reader As New StreamReader(DataStream)
' Mit einem StreamReader wird aus dem Empfangsstream gelesen
Dim ServerResponse As String = reader.ReadToEnd()
' Es wird alles gelesen, was der Webserver zurückgegeben hat
' (den Quelltext quasi)
reader.Close()
DataStream.Close()
Response.Close() ' alles Closen ^^
Natürlich bietet die HttpWebResponse noch viel mehr Inhalte als nur den Seitenquelltext, aber darauf werde ich erst bei dem praktischen Beispiel drauf eingehen (Cookies, Header etc)
Mit den Cookies / Seiteninhalt von der Response weiterarbeiten
Was ihr jetzt damit macht, ist euch überlassen. Ihr könnt prüfen ob etwas in der “Antwort” vorkam wie z.B. “Login erfolgreich!”, ihr könnt Proxylisten per RegEx auslesen etc. Ich hoffe ihr habt das soweit alles verstanden, auf jeden fall gehts jetzt weiter
4. Praktisches Beispiel an Rapidshare
In dem Beispiel werden wir uns einloggen, prüfen ob der Login erfolgreich war und ein paar Daten auslesen. (obwohl das eigentlich Sinnlos ist, Stichwort Rapidshare API). Ist ja nur zu Übungszwecken
Doch wie sehn wir, was überhaupt von dem Browser an Post-Daten geschickt wurde? Es könnte ja usrname, username, uname etc heisen? Dazu gibt es ein FirefoxAdd-On namens HttpLiveHeader. Diese Add-On snifft (lauscht) alle noch so kleinen Requests mit, die von Firefox gesendet werden und stellt diese dar. In der Darstellung bekommt man genau so ein paar Header zurück, wie ich sie oben Vorgestellt habe. Das Tool sollte ansich selbsterklärend sein. (vor dem Login aufrufen, einloggen und “Mitschneiden deaktivieren”. Nun die gesendeten Daten anschaun und in das Tool eintragen).
Ich habe hier mal die Rapidshare Login Request mitgeschnitten:
https://ssl.rapidshare.com/cgi-bin/collectorszone.cgi – hier geht die Request hin (nachzulesen im HTML Code unter <form action=”XX.cgi”>)
Content-Length: 39 – 39 Zeichen werden per Post gesendet
username=meinusername&password=mein1337Password – das ist der Post String.
Wie war das noch… Jaa… Sendeleistung… Nee… Nochmal von vorne.
). Weiter gehts mit 6 Wochen Amerikaaufenthalt. Mit gutem Englisch (und eventuell einem IPhone 4GS wenn der Dollarkurs stimmt) im Gepäck komm ich dann hier zurück und verbringe weitere 48 Stunden um auf Emails, Forenthreads und Telefonate zu Antworten, der Traum eines Nerds.
