Heute möchte ich euch zeigen, wie man mittels C# Blogartikel auf Blogger.com (Blogspot.com) erstellen kann. Hierfür benötigt ihr zu aller erst die Google.GData.Client.dll, welche ihr im Google. Net API Pack findet.
Das API-Pack könnte ihr euch hier von Google herunterladen. (Die Datei heißt Google_Data_API_Setup_2.0.1.0.msi. Beachtet bitte, dass sich die Versionsnummer – 2.0.1.0 – im Laufe der Zeit natürlich ändern kann.) Wenn ihr den Download abgeschlossen habt, installiert das Paket, öffnet ein neues Projekt im Visual Studio und bindet die Google.GData.Client.dll ein.
Die .dll-Datei findet ihr im Downloadverzeichnis des API-Pack. (Wie ihr eine DLL einbinden könnt, habe ich hier bereits beschrieben.)

Wenn ihr die DLL eingebunden habt, kann es auch schon losgehen. Einen Post aka Blogartikel könnt ihr wie folgt erstellen:

private static int AddPost(string title,
                                   string html,
                                   string[] labels,
                                   string user,
                                   string pass,
                                   string blogUrl
                                   bool isDraft)
{
	try
	{
		//Wird benötigt um Google Zertifikatfehler zu "umgehen"
		ServicePointManager.ServerCertificateValidationCallback =
			new RemoteCertificateValidationCallback
			(
				delegate { return true; }
			);

		//Eine Google Service Instanz wird erstellt. "blogger"
		//gibt den Dienst an, den wir nutzen wollen. "api_test"
		//gibt den Namen an, unter dem sich unsere Anwendung
		//ausweisen soll. Im Gegenteil zum Dienstparameter, der
		//für unser Beispiel auf "blogger" festgelegt ist, haben
		//wir beim Namen freie Wahl.
		Service service = new Service("blogger", "api_test");

		//Der Service Instanz werden die Benutzerdaten eines
		//gültigen Blogger (Google) Accounts überegeben.
		service.Credentials = new GDataCredentials(user, pass);

		//Ein neues Blogartikel Objekt wird (lokal) angelegt.
		AtomEntry newPost = new AtomEntry();

		//Die Überschrift des Blogartikels wird gesetzt
		newPost.Title.Text = title;

		//Der Inhalt des Blogartikel wird gesetzt.
		newPost.Content = new AtomContent();
		//Wenn ihr HTML-Code übergebt, solltet ihr zuvor sämtliche
		//Zeilenumbrüche entfernen, da Blogger sonst automatisch alle
		//Zeilenumbrüche durch <br /> ersetzt. Wenn man selbst schon
		//im Quelltext <br /> gesetzt hatte, wird einem sonst das
		//ganze Layout "zerfleddert".
		string[] breaks = new string[] { "\r\n", "\r", "\n" };
		foreach (string breakStr in breaks)
		{
			while (html.Contains(breakStr))
				html = html.Replace(breakStr, "");
		}
		newPost.Content.Content = html;
		newPost.Content.Type = "html";

		//Setzen der Labels für den Blogartikel.
		//(Labels bei Blogger entsprechen Kategorien/Tags)
		foreach (string labelRaw in labels)
		{
			AtomCategory cat = new AtomCategory();
			cat.Scheme = new Uri("http://www.blogger.com/atom/ns#");

			//Blogger verbietet bestimmte Zeichen in den Labels
			//Diese sollten zuvor herausgefiltert werden.
			string label = labelRaw;
			string[] forbiddenChars = new string[] { "&", "<", ">",
													 "@", "!", "," };
			foreach (string forbiddenChar in forbiddenChars)
			{
				while (label.Contains(forbiddenChar))
					label = label.Replace(forbiddenChar, "");
			}
			cat.Term = label;
			newPost.Categories.Add(cat);
		}

		//Festlegen, ob der Artikel direkt gepostet oder als Entwurf
		//gespeichert werden soll. (false = direkt Posten)
		newPost.IsDraft = isDraft;

		AtomEntry response = null;
		try
		{
			//Blogartikel absenden (Woher die blogUrl kommt,
                        //wird später im Artikel geklärt.
			response = service.Insert(new Uri(blogUrl), newPost);
		}
		catch (GDataRequestException iDontCare)
		{
			//Fehler beim Absenden aufgetreten
			if (iDontCare.ResponseString == "Blog has exceeded rate " +
								  "limit or otherwise requires word " +
								  "verification for new posts")
			{
				//Fehler tritt auf, wenn das Tageslimit an Posts
				//erreicht ist. (Mehr dazu weiter unten in
				//diesem Blogartikel.)
				return -2;
			}
			else
			{
				//Anderer Fehler aufgetreten
				throw iDontCare;
			}
		}
		if (response == null)
		{
			throw new Exception("Konnte keine Verbindung herstellen");
		}

		//Blogartikel erfolgreich abgesendet
		return 0;
	}
	catch
	{
		//Es ist ein Fehler aufgetreten
		return -1;
	}
}

