sirmark

Heute möchten wir durch ein C#-Programm automatisch den Task-Planer (Schedueld Task) nutzen, um unsere zuvor erstellten Twitter-Nachrichten zeitversetzt an unser Twitter-Account zu senden. Wir könnten selbstverständliche ein eigenes Programm mit einem Timer schreiben, der zum vordefinierten Zeitpunkt die Twitter-Nachricht sendet. Doch diese wäre eine weitere Anwendung, die ständig auf dem Rechner laufen müsste. Selbst professionelle Anwendungen wie beispielsweise Pinnacles WIN PVR gehen bei der Aufnahme des TV-Programmes inzwischen dazu über, den Windows-eigenen Scheduler zu nutzen. Dies spart Ressourcen und vereinfacht die möglichen Fehlerquellen. Auf einem Linux-System käme schließlich auch niemand auf die Idee, die Crontab nachzubauen …

Unser heutiges Ziel ist, vorhandene WordPress-Artikel über die folgenden Tage verteilt als Tweet zu senden. Hierzu haben wir bereits die WordPress-Tabelle „wp_posts“ von Revisionen befreit und eine Tabelle angelegt, die lediglich die Felder „post_title“ und die „guid“ enthält. Die „Guid“ ist der Link auf die ID in WordPress. Dies ist nicht der SEO-optimierte Link. Da wir sowie einen URL-Verkürzer nutzen, benötigen wir für die Optik keinen lesbaren Link. Suchmaschinen wie Google lieben lesbare Links. Diese werde ich ein wenig enttäuschen. Ich spare mir Zeit und Aufwand. Zumal WordPress von alleine diesen Link per 301 Redirect auf den SEO-optimierten Link auflöst.

Wir erstellen eine weitere SQL-Tabelle, die lediglich eine ID, ein Statusfeld (Tinyint, Default 0) und ein Textfeld enthält. Diese nenne ich „tw_sirmark“. In dieser Tabelle speichere ich die Tweets. Eine eindeutige ID erleichtert das Auffinden der Tweet-Nachricht. Das Statusfeld gibt Auskunft darüber, ob der Tweet „geplant“ oder bereits veröffentlicht wurde.

Scheduled Task: Erstellen und Löschen von Tasks im Task-Planer
Nun schreiten wir zum eigentlichen Thema von Heute: Die Scheduled Task. Wir möchten mittels C#-Konsole für jeden geplanten Tweet einen Scheduled Task erstellen. Wenn dieser abgearbeitet ist, soll der Eintrag gelöscht werden. In unserem Beispiel ist der Weg sicherlich nicht optimal, denn aktuell sollen über 200 Einträge „getweetet“ werden. Doch in einem folgenden Projekt sollen lediglich vier bis fünf Einträge pro Woche generiert werden. So dient dieses Projekt als Vorlage. Ferner werden wir gleich sehen, wie sich der Windows-Scheduler mit einer solchen Menge an Einträgen „schlägt“.

Um den Windows-Task-Scheduler anzusprechen, gibt es viele Möglichkeiten. Mir persönlich sagt die DLL „Microsoft.Win32.TaskScheduler.dll“ am meisten zu. Diese ist über Codeplex kostenfrei erhältlich.

Über den folgenden Beispielcode erstellen wir unseren ersten Test-Task. Dieser ruft einfach testweise das Notepad auf.

static void Main(string[] args)
{
    // Task Service auf der lokalen Maschine
    using (TaskService ts = new TaskService())
    {
        // Task erstellen
        TaskDefinition td = ts.NewTask();

        //Beschreibung hinzufügen
        td.RegistrationInfo.Description = "Meine Task-Beschreibung";

        // Task Trigger: Starte täglich um 15 Uhr  
        td.Triggers.Add(new DailyTrigger {StartBoundary = DateTime.Today + TimeSpan.FromHours(15)});

        // Zum Test das Notepad öffnen
        td.Actions.Add(new ExecAction("notepad.exe", "", null));

        // Register den Task im Root-Ordner
        ts.RootFolder.RegisterTaskDefinition(@"Mein-Test-Trigger 15 Uhr", td);
    }
}

Weitere  Trigger-Einsatzzeiten:

//Task Trigger: Einmaliger Task, 1 Tag nach Erstellung, um 3 Uhr
// Für weitere Verfeinerung: new TimeSpan(hour, min, sec)
td.Triggers.Add(new TimeTrigger { StartBoundary = DateTime.Today + TimeSpan.FromDays(1) + TimeSpan.FromHours(3) });

