Cette page a été traduite par l'API Cloud Translation.

Guide du développeur: .NET

Important: La version 2.0 de l'API Google Data ne sera plus prise en charge à partir du 30 septembre 2024. Pour assurer un fonctionnement continu, mettez à jour vos applications qui s'appuient sur la version 2.0 de vers la dernière version de l'API Data. Pour obtenir la dernière version, utilisez les liens de la barre de navigation de gauche. Remarque : Bien que certaines requêtes GET (telles que les posts de fiches) continuent d'être acceptées en tant qu'URL de flux, leur comportement présente de légères différences. Pour en savoir plus, consultez Aide Blogger.

L'API Blogger Data permet aux applications clientes d'afficher et de mettre à jour Blogger sous la forme de flux de l'API Google Data.

Votre application cliente peut utiliser l'API Blogger Data pour créer un blog des articles, modifier ou supprimer des articles de blog existants, et rechercher des articles de blog qui correspondent des critères particuliers.

En plus de vous présenter les fonctionnalités de Blogger, Data API, ce document fournit des exemples d'interactions élémentaires de l'API Data à l'aide de la bibliothèque cliente.NET. Si vous souhaitez en savoir plus sur le protocole sous-jacent utilisé par la bibliothèque, consultez la section sur le protocole de ce guide du développeur.

Sommaire

Audience
Premiers pas
1. Créer un compte Blogger
2. Exécuter l'exemple de code
Authentification auprès du service Blogger
1. Authentification du proxy AuthSub
2. Authentification par nom d'utilisateur/mot de passe ClientLogin
Récupérer une liste de blogs
Créer des posts
1. Publier un article de blog
2. Créer un brouillon de post de blog
Récupérer des posts
1. Récupérer tous les articles de blog
2. Récupérer des posts à l'aide de paramètres de requête
Modifier des posts
Supprimer des posts
Commentaires

Audience

Ce document s'adresse aux programmeurs qui souhaitent écrire des applications clientes .NET pouvant interagir avec Blogger.

Dans ce document, nous partons du principe que vous comprenez le concept général qui sous-tend les API Google Data protocole.

Pour obtenir des informations de référence sur les classes et les méthodes fournies par la bibliothèque cliente, consultez la documentation de référence de l'API de la bibliothèque cliente .NET. Pour obtenir des informations générales de référence sur l'API Blogger Data, consultez le Guide de référence du protocole.

Premiers pas

Si vous avez besoin d'aide pour configurer la bibliothèque cliente, reportez-vous à la section Guide de démarrage.

Pour utiliser la bibliothèque cliente .NET, vous devez disposer de l'environnement d'exécution .NET 1.1. doit également être à jour sur tous les correctifs. Après avoir téléchargé la bibliothèque cliente, vous trouverez les DLL dont vous avez besoin pour commencer dans le sous-répertoire lib/Release de la distribution.

Créer un compte Blogger

Vous pouvez vous inscrire à un Blogger à des fins de test. Blogger utilise des comptes Google. Si vous possédez déjà un compte Google, vous êtes prêt.

Exécuter l'exemple de code

Un exemple de client entièrement fonctionnel, contenant tous les exemples de code présentés dans ce document, est disponible dans le projet de bibliothèque cliente .NET. L'exemple se trouve à l'emplacement /trunk/clients/cs/samples/blogger/ConsoleSample.cs dans l'onglet "Source" du dépôt SVN.

Avant de compiler et d'exécuter cet exemple, mettez à jour les valeurs de username, password, blogName et postId avec les valeurs appropriées. Les username et Les valeurs password représentent les identifiants utilisés pour se connecter à Blogger. La valeur blogName correspond au début de l'URL blogspot de votre blog.

L'exemple de client effectue plusieurs opérations sur le blog fourni pour illustrer l'utilisation de l'API Blogger Data.

Pour compiler les exemples de ce document dans votre propre code, vous avez besoin des instructions using suivantes :

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

