Vorüberlegungen

Wie fast alle Hobbyprogrammierer erstelle auch ich eine Unzahl unnötiger und zum Teil auch unsinniger Anwendungen. Dies ist der Luxus den man sich leisten kann, wenn man damit nicht sein Geld verdienen muss.

Da ich ab und zu auf Dienstreise gehe, ist die aktuelle Uhrzeit am gegenwärtigen Standort immer ein Thema. Oft kommt auch die Frage auf, wie spät es denn bei den Lieben zu Hause wohl sein mag.

Hierfür  kommt natürlich nur, mein neuestes Steckenpferd, eine Webanwendung in Frage.

Die ersten Überlegungen:

1. Welcher Aufbau einer Webanwendung ist der beste
2. Wie ermittle ich meinen aktuellen Standort
3. Welche zusätzlichen Informationen kann ich noch anzeigen

1. Welcher Aufbau einer Webanwendung ist der beste?

Ich hab mich hier, sehr schnell, für eine Webanwendung entschieden, die ihre Informationen aus einem RSS-Feed bezieht. Vorteil hierbei, es handelt sich um ein XML-Format, welches leicht zu lesen ist und auch anderweitig verwendet werden kann.
Eine Windows-, Linux-, MacOS- oder Android Anwendung könnte den RSS-Feed ebenfalls nutzen.

2. Wie ermittle ich meinen aktuellen Standort

Im Prinzip wäre GPS das ideale Werkzeug um den aktuellen Standort auf der Welt bestimmen zu können. Da ich jedoch nur ein Notebook auf meinen Dienstreisen zur Verfügung habe, fällt das mit dem GPS aus, denn die wenigsten Notebooks verfügen über GPS – meines schon gar nicht.

Eine weitere Möglichkeit meinen Standort zu bestimmen wäre über die IP Adresse, mit der sich mein Computer über den jeweiligen Provider mit dem Internet verbindet. Nicht sehr genau, aber wenn es um die Zeitzone geht – genau genug.

Eine andere Alternative, die mir erst vor kurzem bekannt wurde, ist die Ermittlung des Standortes via HTML 5 – Voraussetzung hierfür sind ein Browser der diese neue Technologie unterstützt und aktiviertes JavaScript.

Die Umsetzung via HTML 5 ist zudem genauer als der Weg über die IP-Adresse. Ideal wäre also die Verknüpfung beider Techniken.

Da meine Seite aktuell mit der IP-Adresse arbeitet, möchte ich das als Basis der folgenden Abhandlungen nehmen.

3. Welche zusätzlichen Informationen kann ich noch anzeigen

Weitere Informationen bietet ASP.NET von allein. IP-Adresse, Sprache, Browser, Auflösung usw.

Die Umsetzung:

Wie schon erwähnt ist ein RSS-Feed nichts anderes als eine XML Datei. Diese wird als Antwort (Response) auf eine Anfrage (Request) vom Webservice zurückgegeben.

Im Prinzip also recht einfach

1. Daten ermitteln
2. XML erstellen
3. Daten zurückgeben

Überlegung:

Welche Daten benötigen wir und welche Daten soll der RSS-Feed zusätzlich enthalten?

Im Prinzip benötigen wir nur drei Werte um die aktuelle Uhrzeit und Zeitzone übermitteln zu können.

1. Die Zeitzone als ID – damit kann dann ganz einfach die passende Zeitzone auf dem Windows-PC gefunden werden.
   (Wie das auf einem MAC OS oder einem Linux Rechner umgesetzt werden kann wäre eine weitere Überlegung wert)
2. Die Zeitverschiebung in Stunden (Als Basis gilt hier immer die koordinierte Weltzeit)
3. Die Zeitverschiebung in Minuten (Als Basis gilt hier immer die koordinierte Weltzeit)

Alle weiteren Daten sind Beiwerk und blähen unseren RSS-Feed nur auf. Aber wer kommt denn schon ohne Beiwerk aus?

Interessant sind natürlich auch

1. Die momentane IP-Adresse
2. Die eingestellte Sprache
3. Der aktuelle Ort (Stadt) bzw. das Land
4. Die Region (hier kommen wir später darauf zurück)
5. Die Geokoordinaten (geographische Länge und Breite)

Umsetzung:

Die erste Schwierigkeit besteht darin aus der IP-Adresse den aktuellen Standort zu ermitteln.

Hierfür gibt es eine Menge Webservices, die aber alle nicht sehr aktuell sind und ihre Daten nicht so einfach zur Verfügung stellen wollen.

Als die beste aller Möglichkeiten hat sich die MaxMind GeoLight City Datenbank in Verbindung mit dem Google Maps UserControl von SubGurim.net gezeigt.
Nachteil hier – die Datenbank ist 30MB schwer und muss jeden Monat aktualisiert werden, da sich die IP-Adressen ständig ändern. Was soviel heißt wie, je länger der Monat dauert je ungenauer die Angaben.

Abhilfe würde hier die kostenpflichtige Datenbank schaffen – diese ist zwar noch Größer wird aber in einem kürzeren Zyklus aktualisiert. Da ich das Ganze aber nur als Hobby-Projekt umsetzen will, sind mir die Kosten dafür zu hoch.

Die kostenpflichtige Datenbank gibt es ebenfalls hier (GeoCity) und kann natürlich auch mit dem gleichen UserControl betrieben werden.

Ich hab mich für das Binary Format der Datenbank entschieden, da diese Version in Verbindung mit dem SubGurim UserControl sehr schnell ist. Die Zugriffszeiten auf meinen RSS-Feed liegen bei etwa 0.5 Sekunden.

Das SubGurim Control wurde für ASP.NET 2.0 entwickelt, arbeitet aber auch im Framework 4 ohne Probleme.

