Sonntag, 29. April 2012


Artikel

Februar 2010 | Artikel

Twittern mit .NET

(Link zum Artikel: http://www.entwickler.de///002881)

Get Socialized!

Text: Mario Fraiß
  • Teilen
  • kommentieren
  • empfehlen
  • Bookmark and Share
In der heutigen Zeit scheint es schier unmöglich geworden zu sein, ihnen zu entkommen. Dabei ist es nicht entscheidend, ob die neuesten Nachrichten und E-Mails abgerufen werden, man sich mit FreundInnen in virtuellen Gruppen unterhält, interaktiv an TV-Sendungen teilnehmen möchte oder einfach nur im Internet umhersurft. Sie haben unsere Gesellschaft und unsere alltägliche Internetnutzung entscheidend beeinflusst und werden dies auch morgen noch tun – die Rede ist von den so genannten Social Networks bzw. Social Services, die besonders im Laufe des letzten Jahres zu einem fixen Bestandteil der heutigen Netzkultur avanciert sind. Einer dieser angebotenen Dienste ist twitter.com. Eine Möglichkeit, der ganzen Welt mitzuteilen, womit man gerade beschäftigt ist. Dieser Artikel zeigt Ihnen, wie einfach Sie auch Ihre Anwendungen schon bald „twittern“ lassen können.

Ob Facebook, Twitter, StudiVZ und Co., einer der Trendbegriffe neben Cloud Computing und Virtualization ist definitiv das Social Web. In direkter Verbindung damit stehen die so genannten Social Networks, Social Services oder auch die Social Apps. In den letzten 24 Monaten haben derartige Dienste und Internetanwendungen einen enormen Hype ausgelöst und unterliegen derzeit einem nicht übersehbaren Boom. Nicht weiter verwunderlich ist es, wenn immer mehr Unternehmen erkennen, dass es sinnvoll ist, das Potenzial dieser etablierten Dienste auch in eigenen Anwendungen und Angeboten zu integrieren, um auf diese Weise völlig neue Ziel- und Kundengruppen anzusprechen. Die Praxis zeigt, dass all diese Unternehmen mit dieser Strategie voll dem Trend der heutigen Internetgesellschaft folgen und mit dem richtigen Konzept damit auch entsprechenden Erfolg erzielen können. Im Laufe dieser zweiteiligen Artikelreihe werden Sie erkennen, dass die Anbindung an solche Dienste auf schnelle und einfache Weise erfolgen kann. Die beste Hilfestellung dazu bieten in erster Linie Developer-Portale, die von den meisten Herstellern der entsprechenden Social Services bereitgestellt werden – aber auch zahlreiche freie Werkzeuge und Communities. Im ersten Teil dieser zweiteiligen Artikelserie beschäftigen wir uns mit dem mittlerweile sehr populären Social Service Twitter. Dazu betrachten wir das frei verfügbare Twitter-API und sehen uns ergänzend dazu kostenlose Werkzeuge und Hilfsmittel sowie passende SDKs an. Am Ende sollten Sie in der Lage sein, Ihre eigenen Applikationen, seien es Client- oder Webanwendungen, innerhalb kürzester Zeit an Twitter anzubinden, denn genau das ist Ihr Ziel – Twittern mit dem Microsoft .NET Framework.

Über Twitter

Was mit einem einfachen Online-Service begonnen hat, wird heute von Millionen von Internetusern genutzt. Die Grundidee ist einfach, nämlich einen Dienst anzubieten, mit dessen Hilfe es möglich ist, anderen mitzuteilen, was man gerade macht. Gekennzeichnet und hervorgehoben durch das mittlerweile zum De-facto-Standard gewordene # und im Rahmen vieler populärer Angebote zu finden – die Twitter-Channels. Dabei spielt es keine Rolle, ob von Reisen, Veranstaltungen, über Produkte oder aktuelle Firmenereignisse berichtet wird. Es wird getwittert und gebloggt, was das Zeug hält. Erstellt werden die Einträge meistens live, über Computer, Netbooks und seit einiger Zeit auch über Handys. Denn auch Mobilfunkhersteller haben erkannt, dass sie sich dem Bedürfnis zu „Zwitschern“ nicht entziehen sollten.

Für die Nutzung und Kommunikation mit Twitter aus eigenen Applikationen heraus ist es notwendig, das Twitter-API zu nutzen. Einen einfachen und guten Einstieg zur Programmierung damit bietet das von Twitter eigens für Entwickler angebotene Twitter-API-Wiki. Dort finden Sie neben der vollständigen Dokumentation zum API auch eine Auflistung von nützlichen Ressourcen sowie Informationen hinsichtlich der letzten Entwicklungen seitens Twitter. Außerdem ist es dort möglich, Implementierungen des API für alle erdenklichen Programmiersprachen zu beziehen. Eine umfassende Übersicht bereits existierender Wrapper-Klassen des Twitter-API für die unterschiedlichsten Programmiersprachen finden Sie unter Auflistung verschiedener Twitter-APIs. Eine Auflistung vorhandener .NET-Implementierungen des Twitter-API sehen Sie in Tabelle 1.

Um erweiterte Mechanismen wie etwa die Authentifizierungsmethode OAuth, die ebenfalls von Twitter unterstützt wird, nutzen zu können, ist es Voraussetzung, die eigene Applikation bei Twitter zu registrieren, um dadurch eine so genannte Twitter Source ID zu erhalten, doch mehr dazu im Laufe des Artikels. Um die Beispiele nachvollziehen zu können, benötigen Sie einen aktiven Twitter-Account. Sollten Sie noch keinen besitzen, registrieren Sie sich bitte jetzt unter www.twitter.com.

Bezeichnung URL
CSharpTwitt http://code.google.com/p/csharptwitt/
LINQ to Twitter http://linqtotwitter.codeplex.com/
TweetSharp http://tweetsharp.com/
Twitterizer http://code.google.com/p/twitterizer/
TwitterooCore API http://rareedge.com/twitteroo/blog/
Yedda Twitter Library http://devblog.yedda.com/index.php/twitter-c-library/
Hello Twitter

Nach dieser kurzen Einführung starten Sie mit Ihrem ersten Beispiel: Hello Twitter! Dazu werden Sie eine Applikation in C# und mithilfe von Microsoft Visual Studio realisieren. Erzeugen Sie dazu ein neues Windows-Forms-Projekt. Platzieren Sie darauf drei Standard-Textboxen und einen Button. Diesen soeben erzeugten Steuerelementen geben Sie bitte folgende Namen:

  • txtTwitterUserName
  • txtTwitterUserPassword
  • txtTwitterUserMessage
  • btnTwitterTweetMessage

Damit ist das UI (User Interface) Ihrer ersten Twitter-Applikation fertiggestellt. Wenn Sie möchten, können Sie noch einige Labels hinzufügen, um die Anwendung etwas benutzerfreundlicher zu gestalten. Ihre Anwendung sollte nach Erstellung aller Steuerelemente in etwa so aussehen wie in Abbildung 1 zu sehen.

In unserem Beispiel werden wir für die direkte Anbindung an Twitter die Implementation Twitterizer nutzen. Zu diesem Zweck laden Sie bitte die aktuelle Version des Frameworks unter .NET-Twitter-Framework Twitterizer herunter. Kopieren Sie im Anschluss die im Framework enthaltene Datei Twitterizer.Framework.dll in das Projektverzeichnis des von Ihnen erstellten Windows-Forms-Projekts und definieren Sie einen Verweis auf die soeben kopierte Datei. Dadurch erhalten Sie Zugriff auf die Objekte des Frameworks (Abb. 2).

Im nächsten Schritt werden Sie den Code erzeugen, um innerhalb der Applikation Statusnachrichten an einen bestimmten Twitter-Account zu übermitteln. Dazu erstellen Sie für die zuvor erzeugte Schaltfläche btnTwitterTweetMesssage eine Ereignisbehandlungsroutine. Für die Kommunikation mit Twitter benutzen Sie das Twitter-Objekt, das durch Twitterizer zur Verfügung gestellt wird. Für eine erfolgreiche Verbindung ist es lediglich notwendig, Benutzername und Passwort eines beliebigen Twitter-Accounts zu übergeben. Die Aktualisierung des Twitter-Status ist im Anschluss durch Nutzung der Methode Update der gleichnamigen Eigenschaft Status des von uns instanziierten Twitter-Objekts (Listing 1) möglich.

Listing 1: Aktualisierung des Twitter-Status

  1. private void tnTwitterTweetMessage_Click(object sender, EventArgs e)
  2. {
  3. //Authentifizierung mit Benutzername und Passwort
  4. Twitter twitterClient = new Twitter(txtTwitterUserName.Text, txtTwitterUserPassword.Text);
  5. //Aktualisierung des Status
  6. twitterClient.Status.Update(txtTwitterTweetMessage.Text);
  7. }

Starten Sie jetzt Ihre Applikation, geben Sie Ihre Anmeldedaten sowie eine beliebige Nachricht in die dafür vorgesehen Felder ein und twittern Sie mit .NET. Besuchen Sie jetzt Ihre Twitter-Seite und Sie werden sehen, dass der Status bereits aktualisiert wurde (Abb. 3).

Das soeben erstellte Hello-Twitter-Beispiel zeigt sehr deutlich, wie einfach die Anbindung an Twitter mithilfe von .NET realisiert werden kann.

Anwendungstypen

Im Umgang mit Twitter unterscheidet man zwischen den folgenden zwei Anwendungstypen:

  • nicht registrierte Applikation
  • registrierte Applikation

Bis jetzt ist Hello Twitter eine nicht registrierte Anwendung. Der Unterschied zwischen registrierten und nicht registrierten Anwendungen besteht darin, dass registrierte Applikationen eine so genannte Twitter-Application-Source-ID erhalten. Diese ID ist weltweit einmalig. Mit deren Hilfe ist es möglich, bei der Übermittlung einer Nachricht an einen Twitter-Account den registrierten Anwendungsnamen zu übertragen. Beachten Sie aber, dass diese Art der Übermittlung nur bei der Nutzung von OAuth zur Authentifikation möglich ist. Besonders interessant ist das vor allem für professionelle Businessanwendungen, denn dadurch ist innerhalb einer Twitter-Profil-Seite sofort ersichtlich, mit welcher Anwendung die Nachricht übermittelt bzw. der Status aktualisiert wurde. Bitte registrieren Sie Ihre Anwendung jetzt unter Registrierung einer Twitter-Anwendung. Achten Sie darauf, dass Sie bei der Registrierung der Anwendung als Application Type Client wählen und den Default Access Type auf Read & Write einstellen. Nach erfolgreichem Abschluss der Registrierung erhalten Sie folgende, auf Ihre Anwendung bezogene, Informationen:

  • Consumer Key
  • Consumer Secret

Diese Schlüssel werden zur Nutzung von OAuth als Methode zur Authentifikation mit Twitter benötigt. Im nächsten Abschnitt werden Sie Ihre Anwendung Hello Twitter um die OAuth-Funktionalität erweitern. Im Detail werden Sie erfahren, wie Sie sich mit Ihrer Anwendung erfolgreich über OAuth an Ihrem Twitter-Account authentifizieren und Ihren Status aktualisieren können. Zum Abschluss werden Sie noch lernen, wie Sie auf bestimmte Objekte Ihres Profils zugreifen und sie auslesen können.

Sichere Anmeldung mit OAuth

Das von Ihnen bis jetzt eingesetzte Framework Twitterizer ist für den Einstieg zwar sehr gut geeignet, unterstützt aber bspw. keine Authentifizierung über OAuth. Deswegen werden Sie im zweiten Beispiel, das auf der Anwendung Hello Twitter aufbaut, die Twitter-Implementierung TweetSharp einsetzen. Laden Sie dazu bitte die entsprechende Bibliothek von .NET-Twitter-Framework TweetSharp herunter, kopieren Sie alle im Archiv enthaltenen Dateien in Ihr Windows-Forms-Projektverzeichnis und definieren Sie einen Verweis auf die Datei Dimebrain.TweetSharp.dll, um auf alle erforderlichen Objekte und Methoden zugreifen zu können. Erweitern Sie die vorhandene Anwendung jetzt um drei Schaltflächen sowie eine Textbox und geben Sie den Steuerelementen die folgenden Namen:

  • btnDoOAuth
  • btnConfirmOAuthPin
  • btnTweetMessageViaOAuth
  • txtOAuthPIN

Sie werden jetzt Schritt für Schritt die Authentifizierung über OAuth unter Einsatz der Library TweetSharp implementieren. Zu diesem Zweck ist es notwendig, den gesamten Ablauf und die Funktionsweise eines Standard-OAuth-Anmeldeprozesses zu verstehen, weshalb dieser vereinfacht in Abbildung 4 dargestellt ist.

Wissenswertes über OAuth

OAuth stellt eine einfache und sichere Möglichkeit dar, um mit geschützten und vertraulichen Daten aus externen Applikationen innerhalb der eigenen Applikation zu arbeiten. Der Fokus liegt dabei auf dem Schutz der Anmeldeinformationen der jeweiligen Nutzer. In diesem Kontext werden aus Entwicklersicht von OAuth folgende Applikationen unterstützt:

  • Desktopanwendungen
  • Dashboard-Widgets und Gadgets
  • JavaScript- und/oder browserbasierte Anwendungen
  • Website-Widgets

Anzumerken ist, dass OAuth nicht nur für Anwendungsentwickler, sondern auch für Entwickler von Web Services und Serviceprovider interessant sein kann, da das umfassende Sicherheitskonzept in eigene Webapplikationen, Server-Side-APIs und auch in Mashups integriert werden kann. Besonders ratsam ist der Einsatz vor allem dann, wenn es erforderlich ist, sensible benutzerbezogene Daten zu speichern und kontrolliert bestimmten Drittanwendungen zur Verfügung zu stellen. Personen, die sich für die Umsetzung eigener OAuth-Projekt interessieren, finden im Beginner’s Guide to OAuth, der unter http://hueniverse.com/oauth/" zu finden ist, einen umfassenden und guten Einstieg in das Thema.

Zu Beginn ist es notwendig, eine Verbindung mit dem OAuth-Service, der von Twitter angeboten wird, herzustellen, um den so genannten RequestToken anzufordern. In der Regel ist dieser Service unter http://twitter.com/oauth/request_token zu erreichen. Der RequestToken ist Teil des OAuth-Authentifizierungsprozesses und wird für alle weiteren Vorgänge benötigt. TweetSharp bietet für die Anforderung des RequestTokens eine passende Methode, die dazu dient, den eigenen ConsumerKey und das ConsumerSecret zu übertragen. Zur Erleichterung des Umgangs mit den für die Authentifizierung notwendigen Daten und Informationen dient das Objekt TwitterClientInfo. Dessen Einsatz empfiehlt sich sehr, da es dadurch nicht notwendig ist, bei jedem Funktionsaufruf ConsumerKey und ConsumerSecret mit zu übergeben. Stattdessen wird jeweils auf eine Instanz vom Typ TwitterClientInfo verwiesen, die zuvor mit den entsprechenden Daten gefüllt wurde.

Im nächsten Schritt ist es erforderlich, vom Twitter-OAuth-Service einen zum RequestToken passenden SecretPIN anzufordern. TweetSharp unterstützt diesen Mechanismus in der Form, die entsprechende Response-Website, normalerweise http://twitter.com/oauth/ authorize, im lokalen Standardbrowser zu öffnen, um den SecretPIN anzuzeigen. Da dieser erst zur Laufzeit und auf einem entfernten Server generiert wird, ist es unumgänglich, den Benutzern Ihrer Applikation eine Möglichkeit zu bieten, den SecretPIN einzugeben. Dafür dient in diesem Fall die neu hinzugefügte TextBox. Nach erfolgreicher Eingabe des SecretPIN in die dafür vorgesehene TextBox und der Übertragung dieser Geheimzahl an den Twitter-OAuth-Service durch Betätigung der Schaltfläche btnConfirmOAuthPIN wird ein entsprechender AccessToken zurückgegeben und der OAuth-Authentifizierungsvorgang ist erfolgreich abgeschlossen. Erst nach Abschluss dieses Vorgangs ist es z. B. möglich, den Status zu aktualisieren. Für den Erfolg aller zukünftigen TweetSharp-Methodenaufrufe ist es entscheidend, den durch den Twitter-OAuth-Service erhaltenen AccessToken mit zu übergeben (Listing 2).

Das Besondere der Art und Weise der erneuten Implementierung der Statusaktualisierung ist die Tatsache, dass diesmal auch die ID Ihrer registrierten Twitter-Anwendung bekannt ist. Dadurch wird bei der Veröffentlich des Status auch der Name der Anwendung übertragen und ist daher auf der Twitter-Profilseite unter dem Statuseintrag ersichtlich (Abb. 5).

Listing 2: Übergabe des AccessTokens

  1. //TweetSharp-Objekt zum Speichern clientbezogener Informationen
  2. private TwitterClientInfo twitterClientInfo = new TwitterClientInfo();
  3. //ConsumerKey
  4. private String twitterConsumerKey = "YOUR_KEY";
  5. //ConsumerSecret
  6. private String twitterConsumerSecret = "YOUR_SECRET";
  7. //RequestToken
  8. private OAuthToken twitterRequestToken;
  9. //AccessToken
  10. private OAuthToken twitterAccessToken;
  11. private void btnDoOAuth_Click(object sender, EventArgs e)
  12. {
  13. //Speichern von ConsumerKey und ConsumerSecret zum vereinfachten Abrufen von Daten
  14. twitterClientInfo.ConsumerKey = twitterConsumerKey;
  15. twitterClientInfo.ConsumerSecret = twitterConsumerSecret;
  16. //Anforderung des RequestToken
  17. twitterRequestToken = FluentTwitter.CreateRequest(twitterClientInfo).Authentication.GetRequestToken().Request().AsToken();
  18. //Aufforderung zum Erhalt der OAuth-SecretPIN durch Twitter
  19. FluentTwitter.CreateRequest(twitterClientInfo).Authentication.AuthorizeDesktop(twitterRequestToken.Token).Request();
  20. }
  21. private void btnConfirmOAuthPIN_Click(object sender, EventArgs e)
  22. {
  23. //Anforderung des OAuth-AccessTokens durch Twitter
  24. twitterAccessToken = FluentTwitter.CreateRequest(twitterClientInfo).Authentication.GetAccessToken(twitterRequestToken.Token, txtOAuthPIN.Text).Request().AsToken();
  25. }
  26. private void btnTweetMessageViaOAuth_Click(object sender, EventArgs e)
  27. {
  28. //Status Aktualisierung über OAuth durchführen
  29. FluentTwitter.CreateRequest(twitterClientInfo).AuthenticateWith(twitterAccessToken.Token, twitterAccessToken.TokenSecret).Statuses().Update(txtTwitterTweetMessage.Text).AsJson().Request();
  30. }

Zum Abschluss des Beispiels werden Sie auf Eigenschaften und Objekte Ihres Twitter-Profils zugreifen. Zu diesem Zweck erweitern Sie bitte Ihre bestehende Hello-Twitter-Anwendung um eine Schaltfläche btnLoadStatuses und eine ListBox lstStatuses. Durch die von TweetSharp zur Verfügung gestellten Schnittstellen ist es ein Leichtes, auf Ihr Profil sowie auf Ihre bisherigen Statuseinträge zuzugreifen und diese beispielsweise in einer ListBox anzuzeigen (Listing 3).

Sie sollten jetzt, nach dem Erstellen und Nachvollziehen der Beispielanwendung, in der Lage sein, jede beliebige .NET-Anwendung erfolgreich mit Twitter zu verbinden. Die in diesem Beispiel eingesetzten Bibliotheken vereinfachen diese Integrationsaufgabe um ein Vielfaches als dies ansonsten der Fall wäre. Sollten im Rahmen der Implementierung dennoch Probleme aufgetreten sein, finden Sie für alle Fälle sämtliche Sourcecodes sowie ein fertiges Visual-Studio-Musterprojekt auf meinem Blog.

Listing 3: Anzeige der Statuseinträge in einer ListBox

  1. private void btnLoadStatuses_Click(object sender, EventArgs e)
  2. {
  3. lstStatuses.Items.Clear();
  4. //Abrufen der Profildaten
  5. TwitterUser profile = FluentTwitter.CreateRequest(twitterClientInfo).AuthenticateWith(twitterAccessToken.Token, twitterAccessToken.TokenSecret).Account().VerifyCredentials().Request().AsUser();
  6. //Abrufen aller Status-Einträge
  7. IEnumerable<TwitterStatus> statuses = FluentTwitter.CreateRequest(twitterClientInfo).AuthenticateWith(twitterAccessToken.Token, twitterAccessToken.TokenSecret).Statuses().OnUserTimeline().Request().AsStatuses();
  8. //Ausgabe der Status-Einträge
  9. foreach (TwitterStatus status in statuses)
  10. {
  11. lstStatuses.Items.Add(String.Format("[{0}] - {1}", status.CreatedDate.ToLongDateString(), status.Text));
  12. }
  13. }
Fazit

Erfreulicherweise stellt Twitter.com ein entsprechendes freies, auf REST basierendes API zur Kommunikation mit den angebotenen Web Services und Twitter-Diensten zur Verfügung. Ergänzend dazu wird eine umfangreiche und vollständige Dokumentation angeboten, um den Einstieg möglichst einfach zu gestalten. Die zunehmende Popularität von Twitter hat letzten Endes auch dazu geführt, dass in der Zwischenzeit viele unterschiedliche Open-Source-Implementierungen des Twitter-APIs existieren, die das Angebot abrunden. Das führt dazu, dass Entwickler, die sich in die Thematik einarbeiten möchten, keinerlei Schwierigkeiten haben sollten. Mit dem im Praxisbeispiel vermittelten Wissen sollte es zukünftig keine Herausforderung für Sie darstellen, Ihre .NET-Anwendungen mit Twitter-Funktionalität auszustatten – Sie haben Ihr Ziel erreicht, denn Sie Twittern mit .NET. Freuen Sie sich auf die Fortsetzung dieses Themas, denn im zweiten Teil dieser Artikelserie erwartet Sie die spannende Welt der Social Communities mit dem besonderen Fokus auf Facebook. Sollten Sie Anregungen oder Fragen zu diesem Artikel haben, so sind Sie herzlich dazu eingeladen, mich unter meiner E-Mail-Adresse m.fraiss@fraiss.at oder über meinen Blog zu kontaktieren.

Mario Fraiß ist Gründer und Inhaber der FRAISS – IT Consulting und Mediendesign, ein auf Softwareentwicklung und Technologieinnovation spezialisiertes Unternehmen mit Sitz in Graz, Österreich. Zusätzlich arbeitet er seit mehr als acht Jahren als freiberuflicher Consultant, Trainer und Autor mit dem Schwerpunkt Softwareentwicklung unter .NET, bietet aber ergänzend dazu Expertise im Java-Umfeld und weiteren Programmiersprachen. Er betreut mittelgroße bis große Unternehmen und war unter anderem bereits als Technologieberater für Microsoft Österreich tätig.

Kommentare