Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerhandbuch: .NET

Wichtig: Dies ist eine alte Version dieser Seite. Die neueste Version finden Sie über die Links in der linken Navigationsleiste.

Mit der Blogger Data API können Clientanwendungen Blogger-Inhalte in Form von Google Data API-Feeds aufrufen und aktualisieren.

Mit der Blogger Data API können Sie in Ihrer Clientanwendung neue Blogbeiträge erstellen, vorhandene Blogbeiträge bearbeiten oder löschen und nach Blogbeiträgen suchen, die bestimmten Kriterien entsprechen.

Dieses Dokument enthält nicht nur einige Hintergrundinformationen zu den Funktionen der Blogger Data API, sondern auch Beispiele für grundlegende Data API-Interaktionen mit der .NET-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Bibliothek verwendet wird, finden Sie im Abschnitt zum Protokoll dieses Entwicklerhandbuchs.

Inhalt

Zielgruppe

Dieses Dokument richtet sich an Programmierer, die .NET-Clientanwendungen schreiben möchten, die mit Blogger interagieren können.

In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Konzepten des Google Data APIs-Protokolls vertraut sind.

Referenzinformationen zu den Klassen und Methoden der Clientbibliothek finden Sie in der API-Referenz der.NET-Clientbibliothek. Allgemeine Informationen zur Blogger Data API findest du im Referenzleitfaden zum Protokoll.

Erste Schritte

Informationen zum Einrichten der Clientbibliothek finden Sie im Leitfaden für den Einstieg.

Für die Verwendung der .NET-Clientbibliothek benötigen Sie die .NET 1.1-Laufzeit und sollten alle aktuellen Patches installiert haben. Nachdem du die Clientbibliothek heruntergeladen hast, findest du die erforderlichen DLLs im Unterverzeichnis lib/Release der Distribution.

Blogger-Konto erstellen

Sie können sich für Testzwecke für ein Blogger-Konto registrieren. Für Blogger werden Google-Konten verwendet. Wenn Sie also bereits ein Google-Konto haben, können Sie sofort loslegen.

Codebeispiel ausführen

Ein vollständiger, funktionierender Beispielclient mit dem gesamten in diesem Dokument gezeigten Beispielcode ist im .NET-Clientbibliotheksprojekt verfügbar. Das Beispiel befindet sich auf dem Tab „Source“ (Quellcode) des SVN-Repositories unter /trunk/clients/cs/samples/blogger/ConsoleSample.cs.

Bevor Sie dieses Beispiel kompilieren und ausführen, aktualisieren Sie die Werte für username, password, blogName und postId mit den entsprechenden Werten. Die Werte username und password sind die Anmeldedaten, mit denen du dich in Blogger anmeldest. Der Wert blogName ist der Beginn der blogspot-URL deines Blogs.

Der Beispielclient führt mehrere Vorgänge am angegebenen Blog aus, um die Verwendung der Blogger Data API zu demonstrieren.

Um die Beispiele in diesem Dokument in Ihren eigenen Code zu kompilieren, benötigen Sie die folgenden using-Anweisungen:

using Google.GData.Client;
using System.Net;
using System.Xml;
using System.Text.RegularExpressions;

Beim Blogger-Dienst authentifizieren

Mit der Blogger Data API können Sie sowohl auf öffentliche als auch auf private Feeds zugreifen. Für öffentliche Feeds ist keine Authentifizierung erforderlich, sie sind jedoch nur lesbar. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor er private Feeds anfordert. Die Authentifizierung kann mit einem der beiden folgenden Ansätze erfolgen: AuthSub-Proxy-Authentifizierung oder ClientLogin-Nutzername/Passwort-Authentifizierung.

Weitere Informationen zur Authentifizierung mit Google Data APIs finden Sie in der Authentifizierungsdokumentation.

AuthSub-Proxy-Authentifizierung

Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer in Google-Konten authentifizieren müssen. Der Website-Betreiber und der Clientcode haben keinen Zugriff auf den Nutzernamen und das Passwort des Blogger-Nutzers. Stattdessen erhält der Client spezielle AuthSub-Tokens, mit denen er im Namen eines bestimmten Nutzers handeln kann. Weitere Informationen finden Sie in der AuthSub-Dokumentation.