Bindet man nun alles ein – ein Lesen der Dokumentation hilft wie immer weiter - reduziert sich der Code zur Ermittlung der Geokoordinaten auf

Dim location As Location = GetLocationFromIP(userIP)

Im Prinzip schon fast alles. Nur war es nicht unser Ziel die Geokoordinaten zu ermitteln, wir wollten die Uhrzeit und Zeitzone am aktuellen Standort ermitteln.

Anmerkung:

Die Klasse Location ist hier ein Teil des SubGurim.Net UserControls und enthält neben den GeoKoordinaten auch die ermittelte Stadt, das Land (beides als Klartext) und die Region als Kürzel (z.B. 02 = Bayern, 05 = Hessen).

Da ich für die nächsten Schritte keine weiteren Controls, Dll’s oder anderes frei verfügbares Werkzeug gefunden habe, musste ich die Verknüpfung der Standortdaten zur Zeitzone und das Decodieren des Regionkürzels selbst erledigen.

Überlegung:

Ein jeder Punkt dieser Welt gehört einer bestimmten Zeitzone an. Hier gilt es 3 Fälle zu beachten.

1. Länder die als Ganzes einer Zeitzone angehören (z.B. Deutschland, Österreich, Schweiz)
2. Länder die mehreren Zeitzonen angehören (z.B. USA, Russland, Indonesien)
3. Gebiete die nicht erfasst werden können (Oceane und Wüsten)

1. Länder die als Ganzes einer Zeitzone angehören

Die einfachste Form, die Inhalte der Klasse Location können direkt zur Ermittlung der Zeitzone herangezogen werden.

Vereinfacht: Land = Zeitzone = Zeitverschiebung

2. Länder die mehreren Zeitzonen angehören

Nicht mehr ganz so einfach. Die Zeitzone wird hier anhand des Landes und der Region bestimmt.

Vereinfacht: Land (z.B. USA) - Region (z.B. CA - Kalifornien) = Zeitzone = Zeitverschiebung

Sonderfall: Eine Region enthält mehrere Zeitzonen (z.B. USA/Indiana – Eastern- und Central Time)

Hierfür habe ich noch keine Lösung – mir fehlen die genauen Daten – aber vermutlich wird es dann eine weitere Unterteilung anhand der ermittelten Stadt geben.

Land (z.B. USA) – Region (z.B. IN - Indiana) – Stadt (?) = Zeitzone = Zeitverschiebung

3. Gebiete die nicht erfasst werden können

Da es auf dem Meer oder in der Wüste keinen Provider bzw. keine Empfang gibt, kann dieser Fall ausgeschlossen werden.

Lösung hierfür wäre eine Ermittlung des Standortes via Geokoordinaten (GPS), was im Moment noch nicht umgesetzt wurde.

Die beschriebene Funktionalität hab ich in eine DLL gepackt, das alles beschreiben zu wollen würde hier aber zu weit führen.

Die Punkte 1. und 2. werden komplett durch eine List(of Structure) abgebildet, die alle Länder dieser Welt, inkl. den unter 2. beschriebenen Fällen, enthält.

    Public Structure myTimeZone
        Public Country As String
        Public Region As String
        Public TimeZoneInfo As TimeZoneInfo

        Public Sub New(ByVal c As String, ByVal r As String, ByVal tzi As TimeZoneInfo)
            Country = c
            Region = r
            TimeZoneInfo = tzi
        End Sub
    End Structure

Private mytimezones As New List(Of myTimeZone)

Die Klasse „TimeZoneInfo“ ist schon Bestandteil des Frameworks und bildet die auf dem jeweiligen System installierten Zeitzonen ab.

Die durch das SubGurim.Net UserControl bereitgestellten Informationen (Klasse Location) dienen somit als Filter für die Suche innerhalb der Liste. Die dadurch ermittelten Daten können nun den RSS-Feed füllen.

Erstellen eines RSS-Feeds:

Wie schon erwähnt ist ein RSS-Feed nichts anderes als eine XML-Datei welche durch eine Webseite zurückgegeben wird.

Dies kann auf vielfältige Art und Weiße geschehen.

Anfangs erstellte ich meinen Feed innerhalb einer WebForm (*.aspx). Später jedoch bin ich auf eine Methode gestoßen, die mir eleganter erschien, nämlich das Erstellen eines RSS-Feeds mittels eines „Generic Handlers“ (*.ashx)

Im Prinzip wird nichts anderes gemacht, als den kompletten Feed mittels LINQ zusammenzubauen und am Schluss als Response zurückzugeben.

Dim doc As New XDocument()

Dim rss As New XElement("rss")
rss.Add(New XAttribute("version", "2.0"))

Dim channel As New XElement("channel")
rss.Add(channel)

channel.Add(New XElement("title", "The TimeZoneNotifier RSS-Feed"))
channel.Add(New XElement("link", "http://TimeZoneNotifier.free-file-download.de"))
channel.Add(New XElement("description", "This site detects the timezone you're currently staying in !"))
channel.Add(New XElement("ttl", "60"))

Dim item As New XElement("item")

Channel.Add(item)

item.Add(New XElement("userIP", userIP))
item.Add(New XElement("userBrowser", userBrowser))
item.Add(New XElement("userLanguage", userLanguage))
item.Add(New XElement("userCity", userCity))
item.Add(New XElement("userRegion", userRegion))
item.Add(New XElement("userLongitude", userLongitude))
item.Add(New XElement("userLatitude", userLatitude))
item.Add(New XElement("userTimeOffsetHours", userTimeOffsetHours))
item.Add(New XElement("userTimeOffsetMinutes", userTimeOffsetMinutes))
item.Add(New XElement("CurrentUTCTime", CurrentUTCTime.ToString))
item.Add(New XElement("userTimeZone", userTimeZone))