//Task Trigger: Einmaliger Task am 12.07.2012 um 13:35:36 Uhr
td.Triggers.Add(new TimeTrigger { StartBoundary = new DateTime(2012, 7, 12, 13, 35, 36) });

Für unser Projekt nutzen wir den TimeTrigger. Über diesen können wir einen exakten Zeitpunkt bestimmen. Nun benötigen wir noch eine Möglichkeit, den Task-Trigger wieder zu löschen.

//Zugriff auf einen bestehenden Task
string taskName = "Mein-Test3";

using (TaskService ts = new TaskService())
{
Task t = ts.GetTask(taskName);
       ts.RootFolder.DeleteTask(taskName);
}

Im obigen Beispiel benötigen wir den Namen des Task, den wir löschen möchten. Natürlich können wir dem per Task aufzurufenden Programm auch den Namen übergeben, damit dieser den abgelaufenen Task löschen kann. Besser ist es jedoch, nach abgelaufenen Tasks zu suchen und diese zu löschen. Vorsicht: Eventuell werden somit mehr Tasks gelöscht, als man vielleicht möchte. Da ich den Anfangsbestandteil des Tasknamen kenne („MeinTask1“,“MeinTask2“ -> „MeinTask%“), werde ich nicht nur nach abgelaufenen Tasks, sondern auch nach dem Namenbestandteil suchen, bevor ich den Task lösche.

Hinweis: Es kann einem Task selbstverständlich auch in den Setting mitgegeben werden, dass der Task sich nach Ausführung selbst löscht.

// Task löschen, wenn er nicht erneut geplant wird
td.Settings.DeleteExpiredTaskAfter = TimeSpan.FromMinutes(2);

// Task beenden nach ....
td.Settings.ExecutionTimeLimit = TimeSpan.FromMinutes(2);

Löschen von bestehenden Scheduled Task mit C#
Da wir den Task vom aufzurufenden Konsolenprogramm auch selbst löschen wollen, benötigen wir eine Möglichkeit, auf diesen zuzugreifen. Sonst würden alle abgelaufenen Tasks im Scheduler bestehen bleiben.

//Zugriff auf bestehende Scheduled-Tasks, Auslesen des Root-Ordners
TaskService taskService = new TaskService();
TaskFolder tasksFolder = taskService.GetFolder(@"");
TaskCollection listOfTasks = tasksFolder.Tasks;
foreach (Task theTask in listOfTasks)
{
//Zugriff auf den Namen aller bestehenden Tasks im Root-Order
       string s = theTask.Name;

       //Nächste Laufzeit: Abgelaufene Tasks zeigen: 01.01.0001 00:00:00
       string sNext = theTask.NextRunTime.ToString();
}

Ändern von bestehenden Scheduled Tasks

//Ändern von bestehenden Tasks

//Zugriff auf bestehende Scheduled-Tasks, Auslesen des Root-Ordners
TaskService taskService = new TaskService();
TaskFolder tasksFolder = taskService.GetFolder(@"");
TaskCollection listOfTasks = tasksFolder.Tasks;
foreach (Task theTask in listOfTasks)
{
    // Zugriff auf den Namen aller bestehenden Tasks im Root-Ordner
	// Nur bestimmte Tasks auslesen
    if (theTask.Name.StartsWith("Mein-"))
    {
        //Auslesen der Eigenschaften (Demo)
        string sName = theTask.Name;
        string sBeschreibung = theTask.Definition.RegistrationInfo.Description;
        string sAusfuehrung = theTask.Definition.Triggers.ToString();
        string sAction = theTask.Definition.Actions.ToString();

		using (TaskService ts = new TaskService())
        {
            // Neuen Task erstellen
            TaskDefinition td = ts.NewTask();

            // Setzen der Werte, die sich ändern sollen
            td.RegistrationInfo.Description = "Meine neue Task-Beschreibung";

            // Task löschen, wenn er nicht erneut geplant wird
            td.Settings.DeleteExpiredTaskAfter = TimeSpan.FromMinutes(2);

            // Task beenden nach ....
            td.Settings.ExecutionTimeLimit = TimeSpan.FromMinutes(2);

            td.Actions.Add(new ExecAction(@sAction, "", null));

            //RegisterTaskDefinition ändert den Task, wenn dieser bereits vorhanden ist
            ts.RootFolder.RegisterTaskDefinition(@sName, td);
        }
    }
}