S'authentifier auprès du service Blogger

Vous pouvez accéder aux flux publics et privés à l'aide de l'API Blogger Data. Les flux publics ne nécessitent aucune authentification, mais ils sont en lecture seule. Si vous souhaitez modifier des blogs, votre client doit s'authentifier avant de demander des flux privés. Il peut utiliser l'une des deux approches suivantes: l'authentification par proxy AuthSub ou l'authentification par nom d'utilisateur/mot de passe ClientLogin.

Pour en savoir plus sur l'authentification avec les API Google Data en général, consultez la documentation sur l'authentification.

Authentification du proxy AuthSub

L'authentification par proxy AuthSub est utilisée par les applications Web qui doivent authentifier leurs utilisateurs auprès de comptes Google. L'opérateur du site Web et le code client n'ont pas accès au nom d'utilisateur et au mot de passe de l'utilisateur Blogger. À la place, le client obtient des jetons AuthSub spéciaux qui lui permettent d'agir au nom d'un utilisateur particulier. Pour en savoir plus, consultez la documentation AuthSub.

Lorsqu'un utilisateur accède à votre application pour la première fois, il n'est pas encore authentifié. Dans ce cas, vous devez afficher des informations et un lien en redirigeant l'utilisateur vers une page Google afin d'authentifier votre demande d'accès à leurs blogs.

Supposons que le lien hypertexte ASP suivant soit défini dans votre page :

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

Pour créer l'URL AuthSubRequest de votre application, effectuez un appel de bibliothèque cliente .NET comme suit :

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

La méthode getRequestUrl utilise les paramètres suivants (correspondant aux paramètres de requête utilisés par le gestionnaire AuthSubRequest) :

suivant: URL de la page vers laquelle Google doit rediriger l'utilisateur après l'authentification.
champ d'application: Indique que l'application demande un jeton pour accéder aux flux Blogger. La chaîne de portée à utiliser est http://www.blogger.com/feeds/ (encodée au format URL, bien entendu).
sécurisé: Indique si le client demande un jeton sécurisé.
session: Indique si le jeton renvoyé peut être échangé contre un jeton à usage multiple (session).

L'exemple ci-dessus montre un appel qui ne demande pas de jeton sécurisé (la valeur de secure est false). L'URL de requête obtenue peut se présenter comme suit :

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

L'utilisateur suit le lien vers le site Google et s'authentifie sur son compte Compte.

Une fois l'utilisateur authentifié, le système AuthSub le redirige vers l'URL. que vous avez spécifié dans le paramètre de requête next de l'AuthSubRequest URL. Le système AuthSub ajoute un jeton d'authentification à cette URL, puisque Valeur du paramètre de requête token. Par conséquent, le jeton est accessible en tant que variable dans le fichier Request.QueryString de la page ASP . L'utilisateur est redirigé vers une URL qui se présente comme suit :

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

Cette valeur de jeton représente un jeton AuthSub à usage unique. Dans cet exemple, comme session = true a été spécifié, ce jeton peut être échangé contre un jeton de session AuthSub, comme suit :

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

Autrement dit, vous transmettez votre jeton à usage unique exchangeForSessionToken, ainsi que null (pour le mode non enregistré) ou privée (pour le mode enregistré), et l'authentification AuthSub renvoie un jeton de session. Pour en savoir plus sur les applications enregistrées et les clés privées, consultez la section Signer des requêtes de la documentation AuthSub.

Votre application peut alors utiliser la valeur du jeton de session dans avec Blogger. Pour demander à la bibliothèque cliente .NET d'envoyer automatiquement l'en-tête d'autorisation (contenant le jeton de session) avec chaque requête, procédez comme suit :

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

Authentification par nom d'utilisateur/mot de passe ClientLogin

Utilisez l'authentification ClientLogin si votre client est un client autonome, "installé" et à un seul utilisateur (par exemple, une application de bureau). Définissez le paramètre les identifiants de votre objet de service comme suit:

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