doc.Add(rss)

(Den RSS-Feed wie er dann ausgegeben wird, sehen Sie am Ende dieses Artikels)

Sind wir erst einmal hier angekommen, wurde die meiste Arbeit schon erledigt. Der Rest besteht nur noch im Anzeigen der ermittelten Daten.

Anzeigen der Daten mittels einer WebForm:

Hier zum Verständnis, noch der Code für die Anzeige der Daten.

Da wir den Feed mittels einer Webanwendung abfragen, sind manche Informationen für den RSS-Feed nicht sichtbar. Bei diesen Daten verwerfen wir die Informationen die der RSS-Feed enthält einfach und füllen die Ausgabe mit den Werten der WebForm.

Protected Sub Page_Load(ByVal sender As Object, _
                    ByVal e As System.EventArgs) Handles Me.Load

if Postback Then
'RSS-Feed holen
    Dim retRss As New Xml.XmlDocument
    retRss.Load("http://timezonenotifier.free-file-download.de/rss.ashx?ip=" & _
                Request.UserHostAddress)
    'IP-Adresse das Feeds stimmt
    Me.LabelIP.Text = retRss.SelectSingleNode("/rss/channel/item/userIP").InnerText
    'Wurde eine nicht gültige IP-Adresse erkannt -> Anzeigen der Daten abbrechen
    If Me.LabelIP.Text = "No valid IP-Adress !!" Then
        Exit Sub
    End If
    'Kein Browser im RSS-Feed vorhanden, da vom Server aus angefragt wird
    Me.LabelBrowser.Text = Request.Browser.Browser
    'Keine Sprache im RSS-Feed vorhanden, da vom Server aus angefragt wird
    Try
        Dim ci As New CultureInfo(Request.UserLanguages(0))
        Me.LabelLanguage.Text = ci.DisplayName
    Catch ex As Exception
        Me.LabelLanguage.Text = "Unknown"
    End Try
    'erkannte Stadt
    Me.LabelCity.Text =
        retRss.SelectSingleNode("/rss/channel/item/userCity").InnerText
    'erkannte Region
    Me.LabelRegion.Text =
        retRss.SelectSingleNode("/rss/channel/item/userRegion").InnerText
    'erkannte Geogr. Länge
    Me.LabelLong.Text =
        retRss.SelectSingleNode("/rss/channel/item/userLongitude").InnerText
    'erkannte Geogr. Breite
    Me.LabelLat.Text =
        retRss.SelectSingleNode("/rss/channel/item/userLatitude").InnerText
    'erkannte Zeitverschiebung
    Dim _offsethours As Integer =
        CInt(retRss.SelectSingleNode("/rss/channel/item/userTimeOffsetHours").InnerText)
    Dim _offsetminutes As Integer =
        CInt(retRss.SelectSingleNode("/rss/channel/item/userTimeOffsetMinutes").InnerText)
    'aktuelle Zeit am Standort berechnen
    Dim tempRSS As String =
        retRss.SelectSingleNode("/rss/channel/item/CurrentUTCTime").InnerText
    Me.LabelCurrentTime.Text =
        CDate(tempRSS).AddHours(_offsethours).AddMinutes(_offsetminutes).ToLongDateString & " - " & CDate(tempRSS).AddHours(_offsethours).AddMinutes(_offsetminutes).ToLongTimeString

    Me.LabelCurrentTimeDiff.Text = _offsethours.ToString & _
        " h " & _offsetminutes.ToString & " min"
    'erkannte Zeitzone
    Me.LabelCurrentTimezone.Text =
        retRss.SelectSingleNode("/rss/channel/item/userTimeZone").InnerText
Else
    'kein Postback
End If
End Sub

Die Ergebnisse meiner Arbeit:

Das oben beschriebene hab ich unter http://timezonenotifier.free-file-download.de als ASP.NET Webseite veröffentlicht.
Den RSS-Feed gibt es unter http://timezonenotifier.free-file-download.de/rss.ashx
RSS-Feed (mein Standort)
<pre>

<rss version="2.0">
    <channel>
        <title>The TimeZoneNotifier RSS-Feed</title>
        <link>http://TimeZoneNotifier.free-file-download.de</link>
        <description>
            This site detects the timezone you're currently staying in !
        </description>
        <ttl>60</ttl>
        <item>
            <userIP>79.249.177.227</userIP>
            <userBrowser>Chrome</userBrowser>
            <userLanguage>Deutsch (Deutschland)</userLanguage>
            <userCity>Mering / Germany</userCity>
            <userRegion>Bayern</userRegion>
            <userLongitude>10,9833</userLongitude>
            <userLatitude>48,2667</userLatitude>
            <userTimeOffsetHours>2</userTimeOffsetHours>
            <userTimeOffsetMinutes>0</userTimeOffsetMinutes>
            <CurrentUTCTime>07.06.2011 09:40:14</CurrentUTCTime>
            <userTimeZone>
                (UTC+01:00) Amsterdam, Berlin, Bern, Rom, Stockholm, Wien
            </userTimeZone>
       </item>
    </channel>
</rss>

Quellen:

http://www.maxmind.com/app/geolitecity
http://de.googlemaps.subgurim.net/
http://lukencode.com/2010/05/19/ip-to-geo-location-in-asp-net-mvc/
http://www.aspcode.net/Creating-an-RSS-feed-for-your-ASPNET-site.aspx

Copyright:

Die Rechte der verwendeten Datenbanken und des UserControls liegt bei den Autoren.

Der angebotene RSS-Feed darf frei verwendet werden – eine Nennung der Quelle des Feeds bzw. der Adresse dieses Artikels wird vorausgesetzt.