[tweet http://twitter.com/sirmark_de/status/220481183354601472]

Im Artikel „WordPress to Twitter Plugin installieren“ haben wir eine Möglichkeit gesehen, wie wir über ein WordPress-Plugin neue Artikel automatisch als Tweet in Twitter veröffentlichen können. Wer kein WordPress nutzt oder auch ältere Artikel in den kommenden Tagen „tweeten“ möchte, der muss sich nach einer anderen Lösung umsehen.

Im folgenden Artikel möchten wir mittels C# in einer Konsolenanwendung Tweets aus einer Datenbank lesen und an Twitter senden. Selbstverständlich sind auf diesem Wege noch viele weitere Verwendungsmöglichkeiten denkbar.
Wir nutzen für die Kommunikation die DLL „tweetsharp“, die auf Github  kostenfrei erhältlich ist. Unzippen Sie die TweetSharp-Binaries und binden Sie referenzieren Sie „Hammock“, „Newtonsoft.Json“, „TweetSharp“ und „TweetSharp.Twitter“.

using System;
using System.Configuration;
using System.Diagnostics;
using TweetSharp;
using TweetSharp.Model;

namespace TweetingTest
{
    class Program
    {
        static void Main(string[] args)
        {

            TwitterClientInfo twitterClientInfo = new TwitterClientInfo();
            twitterClientInfo.ConsumerKey = "Mein-ConsumerKey"; 
            twitterClientInfo.ConsumerSecret = "Mein-ConsumerSecret-Key"; 

            TwitterService twitterService = new TwitterService(twitterClientInfo);
            twitterService.AuthenticateWith(AccessToken, AccessTokenSecret);

            string tweetMessage = "Dies ist die Tweet-Nachricht";
            TwitterStatus twitterStatus = twitterService.SendTweet(tweetMessage);
        }
}

Wie wir aus dem C#-Beispielcode sehen können, ist die Kommunikation über die eingebundenen DLLs sehr einfach. In unserem Beispiel verzichte ich auf die sichere Verwendung der API-Keys. Diese stecken hardcodiert im Quellcode. Wenn wir eine Anwendung schreiben, die in die Masse geht, ist diese Methode natürlich ungeeignet.
Zum Code selbst gibt es nicht viel zu sagen. Wir erstellen ein TwitterClient-Objekt, versorgen es mit den benötigten API-Keys, sorgen für eine Twitter-Authentifizierung und senden mittels „twitterService.SendTweet(MESSAGE)“ unsere Twitter-Nachricht. An dieser Stelle sei darauf hingewiesen, dass die DLL hier nahezu alle gewünschten Möglichkeiten der Twitter-Kommunikation bereitstellt.

Nachricht aus Datenbank lesen und an Twitter senden
Unser Ziel war es, alle bereits vorhandenen Artikel aus unserem Blog nach und nach an Twitter zu senden. Mit jedem automatisierten Aufruf (Scheduled Task) (LINK#) einer Konsolenanwendung soll ein Artikel „getweetet“ werden. Also erstellen wir uns eine kleine Datenbanktabelle. Diese besteht lediglich aus zwei Feldern: „Text“ und „URL“. Ich persönlich bin ein Fan von einem eindeutigen ID-Feld für eine Zeile; aus diesem Grund erweitere ich die Tabelle um eine ID (Primary Key). Im Feld „Text“ füllen wir die Überschrift des Artikel, im Feld URL benötigen wir die komplette URL des Artikels.

Unsere Konsole soll starten, gemäß SQL-Select den ersten Datensatz laden und diesen Twittern. Vorher muss jedoch noch eine Short-URL angelegt werden. Im Code wird per API auf Bit.ly zugegriffen und eine Short-URL erzeugt. Diese wird dann dem Text angehängt. Hier gilt zu beachten, dass die Nachricht nicht größer als 140 Zeichen wird. Aus diesem Grund müssen längere Nachrichten gekürzt werden. Die Routine zum Kürzen ist nicht optimal. Wer sich Mühe geben will, sollte dafür Sorge tragen, dass die Nachricht nur an einem Wortende abgeschnitten wird.
Ist die Nachricht nun mit einer Short-URL versehen, wird diese per API getwittert. Wir benötigen hier wieder die API-Keys von Twitter sowie von Bit.ly. Wie man diese Schlüssel generiert, wurde im Artikel „WordPress to Twitter Plugin installieren“ beschrieben.
Nun wird noch die verschickte Nachricht aus der Tabelle gelöscht.

[tweet http://twitter.com/sirmark_de/status/220479892029054977]

Es klingt banal, dennoch bereitet es oftmals Probleme: Die Konvertierung von Zahlen oder Strings nach Dezimal. Wobei die eigentliche Umrechnung nach Dezimal weniger spannend ist als das Abfangen von falschen Werten. Denn eine Exception auszulösen bei der Prüfung von Werten ist nicht immer wünschenswert. Gerade bei Jobs, die massenweise Daten importieren, kann eine solche Prüfung Zeit kosten. Und zwar massiv Zeit, die sich gewaltig in der Laufzeit des Jobs auswirkt.
Spätestens dann ist der Programmierer gezwungen, sich Gedanken über die beste Konvertierung zu machen. Untersuchen wir doch gemeinsam einmal die unterschiedlichen Methoden, um eine Zahl nach Dezimal zu Konvertieren und falsche Werte zu filtern.

Betrachten wir doch folgenden C#-Code:

string sWert = "5235.65";
decimal dErgebnis = Convert.ToDecimal(sWert);
Console.WriteLine(dErgebnis);

sWert = "falscher string";
dErgebnis = Convert.ToDecimal(sWert);
Console.WriteLine(dErgebnis);

Wir konvertieren den String „5235.65“ per Convert.ToDecimal nach Dezimal. Dies wird funktionieren. Nun nehmen wir beispielsweise eine Benutzereingabe entgegen, die einen Nicht-Dezimal-Wert enthält. C# wird bei „Convert“ eine Exception auslösen. Der Klassiker ist an dieser Stelle, die Konvertierung mit einen try-catch-Block zu umschließen. Wenn nur eine Eingabe so abgefangen werden soll, ist dies sicherlich akzeptabel. Elegant und schnell ist diese Variation jedoch nicht.

Auch die Möglichkeit, die Dezimal-Konvertierung mittels „System.Decimal.Parse“ durchzuführen, wird zum gleichen Ergebnis führen:

string sWert = "5235.65";
decimal dErgebnis = System.Decimal.Parse(sWert);
Console.WriteLine(dErgebnis);

sWert = "falscher string";
dErgebnis = System.Decimal.Parse(sWert);
Console.WriteLine(dErgebnis);

Eleganter ist es auf jeden Fall, mögliche Falscheingaben per „System.Decimal.TryParse“ abzufangen:

string sWert = "5235.65";
decimal dErgebnis = 0.0M;

if (System.Decimal.TryParse(sWert, out dErgebnis)) Console.WriteLine(dErgebnis);
Console.WriteLine(dErgebnis);

sWert = "falscher string";
if (System.Decimal.TryParse(sWert, out dErgebnis)) Console.WriteLine(dErgebnis);
Console.WriteLine(dErgebnis);

Die eben beschriebene Methode eignet sich in der Regel immer, um elegant und schnell Konvertierungen von Werten nach Dezimal vorzunehmen. Allerdings ist es immer noch einem Menge Text, die man angeben muss. Und da Programmieren von Natur aus faul sind, ist auch hier eine Verbesserung denkbar. Um es vorweg zu nehmen: Die folgende Methode erzeugt noch mehr Code. Die eigentliche Umwandlung ist jedoch elegant, schnell und ermöglicht auch einen Default-Wert mitzugeben, wenn die Umwandlung schiefgehen sollte. Wenn also in einem Projekt mehrfach eine Umwandlung nach Dezimal vorgenommen werden muss, sollte man über die folgende Methode nachdenken:

namespace ConsoleApplication1
{
    public static class StringExtensions
    {
        public static Decimal? ToDecimal(this string obj, Decimal? dBaseValue=null)
        {
            Decimal dValue;
            if (Decimal.TryParse(obj, out dValue)) return dValue;
            return dBaseValue;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

            string sWert = "5235.65";
            decimal dErgebnis = sWert.ToDecimal(0).Value;
            Console.WriteLine(dErgebnis);                     

            sWert = "falscher string";
            dErgebnis = sWert.ToDecimal(0).Value;
            Console.WriteLine(dErgebnis);
        }
     }
}

Im Artikel „Amazon S3: Wie wir einen Image-Server realisiert haben“ habe ich bereits über die Vorteile der Amazon S3 berichtet. Nun folgt der Zugriff auf die S3 mittels C#.

Daten zu Amazon S3 hochladen
Amazon selbst stellt eine einfache Oberfläche zur Verfügung. Mit dieser kann man Daten verwalten, hochladen, löschen und auch Rechte und Metadaten verwalten. Da die Daten jedoch maschinell zu S3 hochgeladen werden sollten, musste die Dokumentation studiert werden. Leider bietet Amazon keinen FTP-Zugriff aus die S3. Von Sicherheitsbedenken mal abgesehen wäre dies für uns der einfachste Weg gewesen.

Erste Schritte mit S3
Zuerst sollte man sich mit S3 über die Oberfläche vertraut machen. Man sieht sehr schnell, dass Amazon bewusste die S3 nur mit einem Minimum an Funktionen ausgestattet hat. Man sollte sich mit „Buckets“ (Eimer) auseinandersetzen. In diesem werden die Daten in der S3 gespeichert. Ein besonderes Augenmerk sollte auf die Rechtevergabe fallen, denn alle Daten, die von einem User hochgeladen werden, sind per Default auch nur für diesen zum Download zugänglich. Für einen Image-Server natürlich nicht sinnvoll.
Zudem sollten die Meta-Daten betrachtet werden. Bilder werden bereits mit dem richtigen Header ausgestattet. Um ein Expire-Date zu setzen, muss unter den Meta-Daten dies angegeben werden. Eine allgemeingültige Angabe wie im Apache-Header ist leider nicht möglich. Im Beispielcode unten wird beim Hochladen neben allgemeinen Lese-Rechten auch ein Expires-Date jedem Image vergeben.

Amazon .Net-DLL für .NET
Um die Amazon S3 mittels C# ansprechen zu können, benötigen wir die Amazon DLL „AWSSDK.dll“, die bereits stolze 2.995 KB groß ist. Sie beinhaltet jedoch alles, was man zur Kommunikation mit Amazon benötigt. Also auch weitere Schnittstellen, die über unsere C#-Kommunikation mit S3 hinaus geht. Eingebunden in ein .NET-Projekt, binden wir die DLL per „using Amazon.S3;“ ein. Je nach Anwendung erfolgen noch weitere Using-Anweisungen.

Die S3 ersetzt einen FTP-Server
Untenstehend folgt ein C#-Beispiel samt C#-Code, wie man einen S3-Bucket alternativ eines FTP-Servers nutzen kann. Wir prüfen hier, ob ein Ordner in einem Bucket exisitert und legen gegebenenfalls den Ordner in der Amazon S3 an.
Dann erfolgt der Upload einer Datei. Wir begnügen uns hier, Datei für Datei in die Amazon-Wolke hochzuladen. Die Amazon-DLL bietet auch die Möglichkeit, ganze Ordner in der S3 abzulegen. Hierzu einfach einmal die Amazon-Doku studieren.

S3: Dateien öffentlich lesbar machen
Dateien, die von einem Benutzer hochgeladen werden, sind per default auch nur von diesem lesbar. In unserem Falle möchten wir jedoch, dass alle Besucher die Dateien lesen können. Die Rechte können per Hand über die S3-Oberfläche gesetzt werden. Wenn wir jedoch per C# die Dateien hochladen, können wir den entsprechenden Header-Eintrag gleich setzen:
req.AddHeader(„x-amz-acl“, „public-read“);

S3: Dateien mit einem Expire Date versehen
Um Bandbreite zu sparen und Zugriffe zu minimieren, ist es sinnvoll, Dateien mit einem Expire Date zu versehen. Der lokale Browser wird dadurch angewiesen, bei einem zweiten Aufruf die Datei aus seinem lokalen Cache dem Kunden auszuliefern. Der Vorteil liegt auf der Hand: Die Datei muss nicht erneut angefordert werden und die Kosten für den Webbetreiber werden minimiert, da keine erneute Auslieferung der Datei aus der Cloud erfolgt.
Gerade bei Bildern, die sich selten bis nie ändern, macht es Sinn, das Expire-Date zu setzen. Welches Datum bzw. welchen Zeitraum man wählt, ist Ansichtssache. Es gibt Webmaster, die den Zeitraum nahezu bis ins unendliche ausdehnen. In unserem Beispiel erhöhen wir das aktuelle Datum (Upload-Datum) um fünf Jahre. Eine lange Zeit; die wenigsten Rechner bleiben so lange aktiv bzw. die wenigsten Besucher werden ihren lokalen Internet-Cache in diesem Zeitraum nicht leeren. Doch so haben wir auch genügend Zeit, das Bild irgendwann auszutauschen.

Mit folgendem C#-Beispiel-Code setzen Sie das Expire Date für die Amazon S3-Cloud:

//Optional: Expire Date setzen - für Images sinnvoll
CultureInfo ci = new CultureInfo("en-US");
string sExpire = DateTime.Now.AddYears(5).ToString("ddd, dd MMM yyyy hh:mm:ss", ci) + " GTM";
req.AddHeader("Expires", sExpire);

Der gesamte C#-Beispielcode mit entsprechenden Kommentare:

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Transfer; //Upload
using Amazon.S3.Util;//Upload
using System.Web; //Header
using System.Globalization;

namespace ConsoleApplication1
{
    class Program
    {

        //Amazon S3
        private const string AWS_ACCESS_KEY = "<mein AWS_ACCESS_KEY>";
        private const string AWS_SECRET_KEY = "<mein AWS_SECRET_KEY>";
        private const string BUCKET_NAME = "<mein BUCKET_NAME>";
        private const string S3_KEY = "<mein S3_KEY>";

        public static AmazonS3Client client = new AmazonS3Client(AWS_ACCESS_KEY, AWS_SECRET_KEY);

        static void Main(string[] args)
        {

            //Prüfen, ob ein Ordner in S3 exitiert, ansonsten Ordner anlegen
            if (!DoesFolderExist("mein Ordner")) CreateFolder("mein Ordner");

            //Hochladen von Dateien in die S3
            if (Upload("<Zukünftiger Dateiname in der S3>", "<ordner>", "<lokaler Filepfad>")) Console.WriteLine("Upload in die S3 erfolgreich.");
            else Console.WriteLine("Datei-Upload leider nicht erfolgreich!");

        }

        private static bool Upload(string filename, string ordner, string sFilepfad)
        {
            //Upload - Hochladen von Dateien zu Amazon S3
            bool bRes = false;

            //Ordnerstuktur: Basisornder/unterordner_ordner1
            string basisverzeichnis = "basisordner/" + ordner;

            //Existiert der Ordner in S3?
            if (!DoesFolderExist(basisverzeichnis)) CreateFolder(basisverzeichnis);

            try
            {
                //Upload Datei in Folder
                string key = string.Format("{0}/{1}", basisverzeichnis, filename);

                Amazon.S3.Model.PutObjectRequest req = new Amazon.S3.Model.PutObjectRequest().WithBucketName(BUCKET_NAME);
                req.FilePath = sFilepfad; // Lokaler vollqualifizierter Pfad inkl. Dateiname zur lokalen Quelldatei
                req.Key = key;
                req.Timeout = int.MaxValue; //Timeout nach Wunsch
                req.AddHeader("x-amz-acl", "public-read"); //Optional: Hier werden öffentliche Leserechte gesetzt

                //Optional: Expire Date setzen - für Images sinnvoll
                CultureInfo ci = new CultureInfo("en-US");
                string sExpire = DateTime.Now.AddYears(5).ToString("ddd, dd MMM yyyy hh:mm:ss", ci) + " GTM";
                req.AddHeader("Expires", sExpire);

                client.PutObject(req);

                bRes = true;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message, "Upload Error. File: " + filename);

            }
            return bRes;
        }

        public static bool DoesFolderExist(string folderName)
        {
            //Amazon S3: Prüft, ob ein Ordner vorhanden ist
            try
            {
                ListObjectsRequest request = new ListObjectsRequest();
                request.BucketName = BUCKET_NAME;
                request.WithPrefix(folderName + "/");
                request.MaxKeys = 1;

                using (ListObjectsResponse response = client.ListObjects(request))
                {
                    if (response.S3Objects.Count > 0) return true;
                }
            }
            catch (Amazon.S3.AmazonS3Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return false;
        }

        public static void CreateFolder(string folderName)
        {
            //Neuanlage eines Ordners in S3
            try
            {
                Console.WriteLine("Lege Ordner an: " + folderName);

                //Amazon S3: Anlegen eines Ordners
                var key = string.Format(@"{0}/", folderName);
                var request = new PutObjectRequest().WithBucketName(BUCKET_NAME).WithKey(key);
                request.InputStream = new MemoryStream();
                client.PutObject(request);
            }
            catch (Amazon.S3.AmazonS3Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

UPDATE 22.08.2012: Danke an den Leser „Andreas“, der festgestellt hat, dass der hier angelegte „S3-Key“ im Beispielprojekt nicht verwendet wird. Somit wird der Key auch nicht benötigt.