Dans l'extrait ci-dessus, nous transmettons deux paramètres au constructeur Service. Le premier paramètre est le nom du service avec lequel nous voulons interagir . Le deuxième paramètre est le nom de notre application au format companyName, applicationName et versionID Nous avons également définissez Service.RequestFactory pour qu'il n'utilise qu'un GOOGLE type de compte afin d'autoriser l'authentification appropriée pour les utilisateurs de G Suite.

Pour en savoir plus sur l'authentification ClientLogin, y compris des exemples requêtes et les réponses correspondantes, consultez la section Authentification pour les Applications.

Remarque : Utilisez le même jeton pour toutes les requêtes d'une session donnée. N'obtenez pas de nouveau jeton pour chaque requête Blogger.

Remarque : Comme décrit dans la documentation ClientLogin, la requête d'authentification peut échouer et demander un défi CAPTCHA. Si vous souhaitez que Google émette et gère le test CAPTCHA, redirigez l'utilisateur vers https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (plutôt que vers l'URL de gestion du CAPTCHA indiquée dans la documentation ClientLogin).

Récupérer une liste de blogs

L'API Blogger Data fournit un flux qui répertorie les blogs d'un user; appelé "metafeed".

L'exemple de code suivant utilise un objet Service authentifié. pour récupérer le métaflux, puis imprime le titre de chaque blog.

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);
  }
}

Notez l'URL utilisée par la méthode getFeed. Il s'agit de l'option par défaut metafeed URL; il renvoie une liste de blogs pour l'utilisateur actuellement authentifié. Pour accéder à un flux pour un autre utilisateur, vous pouvez remplacer default par l'ID de l'utilisateur dans l'URL du métaflux. L'identifiant de l'utilisateur est une chaîne de chiffres à la fin de l'URL du profil de l'utilisateur.

Créer des posts

L'API Blogger Data vous permet de créer et de publier de nouveaux articles de blog, et créer des brouillons d'entrées.

Tous les exemples suivants supposent que vous disposez Service.

Remarque: Définir un auteur personnalisé pour les posts est n'est actuellement pas prise en charge. Tous les nouveaux posts apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Publication d'un article de blog

Vous pouvez utiliser la bibliothèque cliente .NET pour publier de nouvelles entrées de blog.

Commencez par créer un objet AtomEntry pour représenter l'article de blog. Vous pouvez ensuite définir le titre, le contenu et d'autres attributs de l'article de blog. Enfin, utilisez l'objet Service pour insérer le post. Voici un exemple de publication d'un nouvel article de blog:

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);

La méthode Insert utilise l'URL de publication du service comme paramètre. La méthode renvoie ensuite l'entrée telle qu'elle a été stockée par Blogger. L'entrée renvoyée est la même que celle que vous avez envoyée, mais elle contient également divers éléments ajoutés par Blogger, tels qu'un ID de post.

Si votre requête échoue pour une raison quelconque, Blogger peut renvoyer un code d'état différent. Pour plus d'informations sur les codes d'état, consultez le document Google Data document de référence du protocole d'API.

Créer un brouillon d'article de blog

Les posts en brouillon sont créés de la même manière que les posts publics, mais vous devez définir l'attribut draft de l'objet AtomEntry. Le blog l'article ci-dessus peut être créé en tant que brouillon en ajoutant la ligne mise en surbrillance suivante:

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);

Vous pouvez transformer un brouillon d'article de blog en article publié en récupérant le brouillon, en définissant l'attribut brouillon sur "false", puis en mettant à jour post. Nous aborderons la récupération et la mise à jour des posts dans les deux sections suivantes.

Récupérer des posts

Les sections suivantes expliquent comment récupérer une liste d'articles de blog, avec et sans paramètres de requête.