Nun haben wir den größten Teil geschafft! Um nun einen Blogartikel zu posten, müssen wir nur noch die eben geschriebene Funktion aufrufen. Das könnte wie folgt aussehen:

Demo.AddPost("Meine Überschrift",
             "<b>das</b><br /><i>ist</i> ein test",
             new string[] { "test", "csharp", "api" },
             "maxmustermann@googlemail.com",
             "demo_passwort",
             "https://www.blogger.com/feeds/XXXXXX/posts/default");

Eine letzte Frage steht nun noch im Raum. Was ist die Blog-Url und wo kommt Sie her? Das klären wir nun. Die Url ist vom Grundaufbau her immer identisch. Lediglich die XXXXXXe müssen durch die ID des Blogs ersetzt werden. Eine Möglichkeit die komplette URL zu bekommen, möchte ich euch nachfolgend zeigen.
Nehmen wir an, euer Blog hat die URL: http://code-bude-test.blogspot.com – dann ist “code-bude-test” der Name des Blogs, den wir nun brauchen.

public static string SelectUserBlogPostUrl(string subdomain,
                                                   string user,
                                                   string pass)
{
	//Erstellen der Google Service Instanz
	ServicePointManager.ServerCertificateValidationCallback =
		new RemoteCertificateValidationCallback
		(
			delegate { return true; }
		);
	Service service = new Service("blogger", "api_test");
	service.Credentials = new GDataCredentials(user, pass);

	//Anfordern einer Liste mit allen Blogs, die unter
	//dem angegeben Google Account existieren
	FeedQuery query = new FeedQuery();
	query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs");
	AtomFeed feed = service.Query(query);

	//Wenn die Liste mit den Blogs nicht null ist...
	string blogUrl = string.Empty;
	if (feed != null)
	{
		//Durchlaufe alle erhaltenen Blogs
		foreach (AtomEntry entry in feed.Entries)
		{
			//Überprüfe, ob der aktuelle Blog der gesuchte
			//Blog ist.
			if (entry.AlternateUri.Content.Contains(subdomain))
			{
				//Suche die Blog Post URL
				for (int i = 0; i < entry.Links.Count; i++)
				{
					if (entry.Links[i].Rel.Equals("http://schemas.google.com/g/2005#post"))
					{
						blogUrl = entry.Links[i].HRef.ToString();
					}
				}
				//Gebe die Blog Post Url zurück
				return blogUrl;
			}
		}
	}
	//Wenn keine URL gefunden wurde, gebe Blog Url
	//= string.empty zurück
	return blogUrl;
}

Nun haben wir alles zusammen. Mit den oben stehenden Funktionen könnt ihr nun die Blog Post Url herausfinden und mittels dieser und der AddPost-Funktion Blogartikel auf Blogger.com veröffentlichen.

Zum Abschluss noch ein paar Worte zum “Rate-Limit” (aka “Blog has exceeded rate limit or otherwise requires word verification for new posts”). Die Blogger API erlaubt nur eine gewisse Anzahl an Posts pro Tag. Eine genaue Zahl gibt Google nicht heraus. Aus Erfahrung kann ich jedoch sagen, dass es ziemlich genau 50 Artikel sind, die man am Tag veröffentlichen kann. Danach geht über die API gar nichts mehr.
Über die Weboberfläche von Blogger.com können jedoch weitere Artikel veröffentlicht werden. Hierbei muss nach Erreichen des Limits jedoch jedes Mal beim Veröffentlichen ein Captcha gelöst werden. Das Limit/die Sperre wird ziemlich genau nach 24 Stunden wieder zurückgesetzt.

So, das war’s dann aber auch wirklich für heute. Wenn ihr noch Fragen, oder noch besser, Anregungen und Ideen habt, dann schreibt einfach einen Kommentar.

Viele Grüße,
Raffi