TCP/IP en C#
- Inleiding
- TCP/IP
- Internet en Web Pagina’s
- WebRequest / WebResponse
- Web Client
- HTTP Client
- Slot
- Voorbeeldprogramma
Inleiding
TCP/IP is een protocol dat in de jaren ’70 van de vorige eeuw werd ontwikkeld en het grootste TCP/IP netwerk ter wereld kennen we inmiddels allemaal want dat is.. het internet. De WebRequest, de WebClient en de HTTPClient zijn .NET framework klassen die gericht zijn op interactie met een TCP/IP netwerk. We zullen in deze post laten zien hoe we in C# het TCP/IP netwerk betreden en hoe we een web pagina kunnen ophalen.
TCP/IP
Je kunt computers en systemen met elkaar verbinden via een netwerk. Voor dat netwerk moet je regels opstellen en afspraken maken over hoe de systemen met elkaar communiceren en hoe informatie uitgewisseld moet worden. De regels en de afspraken leg je uiteindelijk vast in een protocol en het is de bedoeling dat alle aangesloten systemen zich aan dat protocol houden. Misschien wel de belangrijke voorwaarde om het geheel te laten doen slagen.
Men begon In de jaren ’70 van de vorige eeuw met de ontwikkeling van een standaard protocol. Het beestje kreeg een naampje en het werd bekend als het TCP/IP protocol. Daarbij staat TCP voor “Transmission Control Protocol” en IP voor “Internet Protocol“. TCP/IP is blijkbaar een enorm succes geworden want het internet is een internationaal openbaar TCP/IP netwerk met wereldwijd miljoenen aangesloten computers en devices.
Bij een TCP/IP netwerk vragen we iets op en de “andere kant” stuurt naar aanleiding van dat verzoek iets terug. De één doet dus iets op verzoek van de ander en de vragende partij wordt de client genoemd. De client krijgt naar aanleiding van zijn verzoek iets terug en de server is de partij die zorgt draagt voor het antwoord naar de client.
De WebRequest, de WebClient en de HTTPClient zijn .NET framework klassen die gericht zijn op interactie met een TCP/IP netwerk. We zullen de desbetreffende klassen in deze post bespreken.
Internet en Web Pagina’s
Het gaat bij de meeste internet applicaties meestal om web pagina’s die geraadpleegd moeten worden en de client is zo’n geval meestal een web browser van waaruit een verzoek wordt gedaan naar een web server.
Het verzoek wordt gedaan in de vorm van een url (uniform resource locator) en de web server zal daarop reageren. Het antwoord van de web server zal naast wat tekst ook Hyper Text Markup Language (HTML) opmaak elementen bevatten en misschien ook JavaScript en Typescript dat door de browser uitgevoerd moet worden. De web browser herkent de HTML en de JavaScript/TypeScript en de web browser zal naar aanleiding daarvan het één en ander in een bepaalde opmaak tonen en zorg dragen voor het doen uitvoeren van de JavaScript/TypeScript.
Het internet is een TCP/IP netwerk en een web server kan ook door een C# console applicatie benaderd worden. De desbetreffende console applicatie moet dan wel gebruik maken van de klassen die interactie met een TCP/IP netwerk mogelijk maken.
Een web server stuurt voor wat betreft een web pagina meestal tekst en HTML terug. Maar wat de web server ook terug moge sturen, het blijft voor de console applicatie een hele lange string en verder niks. De console applicatie zal verder geen bijzondere dingen doen naar aanleiding van het antwoord van de web server.
WebRequest / WebReponse
De onderstaande console applicatie benadert een web server waarbij gebruik wordt gemaakt van de WebRequest en de WebResponse klasse.
string webPagina = "";
string url =
"https://www.domeinnaam.nl/webpagina.htm";
// instantieer een WebRequest object
WebRequest webRequest =
WebRequest.Create(url);
// maak verbinding met de server
WebResponse webResponse =
webRequest.GetResponse();
// de status
Console.WriteLine(
"- Status:" + (
(HttpWebResponse)webResponse)
.StatusDescription);
// vraag de gegevens op van de server
- we krijgen een stream
using (Stream stroom =
webResponse.GetResponseStream())
{
// Lees de stream uit
StreamReader streamReader
= new StreamReader(stroom);
webPagina =
streamReader.ReadToEnd();
}
// verbreek de verbinding
webResponse.Close();
// toon (een deel van) de Web Pagina
Console.WriteLine(
"- Response van de server:");
Console.WriteLine(
webPagina
.Substring(webPagina.Length - 185));
// Einde
Console.WriteLine(
"- Einde WebRequest.\r\n");
- Je instantieert een WebRequest object en tegelijkertijd met het instantiëren roep je methode .Create() aan waarbij je aan die methode een uniform resource locator (url) meegeeft. De url string begint met het welbekende “http://…” en “https://…” .
- Methode .Create() geeft een HttpWebRequest object terug. Andere objecten zoals een FtpWebRequest of een FileWebRequest kunnen ook geretourneerd worden. In dit voorbeeld gaat het om een web pagina waar we een HttpWebRequest voor gebruiken.
- We moeten van de teruggekregen HttpWebRequest object methode .GetResponse() aanroepen. Methode .GetResponse() retourneert een WebResponse object.
- De WebResponse object heeft een Stream en de stream moeten we ook weer uitlezen met bijvoorbeeld een .ReadToEnd() methode (we zagen deze methode ook in het voorbeeld van de StreamWriter en StreamReader).
We zien ook hier het stream concept terugkomen. De WebResponse is blijkbaar ook een kind van de Stream klasse en gespecialiseerd in een bepaald medium en het medium is in dit geval een TCP/IP netwerk. - In dit voorbeeld lezen we de stream uit waarbij we alles in een string zetten. De string zal na afloop de inhoud van de Web Pagina bevatten (allemaal tekst).
- Na afloop moet de stream en / of het HttpWebRequest object afgesloten worden. Een beperkt aantal web connecties kan maar gebruikt worden en dat aantal zal snel opraken als bestaande web connecties niet afgesloten worden,
De WebRequest klasse is weliswaar wat geavanceerder (omslachtiger), maar het meest geschikt voor gevallen waarin een web server speciale eisen stelt m.b.t. de web request. Een web request kan dan met de WebRequest klasse gecustomized worden opdat het verzoek door die server wordt geaccepteerd.
Web Client
De WebClient is eenvoudiger dan de WebRequest. Je krijgt direct je web pagina zonder tussenkomst van een HttpWebResponse object en een Stream.
Eenvoud siert je programma, maar de WebRequest is in de gevallen waarin uitgebreid gecustomized moet worden meestal de betere kandidaat.
string webPagina = "";
string url =
"https://www.domeinnaam.nl/webpagina.htm";
WebClient webClient =
new WebClient();
webPagina =
webClient.DownloadString(url);
// toon de Web Pagina
Console.WriteLine(
"- Response van de server:");
Console.WriteLine(
webPagina.Substring(
webPagina.Length - 185));
// Einde
Console.WriteLine(
"- Einde WebClient.");
HTTP Client
We zagen hoe een C# console applicatie een web server benadert via het TCP/IP netwerk (het internet). Vanuit Windows Universal Applications kunnen we ook op het TCP/IP netwerk en de HTTPClient klasse is bij uitstek geschikt voor dat soort applicaties. Dit omdat de HTTPClient klasse gespecialiseerd is in asynchrone methoden en alleen maar asynchrone methoden faciliteert.
async Task<string> leesWebPagina()
{
string url =
"https://www.domeinnaam.nl/webpagina.htm";
HttpClient httpClient =
new HttpClient();
return
await HttpClient
.GetStringAsync(url);
}
Windows Universal Applications hebben meestal uitgebreide gebruikerinterfaces (schermen) en je wilt niet dat alle schermen “bevriezen” gedurende de tijd dat de computer op het internet zit voor het doen opvragen en downloaden van het gewenste. Meer over asynchrone methoden in de post over asynchroon programmeren.
Slot
Het internet is het grootste en het bekendste TCP/IP-netwerk ter wereld en het gaat bij de meeste internet applicaties meestal om web pagina’s die op een web server staan. De web pagina’s worden meestal met een web browser bekeken en het is ook de web browser van waaruit je de web pagina’s oproept.
Een web server kan ook door een C# console applicatie benaderd worden mits de console applicatie gebruik maakt van de klassen die interactie met een TCP/IP netwerk mogelijk maken. Ik heb gedemonstreerd hoe we met een C# console applicatie de web server benaderen en we zien dat de console applicatie dingen terugkrijgt van de web server en dat is hetzelfde als wat een browser terugkrijgt.
Maar wat de web server ook terug moge sturen, het blijft voor de console applicatie een hele lange string en verder niks. Dit in tegenstelling tot de web browser. De web browser zal de web pagina wel in een bepaalde opmaak tonen en het zal zorg dragen voor het doen uitvoeren van de JavaScript en de TypeScript die het van de web server krijgt.
Hopelijk ben je met deze posting weer wat wijzer geworden en ik hoop je weer terug te zien in één van mijn volgende blog posts. Wil je weten wat ik nog meer over C# heb geschreven? Hit the C# button…
Voorbeeldprogramma
using System;
using System.IO;
using System.Net;
namespace Voorbeelden
{
class MainClass
{
public static void Main(string[] args)
{
string webPagina = "";
string url =
"https://www.domeinnaam.nl/webpagina.htm";
/*
* -----------
* Web Request
* -----------
*
*/
Console.WriteLine(
"----------\r\n
WebRequest\r\n
---------");
// instantieer een WebRequest object
WebRequest webRequest =
WebRequest.Create(url);
// maak verbinding met de server
WebResponse webResponse =
webRequest.GetResponse();
// de status
Console.WriteLine(
"- Status:" + (
(HttpWebResponse)webResponse)
.StatusDescription);
// vraag de gegevens op van de server
- we krijgen een stream
using (Stream stroom =
webResponse.GetResponseStream())
{
// Lees de stream uit
StreamReader streamReader
= new StreamReader(stroom);
webPagina =
streamReader.ReadToEnd();
}
// verbreek de verbinding
webResponse.Close();
// toon (een deel van) de Web Pagina
Console.WriteLine(
"- Response van de server:");
Console.WriteLine(
webPagina
.Substring(webPagina.Length - 185));
// Einde
Console.WriteLine(
"- Einde WebRequest.\r\n");
/*
* ----------
* Web Client
* ----------
*/
Console.WriteLine(
"---------\r\n
WebClient\r\n
---------");
WebClient webClient =
new WebClient();
webPagina =
webClient.DownloadString(url);
// toon de Web Pagina
Console.WriteLine(
"- Response van de server:");
Console.WriteLine(
webPagina.Substring(
webPagina.Length - 185));
// Einde
Console.WriteLine(
"- Einde WebClient.");
}
}
}
Resultaat
Ik heb, voor het zo goed mogelijk kunnen demonstreren van dingen de C# console applicatie “losgelaten” op een website / webpagina van een winkel (de winkel ga ik verder niet noemen). De desbetreffende web pagina is wat minder complex waardoor je goed de HTML in de output kunt zien.
De wat meer geavanceerde web pagina’s bevatten enorme hoeveelheden geUglifyde JavaScript/TypeScript code en de HTML zul je uiteindelijk ook wel terugvinden in de output, maar het merendeel van de output zal waarschijnlijk bestaan uit enorme hoeveelheden geUglyfyde JavaScript/TypeScript code en dat is voor demonstratiedoeleinden wat minder handig.
----------
WebRequest
---------
- Status:OK
- Response van de server:
<div id="lay7">
<p> Openingstijden:<br><br>
Maandag: <br>
Dinsdag: <br>
Woensdag: <br>
Donderdag: <br>
Vrijdag: <br>
Zaterdag: <br>
Zondag: </p></div>
</body>
</html>
- Einde WebRequest.
---------
WebClient
---------
- Response van de server:
<div id="lay7">
<p> Openingstijden:<br><br>
Maandag: <br>
Dinsdag: <br>
Woensdag: <br>
Donderdag: <br>
Vrijdag: <br>
Zaterdag: <br>
Zondag: </p></div>
</body>
</html>
- Einde WebClient.
Press any key to continue...