Vous pouvez interroger un flux public Blogger sans vous authentifier. Par conséquent, vous n'avez pas besoin de définir d'identifiants ni d'effectuer d'authentification AuthSub avant de récupérer des posts à partir d'un blog public.

Récupérer tous les articles de blog

Pour récupérer les posts de l'utilisateur, appelez la même méthode getFeed utilisée pour récupérer le métaflux des blogs, mais cette fois, envoyez l'URL du flux de posts de blog :

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);
}

Récupérer des posts à l'aide de paramètres de requête

L'API Blogger Data vous permet de demander un ensemble d'entrées correspondant à des critères spécifiés, par exemple en demandant des articles de blog publiés ou mis à jour dans une plage de dates donnée. Pour ce faire, vous devez créer un objet FeedQuery et le transmettre à la Service.Query().

Par exemple, pour envoyer une requête de plage de dates, définissez MinPublication et MaxPublication de l'objet FeedQuery. L'extrait de code suivant imprime le titre de chaque article de blog publié entre les heures de début et de fin données:

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);
}

Notez que l'objet FeedQuery est construit à l'aide de la même URL de flux de posts utilisée pour récupérer les posts.

L'API Blogger Data accepte les paramètres de requête suivants :

alt: Type de flux à renvoyer, par exemple atom (par défaut) ou rss.
/category: Spécifiez des catégories (également appelées "libellés") pour filtrer les résultats du flux. Par exemple, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie renvoie des entrées avec les étiquettes Fritz et Laurie.
max-results: Nombre maximal d'entrées à renvoyer.
trier par: Ordre dans lequel les entrées doivent être renvoyées, tel que lastmodified (par défaut), starttime ou updated.
published-min, published-max: Les limites des dates de publication des entrées.
start-index: Index en base 1 du premier résultat à récupérer (pour la pagination).
mis à jour-min, mis à jour-max: Limites des dates de mise à jour des entrées. Ces paramètres de requête sont ignorés, sauf si le paramètre orderby est défini sur updated.

Pour en savoir plus sur les paramètres de requête, consultez la documentation de référence de l'API Blogger Data. d'assistance et le guide Google Guide de référence des API de données

Mise à jour des posts...

Pour mettre à jour un article de blog existant, vous devez d'abord récupérer l'entrée que vous souhaitez est modifié, puis l'envoie à Blogger à l'aide de la méthode Update(). L'extrait de code suivant modifie le titre d'un article de blog, en supposant que vous l'avez déjà récupéré sur le serveur.

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;
}

Le code ci-dessus renvoie un AtomEntry contenant l'intégralité du post nouvellement mis à jour. Pour mettre à jour d'autres propriétés, il vous suffit de les définir dans l'objet AtomEntry avant d'appeler Update().

Remarque: Modifier les données d'auteur associées à posts n'est pas pris en charge pour le moment.

Supprimer des posts

Pour supprimer un post, appelez la méthode Delete sur un objet AtomEntry existant, comme suit :

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

Commentaires

L'API Blogger Data permet de créer, de récupérer et de supprimer des commentaires. La mise à jour des commentaires n'est pas disponible (cette fonctionnalité n'est pas non plus disponible sur le Web) .

Création de commentaires

Pour publier un commentaire, créez un objet AtomEntry et insérez-le comme suit :

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);

Remarque: Actuellement, vous ne pouvez publier des commentaires que pour un blog appartenant à l’utilisateur authentifié.

Remarque : Il n'est actuellement pas possible de définir un auteur personnalisé pour les commentaires. Tous les nouveaux commentaires apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Récupération des commentaires

Vous pouvez récupérer les commentaires d'un post en particulier à partir des commentaires de l'article. URL du flux:

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);
    }
  }
}

Vous pouvez également obtenir les commentaires de tous les posts à l'aide de l'URL du flux de commentaires du blog :

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

Suppression des commentaires

Pour supprimer un commentaire, appelez la méthode Delete() sur un commentez l'objet AtomEntry comme ceci:

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

Haut de page