Ein Dank geht an Sebastian Gross der mir einige Anregungen gegeben hat.

Dieser Service bleibt kostenlos, die Bedingungen zur Nutzung des RSS-Feed können sich jedoch jederzeit ändern.

Über den Autor

Michael Bernhard
Hobby-Programmierer von VB.NET, C# und ASP.NET Anwendungen. Hauptberuflich als Inbetriebnehmer bei der Böwe Systec GmbH beschäftigt. Vorzeigbare Projekte – TimeZone Notifier und TSV Neusäß Junioren.

Wieso das nützlich ist fragst du dich? Na ganz einfach, habt ihr schon mal die Methode String.toInt32() vermisst? Diese ist nur eine (sehr simple) Methode, die man häufiger gebrauchen könnte, die es aber nicht gibt. Diese könnte man sehr einfach mit einer Extension Method erweitern.

Als Beispiel möchte ich hier aber den Artikel von vor ein paar Tagen nehmen, wo wir eine Methode erstellt haben mit der man ein XmlElement in einem XmlDocument umbenennen konnte. Dies mussten wir machen, da die Klasse XmlDocument keine Methode dafür anbietet. Nun wollen wir mal die XmlDocument Klasse um diese Methode erweitern.

Das ganze funktioniert sehr einfach:

    public static class XmlDocumentExtension
    {
        public static bool RenameXmlElement(this XmlDocument doc,
                                            XmlElement oldElement,
                                            string newName) {
            try {
                //Neues XmlElement mit neuem namen anlegen
                XmlElement newElement = oldElement.OwnerDocument.CreateElement(newName);

                //Dem neuen XmlElement alle Attribute des alten Elements übergeben
                foreach (XmlAttribute a in oldElement.Attributes) {
                    newElement.SetAttributeNode((XmlAttribute)a);
                }

                //Dem neuen XmlElement alle Kinder Elemente des alten Elements anhängen
                foreach (XmlNode n in oldElement.ChildNodes) {
                    newElement.AppendChild(n.Clone());
                }

                oldElement.ParentNode.ReplaceChild(newElement, oldElement);
            } catch {
                return false;
            }

        return true;
        }
    }

Wir legen eine ganz normale Klasse an, diese kann heißen wie man will, ich habe sie hier nur zum besseren Verständnis so benannt. In der klasse legen wir nun die Funktion an um die wir unsere Klasse erweitern wollen. Hierbei ist wichtig, dass sowohl die Klasse als auch die Funktion als public und static markiert wird. Des Weiteren sollte man einen Verweis auf System.Code.dll setzen.

Bei der Deklaration der Funktion muss man dann angeben welche Klasse erweitert werden soll. Hier erweitern wir die Klasse XmlDocument weswegen vor diesem Parameter noch ein this steht. Dieser Parameter wird nur dazu benötigt und muss dann später bei dem Aufruf der Funktion nicht gesetzt werden.

Bild 1: Auch IntelliSense erkennt unsere Erweiterung an und bietet diese an

Natürlich bleibt die "original" Klasse XmlDocument unberührt von dieser Aktion und wird nur virtuell erweitert. Diese Erweiterung ist natürlich auch nur für das Aktuelle Projekt nutzbar.

Ich finde dieses Feature wirklich sehr nützlich und kann es euch deswegen auch nur empfehlen.

Denn wenn man mal einen Blick ins MSDN wirft wird man feststellen, dass diese Eigenschaft read-only ist! Das ist natürlich blöd, da man nun keinen einfachen Weg hat den Namen des Knotens zu ändern.

Wenn man diesen aber unbedingt ändern will muss man das über einen kleinen Umweg machen. Man muss ein neues XmlElement erstellen und dabei den Namen ändern, anschließend noch alle Attribute und Kinder-Elemente des alten Elements übernehmen und an der Stelle des alten wieder in das XmlDocument einfügen.

Bild 1: Struktur & Änderungswunsch

Konkret sieht das Ganze so aus: C#

        private void Form1_Load(object sender, EventArgs e) {
            //XmlDomument erstellen und eine Xml-Datei laden
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load(Application.StartupPath + "\\xml.xml");

            //Zur Demonstration die alte XML-Struktur ausgeben
            System.Console.WriteLine(xmlDoc.OuterXml);

            //Das Element das umbenannt werden soll heraussuchen
            XmlElement oldElement = (XmlElement)xmlDoc.GetElementsByTagName("books")[0];

            //Das herausgesuchte Element mit einem neuen Namen klonen
            XmlElement newElement = renameXmlElement(oldElement, "my-books");

            //Das alte Element mit dem neuen ersetzen
            oldElement.ParentNode.ReplaceChild(newElement, oldElement);

            //Kontrolle: Die neue Struktur ausgeben
            System.Console.WriteLine(xmlDoc.OuterXml);

            xmlDoc.Save(Application.StartupPath + "\\xml.xml");
        }

        public static XmlElement renameXmlElement(XmlElement e, string newname) {
            //Neues XmlElement mit neuem namen anlegen
            XmlElement newElement = e.OwnerDocument.CreateElement(newname);

            //Dem neuen XmlElement alle Attribute des alten Elements übergeben
            foreach (XmlAttribute a in e.Attributes) {
                newElement.SetAttributeNode((XmlAttribute)a);
            }

            //Dem neuen XmlElement alle Kinder Elemente des alten Elements anhängen
            foreach (XmlNode n in e.ChildNodes) {
                newElement.AppendChild(n.Clone());
            }

            //Das neue XmlElement zurückgeben
            return newElement;
        }

Und hier das Ganze noch mal in VB.NET:

Private Sub Form1_Load(sender As Object, e As EventArgs)
	'XmlDomument erstellen und eine Xml-Datei laden
	Dim xmlDoc As New XmlDocument()
	xmlDoc.Load(Application.StartupPath + "\xml.xml")

	'Zur Demonstration die alte XML-Struktur ausgeben
	System.Console.WriteLine(xmlDoc.OuterXml)

	'Das Element das umbenannt werden soll heraussuchen
	Dim oldElement As XmlElement = DirectCast(xmlDoc.GetElementsByTagName("books")(0), XmlElement)

	'Das herausgesuchte Element mit einem neuen Namen klonen
	Dim newElement As XmlElement = renameXmlElement(oldElement, "my-books")

	'Das alte Element mit dem neuen ersetzen
	oldElement.ParentNode.ReplaceChild(newElement, oldElement)

	'Kontrolle: Die neue Struktur ausgeben
	System.Console.WriteLine(xmlDoc.OuterXml)

	xmlDoc.Save(Application.StartupPath + "\xml.xml")
End Sub

Public Shared Function renameXmlElement(e As XmlElement, newname As String) As XmlElement
	'Neues XmlElement mit neuem namen anlegen
	Dim newElement As XmlElement = e.OwnerDocument.CreateElement(newname)

	'Dem neuen XmlElement alle Attribute des alten Elements übergeben
	For Each a As XmlAttribute In e.Attributes
		newElement.SetAttributeNode(DirectCast(a, XmlAttribute))
	Next

	'Dem neuen XmlElement alle Kinder Elemente des alten Elements anhängen
	For Each n As XmlNode In e.ChildNodes
		newElement.AppendChild(n.Clone())
	Next

	'Das neue XmlElement zurückgeben
	Return newElement
End Function

Kompliziert ist es natürlich nicht, aber trotzdem etwas ärgerlich, dass man diese Methode dann doch selber implementieren muss.

Wer öfter mal im Internet unterwegs ist, kennst sicherlich mehrere gute Gründe seine IP zu wechseln. Und das ist sehr einfach, denn alles was dafür nötig ist, ist eine erneute Einwahl ins Internet.

Dies kann man sehr einfach über die Benutzeroberfläche der FritzBox machen oder einfach "oldschool"-mäßig das Netzwerkkabel aus der FritzBox ziehen und wieder einstecken. (Letzteres erfordert ebenfalls keinen Benutzernamen und Passwort)

Doch wenn man des öfteren auf diese Funktionalität angewiesen ist, ist es doch relativ nervig und umständlich. Deswegen werden wir hier ein einfaches kleines Programm entwickeln, dass für uns den Router zu einer Neueinwahl ins Internet "zwingt".

Wie oben bereits erwöhnt heißt die Technologie dafür UPnP (Universal Plug and Play). Über diese Technologie lassen sich sehr viele Befehle an die Fritzbox senden, vorausgesetzt, man befindet sich in dem selben Netzwerk.

Von Statusabfragen über Auslastungen und Übertragung, lassen sich sogar Telefonnummern anwählen und Anrufe steuern, im Prinzip kann man alle Funktionen darüber ansteuern. Hier gibts eine nette Übersicht mit vielen Beispielen.

Wie werden die Anfragen eigentlich an die Fritzbox übertragen? Das geschieht sehr einfach über einen POST Aufruf, denn auf der Fritzbox (und auch auf den meisten anderen Routern) läuft ein kleiner Webserver denn man ganz einfach über den Browser erreicht, wenn man die adresse "fritz.box" in die Adresszeile tippt.

Dort ist die Fritzbox genauso aufgebaut wie eine gewöhnliche Webseite. Und diese nimmt auch POST und GET aufrufe entgegen. Genau hier setzen wir an und werden unsere Befehle rüber schicken.

        Dim client As New TcpClient

        client.Connect("fritz.box", 49000)

        Dim stream As NetworkStream = client.GetStream
        Dim bytes As Byte() = New Byte((My.Resources.msg.Length)) {}

        bytes = Encoding.ASCII.GetBytes(My.Resources.msg)

        stream.Write(bytes, 0, bytes.Length)
        bytes = New Byte(1024) {}

        Dim str As String = String.Empty

        Dim count As Integer = stream.Read(bytes, 0, bytes.Length)

        str = Encoding.ASCII.GetString(bytes, 0, count)

        stream.Close()
        client.Close()

Der Code ist sehr simpel, wir erstellen uns einen WebClient und verbinden uns mit der FritzBox. Nach der Verbindung senden wir ein POST Request raus und lesen anschließend die Antwort wieder aus.

Mit dem obigen Code senden wir folgenden Befehl an die Fritzbox:

POST /upnp/control/WANIPConn1 HTTP/1.1
HOST: fritz.box:49000
SOAPACTION: "urn:schemas-upnp-org:service:WANIPConnection:1#ForceTermination"
CONTENT-TYPE: text/xml ; charset="utf-8"
Content-Length: 293

<?xml version="1.0" encoding="utf-8"?>
<s:Envelope s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
   <s:Body>
      <u:ForceTermination xmlns:u="urn:schemas-upnp-org:service:WANIPConnection:1" />
   </s:Body>
</s:Envelope>

Wie man sieht ist der Befehl ein gewöhnlicher POST Aufruf inkl. Header. Dieser übergibt einen Befehl urn:schemas-"upnp-org:service:WANIPConnection:1#ForceTermination", der der Fritzbox sagt die Verbindung ins Internet neu aufzubauen.

Man muss hierbei sehr aufpassen, besonders die Content-Length Angabe muss genaustens passen, da sonst ein Fehler als Antwort eintrudelt.

Wie immer gibts auch eine kleine Demoanwendung.

Bild 1: Das Demo Programm in action