Wenn ein Nutzer Ihre Anwendung zum ersten Mal besucht, wurde er noch nicht authentifiziert. In diesem Fall müssen Sie einige Informationen und einen Link anzeigen, über den der Nutzer zu einer Google-Seite weitergeleitet wird, um Ihre Anfrage auf Zugriff auf seine Blogs zu authentifizieren.

Angenommen, auf Ihrer Seite ist der folgende ASP-Hyperlink definiert:

<asp:HyperLink ID="GotoAuthSubLink" runat="server"/>

Rufen Sie dann eine .NET-Clientbibliothek auf, um die AuthSubRequest-URL für Ihre Anwendung zu erstellen:

GotoAuthSubLink.Text = "Login to your Google Account";
GotoAuthSubLink.NavigateUrl =
  AuthSubUtil.getRequestUrl("http://www.example.com/RetrieveToken",
  "http://www.blogger.com/feeds/",
  false,
  true);

Die Methode getRequestUrl verwendet die folgenden Parameter (entsprechend den Abfrageparametern, die vom AuthSubRequest-Handler verwendet werden):

Weiter: Die URL der Seite, auf die Google den Nutzer nach der Authentifizierung weiterleiten soll.
Bereich: Gibt an, dass die Anwendung ein Token für den Zugriff auf Blogger-Feeds anfordert. Der zu verwendende Bereichsstring ist http://www.blogger.com/feeds/ (natürlich URL-codiert).
sicher: Gibt an, ob der Client ein sicheres Token anfordert.
Sitzung: Gibt an, ob das zurückgegebene Token gegen ein wiederverwendbares Sitzungstoken eingetauscht werden kann.

Das obige Beispiel zeigt einen Aufruf, bei dem kein sicheres Token angefordert wird (der Wert von secure ist false). Die resultierende Anfrage-URL könnte so aussehen:

https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fwww.blogger.com%2Ffeeds%2F&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2FRetrieveToken

Der Nutzer folgt dem Link zur Google-Website und authentifiziert sich in seinem Google-Konto.

Nach der Authentifizierung des Nutzers leitet das AuthSub-System ihn an die URL weiter, die Sie im Abfrageparameter next der AuthSubRequest-URL angegeben haben. Das AuthSub-System hängt dieser URL ein Authentifizierungstoken als Wert des Abfrageparameters token an. Daher ist das Token im Request.QueryString-Objekt der ASP-Seite als Variable zugänglich. Der Nutzer wird zu einer URL weitergeleitet, die so aussieht:

http://www.example.com/RetrieveToken?token=yourAuthToken

Dieser Tokenwert stellt ein AuthSub-Token zur einmaligen Verwendung dar. Da in diesem Beispiel session = true angegeben wurde, kann dieses Token so gegen ein AuthSub-Sitzungstoken eingetauscht werden:

SessionsessionToken = AuthSubUtil.exchangeForSessionToken(Request.QueryStringtoken, null);

Sie übergeben also Ihr Einmaltoken zusammen mit null (für den nicht registrierten Modus) oder einem privaten Schlüssel (für den registrierten Modus) an die exchangeForSessionToken-Methode. Die AuthSub-Benutzeroberfläche gibt dann ein Sitzungstoken zurück. Weitere Informationen zu registrierten Anwendungen und privaten Schlüsseln finden Sie im Abschnitt Anfragen signieren der AuthSub-Dokumentation.

Ihre Anwendung kann den Sitzungstokenwert dann bei nachfolgenden Interaktionen mit Blogger verwenden. So weisen Sie die .NET-Clientbibliothek an, den Autorisierungsheader (mit dem Sitzungstoken) automatisch mit jeder Anfrage zu senden:

GAuthSubRequestFactory authFactory = new GAuthSubRequestFactory("blogger", "BloggerSampleApp");
authFactory.Token = SessionsessionToken.ToString();
Service service = new Service(authFactory.ApplicationName);
service.RequestFactory = authFactory;

ClientLogin-Nutzername/Passwort-Authentifizierung

Verwenden Sie die ClientLogin-Authentifizierung, wenn Ihr Client ein eigenständiger, für einen einzelnen Nutzer installierter Client ist (z. B. eine Desktopanwendung). So legen Sie die Anmeldedaten Ihres Dienstobjekts fest:

Service service = new Service("blogger", "exampleCo-exampleApp-1");
service.Credentials = new GDataCredentials("user@example.com", "secretPassword");
GDataGAuthRequestFactory factory = (GDataGAuthRequestFactory) service.RequestFactory;
factory.AccountType = "GOOGLE";

Im obigen Snippet übergeben wir dem Service-Konstruktor zwei Parameter. Der erste Parameter ist der Name des Dienstes, mit dem wir interagieren möchten. Der zweite Parameter ist der Name unserer Anwendung im Format companyName-applicationName-versionID. Außerdem haben wir für Service.RequestFactory festgelegt, dass nur ein GOOGLE-Kontotyp verwendet werden darf, um eine ordnungsgemäße Authentifizierung für G Suite-Nutzer zu ermöglichen.

Weitere Informationen zur ClientLogin-Authentifizierung, einschließlich Beispielanfragen und ‑antworten, finden Sie in der Dokumentation Authentifizierung für installierte Anwendungen.

Hinweis: Verwenden Sie dasselbe Token für alle Anfragen in einer bestimmten Sitzung. Rufen Sie nicht für jede Blogger-Anfrage ein neues Token ab.

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, kann die Authentifizierungsanfrage fehlschlagen und eine CAPTCHA-Aufgabe anfordern. Wenn Google die CAPTCHA-Herausforderung stellen und verarbeiten soll, leite den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter (nicht an die in der ClientLogin-Dokumentation angegebene URL für die CAPTCHA-Verarbeitung).

Liste der Blogs abrufen

Die Blogger Data API stellt einen Feed bereit, in dem die Blogs eines bestimmten Nutzers aufgeführt sind. Dieser Feed wird als „Metafeed“ bezeichnet.

Im folgenden Beispielcode wird ein authentifiziertes Service-Objekt verwendet, um den Metafeed abzurufen und dann den Titel jedes Blogs zu drucken.

query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs");
AtomFeed feed = null;
try
{
  feed = service.Query(query);
  foreach (AtomEntry entry in feed.Entries)
  {
    Console.WriteLine("Blog Title: " + entry.Title.Text);
  }
}

Notieren Sie sich die URL, die von der Methode getFeed verwendet wird. Das ist die Standard-Metafeed-URL. Sie gibt eine Liste der Blogs für den aktuell authentifizierten Nutzer zurück. Wenn du auf einen Feed für einen anderen Nutzer zugreifen möchtest, kannst du die ID des Nutzers anstelle von default in die Metafeed-URL einfügen. Die ID des Nutzers ist die Ziffernfolge am Ende der Profil-URL des Nutzers.

Beiträge erstellen

Mit der Blogger Data API können Sie neue Blogbeiträge erstellen und veröffentlichen sowie Beitragsentwürfe erstellen.

In allen folgenden Beispielen wird davon ausgegangen, dass Sie ein authentifiziertes Service-Objekt haben.

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Beiträge wird derzeit nicht unterstützt. Alle neuen Beiträge werden so angezeigt, als wären sie vom aktuell authentifizierten Nutzer erstellt worden.

Blogpost veröffentlichen

Mit der .NET-Clientbibliothek können Sie neue Blogbeiträge veröffentlichen.

Erstellen Sie zuerst ein AtomEntry-Objekt für den Blogpost. Anschließend können Sie den Titel, den Inhalt und andere Attribute des Blogposts festlegen. Verwenden Sie abschließend das Service-Objekt, um den Beitrag einzufügen. Hier ein Beispiel für die Veröffentlichung eines neuen Blogposts:

AtomEntry newPost = new AtomEntry();
newPost.Title.Text = "Marriage!";
newPost.Content = new AtomContent();
newPost.Content.Content = "<div xmlns='http://www.w3.org/1999/xhtml'>" +
  "<p>Mr. Darcy has <em>proposed marriage</em> to me!</p>" +
  "<p>He is the last man on earth I would ever desire to marry.</p>" +
  "<p>Whatever shall I do?</p>" +
  "</div>";
newPost.Content.Type = "xhtml";

Uri blogFeedUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
AtomEntry createdEntry = service.Insert(blogFeedUri, newPost);