Download hier: Download [VS 2008 Projekt]

Diesesmal schreibt die API vor, dass man POST-Requests verwendet um der Seite Daten zu senden. Das macht die Sache etwas komplizierter, und dazu kommt noch, dass wir auch noch ein Bild verschicken müssen, also müssen auchnoch binäre Daten verschickt werden. Aber langsam, erstmal die Theorie!

Ihr kennt doch sicher die normalen Eingabemasken wie zB. die von imageshack.us. Diese besteht aus einem Dateiauswahlfeld, mehreren Checkboxen und einem Textfeld. Wer schonmal HTML gemacht hat wird wissen dass dieses Gebilde aus so genannten Interaktiven Elementen ein Formular darstellt welches nach dem Betätigen des Senden-Buttons an eine vorher definierte Adresse gesendet wird!

Dabei sendet der Browser einen HTTP POST-Request an den Server. Ein solcher Request besteht für gewöhnlich aus einem Kopf, den Daten und einem Fuß. So könnte zB. ein HTTP POST-Request aussehen:

POST /wiki/Spezial:Search HTTP/1.1
Host: de.wikipedia.org
Content-Type: application/x-www-form-urlencoded
Content-Length: 24
search=Katzen&go=Artikel

Der Server verwertet diese Daten dann und schickt eine Antwort. Je nachdem wie wir angefragt haben bekommen wir als Antwort eine XML-Struktur (Wie in den Letzten Beispielen) oder eine HTML Struktur. Die Kommunikation geschieht dabei auf dem HTTP Port 80 und läuft über das TCP Protokoll!

In den letzten beiden Teilen haben wir jeweils so genannte GET-Requests erstellt, bei denen nur der URL-Strang mit den Variablen versandt wurde.

Da wir aber nun ein Bild übertragen wollen, müssen wir versuchen ein POST-Request-Objekt zu erstellen, das wir dann an den TwitPic Server schicken können.

Unser POST-Objekt muss dabei folgende Daten übermitteln:

• Unseren Twitter Benutzernamen
• Unser Twitter Passwort
• Das Bild das wir einstellen wollen

Wenn wir diese Daten nun in unser Objekt verfrachten, müssen wir dafür sorgen, dass der Server später weis, was was ist und die Daten von einander trennen kann. Deswegen müssen wir für jeden Eintrag einen eigenen Head und Body erzeugen.

Das Bild muss dann auch in das binäre Format umgewandelt werden und dann mit den anderen Daten durch ein Strom an den Server gesendet werden! - Hört sich kompliziert an, ich weis aber es hält sich in Grenzen!

Hier erstmal der Code für das Hochladen des Objekts mit allen Daten und der Abruf der Antwort. Tipp: Ihr könnt den Code besser lesen, wenn ihr auf den Knopf oben rechts in der Code Darstellung klickt!

    Public Function uploadPic(ByVal pic As Byte(), ByVal filename As String, ByVal user As String, ByVal pass As String)
        Dim encoding As String = "iso-8859-1"

        'Erzeugen einer einzigartigen identifikation
        Dim gui As String = Guid.NewGuid().ToString()

        'Diese wird für den Header und den footer der Daten benötigt
        Dim head As String = String.Format("--{0}", gui)
        Dim foot As String = String.Format("--{0}--", gui)

        'Einen Stringbuilder erstellen, in dem wir nun bequem die
        'benötigten POST Daten speichern können
        Dim contents As StringBuilder = New StringBuilder()

        'Benutzerdaten schreiben (benutzername)
        contents.AppendLine(head)
        contents.AppendLine(String.Format("Content-Disposition: form-data; name=""{0}""", "username"))
        contents.AppendLine()
        contents.AppendLine(user)

        'Benutzerdaten schreiben (passwort)
        contents.AppendLine(head)
        contents.AppendLine(String.Format("Content-Disposition: form-data; name=""{0}""", "password"))
        contents.AppendLine()
        contents.AppendLine(pass)

        'Header schreiben
        contents.AppendLine(head)
        'Bildinformationen schreiben, Bildkopf und die Binärdaten
        Dim fileHeader As String = String.Format("Content-Disposition: file; name=""{0}""; filename=""{1}""", "media", filename)
        Dim fileData As String = System.Text.Encoding.GetEncoding(encoding).GetString(pic)

        'Informationen zu dem Übergebenen Dateityp schreiben
        contents.AppendLine(fileHeader)
        contents.AppendLine(String.Format("Content-Type: {0}", "image/jpeg"))
        contents.AppendLine()
        contents.AppendLine(fileData)

        'Durch schreiben des footers signalisieren dass keine Daten mehr kommen
        contents.AppendLine(foot)

        MessageBox.Show(contents.ToString)

        'Stream Reader zum lesen der Antwort von Twitpic
        Dim reader As StreamReader
        Dim result As String
        Dim response As HttpWebResponse

        'Einen Webrequest zu der TwitPic API erstellen
        Dim request As HttpWebRequest = WebRequest.Create("http://twitpic.com/api/upload")

        'Die Auflagen die in der API beschreiben sind erfüllen:
        'API-Zitat:
        '---
        'Fields to post in:
        '(post data should be formatted as multipart/form-data)
        '---
        request.ContentType = String.Format("multipart/form-data; boundary={0}", gui)
        request.Method = "POST"

        'Die Daten die noch im Stringbuilder als String vorliegen
        'in das byte (Binär)-Format umwandeln, damit die API diese annimt
        Dim bytes As Byte() = System.Text.Encoding.GetEncoding(encoding).GetBytes(contents.ToString())
        request.ContentLength = bytes.Length

        'Einen Stream aus dem WebRequest erstellen
        Dim writer As Stream = request.GetRequestStream()

        'Die Binären Daten in den Strom schreiben
        writer.Write(bytes, 0, bytes.Length)
        response = request.GetResponse()

        'Antwort von Twitpic empfangen
        reader = New StreamReader(response.GetResponseStream)
        result = reader.ReadToEnd

        reader.Close()

        Return result
    End Function

Wenn ihr diesen Code ausführt, wird ein POST-Objekt erzeugt und an den TwitPic Server gesendet. Dabei werden diese Informationen übermittelt. (Bild 1)

Man sieht ganz klar die Aufteilung. Der Kopf der aus der UID und den Meta Daten besteht und der Body, der nur den Wert beinhaltet.

Das Bild das ich hier sende hat einen etwas größeren Kopf, scheint dafür aber einen sehr kleinen Body zu haben. Ich kann euch beruhigen, das ist nur so, weil Windows, oder das MessageBox Objekt keine Binäre Darstellung von Zeichen beherrscht.

Eigentlich kommt dadrunter noch ein Footer (Fuß), aber dieser wird wegen der binären Daten abgeschnitten!

Natürlich bekommt man auch eine Antwort, in diesem Fall eine im XML-Format. Diese beinhaltet entweder die Erfolgsmeldung oder eine Fehlermeldung mit einer Kurzen Beschreibung, woran es lag. An Bild 2 könnt ihr erkennen wie so ein Fehler aussehen könnte!

Wenn kein Fehler kommt steht dort dementsprechend die URL zum Bild statt der Fehlermeldung!

Wenn ihr nicht direkt den Code versteht ist das nicht schlimm. Man sollte ersteinmal wissen was der Browser da bei jedem Klick eigentlich hin- und herschickt. Dazu kann ich den Wikipedia-Artikel empfehlen. Es schadet auch nicht, weitere Beispiele anzuschauen bei denen mit HTTPWebRequest gearbeitet wird. ZB Hier oder Hier. (leider alles in C#)

Zum Schluss sei hier noch gesagt, dass die TwitPic API noch weitere Möglichkeiten bietet, wie zB. das Anfertigen von Vorschaubildern oder das Anhängen von Tweets an das Bild sodass automatisch auch euer Twitter Status mit dem neuen Bild aktualisiert wird!

Bild 3: Das Demoprojekt in Aktion

Wie immer könnt ihr euch auch das Demoprojekt herunterladen: Download

Ich hoffe das Beispiel hat euch gefallen und freue mich auf euer Feedback!

Ersteinmal die Frage "warum überhaupt bit.ly? Ich habe doch tinyurl.com!"

Nun das ist einfach, denn bit.ly bietet einen größeren Featureumfang. Dawäre:

• Eigene Accounts
• Linkmonitoring (wie oft wurde mein Link geklickt)
• Statistiken
• Erweiterte Abfragen und Parameter
• Kürzerer Name (bit.ly = 6 Zeichen | tinyurl.com = 11 Zeichen)

Allgemein kann man sagen, bit.ly ist professioneller aufgelegt! Aber mit einem höherem Featureumfang wird die Benutzung der APIs auch etwas komplexer.

An die API-Dokumentation von bit.ly kommt man sehr einfach in dem man auf deren Homepage ganz unten auf "API" klickt und dann dem gezeigten Link folgt. Hier findet man eine Komplette Dokumentation aller Möglichkeiten.

Was direkt auffällt ist, dass es viele verschiedene Funktionen gibt und die URL die wir benutzen müssen viel länger ist.

Das was aber auch sehr wichtig ist, ist dass man diesen Dienst nicht anonym benutzen kann, sondern sich einen Account erstellen muss um einen Sogenannten API-Key zu erhalten. Das ist hauptsächlich dafür da, um Missbrauch der Seite zu verhindern (zB. Spam).

Die Registrierung geht sehr schnell nach der Eingabe von Benutzername, E-Mail und Passwort. Wenn mann dann eingeloggt ist muss man folgende Seite aufrufen: http://bit.ly/account/your_api_key/ hier findet man seinen API-Schlüssel, den man unbedingt braucht, um URLs zu generieren, also aufschreiben!

ACHTUNG: In meinem Beispiel hier verwende ich den Demo-API-Schlüssel von bit.ly, der auch in der Doku steht. Wenn ihr was eigenes macht müsst ihr euch unbedingt registrieren!

Hat man das einmal geschafft kann man mit dem Programmieren loslegen:

    Public Function shortURL(ByVal langeURL As String)
        Dim retVal As String = ""

        'Für dem API Aufruf wird benötigt:
        '-> Die Versionsnummer (version)
        '-> ein Benutzername (login)
        '-> ein API-Schlüssel (apiKey)

        'Den API-Aufruf starten:
        Dim myRequest As WebRequest = WebRequest.Create _
            ("http://api.bit.ly/shorten?" & _
            "version=2.0.1" & _
            "&format=xml" & _
            "&longUrl=" & langeURL & _
            "&login=bitlyapidemo" & _
            "&apiKey=R_0da49e0a9118ff35f52f629d2d71bf07")

        Dim myResponse As WebResponse = myRequest.GetResponse

        'Den erzeugen Strom auslesen
        Dim myReader As StreamReader = _
                New StreamReader(myResponse.GetResponseStream)

        'Stream auslesen
        retVal = myReader.ReadToEnd

        myReader.Close()

        Return retVal
    End Function

Wie man sieht hat sich unser Code kaum verändert! Ich habe hier nur dem Link etwas angepasst, und um folgende Punkte erweitert:

• Version (Die Version der API, muss laut Doku mit angegeben werden!)
• Format (Gibt das Format an, das für die Antwort verwendet werden soll)
• Login (Der Benutzername von unserem Account)
• APIKey (Der API-Schlüssel, den wir erhalten haben)
• longURL (Und die zu kürzende URL)

Was hier wichtig ist, ist das Format. Hier hat man die Wahl zwischen XML und "json", wobei ich euch XML empfehlen würde, da es einfach übersichtlicher und einfacher verwendbar ist!

Wenn wir nun einen Request mit diesem langen Link erstellen erhalten wir auch eine Antwort im XML oder json Format:

Bild 1: Die zwei Rückgabetypen von bit.ly

Wie man sieht erhalten wir hier anders als bei tinyurl.com nicht direkt die kurze URL, sondern einen Haufen Informationen, wie Fehlercode, Fehlernachricht etc...

Uns interessiert aber natürlich nur die neue kurze URL, also müssen wir diese ersteinmal aus dem XML Durcheinander auslesen. Dazu habe ich diese Funktion erstellt:

    Public Function extractURL(ByVal response As String)
        'Ein XML-Dokument anhand der Antword von bit.ly erstellen:
        Dim myDoc As New XmlDocument
        myDoc.LoadXml(response)

        'Nun nehmen wir uns das Element raus, in dem die
        'neue kurze URL steht:
        Return myDoc.SelectSingleNode("/bitly/results/nodeKeyVal/shortUrl").InnerText
    End Function

Hier wird einfach nur ein XML-Dokument erzeugt (aus der Antwort) und dann der entsprechende Node ausgelesen!

Ein Hinweis noch: In der Doku wird weiterhin erwähnt, dass man nur ein bengenztes Kontingent an API-Aufrufen hat. Wenn man die API viel nutzen will sollte man sich bei bit.ly melden!

Auch hierzu habe ich ein Kleines Demoprogramm angefertigt:

Bild 2: Der uRL-Kürzer in Aktion

Download Hier: Download

Hat euch der Beitrag gefallen? Ich freu mich auf euer Feedback!

Jetzt hatte ich Zeit und habe die Klasse um die entsprechenden Funktionen erweitert, sodass es nun möglich ist einen ganzen Baum in einer XML Datei abzulegen.

Warum habe ich das nicht gleich so gemacht? Ganz einfach weil ich das nicht brauchte! Und es eigentlich sinnvoller finde die TreeNodes einzeln zu speichern!

Außerdem besteht beim Speichern einer TreeView ein großes Problem! Ansich eignet sich die Struktur einer TreeView perfekt um diese in einer XML Datei abzubilden. Nun kommt aber das Problem ins Spiel, dass eine TreeView mehrere "Kern" (root)-Äßte haben kann. Einer XML erlaubt das aber nicht. Eine XML Datei darf exakt eine Root-Node besitzen!

Wie umgeht man nun dieses Problem? Ich habe das so geregelt, dass ich einfach eine eigene Root-Node erstelle in die ich dann die Root-Nodes aus der TreeView einfüge die exportiert werden soll. Diese habe ich dementsprechend "rootNode" genannt! Also nicht erschrecken, wenn ihr in euren XML Files diese Fremde Node findet, diese wird beim Einlesen natürlich nicht mit eingelesen!

Ansonsten ähneld der neue Code sehr dem alten. Wie immer könnt ihr mir gerne Kommentare mit Bugs, Fehlern und Wünschen schreiben. Viel Spaß beim Testen und benutzen! Ich habe die Klasse wie auch letztes mal in ein Demoprojekt verpackt damit man die neuen Funktionen gleich live erleben kann! Wenn ihr nur auf die Klasse scharf seit, dann kopiert sie einfach aus dem Projektordner in euer eigenes Projekt!

Bei Weiteren Fragen schreibt mir bitte eine Mail!

Download: XMLParser v. 1.1

TreeViews sind ja nichts anderes als Ordner-Bäume. Diese Struktur eignet sich natürlich sehr für XML. Das .NET Framework bietet hier einige sehr bequeme Möglichkeiten um XML Dateien zu erzeugen, zu bearbeiten und einzulesen!

Um das zu demonstrieren habe ich eine VB.NET Klasse angefertigt, die diese Aufgaben für uns übernimmt, also das Abspeichern einer TreeView in einer XML Datei und auch das einlesen eines XML-Baums in eine TreeView.

Die Klasseheißt XMLParser und bietet zur Zeit genau 2 Funktionen nämlich zum Exportiren und Importieren von TreeNodes.

Ihr könnt diese Klasse sehr einach in euer eigenes Projekt Importiren und gleich loslegen! Dazu einfach im Projektmappen-Explorer auf euer Projekt rechtsklicken und über "Hinzufügen"->"Klasse" die XMLParser Klasse hinzufügen.

Ich habe die Anwendung möglichst einfach gehalten, sodass alle Aufrufe maximal eine Zeile in Anspruch nehmen:

Wie man sieht ist die Benutzung sehr einfach gehalten. Desweiteren kann man in dieser Version "nur" TreeNodes abspeichern, will man also eine Komplette TreeView abspeichern muss man mit eine Schleife alle Root-Nodes durchlaufen!

Natürlich können auch XML-Dateien eingelesen werden, die nicht vom XMLParser erzeugt wurden, wie zum Beispiel Config-Dateien oder "richtige" XML-Dateien!

Ich werde mit der Zeit die Funktionalität der Klasse erweitern, sodass auch ganze TreeViews gespeichert und eingelesen werden können. Und auch Merging (deu: Vereinigen) und Synchronisieren wird möglich sein!

Desweiteren werden ich weitere Überladungen einbauen, sodass die Funktionen weiterhin so übersichtlich sein werden!

Wenn ihr Interesse habt könnt ihr euch hier ein Demoprojekt inklusive der Klasse herunterladen.

Dieses Demoprojekt herunterladen: Download