Die Methode Insert verwendet die Post-URL des Dienstes als Parameter. Anschließend gibt die Methode den Eintrag zurück, wie er von Blogger gespeichert wurde. Der zurückgegebene Eintrag ist derselbe, den Sie gesendet haben, enthält aber auch verschiedene von Blogger hinzugefügte Elemente, z. B. eine Beitrags-ID.

Wenn Ihre Anfrage aus irgendeinem Grund fehlschlägt, gibt Blogger möglicherweise einen anderen Statuscode zurück. Informationen zu den Statuscodes finden Sie im Referenzdokument zum Google Data API-Protokoll.

Einen Blogpost-Entwurf erstellen

Entwurfsbeiträge werden genauso erstellt wie öffentliche Beiträge. Sie müssen jedoch das draft-Attribut des AtomEntry-Objekts festlegen. Der obige Blogpost könnte als Entwurf erstellt werden, indem die markierte Zeile hinzugefügt wird:

AtomEntry newPost = new AtomEntry();
newPost.Title.Text = "Marriage!";
newPost.Content = new AtomContent();
newPost.Content.Content = "<div xmlns='http://www.w3.org/1999/xhtml'>" +
    "<p>Mr. Darcy has <em>proposed marriage</em> to me!</p>" +
    "<p>He is the last man on earth I would ever desire to marry.</p>" +
    "<p>Whatever shall I do?</p>" +
    "</div>";
newPost.Content.Type = "xhtml";
newPost.IsDraft = true;

Uri blogFeedUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
AtomEntry createdEntry = service.Insert(blogFeedUri, newPost);

Sie können einen vorhandenen Blogpost-Entwurf in einen veröffentlichten Beitrag umwandeln, indem Sie den Entwurf abrufen, das Attribut „draft“ auf „false“ setzen und den Beitrag dann aktualisieren. In den nächsten beiden Abschnitten erfahren Sie, wie Sie Beiträge abrufen und aktualisieren.

Beiträge abrufen

In den folgenden Abschnitten wird beschrieben, wie Sie eine Liste von Blogbeiträgen mit und ohne Abfrageparameter abrufen.

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Daher müssen Sie keine Anmeldedaten festlegen oder eine AuthSub-Authentifizierung durchführen, bevor Sie Beiträge aus einem öffentlichen Blog abrufen.

Alle Blogbeiträge abrufen

Rufe zum Abrufen der Beiträge des Nutzers dieselbe getFeed-Methode auf, die auch zum Abrufen des Metafeeds des Blogs verwendet wurde. Sende diesmal jedoch die Feed-URL des Blogposts:

query.Uri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
feed = service.Query(query);
Console.WriteLine(feed.Title.Text);
foreach (AtomEntry entry in feed.Entries)
{
  Console.WriteLine("Entry Title: " + entry.Title.Text);
}

Beiträge mithilfe von Abfrageparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen. So können Sie beispielsweise Blogbeiträge anfordern, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden. Dazu erstellen Sie ein FeedQuery-Objekt und übergeben es an die Methode Service.Query().

Wenn Sie beispielsweise eine Abfrage für einen Zeitraum senden möchten, legen Sie die Mitglieder MinPublication und MaxPublication des FeedQuery-Objekts fest. Im folgenden Code-Snippet wird der Titel jedes Blogposts ausgegeben, der zwischen der angegebenen Start- und Endzeit veröffentlicht wurde:

FeedQuery query = new FeedQuery();
query.Uri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
query.MinPublication = new DateTime(2006, 1, 1);
query.MaxPublication = new DateTime(2007, 4, 12);
AtomFeed feed = service.Query(query);
foreach (AtomEntry entry in feed.Entries)
{
  Console.WriteLine("  Entry Title: " + entry.Title.Text);
}

Das FeedQuery-Objekt wird mit derselben Postfeed-URL erstellt, die zum Abrufen von Beiträgen verwendet wird.

Die Blogger Data API unterstützt die folgenden Abfrageparameter:

alt: Der Typ des zurückzugebenden Feeds, z. B. atom (Standard) oder rss.
/category: Geben Sie Kategorien (auch als Labels bezeichnet) an, um die Feedergebnisse zu filtern. Beispiel: http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt Einträge mit den Labels Fritz und Laurie zurück.
max-results: Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
orderby: Die Reihenfolge, in der Einträge zurückgegeben werden sollen, z. B. lastmodified (Standardeinstellung), starttime oder updated.
published-min, published-max: Die Grenzen für die Veröffentlichungsdaten von Einträgen.
start-index: Der Index (ab 1) des ersten Ergebnisses, das abgerufen werden soll (für die Paginierung).
updated-min, updated-max: Die Grenzen für die Datumsangaben der Eintragsaktualisierungen. Diese Abfrageparameter werden ignoriert, es sei denn, der Parameter orderby ist auf updated gesetzt.

Weitere Informationen zu Abfrageparametern findest du im Referenzleitfaden für die Blogger Data API und im Referenzleitfaden für Google Data APIs.

Beiträge aktualisieren

Wenn Sie einen vorhandenen Blogpost aktualisieren möchten, rufen Sie zuerst den Eintrag ab, den Sie aktualisieren möchten, ändern Sie ihn und senden Sie ihn dann mit der Update()-Methode des Eintrags an Blogger. Im folgenden Code-Snippet wird der Titel eines Blogposts geändert, vorausgesetzt, Sie haben den Eintrag bereits vom Server abgerufen.

static AtomEntry EditEntry(AtomEntry toEdit)
{
  // Edit the entry by changing the Title and calling Update().
  if (toEdit != null)
  {
    toEdit.Title.Text = "Marriage Woes!";
    toEdit = toEdit.Update();
  }
  return toEdit;
}

Der obige Code gibt eine AtomEntry zurück, die den gesamten neu aktualisierten Beitrag enthält. Wenn du andere Properties aktualisieren möchtest, musst du sie einfach im AtomEntry-Objekt festlegen, bevor du Update() aufrufst.

Hinweis: Das Ändern der mit Beiträgen verknüpften Autordaten wird derzeit nicht unterstützt.

Beiträge löschen

Wenn du einen Beitrag löschen möchtest, rufe die Methode Delete für ein vorhandenes AtomEntry-Objekt auf. So gehts:

static void DeleteEntry(AtomEntry toDelete)
{
  // Delete the edited entry
  if (toDelete != null)
  {
    toDelete.Delete();
  }
}

Kommentare

Mit der Blogger Data API können Kommentare erstellt, abgerufen und gelöscht werden. Das Aktualisieren von Kommentaren wird nicht unterstützt und ist auch nicht in der Weboberfläche verfügbar.

Kommentare erstellen

Wenn du einen Kommentar posten möchtest, erstelle ein AtomEntry-Objekt und füge es so ein:

AtomEntry comment;
comment = new AtomEntry();
comment.Title.Text = "This is my first comment";
comment.Content.Content = "This is my first comment";
Uri commentPostUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/" + entryId + "/comments/default");
postedComment = service.Insert(commentPostUri, comment);

Hinweis: Derzeit können Sie nur Kommentare in einem Blog posten, der dem authentifizierten Nutzer gehört.

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Kommentare wird derzeit nicht unterstützt. Alle neuen Kommentare werden so angezeigt, als wären sie vom aktuell authentifizierten Nutzer erstellt worden.

Kommentare abrufen

Du kannst die Kommentare zu einem bestimmten Beitrag über die URL des Kommentarfeeds abrufen:

static void ListEntryComments(Service service, Uri commentUri)
{
  if (commentUri != null)
  {
    // Retrieve all comments on a blog entry
    FeedQuery query = new FeedQuery();
    query.Uri = commentUri;
    AtomFeed feed = service.Query(query);
    foreach (AtomEntry entry in feed.Entries)
    {
      Console.WriteLine("  Comment Title: " + entry.Title.Text);
    }
  }
}

Alternativ können Sie die Kommentare zu allen Beiträgen über die Kommentarfeed-URL des Blogs abrufen:

http://www.blogger.com/feeds/blogID/comments/default

Kommentare löschen

Wenn du einen Kommentar löschen möchtest, rufe die Methode Delete() für ein vorhandenes Kommentarobjekt AtomEntry auf:

static void DeleteComment(AtomEntry commentEntry)
{
  if (commentEntry != null)
  {
    // Delete the comment.
    commentEntry.Delete();
  }
}

Nach oben