Einige Worte zuvor

Das Dokument »Neue Rezepte«

Ich veröffentliche die neuen Rezepte, die mit dem C# 2008 Codebook erscheinen, in einem separaten Dokument, das Sie hier finden:

Die Mailingliste

Beispiele und Rezepte

Das Repository

Verbesserte Rezepte

18.02.2008

»074 Befehlszeilenargumente auswerten«: Dieses Rezept habe ich komplett überarbeitet, so dass es zum einen auch für WPF-Anwendungen funktioniert und die Auswertung nicht zwingend in der Main-Methode erfolgen muss.

»075 Ausnahmen global behandeln«: Dieses Rezept habe ich um die Behandlung globaler Ausnahmen in WPF-Anwendungen erweitert.

»229 Die angezeigten Zeilen einer MultiLine-TextBox auslesen«: Dieses Rezept habe ich erneut korrigiert: In der ersten Version wurden angezeigte Zeilen nicht korrekt ausgelesen, wenn diese nur aus einem Zeichen bestanden. In der zweiten Version kam es zu Problemen, wenn Zeilen ein Pluszeichen enthielten. Die neue Version mit der Lösung von Axel Seibel (eines Lesers) sollte nun (endlich) keine Probleme mehr haben (.

»230 ComboBox mit Autovervollständigung«: Wegen des Problems mit der Windows.Forms-ComboBox, dass diese die Einträge nach deren String-Darstellung sortiert, was dann Probleme macht, wenn die Liste als Quelle der Autovervollständigungsliste verwendet wird, habe ich die im ersten Codebook entwickelte AutoCompleteComboBox in einer weiterentwickelten Form wirder aufgenommen.

»262 Daten symmetrisch ver- und entschlüsseln«: Dieses Rezept hatte Probleme mit dem Verschlüsseln von Strings, die Zeichen im Unicode-Bereich über 255 enthielten. Diesen Fehler habe ich beseitigt. Außerdem habe ich die Klasse SymmetricEncryptor um den AES-Algorithmus erweitert.

»263 Daten mit Hashing-Verfahren verschlüsseln«: Dieses Rezept habe ich um die Berücksichtigung der Hashing-Klassen in der CNG-Implementierung (Cryptography Next Generation) erweitert.

»263 Daten mit Hashing-Verfahren verschlüsseln«: Dieses Rezept habe ich um die Berücksichtigung der Hashing-Klassen in der CNG-Implementierung (Cryptography Next Generation) erweitert (die laut der Dokumentation nur unter Windows Vista, Windows XP SP2 und Windows Server 2003 unterstützt werden, auf meinem XP-SP2-System aber trotzdem eine NotSupportedException hervorrufen). Außerdem habe ich der Hasher-Klasse die Eigenschaften MaxKeyLength und SupportsKey hinzugefügt. Im set-Accessor der Key-Eigenschaft wird zusätzlich überprüft, ob die Länge des übergebenen Schlüssels die Maximallänge nicht überschreitet.

»290 Pfeile zeichnen«: Dieses Rezept zeichnet die viel schöneren Pfeile nun auch für WPF-Anwendungen (.

WPF

Die folgenden Rezepte habe ich um die Berücksichtigung von WPF erweitert:

»268 Das Format eines Bilds auslesen«

»269 Bild-Metadaten auslesen«

»270 Das Aufnahmedatum eines Bilds auslesen«

»271 Eingelesene Bilder im Originalformat speichern«

»272 Bild in Byte-Array umwandeln«

»273 Byte-Array in Bitmap umwandeln«

»274 Bilder aus der Zwischenablage auslesen«

»275 Screenshot erstellen«: Dieses Rezept habe ich neben der Berücksichtigung von WPF zusätzlich noch darum verbessert, dass halbtransparente Fenster unterstützt werden.

»276 Bilder skalieren«

»277 Thumbnails aus Bildern erzeugen«

»278 Bilder konvertieren«

»279 (JPEG-)Bilder mit definierter Qualität speichern«

»280 Bilder drehen, neigen und spiegeln«

»281 Bildausschnitte auslesen«

»282 Farben von Bildern auf andere Farben mappen«

»283 Farbinformationen von Bildern gezielt verändern«

»284 Ein Negativ eines Bilds erzeugen«

»285 Die einzelnen Pixel eines Bilds bearbeiten«

»286 Farb-Bilder in Graustufen-Bilder umwandeln«

»289 Rechtecke mit abgerundeten Ecken zeichnen«

»291 Transparente Bilder und Grafiken erzeugen«

»292 Bilder mit Schatten zeichnen«

»293 Schräg zeichnen und Zeichenobjekte rotieren«

»294 Den Drehpunkt eines Rechtecks so ermitteln, dass die Ecke links oben an derselben Position bleibt«

»295 Text an einer definierten Position in 90-Grad-Schritten gedreht ausgeben«

»296 Die Breite und Höhe eines auszugebenden Textes bestimmen«

»297 Texte zentriert oder rechtsbündig «

»298 Strings beim Zeichnen wortgerecht umbrechen«

»312 In einem Thread sicher auf Steuerelemente zugreifen«

LINQ to SQL

Die folgenden Rezepte habe ich um die Berücksichtigung von LINQ to SQL erweitert:

»317 Datenbanken erzeugen«

»318 Abfragen der automatisch vergebenen Id eines neuen Datensatzes«

»319 Bilder und andere binäre Daten in einer Datenbank verwalten«

24.08.2007

»229 Die angezeigten Zeilen einer MultiLine-TextBox auslesen«: In diesem Rezept wurden angezeigte Zeilen nicht korrekt ausgelesen, wenn diese nur aus einem Zeichen bestanden. Diesen Fehler habe ich korrigiert.

09.07.2007

»035 Zufalls-String berechnen«: Die GetRandomString-Methode habe ich um das Argument type erweitert. Über dieses Argument können Sie festlegen, dass der Zufalls-String aus allen »normalen« Zeichen zwischen dem ASCII-Wert 33 und 126, ausschließlich aus Buchstaben oder ausschließlich aus kleingeschriebenen Buchstaben bestehen soll.

»197 E-Mails über einen SMTP-Server versenden«: Dieses Rezept habe ich um das Anfordern einer Übertragungs- und einer Lesebestätigung erweitert und zusätzlich die Konfiguration von SMTP in der app.config erläutert. Zum Beispiel habe ich außerdem ein Formular hinzugefügt, das Sie in Ihren Projekten als Basis für ein Mailversand-Formular verwenden können.

05.05.2007

»041 Arrays, ArrayList- und andere Auflistungen durchsuchen«: In diesem Rezept habe ich die BinarySearch-Methode als effiziente Möglichkeit vorgestellt, ein Array oder eine Auflistung zu sortieren. Ein Fehler im Rezept ist, dass BinarySearch ein sortiertes Array für eine korrekte Funktionsweise erzwingt, und nicht, wie ich beschrieben habe, eine Sortierung lediglich die Performance verbessern würde.

Zudem wird die bessere Performance beim Suchen durch das im Vergleich dazu sehr langsame Sortieren aufgehoben. Das Sortieren dauert sogar häufig so lange, dass BinarySearch sich erst dann lohnt, wenn mehr als 10 Suchvorgänge hintereinander ausgeführt werden.

Eine weitere Verbesserung des Rezepts ist die Feststellung, dass die eigene sequentielle Suche schneller (!) und flexibler ist als die Suche über IndexOf.

»092 Konsolenanwendungen starten und die Ausgabe auswerten«:
Dieses Rezept habe ich um die Auswertung des Rückgabecodes und des Fehlerkanals der Anwendung erweitert.

»157 (ZIP-)Archive entpacken«: Neben dem bereits in einer vorherigen Version korrigierten Bug, dass bei Archiveinträgen, die mit dem Ordner »\« versehen waren, eine Exception auftrat, habe ich einen weiteren Bug beseitigt: Die Vorversion führte zu einer Exception wenn ein Archiv eine 0-Byte-Datei beinhaltete. Die aktuelle Version liest diese Datei natürlich nicht aus dem Archiv aus, erzeugt sie aber.

15.03.2007

»044 Die Nachrichten einer Exception und ihrer inneren Exceptions ermitteln«: Dieses Rezept habe ich um die Behandlung von SoapExceptions und HttpExceptions erweitert.

17.02.2007

»227: Bei der Betätigung der Return-Taste die Tab-Taste simulieren«

20.01.2007

»123 Programmdateien in den Systempfaden suchen«: Die Methode FindFileInSystemPaths berücksichtigte nicht die Tatsache, dass Pfadangaben im Pfad auch in Anführungszeichen eingebettet sein können. Dieser Fall führte zu einer Exception »Illegales Zeichen im Pfad«

18.10.2006

»290 Pfeile zeichnen«: Dieses Rezept zeichnet Pfeile nun viel schöner (.

13.9.2006

»077 Konfigurationsdaten in der .config-Datei verwalten«

Basics

035 Zufalls-String berechnen

Die GetRandomString-Methode habe ich um das Argument type erweitert. Über dieses Argument können Sie festlegen, dass der Zufalls-Sgtring aus allen »normalen« Zeichen zwischen dem ASCII-Wert 33 und 126, ausschließlich aus Buchstaben oder ausschließlich aus kleingeschriebenen Buchstaben bestehen soll.

/* Enum für die Art der Erzeugung von Zufalls-Strings */
public enum RandomStringType
{
   /* Alle normalen Zeichen zwischen 33 und 122 */
   AllRegularChars,

   /* Nur Buchstaben */
   OnlyLetters,

   /* Nur kleingeschriebene Buchstaben */
   OnlyLowercaseLetters
}

/* Erzeugt einen Zufalls-String */
public static string GetRandomString(int count, 
   RandomStringType type)
{
   StringBuilder randomString = new StringBuilder(count);

   // Echte Zufallszahlen im Bereich von 1 bis 255 erzeugen
   RNGCryptoServiceProvider rngCSP = new RNGCryptoServiceProvider();
   byte[] numbers = new byte[count];
   rngCSP.GetNonZeroBytes(numbers);
   
   // Random-Instanz für einen String mit Großbuchstaben erzeugen
   Random ucaseRandom = new Random();
   
   if (type == RandomStringType.AllRegularChars)
   {
      // Die Zahlen so umrechnen, dass Werte zwischen 33 und 126 
      // herauskommen, und die daraus resultierenden Zeichen an den 
      // Ergebnisstring anhängen
      for (int i = 0; i < count; i++)
      {
         numbers[i] = (byte)(numbers[i] / 2.713 + 33);
         randomString.Append((char)numbers[i]);
      }
   }
   else
   {
      // Die Zahlen so umrechnen, dass Werte zwischen 97 und 122 
      // herauskommen, und die daraus resultierenden Zeichen an den 
      // Ergebnisstring anhängen
      for (int i = 0; i < count; i++)
      {
         numbers[i] = (byte)(numbers[i] / 9.81 + 97);
         if (type == RandomStringType.OnlyLetters)
         {
            // Den Buchstaben zufällig in einen 
            // Großbuchstaben umwandeln
            if (ucaseRandom.Next(3) == 2)
            {
               numbers[i] = (byte)(numbers[i] - 32);
            }
         }
         randomString.Append((char)numbers[i]);
      }
   }

   return randomString.ToString();
}

041 Arrays, ArrayList- und andere Auflistungen durchsuchen

In diesem Rezept habe ich die BinarySearch-Methode als effiziente Möglichkeit vorgestellt, ein Array oder eine Auflistung zu sortieren. Ein Fehler im Rezept ist, dass BinarySearch ein sortiertes Array für eine korrekte Funktionsweise erzwingt, und nicht, wie ich beschrieben habe, eine Sortierung lediglich die Performance verbessern würde.

Zudem wird die bessere Performance beim Suchen durch das im Vergleich dazu sehr langsame Sortieren aufgehoben. Das Sortieren dauert sogar häufig so lange, dass BinarySearch sich erst dann lohnt, wenn mehr als 10 Suchvorgänge hintereinander ausgeführt werden.

Hier ist mein neuer Text:

Sequentielle Suche

Sie in der Regel schnellste und flexibelste Möglichkeit ist die eigene, sequentielle Suche. Warum diese Suche normalerweise schneller als die anderen ist, kläre ich nach der Beschreibung von IndexOf und am Ende der Beschreibung von BinarySearch. Flexibel ist diese Art der Suche aus dem Grund, dass Sie selbst entscheiden können, welche Felder oder Eigenschaften der Objekte oder ob Sie die Referenzen vergleichen wollen.

Die folgende Struktur implementiert z. B. Kreisdaten:

public struct CircleStruct 
{
   public int X;
   public int Y;
   public int Radius;

   public CircleStruct(int x, int y, int radius)
   {
      this.X = x;
      this.Y = y;
      this.Radius = radius;
   }
}

Listing 0.2 zeigt, wie Sie in einer Auflistung von Instanzen der CircleStruct-Struktur nach Kreisen mit einem Radius von 50 suchen:

// Auflistung von 1.000.000 Circle-Werttyp-Objekten erzeugen
List<CircleStruct> circleValueTypeList = new List<CircleStruct>();
Random random = new Random();
for (int i = 0; i < 1000000; i++)
{
   circleValueTypeList.Add(new CircleStruct(random.Next(1, 11), 
      random.Next(1, 11), random.Next(1, 101)));
}

// Alle Kreise mit dem Radius 50 suchen
List<int> result = new List<int>();
for (int i = 0; i < circleValueTypeList.Count; i++)
{
   if (circleValueTypeList[i].Radius == 50)
   {
      result.Add(i);
   }
}

Die sequentielle Suche funktioniert natürlich genauso mit einer Auflistung oder einem Array von Referenztypen.

Suche mit IndexOf

Diese Methode sucht sequentiell nach dem übergebenen Objekt. Die Objekte werden dabei intern über deren Equals-Methode verglichen. Ist diese nicht in den Objekten überschrieben, werden bei Referenztypen die Referenzen und bei Werttypen alle öffentlichen Felder und Eigenschaften verglichen. Speichern Sie in einer Auflistung z. B. Instanzen einer Circle-Klasse und übergeben Sie IndexOf eine Referenz auf ein Circle-Objekt, sucht diese Methode nach genau diesem Objekt. Andere Objekte, die denselben Inhalt aufweisen wie das Suchobjekt (in unserem Beispiel dieselben Werte für X, Y und Radius), werden nicht gefunden. Speichern Sie in der Auflistung Instanzen einer Struktur wird natürlich nicht nach der Referenz gesucht. In diesem Fall findet IndexOf alle Objekte, deren Inhalt dem des Suchobjekts entspricht. Beim Suchen nach einem Kreis mit X = 5, Y = 10 und Radius = 100 werden alle Kreise gefunden, deren Eigenschaften dieselben Werte aufweisen. Implementieren die Objekte allerdings die von object geerbte Equals-Methode, entspricht das Suchergebnis natürlich dieser Implementierung.

Um alle Objekte zu finden, müssen Sie IndexOf in einer Schleife aufrufen.

Listing 0.3 zeigt, wie Sie mit IndexOf in einer Auflistung von Strukturen nach Objekten suchen:

// Auflistung von 1.000.000 Circle-Werttyp-Objekten erzeugen
List<CircleStruct> circleValueTypeList = new List<CircleStruct>();
Random random = new Random();
for (int i = 0; i < 1000000; i++)
{
   circleValueTypeList.Add(new CircleStruct(random.Next(1, 11), 
      random.Next(1, 11), random.Next(1, 101)));
}

// Mit IndexOf in der Auflistung der Werttyp-Kreise suchen.
// Bei der Suche in einer Auflistung von Werttypen werden immer die 
// öffentlichen Eigenschaften und Felder der Objekte verglichen.
CircleStruct compareCircle = new CircleStruct(5, 10, 50);
List<int> result = new List<int>();

// Ersten Kreis suchen
int index = circleValueTypeList.IndexOf(compareCircle);
while (index > -1)
{
   result.Add(index);

   // Weitersuchen
   index = circleValueTypeList.IndexOf(compareCircle, index + 1);
}

Die Performance

Ich habe auch eine Erklärung für die bessere Performance beim eigenen sequentiellen Suchen: IndexOf verwendet intern eine Schleife über alle Elemente. Innerhalb der Schleife wird das zu suchende Objekt über die Equals-Methode verglichen. Der Aufruf einer Methode benötigt natürlich ein wenig mehr Zeit als ein direkter Vergleich von Objekten.

IndexOf ist also eigentlich nur dann für eine Suche geeignet, wenn Sie nach einem Objekt suchen, das nur einmal in der Liste vorkommt, und Sie den Vergleich über Equals verwenden wollen.

Suchen mit BinarySearch

BinarySearch führt eine effiziente binäre Suche in den Elementen aus, was allerdings voraussetzt, dass die Liste aufsteigend sortiert ist. Ohne eine aufsteigende Sortierung führt BinarySearch zu keinem oder einem falschen Ergebnis! Das Sortieren setzt voraus, dass der in der Auflistung verwaltete Typ CompareTo-Methode der IComparable-Schnittstelle implementiert.

Das notwendige Sortieren ist der Knackpunkt dieser Methode, da es sehr viel Zeit in Anspruch nimmt. BinarySearch lohnt sich nur deswegen dann, wenn Sie mehrfach in demselben Array bzw. in derselben Auflistung suchen müssen, oder wenn diese sowieso schon sortiert sind.

Listing 0.4 zeigt eine erweiterte CircleClass-Klasse, die das Sortieren und Suchen nach dem Radius ermöglicht.

public class CircleClass: IComparable<Circle>
{
   public int x;
   public int y;
   public int Radius;

   public CircleClass (int x, int y, int radius)
   {
      this.x = x;
      this.y = y;
      this.Radius = radius;
   }

   /* Implementierung der CompareTo-Methode */
   public int CompareTo(CircleClass otherCircle)
   {
      return (this.Radius.CompareTo(otherCircle.Radius));
   }
}

Die CompareTo-Methode ist in diesem Beispiel sehr einfach, weil zum Vergleich die gleichnamige Methode der Radius-Eigenschaft aufgerufen werden kann.

Um mit BinarySearch zu suchen, rufen Sie diese Methode zunächst einmal auf, um das erste Objekt zu finden. Dieses Objekt ist aber nicht unbedingt auch das erste der Objekte, in der Auflistung, die die Suchkriterien erfüllen. Das liegt an der Natur des Suchalgorithmus, der die Liste immer wieder in Hälften aufteilt und das Objekt in der Mitte mit dem Suchobjekt vergleicht. Das erste gefundene Objekt kann also irgendwo innerhalb der Unter-Liste der Objekte liegen, die die Suchkriterien erfüllen.

Um alle Objekte zu finden, müssen Sie nach der ersten Suche die Liste ab dem gefundenen Index einmal nach oben und einmal nach unten durchgehen. Ich zeige dies am Beispiel der bereits oben verwendeten Auflistung von 1.000.000 Kreis-Objekten:

// Auflistung von 1.000.000 Kreis-Referenztyp-Objekten erzeugen
List<CircleClass> circleReferenceTypeList = new List<CircleClass>();
Random random = new Random();
for (int i = 0; i < 1000000; i++)
{
   circleReferenceTypeList.Add(new CircleClass(random.Next(1, 11), 
      random.Next(1, 11), random.Next(1, 101)));
}

// Ersten Kreis mit einem Radius von 50 suchen
CircleClass compareCircle = new CircleClass(0, 0, 50);
List<int> result = new List<int>();
int index = circleReferenceTypeList.BinarySearch(compareCircle);
if (index > -1)
{
   // Ergebnis speichern
   result.Add(index);
}

// Nächsten Kreis nach unten suchen
for (int i = index + 1; i < circleReferenceTypeList.Count; i++)
{
   if (circleReferenceTypeList[i].CompareTo(compareCircle) == 0)
   {
      // Ergebnis speichern
      result.Add(i);
   }
   else
   {
      // Schleife abbrechen
      break;
   }
}

// Nächsten Kreis nach oben suchen
for (int i = index - 1; i > -1; i--)
{
   if (circleReferenceTypeList[i].CompareTo(compareCircle) == 0)
   {
      // Ergebnis speichern
      result.Add(i);
   }
   else
   {
      // Schleife abbrechen
      break;
   }
}

044 Die Nachrichten einer Exception und ihrer inneren Exceptions ermitteln

Dieses Rezept habe ich um die Behandlung von Ausnahmen vom Typ SoapException und HttpException erweitert:

SoapExceptions, die dann auftreten, wenn aufgerufene Webdienst-Methoden Exceptions werfen, erfahren eine Sonderbehandlung. Bei diesen Exceptions existiert nach meinen Erfahrungen und Informationen aus dem Internet keine innere Exception. Die Nachricht der SoapException ist leider (zumindest für den Endanwender) recht kryptisch. Eine solche Nachricht sieht prinzipiell (zumindest für .NET-Webdienste) so aus:

Die Anforderung konnte vom Server nicht verarbeitet werden. --->
<Nachricht der eigentlichen Ausnahme>

Dies gilt für den Fall, dass in der Webanwendung der Modus der CustomErrors-Einstellung auf on geschaltet ist (oder auf remoteOnly und der Aufruf der Webmethode stammt von einem anderen Rechner). Ist der Modus der

CustomErrors-Einstellung auf off geschaltet (oder auf remoteOnly und der Aufruf stammt von demselben Rechner), ist die Nachricht detaillierter:

System.Web.Services.Protocols.SoapException: Die Anforderung 
konnte vom Server nicht verarbeitet werden. ---> <Typ der 
eigentlichen Exception>: <Nachricht der eigentlichen Exception>
<Stack-Trace>
   --- Ende der internen Ausnahmestapelüberwachung ---

Die Auswertung der eigentlichen Nachricht gestaltet sich damit leider etwas kompliziert.

Der Start der Nachricht wird an dem String "--->" gefolgt von beliebigem Text und einem Doppelpunkt erkannt. Das Ende der Nachricht ist etwas schwerer zu erkennen, da es ja sein kann, dass der Stack-Trace an die Nachricht angehängt ist. Der Start des Stack-Trace könnte daran erkannt werden, dass die Zeile mit " bei" beginnt, aber das wäre sehr unsicher und müsste für alle möglichen Sprachen implementiert werden. Deshalb werte ich das Muster "\n " als Anfang des Stack-Trace.

Zum Kompilieren dieser Methode müssen Sie die Namensräume System und System.Text.RegularExpressions importieren. Wenn Sie den Teil mit der Auswertung der HttpException-Ausnahmen übernehmen, müssen Sie außerdem die Assembly System.Web referenzieren.

public static string GetExceptionMessages(Exception ex)
{
   string messages = null;

   if (ex is System.Web.HttpException)
   {
      // Bei einer HttpException sollte GetBaseException aufgerufen
      // werden um den zugrundeliegenden Fehler herauszufinden
      ex = ((System.Web.HttpException)ex).GetBaseException();
   }

   // SoapExceptions müssen separat behandelt werden, da diese
   // einen allgemeinen Text, die Nachricht der ursprünglichen
   // Exception und den StackTrace in der Message-Eigenschaft,
   // und leider keine InnerException verwalten.
   if (ex is System.Web.Services.Protocols.SoapException)
   {
      // Nachricht auslesen
      messages = ex.Message;

      // Löschen des einleitenden Textes, der mit ---> beginnt
      int pos1 = messages.IndexOf("--->");
      if (pos1 > -1)
      {
         int pos2 = messages.IndexOf(":", pos1 + 3);
         if (pos2 > -1)
         {
            messages = messages.Remove(0, pos2 + 1).Trim();
         }
         else
         {
            messages = messages.Remove(0, pos1 + 4).Trim();
         }
      }

      // Löschen des StackTrace (der mit "\n   " eingeleitet wird)
      Match match = Regex.Match(messages, "\n   ");
      if (match.Success)
      {
         messages = messages.Remove(match.Index,
            messages.Length - match.Index).Trim();
      }
   }
   else
   {
      // Die Nachricht der aktuellen Exception ermitteln
      messages = ex.Message;

      // Die Nachricht(en) der inneren Exception ermitteln
      if (ex.InnerException != null)
      {
         messages += Environment.NewLine +
            GetExceptionMessages(ex.InnerException);
      }

      // Überprüfen, ob Nachrichten eventuell mehrfach vorkommen
      string[] messageList = Regex.Split(messages, 
         Environment.NewLine);
      for (int i = 0; i < messageList.Length; i++)
      {
         string message = messageList[i];
         for (int j = i + 1; j < messageList.Length; j++)
         {
            if (messageList[j] == messageList[i])
            {
               messageList[j] = null;
            }
         }
      }

      // Die übrig gebliebenen Nachrichten wieder zu einem String
      // zusammensetzen
      messages = null;
      for (int i = 0; i < messageList.Length; i++)
      {
         if (messageList[i] != null)
         {
            if (messages != null)
            {
               messages += Environment.NewLine;
            }
            messages += messageList[i];
         }
      }
   }

   // Ergebnis zurückgeben
   return messages;
}

Anwendungen, Anwendungs-Konfiguration, Prozesse und Dienste

074 Befehlszeilenargumente auswerten

Dieses Rezept habe ich komplett überarbeitet, so dass es zum einen auch für WPF-Anwendungen funktioniert und die Auswertung nicht zwingend in der Main-Methode erfolgen muss:

explorer C:\Windows

Befehlszeilenargumente werden dabei durch Leerzeichen vom Programmdateinamen und von anderen Befehlszeilenargumenten getrennt. Beim folgenden Aufruf eines Programms:

Demo.exe Das ist ein Test

werden die Argumente "Das", "ist", "ein" und "Test" übergeben. Werden Argumente in Anführungszeichen eingeschlossen, resultiert ein einziges Argument:

Demo.exe "Das ist ein Test"

Dieses Beispiel resultiert in dem einzigen Argument "Das ist ein Test". Argumente, die selbst Leerzeichen enthalten, müssen beim Aufruf also in Anführungszeichen eingeschlossen werden:

explorer "C:\Dokumente und Einstellungen"

In Ihren (Windows-)Anwendungen können Sie Befehlszeilenargumente ebenfalls auswerten. In einer Windows.Forms- oder Konsolenanwendung können Sie dazu die Main-Methode, die normalerweise in der Klasse Program implementiert ist, um ein Argument vom Typ string-Array erweitern:

[STAThread]
static void Main(string[] arguments)
{

In diesem Array werden alle Argumente übergeben, die beim Aufruf des Programms angegeben wurden. Dieses Vorgehen ist jedoch nicht zu empfehlen, da Sie zum einen auf die Auswertung in der Main-Methode eingeschränkt sind. Zum anderen wird die Main-Methode in einer mit Visual Studio entwickelten WPF-Anwendung automatisch erzeugt und Sie haben keine Möglichkeit, darin zu programmieren.

Um keine Probleme bei der Auswertung zu haben, sollten Sie die Syntax der einzelnen Argumente so festlegen, dass diese prinzipiell keine Leerzeichen enthalten. In der Praxis bestehen viele Befehlszeilenargumente aus einem Binde- oder Schrägstrich, gefolgt von einem Namen, einem Doppelpunkt und einem Wert:

-Argumentname:Argumentwert

Beim Aufruf der Anwendung kann der Argumentwert in Anführungszeichen eingeschlossen werden, sofern dieser Leerzeichen enthält:

Imager.exe -imageFolder:"C:\Bilder für die Website"

Die Auswertung solcher Argumente ist dann relativ einfach. Dazu gehen Sie die Elemente des von GetCommandLineArgs zurückgegebenen String-Array ab dem Index 1 durch und vergleichen die einzelnen Argumente mit den erwarteten. Die Programmierung kann an beliebiger Stelle innerhalb der Anwendung erfolgen, wird aber meistens in der Load-Methode des Start-Formulars bzw. -Fensters oder in der Main-Methode untergebracht.

Das folgende Beispiel liest auf diese Weise die erwarteten Argumente -debugmode und -imagefolder:Ordnerangabe aus. Beim imagefolder-Argument wird die Angabe eines Ordners erwartet, der mit einem Doppelpunkt vom Argumentnamen getrennt wird. Um die Groß-/Kleinschreibung nicht zu berücksichtigen werden die Argumente über die ToLower-Methode in Kleinschreibung umgewandelt. Zur Sicherheit werden unbekannte Argumente in der String-Variablen unknownArguments gesammelt und falls vorhanden nach der Auswertung in einer MessageBox gemeldet.

Das Beispiel basiert auf einer WPF-Anwendung mit den üblichen Referenzen und using-Direktiven. Im Formular ist ein Label angelegt, das lblArguments heißt. In diesem Label werden die übergebenen Befehlszeilenargumente ausgegeben.

private void Window_Loaded(object sender, RoutedEventArgs e)
{
   // Auswerten der Befehlszeilenargumente
   bool debugMode = false;
   string imageFolder = null;
   string unknownArguments = null;
   string[] args = Environment.GetCommandLineArgs();
   for (int i = 1; i < args.Length; i++)
   {
      string loweredArgument = args[i].ToLower();
      if (loweredArgument == "-debugmode")
      {
         debugMode = true;
      }
      else if (loweredArgument.StartsWith("-imagefolder:"))
      {
         // Den Argumentwert auslesen
         imageFolder = args[i].Substring(13, args[i].Length - 13);
      }
      else
      {
         // Unbekanntes Argument
         if (unknownArguments != null)
         {
            unknownArguments += ", ";
         }
         unknownArguments += args[i];
      }
   }

   // Unbekannte Argumente auswerten
   if (unknownArguments != null)
   {
      MessageBox.Show("Die folgenden Argumente sind ungültig: " +
         unknownArguments, "Befehlszeilenargumente auswerten", 
         MessageBoxButton.OK, MessageBoxImage.Exclamation);
   }

   // Die Argumente auswerten
   this.lblArguments.Content = "debugmode: " + debugMode + 
      Environment.NewLine + "imageFolder: " + imageFolder;
}

Sehr nett von Windows ist, dass in Anführungszeichen eingeschlossene Argumente automatisch so ausgewertet werden, dass die Anführungszeichen entfernt werden. Beim Aufruf mit den Argumenten

-debugMode -imageFolder:"C:\Bilder für die Website"

werden zum Beispiel "-debugMode" und "-imageFolder:C:\Bilder für die Website" übergeben.

075 Ausnahmen global behandeln

Dieses Rezept habe ich um die Behandlung globaler Ausnahmen in WPF-Anwendungen erweitert:

Der Debuggen-Schalter im neueren Dialog (Abbildung 0.2) ist nur dann vorhanden, wenn auf dem System ein Debugger installiert ist. Dies ist nur dann der Fall, wenn das .NET-Framework-SDK installiert ist. Über diesen Schalter kann die Anwendung debugt werden. Der Debugger berücksichtigt aber für den Fall, dass der Quellcode nicht im Ordner der Anwendung gespeichert ist (was ja in der Regel nicht der Fall ist), nur den CIL-Code. Damit können nur absolute System-Profis etwas anfangen.

Die meisten Benutzer werden wohl mit diesen Möglichkeiten überfordert sein. Außerdem kann es sein, das beim Beenden der Anwendung Daten verloren gehen. Um dies zu verhindern können Sie selbstverständlich alle Ausnahmen im Programm explizit behandeln, was Sie dadurch erreichen, dass Sie zumindest in jeder Ereignismethode eine Ausnahmebehandlung implementieren. Eigentlich ist dies auch der bessere Weg, da Sie dem Benutzer dann genauere Informationen über den Kontext des Fehlers geben können.

In einer WPF-Anwendung erreichen Sie das DispatcherUnhandledException-Ereignis über die von Application abgeleitete Klasse (normalerweise die App-Klasse), die die WPF-Anwendung repräsentiert. Im Konstruktor können Sie das Ereignis zuweisen. Die Eigenschaft Exception des Ereignisargument-Objekts liefert die aufgetretene Ausnahme. Nach der Verarbeitung der Ausnahme müssen Sie die Eigenschaft Handled des übergebenen Ereignisargument-Objekts auf true setzen, damit die Ausnahme nicht an die CLR weiter gegeben wird:

public partial class App : Application
{
   /* Konstruktor */
   public App()
   {
      // Zuweisen der globalen Ausnahmebehandlung für den UI-Thread
      this.DispatcherUnhandledException +=  new System.Windows.Threading.
         DispatcherUnhandledExceptionEventHandler(
         this.App_DispatcherUnhandledException);
   }

   /* Behandelt alle unbehandelten Ausnahmen, die im UI-Thread auftreten.
      Behandelt keine unbehandelten Ausnahmen, die in anderen Threads 
      auftreten! */
   private void App_DispatcherUnhandledException(object sender, 
      System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
   {
      // Ausnahme ausgeben
      MessageBox.Show("Unerwarteter Fehler: " + e.Exception.Message,
         "Globale Ausnahmebehandlung in WPF", MessageBoxButton.OK, 
         MessageBoxImage.Error);
      
      // Das Ereignis als 'Behandelt' kennzeichnen, damit die Ausnahme
      // nicht an die CLR weitergegebern wird
      e.Handled = true;

      // Hier können (und sollten) Sie Ausnahmen protokollieren. 
      // Wenn Sie den Stack-Trace protokollieren, hilft diese enorm
      // bei der späteren Fehlersuche.
   }
}

static class Program
{
   [STAThread]
   static void Main()
   {
      // Zuweisen der globalen Ausnahmebehandlung für den UI-Thread
      Application.ThreadException += 
         new System.Threading.ThreadExceptionEventHandler(
         Application_ThreadException);

      Application.EnableVisualStyles();
      Application.SetCompatibleTextRenderingDefault(false);
      Application.Run(new MainForm());
   }

   /* Behandelt alle unbehandelten Ausnahmen, die im UI-Thread auftreten. 
      Behandelt keine unbehandelten Ausnahmen, die in anderen Threads
      auftreten! */
   private static void Application_ThreadException(object sender,
      System.Threading.ThreadExceptionEventArgs e)
   {
      // Ausnahme ausgeben
      MessageBox.Show("Unerwarteter Fehler: " + e.Exception.Message, 
         Application.ProductName, MessageBoxButtons.OK,
         MessageBoxIcon.Error);

      // Hier können (und sollten) Sie Ausnahmen protokollieren. 
      // Wenn Sie den Stack-Trace protokollieren, hilft diese enorm
      // bei der späteren Fehlersuche.
   }
}

077 Konfigurationsdaten in der .config-Datei verwalten

Zum Schreiben und Lesen der Programmeinstellungen müssen Sie keine Instanz der Settings-Klasse erzeugen, sondern können Sie einfach die Default-Instanz verwenden, die Sie über die statische Default-Eigenschaft erreichen:

// Hintergrundfarbe des Formulars einlesen
this.BackColor = Properties.Settings.Default.BackColor;

// Position und Größe des Formulars auslesen
this.Left = Properties.Settings.Default.StartFormLeft;
this.Top = Properties.Settings.Default.StartFormTop;
this.Width = Properties.Settings.Default.StartFormWidth;
this.Height = Properties.Settings.Default.StartFormHeight;

// Position und Größe des Formulars in der Konfiguration ablegen
Properties.Settings.Default.StartFormLeft = this.Left;
Properties.Settings.Default.StartFormTop = this.Top;
Properties.Settings.Default.StartFormWidth = this.Width;
Properties.Settings.Default.StartFormHeight = this.Height;

// Konfiguration speichern
try
{
   Properties.Settings.Default.Save();
}
catch (Exception ex)
{
   MessageBox.Show("Fehler beim Speichern der Konfiguration: " + ex.Message, 
      Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}

Listing 0.6: Schreiben von Programmeinstellungen

092 Konsolenanwendungen starten und die Ausgabe auswerten

Dieses Rezept habe ich um die Auswertung des Rückgabecodes und des Fehlerkanals der Anwendung erweitert. Hier ist der neue Text:

Zunächst benötigen Sie ein ProcessStartInfo-Objekt (aus dem Namensraum System.Diagnostics), das Sie im Konstruktor mit dem Dateinamen der zu startenden Anwendung initialisieren. Das Beispiel in Listing 0.7 erzeugt ein solches Objekt für das Windows-Zubehör-Programm ipconfig (das die aktuelle IP-Konfiguration an der Konsole ausgibt). Wenn Sie Argumente übergeben wollen (oder müssen), schreiben Sie diese in die Eigenschaft Arguments.

Dann starten Sie den Prozess über die Start-Methode der Process-Klasse, der Sie die ProcessStartInfo-Instanz übergeben. Über die WaitForExit-Methode warten Sie auf das Ende des Prozesses. Hier sollten Sie am ersten Argument einen Timeout in Millisekunden übergeben, da es vorkommen kann, dass die Ausführung der Konsolenanwendung blockiert wird (z. B. weil diese den Anwender fragt, ob eine bestimmte Aktion wirklich ausgeführt werden soll).

Die Start-Methode gibt eine Referenz auf das Process-Objekt zurück, das den gestarteten Prozess repräsentiert. Sie sollten diese Referenz in eine Variable schreiben.

Um auszuwerten, ob der Prozess innerhalb des Timeout beendet wurde, fragen Sie die HasExited-Eigenschaft des Process-Objekts ab. Ist diese true, sollten Sie zunächst ermitteln, ob ein Fehler aufgetreten ist. Viele Konsolenanwendungen geben dazu einen Integerwert zurück, den Sie über die Eigenschaft ExitCode erreichen. Der Wert 0 bedeutet normalerweise, dass kein Fehler aufgetreten ist. Verlassen können Sie sich darauf aber nicht, eine Anwendung ist nicht gezwungen, den Rückgabewert zu setzen. Sie müssen die Rückgabe des Programms im Einzelfall also immer prüfen.

ber die Eigenschaft StandardError können Sie den Fehlerkanal auslesen. Die eigentliche Ausgabe des Programms erreichen Sie über StandardOutput. Diese Eigenschaften referenzieren je einen StreamReader.

Das folgende Listing zeigt am Beispiel von ipconfig, wie Sie eine »normale« Konsolenanwendung starten und deren Ergebnis auswerten. Das Beispiel geht davon aus, dass die Anwendung bei einem Fehler einen Rückgabewert ungleich 0 zurückgibt und die Fehlermeldung in den Fehlerkanal schreibt.

Zum Kompilieren des Beispiels müssen Sie den Namensraum System.Diagnostics importieren.

// ProcessStartInfo-Objekt erzeugen und initialisieren
ProcessStartInfo psi = new ProcessStartInfo("ipconfig");
psi.Arguments = "/all";
psi.UseShellExecute = false;
psi.RedirectStandardOutput = true;
psi.RedirectStandardError = true;

// Prozess starten und auf dessen Ende warten
Process process = Process.Start(psi);
int timeout = 1000;
process.WaitForExit(timeout);

// Das Ergebnis auswerten
string errors = null;
string result = null;
if (process.HasExited)
{
   // Der Prozess wurde innerhalb des Timeout beendet:
   // Fehler auslesen
   if (process.ExitCode != 0)
   {
      errors = "Der Prozess wurde mit dem Code " +
         process.ExitCode + " beendet.";
   }
   string standardError = process.StandardError.ReadToEnd();
   if (string.IsNullOrEmpty(standardError) == false)
   {
      if (errors != null)
      {
         errors += Environment.NewLine;
      }
      errors += standardError;
   }
   
   // Das Ergebnis auslesen
   result = process.StandardOutput.ReadToEnd();
}
else
{
   // Der Prozess wurde innerhalb des Timeout nicht beendet
   errors = "Der Prozess konnte innerhalb des Timeout von " + 
      timeout + " Millisekunden nicht beendet werden";
}

// Das Ergebnis auswerten
if (errors == null)
{
   // Kein Fehler aufgetreten
   ...
}
else
{
   // Fehler aufgetreten
   ...
}

Dateisystem

123 Programmdateien in den Systempfaden suchen

Die Methode FindFileInSystemPaths berücksichtigte nicht die Tatsache, dass Pfadangaben im Pfad auch in Anführungszeichen eingebettet sein können. Dieser Fall führte zu einer Exception »Illegales Zeichen im Pfad«. Die korrigierte Version berücksichtigt diesen Umstand:

/* Deklaration der API-Funktion GetWindowsDirectory */
[DllImport("kernel32.dll", SetLastError = true)]
private static extern uint GetWindowsDirectory(StringBuilder lpBuffer,
   uint uSize);

/* Sucht eine Datei in den Systempfaden */
public static string FindFileInSystemPaths(string fileName)
{
   string path = null;

   // Im Windows-Systemordner suchen
   path = Path.Combine(Environment.SystemDirectory, fileName);
   if (File.Exists(path))
   {
      return path;
   }

   // Im Windows-Ordner suchen
   const int MAX_PATH = 160;
   string windowsDirectoryName = null;
   StringBuilder buffer = new StringBuilder(MAX_PATH + 1);
   if (GetWindowsDirectory(buffer, 260) > 0)
   {
      windowsDirectoryName = buffer.ToString();
      path = Path.Combine(windowsDirectoryName, fileName);
      if (File.Exists(path))
      {
         return path;
      }
   }

   // In den Ordnern suchen, die in der Umgebungsvariablen Path eingestellt
   // sind
   string[] systemPaths = Environment.GetEnvironmentVariable(
      "path").Split(new char[] { ';' });
   for (int i = 0; i < systemPaths.Length; i++)
   {
      path = Path.Combine(systemPaths[i].Trim().Trim('\"'), fileName);
      if (File.Exists(path))
      {
         return path;
      }
   }

   return null;
}

Vielen Dank an Mirek Virius von der Czech Technical University, Prague, der mir diesen Fehler meldete.

Text-, binäre und ZIP-Dateien

154 Dateien in ZIP-Archive komprimieren

Die im Codebook beschriebene Methode ZipFiles ist leider ein klein wenig buggy: Wenn Sie am Argument comment null übergeben, resultiert dies in einer Exception beim Setzen des Kommentars. Deswegen überprüft die verbesserte Version, ob der Kommentar nicht null ist:

public static void ZipFiles(string[] sourceFileNames, string zipFileName, 
   int blockSize, int zipLevel, bool includePaths, string comment)
{
   // Datei-Stream als Basis-Stream erzeugen
   Stream zipFileStream = File.Open(zipFileName, FileMode.CreateNew);

   // ZipOutputStream zum Schreiben der Zip-Datei erzeugen
   ZipOutputStream zipOutputStream = new ZipOutputStream(zipFileStream);

   // Kompressionsrate definieren (0 bis 9)
   zipOutputStream.SetLevel(zipLevel);

   // Kommentar zum Archiv definieren
   if (comment != null)
   {
      zipOutputStream.SetComment(comment);
   }

   // Alle im Array sourceFileNames übergebenen Dateien 
   // durchgehen und in das Archiv schreiben
   for (int i = 0; i < sourceFileNames.Length; i++)
   {
      // ZipEntry-Objekt für die neue Datei erzeugen. Der im Konstruktor 
      // übergebene Name wird als Dateiname beim Extrahieren verwendet. 
      // Sie können hier auch (relative) Pfadangaben mit angeben. 
      // Das Programm speichert den Pfad (ohne Laufwerkangabe) mit, 
      // wenn das Argument includePaths true ist         
      string fileNameForZip;
      FileInfo fi = new FileInfo(sourceFileNames[i]);
      if (includePaths) 
      {
         // Dateiname ohne Laufwerkbuchstabe ermitteln
         int pos = fi.FullName.IndexOf('\\');
         if (pos > -1)
         {
            fileNameForZip = fi.FullName.Substring(pos,
               fi.FullName.Length - pos);
         }
         else
         {
            fileNameForZip = fi.FullName;
         }
      }
      else
      {
         // Nur den Dateinamen speichern
         fileNameForZip = fi.Name;
      }
      ZipEntry zipEntry = new ZipEntry(fileNameForZip);

      // ZipEntry-Objekt dem ZipOutputStream hinzufügen
      zipOutputStream.PutNextEntry(zipEntry);

      // Zu archivierende Datei in einem FileStream öffnen
      FileStream fileStream = new FileStream(sourceFileNames[i],
         FileMode.Open, FileAccess.Read);

      // Quellstream blockweise in ein Byte-Array lesen und in den
      // ZipOutputStream schreiben
      byte[] buffer = new byte[blockSize];
      int bytesRead = 0;
      while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) > 0)
      {
         zipOutputStream.Write(buffer, 0, bytesRead);
      }

      // FileStream schließen
      fileStream.Close();
   }

   // ZipOutputStream abschließen und schließen
   zipOutputStream.Finish();
   zipOutputStream.Close();
}

155 (ZIP-)Archive aus einem Ordner erzeugen

Die in diesem Rezept beschriebene Methode ZipFolder habe ich um das params-Argument extensionsToInclude erweitert. In diesem Argument können Sie nun die Endungen der Dateien angeben, die in das Archiv kopiert werden sollen. Ist keine Endung angegeben, werden grundsätzlich alle Dateien übernommen. So können Sie zum Beispiel ausschließlich alle Text- und HTML-Dateien eines Ordners in ein Archiv packen, indem Sie am letzten Argument ".txt" angeben. Beachten Sie, dass Sie bei der Endung den Punkt mit angeben müssen.

Daneben habe ich noch einen kleinen Bug beseitigt: Wenn am Argument comment null übergeben wurde warf die SetComment-Methode des ZipOutputStream-Objekts eine Exception. Deshalb überprüft die Methode nun vor dem Setzen des Kommentars, ob dieser nicht null ist.

/* Archiviert einen Ordner in eine ZIP-Datei */
public static void ZipFolder(string folderName, string zipFileName,
   int blockSize, int zipLevel, string comment, params string[] extensionsToInclude)
{
   // Datei-Stream als Basis-Stream erzeugen
   Stream zipFileStream = File.Open(zipFileName, FileMode.CreateNew);

   // ZipOutputStream zum Schreiben der Zip-Datei erzeugen
   ZipOutputStream zipOutputStream = new ZipOutputStream(zipFileStream);

   // Kompressionsrate definieren (0 bis 9)
   zipOutputStream.SetLevel(zipLevel);

   // Kommentar zum Archiv definieren
   if (comment != null)
   {
      zipOutputStream.SetComment(comment);
   }

   // Ordner rekursiv archivieren
   AddFilesFromFolder(folderName, folderName, zipOutputStream, 
      blockSize, extensionsToInclude);

   // ZipOutputStream abschließen und schließen
   zipOutputStream.Finish();
   zipOutputStream.Close();
}

/* Fügt alle Dateien eines Ordners (rekursiv) einem ZIP-Archiv hinzu */
private static void AddFilesFromFolder(string baseFolderName,
   string folderName, ZipOutputStream zipOutputStream,
   int blockSize, params string[] extensionsToInclude)
{
   // Alle Dateien des Ordners durchgehen und in das Archiv schreiben
   DirectoryInfo folder = new DirectoryInfo(folderName);
   FileInfo[] files = folder.GetFiles();
   for (int i = 0; i < files.Length; i++)
   {
      // Überprüfen, ob Erweiterungen für einzuschließende Dateien 
      // angegeben sind
      bool includeFile = true;
      if (extensionsToInclude != null && extensionsToInclude.Length > 0)
      {
         includeFile = false;
         foreach (string extensionToInclude in extensionsToInclude)
         {
            if (files[i].Extension.ToLower() == extensionToInclude.ToLower())
            {
               includeFile = true;
               break;
            }
         }
      }

      if (includeFile == false)
      {
         continue;
      }

      // Relativen Pfad des aktuellen Ordners über das Entfernen des
      // Basisordnernamens ermitteln
      string relativePath = folderName.Replace(baseFolderName, "");
      if (relativePath != null)
      {
         if (relativePath.StartsWith("\\"))
            relativePath = relativePath.Remove(0, 1);
         if (relativePath.EndsWith("\\") == false)
            relativePath += "\\";
      }

      // ZipEntry-Objekt für die neue Datei mit dem relativen Pfad
      // erzeugen und dem ZipOutputStream hinzufügen
      zipOutputStream.PutNextEntry(
         new ICSharpCode.SharpZipLib.Zip.ZipEntry(
         relativePath + files[i].Name));

      // Zu archivierende Datei in einem FileStream öffnen und über ein
      // Byte-Array blockweise in den ZipOutputStream schreiben
      FileStream fileStream = files[i].OpenRead();
      byte[] buffer = new byte[blockSize];
      int bytesWritten = 0;
      do
      {
         int size = fileStream.Read(buffer, 0, buffer.Length);
         zipOutputStream.Write(buffer, 0, size);
         bytesWritten += size;

      } while (bytesWritten < fileStream.Length);

      // FileStream schließen
      fileStream.Close();
   }

   // Alle Unterordner durchgehen und die Methode rekursiv aufrufen
   DirectoryInfo[] subFolders = folder.GetDirectories();
   for (int i = 0; i < subFolders.Length; i++)
   {
      AddFilesFromFolder(baseFolderName, subFolders[i].FullName,
         zipOutputStream, blockSize);
   }
}

157 (ZIP-)Archive entpacken

Die in diesem Rezept beschriebene Methode wies zwei Bugs auf: In einigen Fällen speichert ein ZIP-Archiv für die einzelnen Dateien den Unterordner \. In diesem Fall warf die in ExtractToFolder verwendete Path.Combine-Methode eine Exception. Außerdem berücksichtigte ExtractToFolder nicht die Tatsache, dass Dateien in ZIP-Archiven auch eine Größe von null Byte aufweisen können. Das Entpacken einer solchen Datei führte zu einer Exception. Die korrigierte Version finden Sie hier:

/* Merker für das Überschreiben aller Dateien */
private static bool overwriteAllFiles;
private static bool alreadyAskedForOverwriteAllFiles;

/* Extrahiert die Dateien eines ZIP-Archivs in einen Ordner */
public static void ExtractToFolder(string zipFileName, string folderName,
   int blockSize, bool overwriteWithoutWarning)
{
   // Eigenschaften voreinstellen
   overwriteAllFiles = false;
   alreadyAskedForOverwriteAllFiles = false;

   // ZipInputStream für die Zip-Datei erzeugen 
   ZipInputStream zipInputStream = new ZipInputStream(
      File.Open(zipFileName, FileMode.Open, FileAccess.Read));

   // Alle im Archiv gespeicherten ZipEntry-Objekte durchgehen
   ZipEntry zipEntry;
   while ((zipEntry = zipInputStream.GetNextEntry()) != null)
   {
      // Aus dem (relativen) Dateinamen den Unterordner und den
      // Namen extrahieren
      string subFolderName = Path.GetDirectoryName(zipEntry.Name);

      // Für den Fall, dass die Zip-Einträge mit einem \ beginnen,
      // den Unterordner auf null setzen
      if (subFolderName == "\\")
      {
         subFolderName = null;
      }

      // Den Dateinamen des Eintrags ermitteln
      string entryName = Path.GetFileName(zipEntry.Name);

      // Den vollen Ordnernamen des Zielordners ermitteln
      string destFolderName;
      if (subFolderName != null)
      {
         destFolderName = Path.Combine(folderName, subFolderName);
      }
      else
      {
         destFolderName = folderName;
      }

      // Unterordner erzeugen, falls notwendig
      if (subFolderName != null)
      {
         Directory.CreateDirectory(destFolderName);
      }

      if (zipEntry.IsDirectory == false &&
         entryName != null && entryName.Length > 0)
      {
         bool overwriteFile = true;

         if (overwriteWithoutWarning == false &&
            overwriteAllFiles == false)
         {
            // Wenn Dateien nicht ohne Warnung überschrieben werden
            // sollen: Überprüfen, ob bereits eine gleichnamige Datei
            // existiert
            if (File.Exists(Path.Combine(destFolderName, entryName)))
            {
               // Nachfragen, ob die Datei überschrieben werden soll
               switch (MessageBox.Show("Die Datei '" + entryName +
                  "' existiert bereits im Ordner '" + destFolderName +
                  "'\r\n\r\nSoll diese Datei überschrieben werden?",
                  Application.ProductName, MessageBoxButtons.YesNoCancel,
                  MessageBoxIcon.Question))
               {
                  case DialogResult.Yes:
                     overwriteFile = true;
                     break;
                  
                  case DialogResult.No:
                     overwriteFile = false;
                     break;
                  
                  case DialogResult.Cancel:
                     // Stream schließen und beenden
                     zipInputStream.Close();
                     return;
               }

               // Nachfragen, ob alle Dateien überschrieben werden
               // sollen, sofern dies noch nicht geschehen ist
               if (overwriteFile == true &&
                  alreadyAskedForOverwriteAllFiles == false)
               {
                  switch (MessageBox.Show("Sollen alle vorhandenen " +
                     "Dateien automatisch überschrieben werden?",
                     Application.ProductName, MessageBoxButtons.YesNoCancel,
                     MessageBoxIcon.Question))
                  {
                     case DialogResult.Yes:
                        overwriteAllFiles = true;
                        break;

                     case DialogResult.No:
                        overwriteAllFiles = false;
                        break;

                     case DialogResult.Cancel:
                        // Stream schließen und beenden
                        zipInputStream.Close();
                        return;
                  }
                  // Definieren, dass nicht noch einmal gefragt wird
                  alreadyAskedForOverwriteAllFiles = true;
               }
            }
         }

         if (overwriteFile)
         {
            // FileStream für die Datei erzeugen
            FileStream fileStream =
               File.Create(Path.Combine(destFolderName, entryName));

            if (zipEntry.CompressedSize > 0)
            {
               // Datei in Blöcken von maximal 1 MB in den Stream schreiben
               // um den Speicher nicht mit großen Dateien zu überlasten
               int size;
               byte[] buffer = new byte[1048576];
               do
               {
                  // Den nächsten Datenblock aus dem ZipInputStream lesen
                  size = zipInputStream.Read(buffer, 0, buffer.Length);
                  if (size > 0)
                  {
                     // Wenn Daten gelesen wurden, diese in die Datei
                     // schreiben
                     fileStream.Write(buffer, 0, size);
                  }
               } while (size > 0);
            }

            // FileStream schließen
            fileStream.Close();
         }
      }
   }

   // ZipInputStream schließen
   zipInputStream.Close();
}

Internet

197 E-Mails über einen SMTP-Server versenden

Dieses Rezept habe ich um das Anfordern einer Übertragungs- und einer Lesebestätigung erweitert und zusätzlich die Konfiguration von SMTP in der app.config erläutert. Zu dem einfachen Beispiel habe ich außerdem ein Beispiel mit einem Formular hinzugefügt, das Sie in Ihren Projekten als Basis für ein Mailversand-Formular verwenden können.

Hier ist der geänderte Text:

Zum Senden einer E-Mail erzeugen Sie zunächst eine Instanz der SmtpClient-Klasse. Dem Konstruktor können Sie die Adresse des SMTP-Servers übergeben (sofern Sie die Konfiguration nicht in der Anwendungs-Konfigurationsdatei vornehmen und nicht die Pickup-Ausliefer-Methode über den IIS verwenden wollen, die ich weiter unten beschreibe):

// SmtpClient erzeugen
string smtpHost = "localhost";
SmtpClient smtpClient = new SmtpClient(smtpHost);

Wenn Sie den lokalen SMTP-Server angeben wollen (der ein Teil der Windows-Internet-Informationsdienste ist), geben Sie localhost an.

// Authentifizierungs-Informationen für SMTP-Server,
// die eine Authentifizierung verlangen
string userName = " jb ";
string password = "galaxy";
smtpClient.Credentials = new NetworkCredential(userName, password);

// Authentifizierungs-Informationen für den SMTP-Server von 
// Windows XP, wenn dieser so eingestellt ist, dass die 
// Clients sich über die Windows-Authentifizierung anmelden müssen
//smtpClient.Credentials = CredentialCache.DefaultNetworkCredentials;

// Ausliefer-Methode festlegen (Network ist Default)
smtpClient.DeliveryMethod = SmtpDeliveryMethod.Network;

Alternativ können Sie den SMTP-Server, die Authentifizierungsinformationen, die Absender-Adresse, die Ausliefer-Methode und weitere Grundeinstellungen auch in der Anwendungs-Konfigurationsdatei angeben:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <system.net>
    <mailSettings>
      <smtp from="jb@galaxy.com" deliveryMethod="Network">
        <network host="mail.galaxy.com" userName="jb" password="galaxy" />
      </smtp>
    </mailSettings>
  </system.net>
</configuration>

In diesem Fall können Sie eine Instanz der SmtpClient-Klasse über den parameterlosen Konstruktor erzeugen und brauchen den SMTP-Server, die Authentifizierungs-Informationen, den Absender und die Ausliefer-Methode nicht anzugeben (was Sie aber trotzdem natürlich können).

// Nachricht erzeugen und initialisieren
MailMessage message = new MailMessage();
message.From = new MailAddress("jb@galaxy.com", "Jürgen Bayer");
message.To.Add("zaphod@galaxy.com");
message.CC.Add("ford@galaxy.com");
message.Bcc.Add("trillian@galaxy.com");
message.Subject = "Party";
message.IsBodyHtml = true;
message.Body = "Hallo Zaphod,<br><br>" +
   "Lust auf eine Party im <i>Restaurant am Ende der Galaxis</i>?";

Um Sonderzeichen wie unsere Umlaute korrekt übertragen zu können, ist wichtig, dass Sie die Codierung des Body auf UTF-8 einstellen (UTF-8 ist eine Unicode-Codierung, die zum einen alle Zeichen des Unicode-Zeichensatzes beinhaltet und zum anderen von allen Routern und E-Mail-Servern im Internet unterstützt wird):

message.BodyEncoding = Encoding.UTF8;

message.Priority = MailPriority.High;

Neben der Priorität sind in der Praxis das Anfordern einer Übertragungs- und das Anfordern einer Lesebestätigung wichtig.

message.DeliveryNotificationOptions = DeliveryNotificationOptions.OnSuccess |
   DeliveryNotificationOptions.OnFailure | DeliveryNotificationOptions.Delay;

string fileName = Path.Combine(
   Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), 
   "dontpanic.gif");
message.Attachments.Add(new Attachment(fileName));

Schließlich können Sie die E-Mail über die Send-Methode der SmtpClient-Instanz versenden. Da beim Senden von E-Mails auch Exceptions vorkommen, deren aussagekräftige Meldungen sich in einer der inneren Exceptions verstecken, habe ich dem Beispiel die Methode GetExceptionMessages aus dem Rezept 44 hinzugefügt, die auch die Nachrichten der inneren Exceptions ermittelt. Diese Methode habe ich allerdings nicht in das Listing 0.3 aufgenommen.

Das Beispiel erfordert den Import der Namensräume System, System.IO, System.Net, System.Net.Mail, System.Windows.Forms, System.Text, System.Text.RegularExpressions und System.Reflection.

try
{
   smtpClient.Send(message);
   MessageBox.Show("E-Mail erfolgreich versendet", Application.ProductName, 
      MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (SmtpFailedRecipientException ex)
{
   if (ex.Message.IndexOf("Unable to relay for") > -1)
   {
      this.Cursor = Cursors.Default;
      MessageBox.Show("Der SMTP-Server '" + smtpClient.Host +
        "' kann die E-Mail an die angegebene Adresse nicht " +
        "weiterleiten. Wahrscheinlich ist die Weiterleitung " +
        "von E-Mails für die IP-Adresse des Client in der " +
        "Konfiguration des SMTP-Servers untersagt",
        Application.ProductName, MessageBoxButtons.OK,
        MessageBoxIcon.Exclamation);
   }
   else
   {
      this.Cursor = Cursors.Default;
      MessageBox.Show(this.GetExceptionMessages(ex), Application.ProductName,
         MessageBoxButtons.OK, MessageBoxIcon.Error);
   }
}
catch (Exception ex)
{
   this.Cursor = Cursors.Default;
   MessageBox.Show(this.GetExceptionMessages(ex), Application.ProductName,
      MessageBoxButtons.OK, MessageBoxIcon.Error);
}

198 E-Mails über MAPI bzw. Outlook versenden

Formulare und Steuerelemente

227: Bei der Betätigung der Return-Taste die Tab-Taste simulieren

In diesem Rezept ist mir ein kleiner Fehler unterlaufen, der dazu führte, dass das Programm eine Exception warf, wenn das Steuerelement, bei dem die Return-Taste in die Betätigung der Tab-Taste umgewandelt wurde, auf einem Container-Steuerelement (z. B. einem Panel) lag. In OnKeyPress habe ich nicht das ermittelte Container-Steuerelement, sondern den Parent des Steuerelements verwendet, um dessen ProcessTabKey-Methode aufzurufen. Hier ist die korrigierte Version:

public class Return2TabTextBox: TextBox
{
   private bool simulateTabOnReturn = true;
   /* Gibt an, ob bei der Betätigung der Return-Taste 
     die Tab-Taste simuliert wird */
   [DefaultValue(true)]
   [Category("Behavior")]
   public bool SimulateTabOnReturn
   {
      get { return this.simulateTabOnReturn; }
      set { this.simulateTabOnReturn = value; }
   }

   /* OnKeyPress wird überschrieben, um bei der Betätigung der */
   /* Return-Taste die TAB-Taste zu simulieren */
   protected override void OnKeyPress(KeyPressEventArgs e)
   {
      if (this.simulateTabOnReturn && e.KeyChar == '\r')
      {
         // Return wurde betätigt und soll in Tab umgewandelt werden
         ContainerControl container = this.getContainerControl(this);
         if (container != null)
         {
            // Die leider geschützte ProcessTabKey-Methode
            // des ContainerControls über Reflection aufrufen
            Type type = container.GetType();
            type.InvokeMember("ProcessTabKey",
               System.Reflection.BindingFlags.InvokeMethod |
               System.Reflection.BindingFlags.NonPublic |
               System.Reflection.BindingFlags.Instance, null,
               container, new object[] { true });

            // Das Ereignis als behandelt kennzeichnen
            e.Handled = true;
         }
      }

      // Die geerbte Methode aufrufen
      base.OnKeyPress(e);
   }

   /* Liefert das ContainerControl eines Steuerelements */
   private ContainerControl getContainerControl(Control control)
   {
      if (control.Parent != null)
      {
         if (control.Parent is ContainerControl)
         {
            return (ContainerControl)control.Parent;
         }
         else
         {
            // Rekursiv aufrufen um den Parent des
            // übergebenen Steuerelements zu überprüfen
            return this.getContainerControl(control.Parent);
         }
      }
      else
      {
         return null;
      }
   }
}

229 Die angezeigten Zeilen einer MultiLine-TextBox auslesen

In diesem Rezept wurden angezeigte Zeilen nicht korrekt ausgelesen, wenn diese nur aus einem Zeichen bestanden. Diesen von Axel Seibel gefundenen Fehler habe ich korrigiert. Außerdem habe ich den weiteren Fehler mit einer von Axel Seibel gefundenen Lösung korrigiert, der dazu führte, dass Pluszeichen zu Problemen führten.

/* Deklaration der benötigten API-Funktion */
[DllImport("User32.Dll")]
private static extern int SendMessage(IntPtr hWnd, int msg,
     IntPtr wParam, IntPtr lParam);

/* Gibt die tatsächlich angezeigten Zeilen einer TextBox zurück */
public static ReadOnlyCollection<string> GetDisplayedTextBoxRows(
   TextBox textBox)
{
   // Ergebnis-Auflistung erzeugen
   List<string> result = new List<string>();

   // Konstanten für SendMessage
   const int EM_GETLINECOUNT = 0x00BA;
   const int EM_LINELENGTH = 0x00C1;
   const int EM_LINEINDEX = 0x00BB;
   const int EM_GETLINE = 0x00C4;

   // Anzahl der Zeilen ermitteln
   int lineCount = SendMessage(textBox.Handle, EM_GETLINECOUNT,
      IntPtr.Zero, IntPtr.Zero);

   for (uint lineIndex = 0; lineIndex < lineCount; lineIndex++)
   {
      // Die Position des ersten Zeichens der Zeile ermitteln
      int pos = (int)SendMessage(textBox.Handle, EM_LINEINDEX,
         (IntPtr)lineIndex, IntPtr.Zero);

      // Die Länge der Zeile ab dieser Position ermitteln
      int lineLength = (int)SendMessage(textBox.Handle, EM_LINELENGTH,
         (IntPtr)pos, IntPtr.Zero);

      if (lineLength > 0)
      {
         // Wenn die Zeile Zeichen enthält: 
         // Platz für das abschließende 0-Zeichen berücksichtigen
         lineLength++;

         IntPtr apiBuffer = IntPtr.Zero;
         try
         {
            // Speicher im nicht verwalteten Bereich 
            // mit der Länge der Zeile reservieren 
            apiBuffer = Marshal.AllocHGlobal(lineLength);

            // Die Länge der Zeile muss laut der Dokumentation in die ersten
            // beiden Bytes des Puffers geschrieben werden, also:
            // über BitConverter.GetBytes die Länge in ein Byte-Array
            // lesen und dieses in die ersten zwei Bytes des Puffers
            // kopieren
            byte[] lengthInfo = BitConverter.GetBytes((short)lineLength);
            Marshal.Copy(lengthInfo, 0, apiBuffer, 2);

            // Die Zeile einlesen
            SendMessage(textBox.Handle, EM_GETLINE,
              (IntPtr)lineIndex, apiBuffer);

            // Den unverwalteten Puffer in ein verwaltetes 
            // Byte-Array kopieren
            byte[] clrBuffer = new byte[lineLength];
            Marshal.Copy(apiBuffer, clrBuffer, 0, lineLength);
            string row = String.Empty;
            // Hier wird nicht mer Encoding.xyz.GetString kopiert, weil
            // dabei verschiedene Probleme auftraten, wie z. B., dass
            // Umlaute nicht korrekt funktionierten oder das Pluszeichen
            // zu Problemen führte. Ein Kopieren der einzelnen Zeichen
            // funktioniert aber. Dank an Axel Seibel, der mir die Fehler
            // und die Lösung gemeldet hat.
            for (int i = 0; i < clrBuffer.Length; i++)
            {
               row += Convert.ToChar(clrBuffer[i]);
            }
            if (row.EndsWith("\0"))
            {
               row = row.Remove(row.Length - 1, 1);
            }
            result.Add(row);
         }
         finally
         {
            if (apiBuffer != IntPtr.Zero)
            {
               // Puffer-Speicher freigeben
               Marshal.FreeHGlobal(apiBuffer);
            }
         }
      }
      else
      {
         // Die Zeile war leer, also eine leere Zeile hinzufügen,
         // allerdings nur dann, wenn die TextBox nicht leer ist 
         // (also nur eine virtuelle Zeile enthält)
         if (lineCount != 1)
         {
            result.Add(String.Empty);
         }
      }
   }

   // Ergebnis zurückgeben
   return new ReadOnlyCollection<string>(result);
}

230 ComboBox mit Autovervollständigung

Wegen des Problems mit der Windows.Forms-ComboBox, dass diese die Einträge nach deren String-Darstellung sortiert, was dann Probleme macht, wenn die Liste als Quelle der Autovervollständigungsliste verwendet wird, habe ich die im ersten Codebook entwickelte AutoCompleteComboBox in einer weiterentwickelten Form wirder aufgenommen.

Hier sind die möglichen Probleme mit der Windows.Forms-ComboBox:

• Wenn Sie als Quelle der Autovervollständigungs-Liste die ComboBox-Liste verwenden, kann es sein, dass bei einer Eingabe nicht der erste passende Eintrag der ComboBox-Liste vorgeschlagen wird. Dies ist dann der Fall, wenn die ComboBox-Liste eine andere Sortierung aufweist als eine Sortierung der dargestellten Strings ergeben würde. Die Autovervollständigungs-Liste besteht nämlich aus Strings und wird von der ComboBox vor der Anzeige sortiert. Speichert die ComboBox z. B. die Versionswerte 1.0.0.5, 1.0.0.100 und 1.0.0.101, schlägt die Autovervollständigung den Wert 1.0.0.100 vor wenn der Benutzer eine 1 eingibt. Eigentlich sollte aber der erste passende Wert der Liste, nämlich 1.0.0.5 (der ja als Version gesehen kleiner ist als 1.0.0.100) vorgeschlagen werden.
• Ist die Eigenschaft AutoCompleteMode auf Suggest oder SuggestAppend eingestellt und DropDownStyle auf Simple, scheint die ComboBox einen Bug zu beinhalten. Wenn nach einer Eingabe die Liste automatisch aufklappt und Sie über die Cursor-Tasten einen der Einträge auswählen, können Sie Ihre Auswahl nicht mit der Return-Taste übernehmen. Der Eintrag im Textfeld der ComboBox wird in diesem Fall einfach gelöscht. Sie können Ihre Auswahl lediglich über die Tab-Taste übernehmen. Ich habe diesen Bug gemeldet. Möglicherweise wird dieses Problem im ersten Service Pack des Dotnet-Framework 3.5 gelöst.

Und hier ist meine AutoCompleteComboBox:

public class AutoCompleteComboBox : ComboBox
{
   /* Privates Feld zur Vermeidung rekursiver Aufrufe 
      des TextChanged-Ereignisses */
   private bool dontHandleTextChanged = false;

   /* Verwaltet den Index des aktuellen Treffers */
   private int currentMatchIndex = -1;

   /* Verwaltet den aktuell vom Benutzer eingegebenen Text */
   private string currentInput = null;

   /* OnTextChanged wird überschrieben, um bei einer Änderung des Textes 
      den ersten passenden Eintrag zu suchen und den Text zu erweitern */
   protected override void OnTextChanged(EventArgs e)
   {
      if (this.dontHandleTextChanged == false)
      {
         // Die aktuelle Eingabe merken
         this.currentInput = this.Text;

         // Nach einem Eintrag suchen, der am Anfang dem eingegebenen
         // Text entspricht
         this.currentMatchIndex = this.FindString(this.currentInput);
         
         // Den aktuellen Treffer selektieren
         this.SelectCurrentMatch();
      }

      // Die geerbte Methode aufrufen 
      base.OnTextChanged(e);
   }

   /* OnKeyDown wird überschrieben, um die Verarbeitung von OnTextChanged zu 
      vermeiden, wenn die Backspace-, die Löschen-, die Cursor-Up oder die
      Cursor-Down-Taste betätigt wurde. Außerdem behandelt OnKeyDown die 
      Betätigung der Cursor-Up- und der Cursor-Down-Taste, um den
      vorherigen bzw. nächsten passenden Eintrag auszuwählen und die
      Betätigung der Backspace oder Löschen-Teste, um die intern
      verwaltete aktuelle Eingabe zurückzusetzen. */
   protected override void OnKeyDown(KeyEventArgs e)
   {
      // Verarbeitung vermeiden, wenn die Backspace- oder die Löschen-
      // Taste betätigt wurde
      this.dontHandleTextChanged = (e.KeyCode == Keys.Back || 
         e.KeyCode == Keys.Delete || e.KeyCode == Keys.Up || 
         e.KeyCode == Keys.Down);

      int newMatchIndex = -1;
      switch (e.KeyCode)
      {
         case Keys.Up:
            if (this.currentMatchIndex > -1)
            {
               // Ermitteln, ob der Eintrag über dem aktuellen 
               // zu der aktuellen Eingabe passt
               if (this.currentMatchIndex > 0)
               {
                  if (this.Items[this.currentMatchIndex - 1].ToString()
                     .StartsWith(this.currentInput,
                     StringComparison.CurrentCultureIgnoreCase))
                  {
                     newMatchIndex = this.currentMatchIndex - 1;
                  }
               }
            }
            break;

         case Keys.Down:
            if (this.currentMatchIndex > -1)
            {
               // Ermitteln, ob der Eintrag unter dem aktuellen zu der
               // aktuellen Eingabe passt
               if (this.currentMatchIndex < this.Items.Count - 1)
               {
                  if (this.Items[this.currentMatchIndex +1]
                     .ToString().StartsWith(this.currentInput,
                     StringComparison.CurrentCultureIgnoreCase))
                  {
                     newMatchIndex = this.currentMatchIndex + 1;
                  }
               }
            }
            break;

         case Keys.Back:
         case Keys.Delete:
         case Keys.Left:
         case Keys.Right:
            // Bei Backspace, Löschen, Cursor-Links oder Cursor-Rechts 
            // die aktuelle Eingabe zurücksetzen
            this.currentInput = null;
            this.currentMatchIndex = -1;
            break;
      }

      if (newMatchIndex > -1)
      {
         // Eintrag gefunden, der zur aktuellen Eingabe passt: 
         // Diesen selektieren
         this.currentMatchIndex = newMatchIndex;
         this.SelectCurrentMatch();
      }

      if (newMatchIndex > -1 || 
         ((e.KeyCode == Keys.Up || e.KeyCode == Keys.Down) && 
         this.currentMatchIndex > -1 && (this.SelectionLength > 0 &&
         this.SelectionLength < this.Text.Length)))
      {
         // Wenn ein neuer Treffer ermittelt wurde, oder wenn der Benutzer 
         // die Cursor-Up-oder die Cursor-Down-Taste betätigt hat, während 
         // aktuell ein Vorschlag angezeigt wird, aber nicht kein Text oder
         // der gesamte Text selektiert ist: Das Ereignis als behandelt 
         // kennzeichnen, damit die ComboBox die Tasten-Betätigung
         // nicht auswertet.
         e.Handled = true;
      }

      // Die geerbte Methode aufrufen
      base.OnKeyDown(e);
   }

   /* Schreibt den aktuellen Treffer in die TextBox und selektiert den von der
     aktuellen Eingabe differenten Teil */
   private void SelectCurrentMatch()
   {
      if (this.currentMatchIndex >= 0)
      {
         // Eintrag gefunden: Alten Text merken, neuen Eintrag
         // auswählen und den differenten Teil selektieren
         try
         {
            this.dontHandleTextChanged = true;
            this.SelectedIndex = -1;
            this.SelectedIndex = this.currentMatchIndex;
         }
         finally
         {
            this.dontHandleTextChanged = false;
         }
         this.Select(this.currentInput.Length, this.Text.Length);
      }
   }
}

Benutzer, Gruppen und Sicherheit

262 Daten symmetrisch ver- und entschlüsseln

Dieses Rezept hatte Probleme mit dem Verschlüsseln von Strings, die Zeichen im Unicode-Bereich über 255 enthielten. Einige dieser Zeichen wurden nicht korrekt ver- bzw. entschlüsselt. Dieses Problem habe ich dadurch gelöst, dass die Encrypt-Methode den übergebenen String über die UFT8-Codierung in einen MemoryStream liest, aber beim der Rückgabe des verschlüsselten Strings diesen über die ISO-8859-1-Codierung ermittelt. Diese Codierung verwendet Decrypt dann auch, um den übergebenen (verschlüsselten) String in einen MemoryStream umzuwandeln, bevor dieses entschlüsselt wird. Das Ergebnis-Byte-Array wird dann wieder über die UFT8-Codierung in einen String umgewandelt. Ein Test mit einem String, der einige Zeichen um Unicode-Bereich über 255 enthält, ergab keine Fehler mehr (siehe Beispiel).

Außerdem habe ich die Klasse SymmetricEncryptor um den AES-Algorithmus erweitert. Hier ist die neue Version dieser Klasse:

/* Aufzählung für die unterstützten symmetrischen Verschlüsselungen  */
public enum SymmetricEncryptAlgorithm
{
   /* Advanced-Encryption-Standard-Algorithmus */
   AES,

   /* Data-Encryption-Standard-Algorithmus */
   DES,

   /* TripleDES-Algorithmus */
   TrippleDES,

   /* RC2-Algorithmus */
   RC2,

   /* Rijndael-Algorithmus */
   Rijndael
}

/* Klasse zum Ver- und Entschlüseln von Daten */
public class SymmetricEncryptor
{
   /* Verwaltet die Instanz des Verschlüsselers */
   private SymmetricAlgorithm encryptor;

   /* Verwaltet den Namen des Verschlüsselungs-Algorithmus */
   private string algorithmName;

   /* Die Codierung für das Konvertieren von Strings in Byte-Arrays
      und umgekehrt. Es muss sich dabei zwingend um eine 8-Bit-Codierung
      handeln, da es ansonsten Probleme mit dem Entschlüsseln von
      verschlüsselten Strings gibt. */
   private Encoding stringEncoding = Encoding.GetEncoding("ISO-8859-1");

   /* Konstruktor  */
   public SymmetricEncryptor(SymmetricEncryptAlgorithm algorithm)
   {
      switch (algorithm)
      {
         case SymmetricEncryptAlgorithm.AES:
            this.encryptor = new AesManaged();
            this.algorithmName = "AES";
            break;

         case SymmetricEncryptAlgorithm.DES:
            this.encryptor = new DESCryptoServiceProvider();
            this.algorithmName = "DES";
            break;

         case SymmetricEncryptAlgorithm.TrippleDES:
            this.encryptor = new TripleDESCryptoServiceProvider();
            this.algorithmName = "TripleDES";
            break;

         case SymmetricEncryptAlgorithm.RC2:
            this.encryptor = new RC2CryptoServiceProvider();
            this.algorithmName = "RC2";
            break;

         case SymmetricEncryptAlgorithm.Rijndael:
            this.encryptor = new RijndaelManaged();
            this.algorithmName = "Rijndael";
            break;
      }
   }

   /* Gibt den Chiffrier-Modus an */
   public CipherMode CipherMode
   {
      get { return this.encryptor.Mode; }
      set { this.encryptor.Mode = value; }
   }

   /* Verwaltet die zu verwendende Blockgröße */
   public int BlockSize
   {
      get { return this.encryptor.BlockSize; }
      set { this.encryptor.BlockSize = value; }
   }

   /* Gibt den Padding-Modus an */
   public PaddingMode PaddingMode
   {
      get { return this.encryptor.Padding; }
      set { this.encryptor.Padding = value; }
   }

   /* Verwaltet den Schlüssel */
   public string Key
   {
      get
      {
         return this.stringEncoding.GetString(this.encryptor.Key);
      }

      set
      {
         // Den übergebenen Schlüssel überprüfen
         if (this.encryptor.ValidKeySize(value.Length * 8) == false)
         {
            // Ungültiger Schlüssel: Ausnahme mit erweiterten Informationen
            // werfen
            string allowedKeySizes = null;
            for (int i = 0; i < this.encryptor.LegalKeySizes.Length; i++)
            {
               if (allowedKeySizes != null)
               {
                  allowedKeySizes += ", ";
               }
               allowedKeySizes += this.encryptor.LegalKeySizes[i].MinSize +
                  ", " + this.encryptor.LegalKeySizes[i].MaxSize;
            }
            throw new CryptographicException("Der übergebene Schlüssel " +
               "ist mit " + (value.Length * 8) + " Bit für den " +
               this.algorithmName + "-Algorithmus ungültig. Erlaubt " +
               "sind die folgenden Größen: " + allowedKeySizes + ".");
         }

         // Auf Unicode-Zeichen größer 0x00FF überprüfen
         for (int i = 0; i < value.Length; i++)
         {
            if ((int)value[i] > 255)
            {
               throw new CryptographicException("Der übergebene " +
                  "Schlüssel enthält mindestens ein Unicode-Zeichen, " +
                  "das größer ist als 0x00FF (255): " + value[i] +
                  " (" + (int)value[i] + "). Unterstützt werden lediglich " +
                  "8-Bit-Unicode-Zeichen");
            }
         }

         // Den Schlüssel setzen
         this.encryptor.Key = this.stringEncoding.GetBytes(value);
      }
   }

   /* Verwaltet den Initialisierungsvektor */
   public string InitializationVector
   {
      get
      {
         return this.stringEncoding.GetString(this.encryptor.IV);
      }

      set
      {
         // Den übergebenen Initialisierungsvektor überprüfen
         if ((value.Length * 8) != this.encryptor.BlockSize)
         {
            // Ungültiger Initialisierungsvektor: Ausnahme mit erweiterten
            // Informationen werfen
            throw new CryptographicException("Der übergebene " +
               "Initialisierungsvektor ist mit " + (value.Length * 8) +
               " Bit für den " + this.algorithmName + "-Algorithmus " +
               "ungültig. Die Länge des Initialisierungsvektors muss " +
               "durch die Blockgröße (aktuell " + this.encryptor.BlockSize +
               ") ohne Rest teilbar sein");
         }

         // Auf Unicode-Zeichen größer 0x00FF überprüfen
         for (int i = 0; i < value.Length; i++)
         {
            if ((int)value[i] > 255)
            {
               throw new CryptographicException("Der übergebene " +
                  "Initialisierungsvektor enthält mindestens ein " +
                  "Unicode-Zeichen, das größer ist als 0x00FF (255): " +
                  value[i] + " (" + (int)value[i] + "). Unterstützt " +
                  "werden lediglich 8-Bit-Unicode-Zeichen");
            }
         }

         // Den Initialisierungsvektor setzen
         this.encryptor.IV = this.stringEncoding.GetBytes(value);
      }
   }

   /* Erzeugt einen zufälligen Schlüssel */
   public string GenerateKey()
   {
      this.encryptor.GenerateKey();
      return this.Key;
   }

   /* Erzeugt einen zufälligen Initialisierungsvektor */
   public string GenerateInitializationVector()
   {
      this.encryptor.GenerateIV();
      return this.InitializationVector;
   }

   /* Verschlüsselt die Daten aus einem Stream */
   public void Encrypt(Stream sourceStream, Stream destStream)
   {
      // CryptoStream zum Verschlüsseln erzeugen. Als Transformations-
      // Objekt wird das Verschlüssel-Objekt der aktuellen 
      // SymmetricAlgorithm-Instanz übergeben
      CryptoStream cryptoStream = new CryptoStream(destStream,
         this.encryptor.CreateEncryptor(), CryptoStreamMode.Write);

      // Die Rohdaten blockweise in den CryptoStream schreiben (der diese
      // verschlüsselt in den Ziel-Stream schreibt)
      int bytesRead = 0;
      byte[] buffer = new byte[1024];
      do
      {
         bytesRead = sourceStream.Read(buffer, 0, 1024);
         cryptoStream.Write(buffer, 0, bytesRead);
      } while (bytesRead > 0);

      // Den Zielstream aktualisieren und den Puffer löschen 
      cryptoStream.FlushFinalBlock();

      // Der CryptoStream darf hier nicht geschlossen werden, da
      // dieser den Ziel-Stream ansonsten auch schließt
   }

   /* Entschlüsselt die Daten aus einem Stream */
   public void Decrypt(Stream sourceStream, Stream destStream)
   {
      // CryptoStream zum Entschlüsseln erzeugen. Als Transformations-
      // Objekt wird das Entschlüssel-Objekt der aktuellen
      // SymmetricAlgorithm-Instanz übergeben
      CryptoStream cryptoStream = new CryptoStream(sourceStream,
         this.encryptor.CreateDecryptor(), CryptoStreamMode.Read);

      // Daten blockweise einlesen
      int bytesRead = 0;
      byte[] buffer = new Byte[1024];
      do
      {
         bytesRead = cryptoStream.Read(buffer, 0, 1024);
         destStream.Write(buffer, 0, bytesRead);
      } while (bytesRead > 0);

      // Der CryptoStream darf hier nicht geschlossen werden, da
      // dieser den Quell-Stream ansonsten auch schließt
   }

   /* Verschlüsselt einen String */
   public string Encrypt(string source)
   {
      // MemoryStreams für die Daten erzeugen
      MemoryStream sourceStream =
         new MemoryStream(Encoding.UTF8.GetBytes(source));
      MemoryStream destStream = new MemoryStream();

      // Daten verschlüsseln
      sourceStream.Position = 0;
      this.Encrypt(sourceStream, destStream);

      // Ergebnis auslesen
      destStream.Position = 0;
      byte[] encryptedBytes = destStream.ToArray();

      // Streams schließen
      sourceStream.Close();
      destStream.Close();

      // String zurückgeben
      return this.stringEncoding.GetString(encryptedBytes);
   }

   /* Entschlüsselt einen String */
   public string Decrypt(string source)
   {
      // MemoryStreams für die Daten erzeugen
      MemoryStream sourceStream =
         new MemoryStream(this.stringEncoding.GetBytes(source));
      MemoryStream destStream = new MemoryStream();

      // Daten entschlüsseln
      this.Decrypt(sourceStream, destStream);

      // Ergebnis auslesen
      destStream.Position = 0;
      byte[] encryptedBytes = destStream.ToArray();

      // Streams schließen
      sourceStream.Close();
      destStream.Close();

      // String zurückgeben
      return Encoding.UTF8.GetString(encryptedBytes);
   }
}

263 Daten mit Hashing-Verfahren verschlüsseln

Dieses Rezept habe ich um die Berücksichtigung der Hashing-Klassen in der CNG-Implementierung (Cryptography Next Generation) erweitert (die laut der Dokumentation nur unter Windows Vista, Windows XP SP2 und Windows Server 2003 unterstützt werden, auf meinem XP-SP2-System aber trotzdem eine NotSupportedException hervorrufen). Außerdem habe ich der Hasher-Klasse die Eigenschaften MaxKeyLength und SupportsKey hinzugefügt. Im set-Accessor der Key-Eigenschaft wird zusätzlich überprüft, ob die Länge des übergebenen Schlüssels die Maximallänge nicht überschreitet.

/* Aufzählung für die unterstützten Hashing-Algorithmen */
public enum HashAlgorithmKind
{
   MD5,
   MD5Cng,
   RIPEMD160,
   SHA1,
   SHA1Cng,
   SHA256,
   SHA256Cng,
   SHA384,
   SHA384Cng,
   SHA512,
   SHA512Cng,
   HMACMD5,
   HMACRIPEMD160,
   HMACSHA1,
   HMACSHA256,
   HMACSHA384,
   HMACSHA512,
   MACTripleDES
}

/* Klasse für verschiedene Hash-Algorithmen */
public class Hasher
{
   /* Verwaltet das Hash-Objekt */
   private HashAlgorithm hashAlgorithm;

   /* Die Codierung für das Konvertieren von Strings in Byte-Arrays 
      und umgekehrt. Es muss sich dabei zwingend um eine 8-Bit-Codierung 
      handeln. */
   private Encoding stringEncoding = Encoding.GetEncoding("ISO-8859-1");

   /* Verwaltet die maximale Schlüssel-Länge. Wird im Konstruktor gesetzt. */
   public int MaxKeyLength
   {
      private set;
      get;
   }

   /* Konstruktor */
   public Hasher(HashAlgorithmKind algorithm)
   {
      // Algorithmus definieren
      switch (algorithm)
      {
         case HashAlgorithmKind.MD5:
            this.hashAlgorithm = new MD5CryptoServiceProvider();
            break;

         case HashAlgorithmKind.MD5Cng:
            this.hashAlgorithm = new MD5Cng();
            break;

         case HashAlgorithmKind.RIPEMD160:
            this.hashAlgorithm = new RIPEMD160Managed();
            break;

         case HashAlgorithmKind.SHA1:
            this.hashAlgorithm = new SHA1Managed();
            break;

         case HashAlgorithmKind.SHA1Cng:
            this.hashAlgorithm = new SHA1Cng();
            break;

         case HashAlgorithmKind.SHA256:
            this.hashAlgorithm = new SHA256Managed();
            break;

         case HashAlgorithmKind.SHA256Cng:
            this.hashAlgorithm = new SHA256Cng();
            break;

         case HashAlgorithmKind.SHA384:
            this.hashAlgorithm = new SHA384Managed();
            break;

         case HashAlgorithmKind.SHA384Cng:
            this.hashAlgorithm = new SHA384Cng();
            break;

         case HashAlgorithmKind.SHA512:
            this.hashAlgorithm = new SHA512Managed();
            break;

         case HashAlgorithmKind.SHA512Cng:
            this.hashAlgorithm = new SHA512Cng();
            break;

         case HashAlgorithmKind.HMACMD5:
            this.hashAlgorithm = new HMACMD5();
            break;

         case HashAlgorithmKind.HMACRIPEMD160:
            this.hashAlgorithm = new HMACRIPEMD160();
            break;

         case HashAlgorithmKind.HMACSHA1:
            this.hashAlgorithm = new HMACSHA1();
            break;

         case HashAlgorithmKind.HMACSHA256:
            this.hashAlgorithm = new HMACSHA256();
            break;

         case HashAlgorithmKind.HMACSHA384:
            this.hashAlgorithm = new HMACSHA384();
            break;

         case HashAlgorithmKind.HMACSHA512:
            this.hashAlgorithm = new HMACSHA512();
            break;

         case HashAlgorithmKind.MACTripleDES:
            this.hashAlgorithm = new MACTripleDES();
            break;
      }

      // Die Maximallänge des Schlüssels ermitteln
      if (this.hashAlgorithm is KeyedHashAlgorithm)
      {
         this.MaxKeyLength =
            ((KeyedHashAlgorithm)this.hashAlgorithm).Key.Length;
      }
      else
      {
         this.MaxKeyLength = 0;
      }
   }

   /* Gibt zurück, ob der aktuell verwendete Algorithmus 
      einen Schlüssel erlaubt */
   public bool SupportsKey
   {
      get
      {
         return (this.MaxKeyLength > 0);
      }
   }

   /* Verwaltet den Schlüssel für Algorithmen, die einen solchen benötigen */
   public string Key
   {
      get
      {
         // Überprüfen, ob der Algorithmus einen Schlüssel erlaubt
         if (this.SupportsKey)
         {
            // Schlüssel in einen String umwandeln und zurückgeben
            return this.stringEncoding.GetString(
               ((KeyedHashAlgorithm)this.hashAlgorithm).Key);
         }
         else
         {
            throw new NotSupportedException("Der aktuell verwendete " +
               "Hash-Algorithmus unterstützt keine Schlüssel");
         }
      }

      set
      {
         // Auf Unicode-Zeichen größer 0x00FF überprüfen
         for (int i = 0; i < value.Length; i++)
         {
            if ((int)value[i] > 255)
            {
               throw new CryptographicException("Der übergebene " +
                  "Schlüssel enthält mindestens ein Unicode-Zeichen, " +
                  "das größer ist als 0x00FF (255): " + value[i] + " (" +
                  (int)value[i] + "). Unterstützt werden lediglich " +
                  "8-Bit-Unicode-Zeichen");
            }
         }

         // Überprüfen, ob der Algorithmus einen Schlüssel erlaubt
         if (this.SupportsKey)
         {
            // Schlüssel in ein Byte-Array überführen
            byte[] key = this.stringEncoding.GetBytes(value);

            // Überprüfen, ob die Schlüssellänge zum Algorithmus passt.
            if (key.Length <= this.MaxKeyLength)
            {
               // Schlüssel setzen
               ((KeyedHashAlgorithm)this.hashAlgorithm).Key = key;
            }
            else
            {
               throw new NotSupportedException("Der übergebene Schlüssel " +
                  "ist mit " + key.Length + " Byte zu groß für den " +
                  "gesetzten Hash-Algorithmus. Dieser unterstützt nur " +
                  "maximal " + this.MaxKeyLength + " Byte große Schlüssel");
            }
         }
         else
         {
            throw new NotSupportedException("Der aktuell verwendete " +
               "Hash-Algorithmus unterstützt keine Schlüssel");
         }
      }
   }

   /* Erzeugt einen Hash aus einem Byte-Array */
   public string ComputeHash(byte[] data)
   {
      return this.stringEncoding.GetString(
         this.hashAlgorithm.ComputeHash(data));
   }

   /* Erzeugt einen Hash aus einem Byte-Array */
   public string ComputeHash(byte[] data, int offset, int count)
   {
      return this.stringEncoding.GetString(
         this.hashAlgorithm.ComputeHash(data, offset, count));
   }

   /* Erzeugt einen Hash aus den Daten eines Stream */
   public string ComputeHash(Stream inputStream)
   {
      return this.stringEncoding.GetString(
         this.hashAlgorithm.ComputeHash(inputStream));
   }

   /* Erzeugt einen Hash für einen String */
   public string ComputeHash(string inputString)
   {
      // Byte-Array aus dem String erzeugen und damit den Hashcode erzeugen
      byte[] buffer = Encoding.Unicode.GetBytes(inputString);

      return this.stringEncoding.GetString(
         this.hashAlgorithm.ComputeHash(buffer));
   }
}

Bildbearbeitung

268 Das Format eines Bilds auslesen

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In einer WPF-Anwendung können Sie das Format eines Bildes aus einem BitmapDecoder-Objekt auslesen, das Sie zum Einlesen des Bildes verwenden. Die Eigenschaft CodecInfo verwaltet Informationen zu Codec. Diese (unzureichend dokumentierte) Eigenschaft ist vom Typ BitmapCodecInfo. Die einzelnen Codecs werden leider nicht durch eigene Codec-Info-Klassen repräsentiert, obwohl BitmapCodecInfo abstrakt ist. Das liegt wahrscheinlich daran, dass auf einem System andere Codecs vorliegen können als auf einem anderen.

In der Eigenschaft MimeTypes dieses Objekts finden Sie eine Angabe der MIME-Typen, die dem Codec zugeordnet sind. Die möglichen (Standard-)MIME-Typen sind leider nicht dokumentiert. Ich habe die folgenden MimeTypes-Werte für die Standard-Bildformate herausgefunden:

269 Bild-Metadaten auslesen

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der komplette neue Text:

Grundlagen

Metadaten werden von verschiedenen Programmen in Bilder geschrieben. Eine Digitalkamera speichert z. B. das Aufnahmedatum, das Kameramodell um den Hersteller in den erzeugten Bildern. Die Nachrichtenagentur Reuters speichert Copyright-Informationen in den online veröffentlichten Bildern. Windows Vista zeigt diese Metadaten übrigens im Explorer an (wobei dieser die WPF-Klassen zum auslesen der Metainformationen verwendet).

Metadaten können in verschiedenen Standards (auch mehrere pro Bild) in einem Bild gespeichert sein. WPF unterstützt die Standards Exchangeable Image Format (EXIF, z. B. in JPEG, TIFF- und JFIF-Dateien), International Press Telecommunications Council (IPTC, z. B. in TIFF- und JFIF-Dateien), Extensible Metadata Platform (XMP, in PDF-Dateien), PNG Textual Data (tEXt, in PNG-Dateien) und Image File Directory (IFD, in TIFF-Dateien).

Nähere Informationen zu den Standards finden Sie größtenteils bei Wikipedia:

WPF

Andere Metadaten, die nicht zum »Standard« gehören, können Sie über die GetQuery-Methode der BitmapMetadata-Klasse auslesen. Soweit will ich aber nicht gehen, und zeige nur, wie Sie die Standard-Daten auslesen. Das Beispiel erfordert den Import der Namensräume System und System.Windows.Media.Imaging.

// BitmapSource-Objekt für das Bild erzeugen
string fileName = "C:\\Bilder\\Windsurfen.jpg";
BitmapSource bitmapSource = BitmapFrame.Create(new Uri(fileName));

// Ermitteln, ob Metadaten vorhanden sind
if (bitmapSource.Metadata != null)
{
   // Ermitteln, ob die Metadaten vom Typ BitmapMetadata sind
   // (die einzige zurzeit von ImageMetadata abgeleitete Klasse)
   BitmapMetadata bitmapMetadata = bitmapSource.Metadata as BitmapMetadata;
   if (bitmapMetadata != null)
   {
      Console.WriteLine("Autor(en):");
      if (bitmapMetadata.Author != null)
      {
         foreach (var author in bitmapMetadata.Author)
         {
            Console.WriteLine("   " + author);
         }
      }
      Console.WriteLine("Titel: " + bitmapMetadata.Title);
      Console.WriteLine("Copyright: " + bitmapMetadata.Copyright);
      Console.WriteLine("Bild-Format :" + bitmapMetadata.Format);
      Console.WriteLine("Themenbeschreibung: " + bitmapMetadata.Subject);
      Console.WriteLine("Kommentar: " + bitmapMetadata.Comment);
      Console.WriteLine("Aufnahmedatum: " + bitmapMetadata.DateTaken);
      Console.WriteLine("Kamera-Hersteller: " + 
         bitmapMetadata.CameraManufacturer);
      Console.WriteLine("Kamera-Modell: " + bitmapMetadata.CameraModel);
      Console.WriteLine("Name der Anwendung, mit der das Bild " +
         "erzeugt wurde: " + bitmapMetadata.ApplicationName);
      Console.WriteLine("Schlüsselwörter:");
      if (bitmapMetadata.Keywords != null)
      {
         foreach (var keyword in bitmapMetadata.Keywords)
         {
            Console.WriteLine(keyword);
         }
      }
      Console.WriteLine("Bildbewertung: " + bitmapMetadata.Rating);   }
   else
   {
      // Unbekannte (neue) Metadaten-Klasse
      Console.WriteLine("Unbekannte (neue) Metadaten-Klasse '" +
         bitmapSource.Metadata.GetType().Name + "'");
   }
}
else
{
   // Keine Metadaten vorhanden
   Console.WriteLine("Keine Metadaten vorhanden");
}

Die Metadaten sind natürlich nicht immer gefüllt. Die Eigenschaften DateTaken, CameraManufacturer und CameraModel sind z. B. normalerweise nur dann mit einem Wert belegt, wenn das Bild von einer Digitalkamera erzeugt wurde.

Windows.Forms

270 Das Aufnahmedatum eines Bilds auslesen

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der vollständige neue Text:

Zum Kompilieren der WPF-Variante müssen Sie die Namensräume System und System.Windows.Media.Imaging importieren. Diese Methode gibt (wie auch die GDI-Variante) eine Nullable<DateTime>-Instanz zurück. null wird zuückgegeben wenn kein Datum existiert. Im Falle eines Datums, das nicht geparst werden kann, wirft GetCreationDate eine FormatException.

public static DateTime? GetCreationDate(BitmapSource bitmapSource)
{
   // Ermitteln, ob Metadaten vorhanden sind
   if (bitmapSource.Metadata != null)
   {
      // Ermitteln, ob die Metadaten vom Typ BitmapMetadata sind
      // (die einzige zurzeit von ImageMetadata abgeleitete Klasse)
      BitmapMetadata bitmapMetadata = bitmapSource.Metadata as BitmapMetadata;
      if (bitmapMetadata != null)
      {
         if (bitmapMetadata.DateTaken != null)
         {
            // Versuch, das Datum mit der aktuellen Kultur zu konvertieren
            DateTime result;
            if (DateTime.TryParse(bitmapMetadata.DateTaken, out result))
            {
               return result;
            }
            else
            {
               throw new FormatException("Der String '" +
                  bitmapMetadata.DateTaken +
                  "' kann nicht in einen DateTime-Wert " +
                  "konvertiert werden");
            }
         }
      }
   }

   // Das Datum existiert nicht oder ist nicht angegeben
   return null;
}

Die (langsame) GDI-Variante (die wohl vorwiegend in Windows.Forms-Anwendungen Verwendung finden wird, die aus Speicher-Gründen die WPF-Assemblys nicht referenzieren sollen) benötigt den Import der Assemblys System, System.Drawing, System.Drawing.Imaging, System.Globalization und System.Text.RegularExpressions.

public static DateTime? GetCreationDate(Bitmap bitmap)
{
   const int propertyTagDateTime = 0x0132;

   string propertyValue = null;
   for (int i = 0; i < bitmap.PropertyItems.Length; i++)
   {
      PropertyItem item = bitmap.PropertyItems[i];
      if (item.Id == propertyTagDateTime)
      {
         // Den String ermitteln, der das Datum speichert
         for (int j = 0; j < item.Len - 1; j++)
         {
            propertyValue += (char)item.Value[j];
         }

         // Berücksichtigen, dass bei einstelligen Zahlen auch 
         // Leerzeichen statt der 0 angegeben sein können.
         propertyValue = Regex.Replace(propertyValue, @": (\d)", @":0${1}");
         propertyValue = Regex.Replace(propertyValue, @" (\d):", @"0${1}:");

         // Versuch, den im Format yyyy:MM:dd HH:mm:ss 
         // ermittelten String in ein Datum zu konvertieren
         if (propertyValue != "0000:00:00 00:00:00")
         {
            DateTime result;
            if (DateTime.TryParseExact(propertyValue, "yyyy:MM:dd HH:mm:ss",
               CultureInfo.InvariantCulture, DateTimeStyles.AllowInnerWhite,
               out result))
            {
               return result;
            }
            else
            {
               throw new FormatException("Der String '" + propertyValue +
                  "' kann nicht in einen DateTime-Wert " +
                  "konvertiert werden");
            }
         }

         break;
      }
   }

   // Das Datum existiert nicht oder ist nicht angegeben
   return null;
}

271 Eingelesene Bilder im Originalformat speichern

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In einer WPF-Anwendung lesen Sie Bilder (mehr oder weniger direkt) immer über Instanzen der Klasse BitmapDecoder oder davon abgeleiteter, auf bestimmte Codecs spezialisierte Klassen wie z. B. JpegBitmapDecoder. Wenn Sie BitmapDecoder verwenden, ermittelt die Create-Methode beim Einlesen eines Bildes den Codec und sucht diesen in der Windows-Registry. Wird ein passender Codec gefunden, wird das Bild über diesen dekodiert und eingelesen. Informationen über den Codec stehen in der Eigenschaft CodecInfo zur Verfügung.

Speichern können Sie über Instanzen der BitmapEncoder-Klasse oder davon abgeleiteter Klassen (wie JpegBitmapEncoder). Die spezialisierten Klassen erwarten keine weitere Angabe (des Codec). Ein Bild in einem der Standardformate zu speichern ist also kein Problem. Die Create-Methode der allgemeinen BitmapEncoder-Klasse erwartet aber den GUID des Codec, der verwendet werden soll. Und das ist auch schon der Trick um ein Bild in dem Format abzuspeichern, in dem es eingelesen wurde. Den Codec-GUID erhalten Sie nämlich über die Eigenschaft ContainerFormat des CodecInfo-Objekts.

Das folgende Beispiel liest ein Bild ein, erzeugt davon einen Klon (als Demo für eine Bearbeitung) und speichert den Klon dann unter einem anderen Namen, aber im Originalformat. Zum Kompilieren müssen Sie die Namensräume System, System.IO und System.Windows.Media.Imaging einbinden.

// Bild einlesen
string sourceFilename = "C:\\Bilder\\Hitchhiker.gif";
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(sourceFilename),
   BitmapCreateOptions.None, BitmapCacheOption.None);
BitmapSource bitmapSource = decoder.Frames[0];

// Bild bearbeiten (hier nur: Kopie erzeugen) 
BitmapSource destBitmapSource = bitmapSource.Clone();

// Bild mit dem Original-Codec speichern
string destFilename = "C:\\Bilder\\Hitchhiker-Klon.gif";
BitmapEncoder encoder = BitmapEncoder.Create(
   decoder.CodecInfo.ContainerFormat);
encoder.Frames.Add(BitmapFrame.Create(destBitmapSource));
using (FileStream fileStream = new FileStream(destFilename, FileMode.Create))
{
   encoder.Save(fileStream);
}

272 Bild in Byte-Array umwandeln

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

Deshalb habe ich eine andere Lösung entwickelt. Diese Lösung verwendet einen BitmapEncoder, der die Daten eines Bildes codiert und in einen Stream schreiben kann. Als Stream verwende ich einen MemoryStream, der dann einfach über ToArray in ein Byte-Array überführt wird.

Der Methode BitmapSource2Byte in Listing 12 müssen Sie deswegen neben dem zu konvertierenden Bild auch den BitmapEncoder übergeben. Damit überlasse ich Ihnen die Wahl des Bildformats (ich würde das verlustfreie PNG-Format bevorzugen, das allerdings keine Animationen unterstützt …).

Zum Kompilieren dieser Methode müssen Sie die Namensräume System, System.IO und System.Windows.Media.Imaging importieren.

public static byte[] BitmapSource2Byte(BitmapSource bitmapSource, 
   BitmapEncoder encoder)
{
   if (encoder == null)
   {
      throw new ArgumentNullException("encoder");
   }
   
   // Das Bild dem Encoder hinzufügen
   encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
   
   // MemoryStream erzeugen und das Bild in diesen schreiben
   using (MemoryStream imageStream = new MemoryStream())
   {
      encoder.Save(imageStream);
      imageStream.Flush();

      // MemoryStream in ein Byte-Array schreiben und dieses zurückgeben
      return imageStream.ToArray();
   }
}

Die Anwendung dieser Methode ist einfach. Das folgende Beispiel verwendet den PngBitmapEncoder zum Kodieren der Bilddaten im PNG-Format:

// Die Datei in ein BitmapSource-Objekt einlesen
BitmapSource bitmapSource = BitmapFrame.Create(new Uri(imageFilename));

// Das Bitmap in ein byte-Array umwandeln
byte[] imageData2 = ImageUtils.BitmapSource2Byte(bitmapSource, 
   new PngBitmapEncoder());

273 Byte-Array in Bitmap umwandeln

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

Wenn Sie ein Bild nach dem Rezept 272 in WPF in ein Byte-Array geschrieben haben, das einem bestimmten Bildformat entspricht, können Sie dieses recht einfach wieder in ein BitmapSource-Objekt konvertieren, indem Sie die Byte-Daten in einen MemoryStream schreiben und diesen der Create-Methode der BitmapDecoder-Klasse übergeben (die das Format an den Daten automatisch erkennt). Die Methode Byte2BitmapSource in Listing 14 macht genau das. Damit der MemoryStream sauber geschlossen wird, erzeugt diese Methode den Stream in einer using-Anweisung. Der BitmapDecoder wird mit der BitmapCacheOption OnLoad erzeugt, was sehr wichtig ist, denn diese Option sorgt dafür, dass die Bitmap-Daten sofort aus dem Stream eingelesen werden (und nicht erst, wenn das Bild benötigt wird, das dann zu spät ist, da der Stream zwischenzeitlich geschlossen wurde).

Byte2BitmapSource benötigt den Import der Namensräume System.IO und System.Windows.Media.Imaging.

public static BitmapSource Byte2BitmapSource(byte[] imageBytes)
{
   // MemoryStream mit den Bytes des Bildes erzeugen und 
   // ein damit erzeugtes Bitmap zurückgeben
   using (MemoryStream imageStream = new MemoryStream(imageBytes))
   {
      BitmapDecoder decoder = BitmapDecoder.Create(imageStream,
         BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
      return decoder.Frames[0];
   }
}

274 Bilder aus der Zwischenablage auslesen

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

if (Clipboard.ContainsImage)
{
   BitmapSource bitmapSource = Clipboard.GetImage();
   ...
}

275 Screenshot erstellen

Dieses Rezept habe ich neben der Berücksichtigung von WPF zusätzlich noch darum verbessert, dass halbtransparente Fenster unterstützt werden. Hier ist der vollständige neue Text:

Rectangle screenClip = Screen.PrimaryScreen.Bounds;

// Bitmap für das Ergebnis erzeugen und das& zugehörige
// Graphics-Objekt auslesen
Bitmap bitmap = new Bitmap(screenClip.Width, screenClip.Height);
Graphics g = Graphics.FromImage(bitmap);

// Den Bildschirminhalt in das Bitmap kopieren
g.CopyFromScreen(screenClip.Left, screenClip.Top, 0, 0,
   new Size(screenClip.Width, screenClip.Height),
   CopyPixelOperation.SourceCopy);

In WPF können Sie das Bitmap-Objekt dann in ein BitmapSource-Objekt umwandeln, wie ich es in´m Codebook (in einem neuen Rezept) zeige.

Das Problem mit dieser Variante ist lediglich, dass sie nicht für (mehr oder weniger) transparente Fenster funktioniert. Wenn Sie z. B. die Opacity-Eigenschaft eines Windows.Forms-Formulars auf einen Wert kleiner 1 setzen, und einen Screenshot von dem Bereich erzeugen, auf dem das Formular liegt, ist das Formular auf dem Screenshot nicht sichtbar.

Um halb-transparente Fenster in den Screenshot zu integrieren wäre die zusätzliche Angabe von CopyPixelOperation.CaptureBlt notwendig, was laut Dokumentation dafür sorgt, dass Fenster, die andere überlappen, mit in den Screenshot aufgenommen werden. Leider lässt CopyFromScreen aber die Kombination CopyPixelOperation.SourceCopy | CopyPixelOperation.CaptureBlt nicht zu und wirft in diesem Fall eine InvalidEnumArgumentException.

Die Lösung für das Problem ist, dass Sie das, was CopyFromScreen macht, selbst implementieren. Und dazu benötigen Sie API-Funktionen. Und ein wenig Theorie (aber nur ein ganz klein wenig):

Windows verwaltet in einem System mit mehreren angeschlossenen Monitoren alle Bildschirme gemeinsam als einen virtuellen Bildschirm. Wenn Sie z. B. zwei Bildschirme mit einer Auflösung von 1280 * 1024 besitzen und diese in den Eigenschaften des Desktop so platziert haben, dass der sekundäre Monitor rechts vom primären liegt, beginnt der primäre Bildschirm an der X-Position 0 und der sekundäre an der X-Position 1281. Da Sie den sekundären Monitor aber auch links vom primären platzieren können, kann die X-Position eines Bildschirms auch negativ sein. Ähnliches gilt für die Y-Position, die alle möglichen Werte besitzen kann, da Sie die einzelnen Bildschirme frei auf dem virtuellen Bildschirm ausrichten können.

Die Methode Screenshot in Listing 19 zeigt, wie Sie diese Technik einsetzen können. Diese Methode erwartet am einzigen Argument ein Rechteck, das den zu kopierenden Bildschirm-Ausschnitt angibt. Dieser Ausschnitt bezieht sich auf den virtuellen Bildschirm.

Zum Kompilieren dieser Methode müssen Sie die Assemblys System.Drawing.dll und System.Windows.Forms.dll referenzieren und die Namensräume System, System.Drawing, System.Windows.Forms und System.Runtime.InteropServices importieren.

Zur Umsetzung sind zunächst einige API-Deklarationen notwendig:

[DllImport("gdi32.dll", SetLastError=true)]
private static extern int BitBlt(IntPtr hdcDest, int nXDest, int nYDest,
   int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc,
   CopyPixelOperation dwRop);

[DllImport("gdi32.dll", SetLastError=true)]
private static extern IntPtr CreateDC(string lpszDriver, string lpszDevice,
   string lpszOutput, IntPtr lpInitData);

private static int SRCCOPY = 0x00CC0020;

Vor dem Aufruf von BitBlt muss der DC des Bildschirms erneut ermittelt werden, da dieser anscheinend beim Aufruf der FromHdc-Methode der Graphics-Klasse freigegeben wurde (ohne dieses erneute Auslesen schlägt BitBlt ohne Fehlermeldung fehl und die Freigabe des DC führt zu einem Fehler).

Dann wird das Bild über BitBlt kopiert. Am letzten Argument übergibt Screenshot den Wert CopyPixelOperation.SourceCopy | CopyPixelOperation.CaptureBlt, was zum einen dafür sorgt, dass das Quellbild alle Farbinformationen des Ziels überschreibt. Zum anderen ermöglichen Sie damit auch das Kopieren von halbtransparenten Fenstern. Über andere Konstanten, die in der Referenz erläutert werden, können Sie die Farbinformationen des Ziels auch auf verschiedene Weise mit denen der Quelle vermischen, was aber für unsere Lösung nicht interessant ist. Schließlich müssen die DCs noch über die ReleaseHdc-Methode des jeweiligen Graphics-Objekts freigegeben werden, da diese Freigabe nicht automatisch über den Garbage Collector erfolgt.

public static Bitmap GetScreenshot(Rectangle screenClip)
{
   // Device Context für den virtuellen Windows-Bildschirm ermitteln 
   // und damit ein Graphics-Objekt erzeugen
   IntPtr screenDC = CreateDC("DISPLAY", null, null, (IntPtr)null);
   using (Graphics screenGraphics = Graphics.FromHdc(screenDC))
   {
      // Bitmap mit den Ausmaßen des zu erzeugenden Ausschnitts 
      // und der Auflösung des Graphics-Objekts erzeugen
      Bitmap bitmap = new Bitmap(screenClip.Width, screenClip.Height,
         screenGraphics);

      // Zweites Graphics-Objekt aus dem noch leeren Bitmap erzeugen 
      // um den DC des Bitmap-Objekts auslesen zu können
      using (Graphics bitmapGraphics = Graphics.FromImage(bitmap))
      {
         IntPtr bitmapDC = bitmapGraphics.GetHdc();

         // DC des Bildschirms noch einmal ermitteln
         screenDC = screenGraphics.GetHdc();

         // Über BitBlt das über den Bildschirm-DC repräsentierte Bild 
         // in das über den Bitmap-DC repräsentierte Bild kopieren
         if (BitBlt(bitmapDC, 0, 0, screenClip.Width, screenClip.Height,
            screenDC, screenClip.Left, screenClip.Top,
            CopyPixelOperation.SourceCopy | 
            CopyPixelOperation.CaptureBlt) == 0)
         {
            bitmapGraphics.ReleaseHdc(bitmapDC);
            screenGraphics.ReleaseHdc(screenDC);
            throw new Exception("API-Fehler " + Marshal.GetLastWin32Error() +
               " beim Aufruf von BitBlt");
         }

         // Die DCs freigeben und das Bild zurückgeben
         bitmapGraphics.ReleaseHdc(bitmapDC);
         screenGraphics.ReleaseHdc(screenDC);
         return bitmap;
      }
   }
}

Die Anwendung der Methode ist nun sehr einfach. Wenn Sie z. B. einen Screenshot des primären Bildschirms erstellen wollen, geben Sie die Bounds-Eigenschaft des Screen-Objekts an, das Screen.PrimaryScreen referenziert:

Bitmap captureBitmap = GetScreenshot(Screen.PrimaryScreen.Bounds);

In WPF müssen Sie übrigens wohl leider auch die Screen-Klasse aus dem Namensraum System.Windows.Forms verwenden, da WPF anscheinend keine Möglichkeit bietet, Informationen über die Bildschirme des Systems auszulesen (außer der Breite und Höhe des primären Bildschirms über SystemParameters.PrimaryScreenWidth und SystemParameters.PrimaryScreenHeight). Das zurückgegebene Bitmap wandeln Sie für WPF-Anwendungen in ein BitmapSource-Objekt um.

Wollen Sie einen Screenshot eines (sichtbaren) Formulars erzeugen, geben Sie dessen Bounds-Eigenschaft an:

Bitmap captureBitmap = GetScreenshot(form.Bounds);

Meine Lösung des Problems setzt eine eigene Berechnung ein. Dazu müssen Sie allerdings die Auflösung des Bildschirms ermitteln, auf dem das Fenster liegt. Diese ist zwar normalerweise 96 DPI, kann aber auch eine andere sein (was Sie unter Windows in den Eigenschaften des Desktop einstellen können). Also muss ein wenig gerechnet werden. Die Methode GetScreenshot in Listing 44 zeigt, wie dies geht.

public static Bitmap GetScreenshot(Window window)
{
   // Das Argument überprüfen
   if (window == null)
   {
      throw new ArgumentNullException("window");
   }

   // PresentationSource für das Visual-Objekt erzeugen,
   // das das übergebene Fenster darstellt
   PresentationSource presentationSource = 
      PresentationSource.FromVisual(window);
   if (presentationSource != null)
   {
      // Die Auflösung ermitteln
      double dpiX = 96.0 * 
         presentationSource.CompositionTarget.TransformToDevice.M11;
      double dpiY = 96.0 * 
         presentationSource.CompositionTarget.TransformToDevice.M22;

      // Die auf den  Bildschirm bezogene Position 
      // und Größe des Fensters ermitteln
      int screenLeft = (int)(window.Left * 96 / dpiX);
      int screenTop = (int)(window.Top * 96 / dpiY);
      int screenWidth = (int)(window.Width * 96 / dpiX);
      int screenHeight = (int)(window.Height * 96 / dpiY);
      System.Drawing.Rectangle screenClip = new System.Drawing.Rectangle(
         screenLeft, screenTop, screenWidth, screenHeight);

      // Mit dem auf den Bildschirm bezogenen Rechteck 
      // einen Screenshot erzeugen und zurückgeben
      return GetScreenshot(screenClip);
   }
   else
   {
      throw new Exception("Kann für das Fenster kein "
         "PresentationSource-Objekt erzeugen");
   }
}

276 Bilder skalieren

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

Der zum Skalieren verwendeten ScaleTransform-Instanz übergeben Sie am Konstruktor einen Faktor für die neue Breite und die neue Höhe. Das Skalieren gestaltet sich damit sehr einfach:

// Bild einlesen
string sourceFilename = "C:\\Bilder\\Karpathos.jpg";
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(sourceFilename),
   BitmapCreateOptions.None, BitmapCacheOption.Default);
BitmapSource bitmapSource = decoder.Frames[0];

// Skalieren
double scaleFactor = 0.5;
ScaleTransform scaleTransform = new ScaleTransform(scaleFactor, scaleFactor);
TransformedBitmap transformedBitmap = new TransformedBitmap(bitmapSource,
   scaleTransform);

Der Beispiel-Quellcode benötigt den Import der Namensräume System, System.Windows.Media und System.Windows.Media.Imaging.

Die Qualität der Skalierung ist sehr gut. Leider können Sie aber in WPF die Interpolation nicht selbst bestimmen. In einigen Fällen ergibt eine andere Interpolation als die, die ScaleTransform verwendet (welche das ist, konnte ich nicht herausfinden), ein besseres Ergebnis (wie Sie ggf. mit dem GDI-Beispiel nachvollziehen können).

277 Thumbnails aus Bildern erzeugen

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In WPF-Anwendungen können Sie Thumbnails über das Skalieren erzeugen, das ich in Rezept 276 beschreiben habe. Falls Sie auf die Thumbnail-Eigenschaft der BitmapDecoder-Klasse gestoßen sind: Diese ist vorgesehen für Bildformate wie JPEG und TIFF, die Thumbnails neben den Daten des eigentlichen Bildes verwalten können (aber nicht müssen).

Das folgende Beispiel liest eine Bilddatei ein und skaliert diese auf die Größe eines Image-Steuerelements (was dieses über die Stretch-Eigenschaft natürlich auch selber kann …). Beim Skalieren wird der Faktor so ausgerechnet, dass die Proportionen des Bildes erhalten bleiben. Das Programm läuft in einer WPF-Anwendung mit den üblichen Referenzen und einem Image-Steuerelement, das image genannt wird.

// Bild einlesen
string imageFileName = "C:\\Bilder\\Tabou Rocket Ltd 105.jpg");
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imageFileName),
   BitmapCreateOptions.None, BitmapCacheOption.Default);
BitmapSource bitmapSource = decoder1.Frames[0];

// Thumbnail über das Skalieren des Bildes erzeugen
double scaleX = this.image.Width / (double)bitmapSource.Width;
double scaleY = this.image.Height / (double)bitmapSource.Height;
double scaleFactor = Math.Min(scaleX, scaleY);
ScaleTransform scaleTransform = new ScaleTransform(scaleFactor, scaleFactor);
TransformedBitmap transformedBitmap = new TransformedBitmap(bitmapSource,
   scaleTransform);
this.image.Source = transformedBitmap;

278 Bilder konvertieren

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In einer WPF-Anwendung lesen Sie das Bild über eine BitmapDecoder-Instanz ein (die das Originalformat automatisch erkennt) und speichern Sie dieses über einen der verfügbaren Bild-Encoder ab. Zurzeit stehen die folgenden (aus dem Namensraum System.Windows.Media.Imaging) zur Verfügung, deren Format sich größtenteils aus dem Namen ablesen lässt: BmpBitmapEncoder, GifBitmapEncoder, JpegBitmapEncoder, PngBitmapEncoder, TiffBitmapEncoder und WmpBitmapEncoder (Windows-Media-Photo-Format).

Falls Sie auf Ihrem System Codecs für spezielle Formate installiert haben, können Sie deren GUID auch dem Konstruktor der BitmapEncoder-Klasse übergeben, um Bilder in einem der nicht direkt unterstützten Formate zu speichern.

Das folgende Beispiel zeigt, wie Sie eine Bilddatei einlesen und im PNG-Format speichern. Das Beispiel benötigt den Import der Namensräume System, System.IO und System.Windows.Media.Imaging.

// Bild einlesen
string imageFileName = "C:\\Bilder\\Karpathos.jpg";
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imageFileName),
   BitmapCreateOptions.None, BitmapCacheOption.Default);
BitmapSource bitmapSource = decoder.Frames[0];

// Bild im PNG-Format abspeichern
PngBitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
string destFilename = Path.ChangeExtension(imageFileName, ".png");
using (FileStream fileStream = new FileStream(destFilename, FileMode.Create))
{
   encoder.Save(fileStream);
}

279 (JPEG-)Bilder mit definierter Qualität speichern

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

Bei den von BitmapEncoder abgeleiteten Klassen für die verschiedenen per Default unterstützten Bildformate bieten die Klassen JpegBitmapEncoder, PngBitmapEncoder, TiffBitmapEncoder und WmpBitmapEncoder Eigenschaften zur Einstellung der Qualität.

Listing 48 zeigt, wie Sie ein eingelesenes Bild im JPEG-Format mit einer definierten Qualität speichern. Das Beispiel benötigt den Import der Namensräume System, System.IO und System.Windows.Media.Imaging.

// Bild einlesen
string imageFileName = "C:\\Bilder\\Los Roques.png";
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imageFileName),
   BitmapCreateOptions.None, BitmapCacheOption.Default);
BitmapSource bitmapSource = decoder.Frames[0];

// Als Jpeg-Bild mit definierter Qualität abspeichern
string destFileName = Path.ChangeExtension(imageFileName, ".jpg");
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
encoder.QualityLevel = 70; // 70% - Default ist 75%
using (FileStream fileStream = new FileStream(destFileName, FileMode.Create))
{
   encoder.Save(fileStream);
}

280 Bilder drehen, neigen und spiegeln

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

Listing 49 zeigt, wie Sie ein eingelesenes Bild um 90 Grad nach rechts drehen und um die Y-Achse spiegeln.

// Bild einlesen
string imageFileName = "C:\\Bilder\\Hitchhiker.gif");
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imageFileName),
   BitmapCreateOptions.None, BitmapCacheOption.None);
BitmapSource bitmapSource = decoder.Frames[0];

// TransformGroup-Instanz für die Transformationen erzeugen
TransformGroup transformGroup = new TransformGroup();

// RotateTransform-Objekt für das Drehen des Bildes ermitteln
// und der Transformationsgruppe hinzufügen
double rotationAngle = 90;
RotateTransform rotateTransform = new RotateTransform(rotationAngle);
transformGroup.Children.Add(rotateTransform);

// ScaleTransform-Objekt für das Spiegeln des Bildes um die Y-Achse
// ermitteln und der Transformationsgruppe hinzufügen
ScaleTransform scaleTransform = new ScaleTransform(1, -1);
   transformGroup.Children.Add(scaleTransform);
transformGroup.Children.Add(scaleTransform);

// Das eingelesene Bild transformieren
TransformedBitmap transformedBitmap = new TransformedBitmap(
   bitmapSource, transformGroup);

281 Bildausschnitte auslesen

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

Das folgende Beispiel schneidet ein 100 * 100 Pixel großes Teil aus der Mitte eines eingelesenen Bilds aus. Es benötigt den Import der Namensräume System, System.Windows.Media.Imaging und System.Windows.

// Bild einlesen
string imageFileName = "C:\\Bilder\\Les Crosets.jpg";
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imageFileName),
   BitmapCreateOptions.None, BitmapCacheOption.None);
BitmapSource bitmapSource = decoder.Frames[0];

// Ein 100 * 100 Pixel großes Stück aus der Mitte auslesen
CroppedBitmap croppedBitmap = new CroppedBitmap(bitmapSource,
   new Int32Rect((bitmapSource.PixelWidth - 100) / 2,
   (bitmapSource.PixelHeight - 100) / 2, 100, 100));

282 Farben von Bildern auf andere Farben mappen

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

WPF

Wie gesagt können Sie in WPF Farben mappen, indem Sie die einzelnen Pixel des Bildes durchgehen. Das folgende Beispiel zeigt, wie Sie die Farbe des ersten Pixel eines eingelesenen Bildes auf die Farbe Navy mappen. Das Beispiel erfordert den Import der Namensräume System, System.Windows.Media und System.Windows.Media.Imaging.

// Bild einlesen
string imageFileName = "C:\\Temp\\Hitchhiker.gif";
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imageFileName),
   BitmapCreateOptions.None, BitmapCacheOption.None);
BitmapSource bitmapSource = decoder.Frames[0];

// Das Bild zunächst in das BGRA-Format konvertieren, 
// falls es ein anderes Format aufweist
if (bitmapSource.Format != PixelFormats.Bgra32)
{
   bitmapSource = new FormatConvertedBitmap(bitmapSource, 
      PixelFormats.Bgra32, null, 0.0);
}

// Die Pixel einlesen
int stride = bitmapSource.PixelWidth * 
   ((bitmapSource.Format.BitsPerPixel + 7) / 8);
byte[] pixelData = new byte[stride * bitmapSource.PixelHeight];
bitmapSource.CopyPixels(pixelData, stride, 0);

// Die Farbe des ersten Pixel ermitteln
byte blue = pixelData[0];
byte green = pixelData[1];
byte red = pixelData[2];

// Die einzelnen Pixel durchgehen und deren Farbe ggf. mappen
for (int i = 0; i < bitmapSource.PixelHeight * stride;
   i += ((bitmapSource.Format.BitsPerPixel + 7) / 8))
{
   if (pixelData[i] == blue &&
      pixelData[i + 1] == green &&
      pixelData[i + 2] == red)
   {
      pixelData[i] = Colors.Navy.B;
      pixelData[i + 1] = Colors.Navy.G;
      pixelData[i + 2] = Colors.Navy.R;
   }
}

// Mit den neuen Pixel-Daten ein neues Bild erzeugen
BitmapSource transformedBitmap = BitmapSource.Create(
   bitmapSource.PixelWidth, bitmapSource.PixelHeight,
   bitmapSource.DpiX, bitmapSource.DpiY, PixelFormats.Bgra32,
   bitmapSource.Palette, pixelData, stride);

Ein Problem dieser Technik ist, dass sie (besonders bei großen Bildern) nicht besonders schnell ist. Eine mögliche Lösung wäre das Durchgehen der nativen Bilddaten über einen Zeiger, das ich für WPF in Rezept 285 diskutiere und für GDI zeige.

283 Farbinformationen von Bildern gezielt verändern

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

WPF

In WPF können Sie einzelne Farben eines Bilds scheinbar nur so verändern, dass Sie die einzelnen Pixel des Bilds bearbeiten. Rezept 285 geht näher darauf ein. Hier zeige ich nur eine Lösung für das Aufhellen eines Bilds um 50%. Das Beispiel erfordert, dass Sie die Namensräume System, System.Windows.Media und System.Windows.Media.Imaging einbinden.

// Bild einlesen
string imageFileName = "C:\\Temp\\Hitchhiker.gif";
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imageFileName),
   BitmapCreateOptions.None, BitmapCacheOption.None);
BitmapSource bitmapSource = decoder.Frames[0];

// Das Bild zunächst in das BGRA-Format konvertieren, 
// falls es ein anderes Format aufweist
if (bitmapSource.Format != PixelFormats.Bgra32)
{
   bitmapSource = new FormatConvertedBitmap(bitmapSource,
      PixelFormats.Bgra32, null, 0.0);
}

// Die Pixel einlesen
int stride = bitmapSource.PixelWidth * 
   ((bitmapSource.Format.BitsPerPixel + 7) / 8);
byte[] pixelData = new byte[stride * bitmapSource.PixelHeight];
bitmapSource.CopyPixels(pixelData, stride, 0);

// Die einzelnen Pixel durchgehen und die Farbe aufhellen
for (int i = 0; i < bitmapSource.PixelHeight * stride;
   i += ((bitmapSource.Format.BitsPerPixel + 7) / 8))
{
   int blue = (int)(pixelData[i] * 1.5);
   if (blue > 255) blue = 255;
   int green = (int)(pixelData[i + 1] * 1.5);
   if (green > 255) green = 255;
   int red = (int)(pixelData[i + 2] * 1.5);
   if (red > 255) red = 255;
   pixelData[i] = (byte)blue;
   pixelData[i + 1] = (byte)green;
   pixelData[i + 2] = (byte)red;
}

// Mit den neuen Pixel-Daten ein neues Bild erzeugen
BitmapSource transformedBitmap = BitmapSource.Create(
   bitmapSource.PixelWidth, bitmapSource.PixelHeight,
   bitmapSource.DpiX, bitmapSource.DpiY, PixelFormats.Bgra32,
   bitmapSource.Palette, pixelData, stride);

284 Ein Negativ eines Bilds erzeugen

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In WPF müssen Sie (leider) wieder die einzelnen Pixel des Bildes von Hand bearbeiten. Die Methode CreateNegative in Listing 53 zeigt, wie das geht. Diese Methode erfordert den Import der Namensräume System.Windows.Media und System.Windows.Media.Imaging.

public static BitmapSource CreateNegative(BitmapSource sourceBitmap)
{
   // Das Bild zunächst in das BGRA-Format konvertieren, 
   // falls es ein anderes Format aufweist
   if (sourceBitmap.Format != PixelFormats.Bgra32)
   {
      sourceBitmap = new FormatConvertedBitmap(sourceBitmap,
         PixelFormats.Bgra32, null, 0.0);
   }

   // Die Pixel einlesen
   int stride = sourceBitmap.PixelWidth * 
      ((sourceBitmap.Format.BitsPerPixel + 7) / 8);
   byte[] pixelData = new byte[stride * sourceBitmap.PixelHeight];
   sourceBitmap.CopyPixels(pixelData, stride, 0);

   // Die einzelnen Pixel durchgehen und die Farbwerte negativieren
   for (int i = 0; i < sourceBitmap.PixelHeight * stride;
      i += ((sourceBitmap.Format.BitsPerPixel + 7) / 8))
   {
      pixelData[i] = (byte)(pixelData[i] * -1);
      pixelData[i + 1] = (byte)(pixelData[i + 1] * -1);
      pixelData[i + 2] = (byte)(pixelData[i + 2] * -1);
   }

   // Mit den neuen Pixel-Daten ein neues Bild erzeugen 
   // und zurückgeben
   return BitmapSource.Create(
      sourceBitmap.PixelWidth, sourceBitmap.PixelHeight,
      sourceBitmap.DpiX, sourceBitmap.DpiY, PixelFormats.Bgra32,
      sourceBitmap.Palette, pixelData, stride);
}

285 Die einzelnen Pixel eines Bilds bearbeiten

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In WPF setzen Sie vorwiegend die CopyPixels-Methode der BitmapSource-Klasse ein um die Pixeldaten in ein Byte-Array zu kopieren. Dieses Array verwenden Sie zur Bearbeitung der einzelnen Pixel. Nach der Bearbeitung erzeugen Sie mit diesen Rohdaten ein neues BitmapSource-Objekt.

Die Schrittweite passt nicht immer genau zu den benötigten Bytes pro Zeile. Ein Bild mit einer Breite von elf Pixeln und einer Farbtiefe von vier Bits pro Pixel hat eine Schrittweite von theoretisch 44 Bits = 5,5 Bytes. Da das Byte die kleinste Speichereinheit im (Windows-)System ist, werden (zumindest) sechs Bytes pro Zeile verwendet. Die restlichen vier Bits pro Zeile bleiben einfach leer. In Bilddateien wird aus Performancegründen zusätzlich häufig dafür gesorgt, dass die Anzahl der Bytes pro Zeile ohne Rest durch vier teilbar ist. Im 4-bpp-Bild mit elf Pixeln Breite (6 Bytes) würden also z. B. an jede »Zeile« noch zwei leere Byte angehängt werden.

Wenn Sie selbst Bilder in Byte-Arrays speichern, müssen Sie die Schrittweite bestimmen, in der die Bilder im Array verwaltet werden. Der Grund liegt darin, dass Sie die Schrittweite beim Decodieren wieder angeben müssen, damit der BitmapDecoder weiß, wann eine Zeile aufhört. Die Schrittweite sollte natürlich so groß sein, dass eine Bildzeile hineinpasst.

Ich berechne die Schrittweite so, dass unabhängig vom gewählten Pixelformat genügend Platz bleibt:

int stride = bitmapSource.PixelWidth * 
   ((bitmapSource.Format.BitsPerPixel + 7) / 8);

Nun können Sie über CopyPixels die Pixel einlesen:

byte[] pixelData = new byte[stride * bitmapSource.PixelHeight];
bitmapSource.CopyPixels(pixelData, stride, 0);

Das letzte Argument gibt einen Offset an, der natürlich 0 ist wenn Sie das gesamte Bild einlesen wollen.

Dann können Sie das Array durchlaufen und die einzelnen Pixel bearbeiten. Dabei müssen Sie natürlich beachten, dass je nach gewähltem Pixelformat ein Pixel mehr oder weniger Bytes verwendet. In unserem Fall (Bgra32) wird ein Pixel in vier Byte definiert und Sie müssen demnach in einer Schleife um jeweils vier Byte weiterspringen. Um zum Pixelformat neutral zu bleiben, berechne ich die Sprungweite mit (bpp + 7) / 8.

Das Beispiel setzt jedes zweite Pixel auf die Farbe mit den Werten Rot = 0; Grün= 0, Blau = 50 und Alpha = 255:

for (int i = 0; i < bitmapSource.PixelHeight * stride;
   i += ((bitmapSource.Format.BitsPerPixel + 7) / 8))
{
   if ((i / 4) % 2 == 0)
   {
      pixelData[i] = 50;      // Blau
      pixelData[i + 1] = 0;   // Grün
      pixelData[i + 2] = 0;   // Rot
      pixelData[i + 3] = 255; // Alpha
   }
}

Schließlich erzeugen Sie aus den Rohdaten wieder ein BitmapSource-Objekt:

BitmapSource transformedBitmap = BitmapSource.Create(
   bitmapSource.PixelWidth, bitmapSource.PixelHeight,
   bitmapSource.DpiX, bitmapSource.DpiY, PixelFormats.Bgra32,
   bitmapSource.Palette, pixelData, stride);

286 Farb-Bilder in Graustufen-Bilder umwandeln

Dieses Rezept habe ich (wie alle Bildverarbeitungs-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In WPF-Anwendungen können Sie einfach das Pixelformat eines Bildes in ein anderes transformieren um ein Graustufenbild zu erzeugen. Für solche bieten sich die Formate Gray16 und Gray32Float an, die 65.536 bzw.4 Millarden Grauschattierungen erlauben.

Das folgende Beispiel, das den Import der Namensräume System, System.Windows.Media und System.Windows.Media.Imaging erfordert, liest ein Bild ein und wandelt es auf diese Weise in ein Graustufenbild um.

// Bild einlesen
string imageFileName = "C:\\Bilder\\Les Crosets.jpg";
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imageFileName),
   BitmapCreateOptions.None, BitmapCacheOption.None);
BitmapSource bitmapSource = decoder.Frames[0];

// Das Bild in ein Graustufenbild umwandeln
FormatConvertedBitmap convertedBitmap = new FormatConvertedBitmap(
   bitmapSource, PixelFormats.Gray16, null, 0);

In WPF können Sie natürlich (in meinem Fall leider nur theoretisch) auch in XAML dafür sorgen, dass ein Bild als Graustufenbild angezeigt wird:

<Image Height="100">
   <Image.Source>
      <FormatConvertedBitmap DestinationFormat="Gray16">
         <FormatConvertedBitmap.Source>
            <BitmapImage 
               UriSource="pack://siteOfOrigin:,,,/Les Crosets.jpg" />
         </FormatConvertedBitmap.Source>
      </FormatConvertedBitmap>
   </Image.Source>
</Image>

Auf die Abbildung der Beispielanwendung, die ein Farb-Bild auf diese Weise in ein Graustufen-Bild umwandelt, verzichte ich an dieser Stelle. Sie würden im Buch wohl keinen Unterschied erkennen (.

Zeichnen

289 Rechtecke mit abgerundeten Ecken zeichnen

Dieses Rezept habe ich um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

LineTo übergeben Sie am ersten Argument den Zielpunkt, ArcTo übergeben Sie den Zielpunkt, die Größe der Kurve (als Breite und Höhe am Argument size), einen Drehwinkel (rotationAngle), über den Sie die Krümmung einer ovalen Kurve bestimmen können (in unserem Fall nicht erforderlich), eine Information, ob es sich um einen Bogen mit mehr als 180 Grad handelt (isLargeArc) und eine Information darüber und ob der Bogen im Uhrzeigersinn gezeichnet wird (sweepDirection).

An den letzten beiden Argumenten übergeben Sie beiden Methoden eine Information darüber, ob die Linie bzw. Kurve tatsächlich als Line (später, über einen Pen) gezeichnet wird (isStroked) und ob die Linie/Kurve mit angrenzenden Linien/Kurven weich verknüpft wird (isSmoothJoin).

Ist der Pfad fertig definiert, können Sie das StreamGeometry-Objekt über die DrawGeometry-Methode des DrawingContext-Objekts, auf dem Sie die Zeichnung ausgeben wollen, zeichnen. Die Methode DrawRoundedRectangle im folgenden Listing nimmt Ihnen diese Arbeit ab.

Diese Methode erwartet an ihren Argumenten das DrawingContext-Objekt, auf dem gezeichnet werden soll, die Position und die Ausmaße des zu zeichnenden Rechtecks, den Radius der abgerundeten Ecke, einen Brush, der zum Füllen verwendet wird, und einen Pen, über den der Rahmen des Rechtecks gezeichnet wird. Für den Brush und den Pen können Sie auch null übergeben, wenn Sie nicht wollen, dass das Rechteck gefüllt bzw. dass der Rand gezeichnet wird.

Zum Kompilieren dieser Methode müssen Sie die Namensräume System.Windows und System.Windows.Media importieren.

public static void DrawRoundedRectangle(this DrawingContext dc, int x, int y, 
   int width, int height, int cornerRadius, Brush brush, Pen pen)
{
   // StreamGeometry-Instanz erzeugen, die die Geometrie der Form verwaltet
   // und deren StreamGeometryContext holen
   StreamGeometry geometry = new StreamGeometry();
   using (StreamGeometryContext sgc = geometry.Open())
   {
      // Size-Objekt für die Größe des Viertelkreises der Ecken berechnen
      Size cornerSize = new Size(cornerRadius, cornerRadius);

      // Figur starten
      sgc.BeginFigure(new Point(x + cornerRadius, y), true, true);

      // Linie oben hinzufügen
      sgc.LineTo(new Point(x + width - cornerRadius, y), true, true);

      // Ecke rechts oben hinzufügen
      sgc.ArcTo(new Point(x + width, y + cornerRadius), cornerSize, 
         0, false, SweepDirection.Clockwise, true, true);

      // Linie rechts hinzufügen
      sgc.LineTo(new Point(x + width, y + height - cornerRadius), true, true);

      // Ecke rechts unten hinzufügen
      sgc.ArcTo(new Point(x + width - cornerRadius, y + height), cornerSize,
         0, false, SweepDirection.Clockwise, true, true);

      // Linie unten hinzufügen
      sgc.LineTo(new Point(x + cornerRadius, y + height), true, true);

      // Ecke links unten hinzufügen
      sgc.ArcTo(new Point(x, y + height - cornerRadius), cornerSize, 
         0, false, SweepDirection.Clockwise, true, true);

      // Linie links hinzufügen
      sgc.LineTo(new Point(x, y + cornerRadius), true, true);

      // Ecke links oben hinzufügen
      sgc.ArcTo(new Point(x + cornerRadius, y), cornerSize, 
         0, false, SweepDirection.Clockwise, true, true);
   }

   // Das Geometry-Objekt zeichnen
   dc.DrawGeometry(brush, pen, geometry);
}

290 Pfeile zeichnen

Dieses Rezept zeichnet Pfeile nun viel schöner (. Und in der ganz neuen Version auch für WPF (.

Ich stelle hier lediglich die WPF-Variante der Methode DrawArrow vor. Die GDI-Variante arbeitet ähnlich und ist im Repository, in der Codebook-Klassenbibliothek und im Windows.Forms-Beispiel zu diesem Rezept zu finden. Die Argumente der WPF-Version sind die folgenden:

• dc: Das DrawingContext-Objekt, auf dem gezeichnet werden soll
• startPoint: Der Startpunkt des Pfeils
• endPoint: Der Endpunkt des Pfeils (Ende der Pfeilspitze)
• shaftWidth: Die Breite des Pfeilschafts
• arrowHeadLength: Gibt die Länge der Pfeilspitze bis zum linken bzw. rechten Eckpunkt an
• arrowHeadLengthFromShaft: Gibt die Länge der Pfeilspitze auf der Y-Linie an, die die Mitte des Pfeilschafts bildet
• arrowHeadWidth: Gibt die Breite der Pfeilspitze am Anfang derselben an
• arrowHeadMiddleWidth: Gibt die Breite der Pfeilspitze in der Mitte derselben an
• brush: Der Brush, mit dem der Pfeil gefüllt werden soll. Kann null sein.
• pen: Der Pen, der den Rand des Pfeils definiert. Kann null sein.

Ein Wert größer 0 in arrowHeadMiddleWidth führt dazu, dass die Seitenlinien der Pfeilspitze als Kurve gezeichnet werden. Bei einem Wert kleiner/gleich 0 werden diese Linien als Gerade gezeichnet.

DrawArrow benötigt den Import der Namensräume System, System.Windows und System.Windows.Media.

public static void DrawArrow(this DrawingContext dc, Point startPoint,
   Point endPoint, double shaftWidth, double arrowHeadLength,
   double arrowHeadLengthFromShaft, double arrowHeadWidth,
   double arrowHeadMiddleWidth, Brush brush, Pen pen)
{
   // Länge des Pfeils berechnen
   double x1 = Math.Abs(startPoint.X);
   double y1 = Math.Abs(startPoint.Y);
   double x2 = Math.Abs(endPoint.X);
   double y2 = Math.Abs(endPoint.Y);
   double a = x2 - x1;
   double b = y2 - y1;
   double arrowLength = Math.Sqrt(Math.Pow(a, 2) + Math.Pow(b, 2));

   // Der Pfeil wird virtuell so gezeichnet, dass die Spitze 
   // auf dem Punkt (0,0) liegt und der Anfang auf dem Punkt (0, Pfeillänge): 
   // Virtuellen Start- und Endpunkt berechnen
   double widthOffset = (shaftWidth / 2);
   Point virtualEndPoint = new Point(0, 0);
   Point virtualStartPoint = new Point(virtualEndPoint.X,
      virtualEndPoint.Y + arrowLength);
   Point virtualCenterPoint = new Point(virtualEndPoint.X,
      virtualEndPoint.Y + (int)(arrowLength / 2F));

   // Den Mittelpunkt des Pfeils ermitteln
   double xDiff = (endPoint.X - startPoint.X) / 2F;
   double yDiff = (endPoint.Y - startPoint.Y) / 2F;
   Point centerPoint = new Point(startPoint.X + xDiff, startPoint.Y + yDiff);

   // Der Pfeil wird beim Zeichnen so transformiert, dass er korrekt gedreht
   // und verschoben gezeichnet wird:

   // Den Rotationswinkel für die notwendige Drehung berechnen 
   Point rotationPoint = new Point(endPoint.X - centerPoint.X,
      endPoint.Y - centerPoint.Y);
   int angleOffset;
   // Grundrechnung: Tan(alpha) = b / a => alpha = Atan(b / a)
   if (rotationPoint.X >= 0 && rotationPoint.Y < 0)
   {
      // Erster Quadrant
      a = rotationPoint.X;
      b = rotationPoint.Y * -1;
      angleOffset = 90;
   }
   else if (rotationPoint.X >= 0 && rotationPoint.Y >= 0)
   {
      // Zweiter Quadrant
      a = rotationPoint.Y;
      b = rotationPoint.X;
      angleOffset = 180;
   }
   else if (rotationPoint.X < 0 && rotationPoint.Y >= 0)
   {
      // Dritter Quadrant
      a = rotationPoint.X * -1;
      b = rotationPoint.Y;
      angleOffset = 270;
   }
   else
   {
      // Vierter Quadrant
      b = rotationPoint.X * -1;
      a = rotationPoint.Y * -1;
      angleOffset = 360;
   }

   // Winkel im Bogenmaß berechnen
   double radian = Math.Atan(b / a);

   // Winkel in Grad umrechnen
   double rotationAngle = angleOffset - (radian * (180 / Math.PI));

   // Matrix erzeugen und die Rotation anwenden
   Matrix matrix = new Matrix();
   matrix.RotateAt(rotationAngle, virtualCenterPoint.X, virtualCenterPoint.Y);

   // Verschiebung berechnen und anwenden
   double offsetX = centerPoint.X - virtualCenterPoint.X;
   double offsetY = centerPoint.Y - virtualCenterPoint.Y;
   matrix.Translate(offsetX, offsetY);

   // Punkte für den Pfeil zusammenstellen
   Point[] arrowPoints;
   if (arrowHeadMiddleWidth > 0)
   {
      arrowPoints = new Point[10];
      // Linkes unteres Ende des Pfeilschafts
      arrowPoints[0] = new Point(widthOffset * -1, virtualStartPoint.Y);
      // Linkes oberes Ende des Pfeilschafts 
      arrowPoints[1] = new Point(arrowPoints[0].X, arrowHeadLength);
      // Linke untere Ecke der Pfeilspitze
      arrowPoints[2] = new Point((arrowHeadWidth / 2) * -1,
         arrowHeadLengthFromShaft);
      // Mitte der Pfeilspize links (für eine gerümmte Pfeilspitze)
      arrowPoints[3] = new Point(-(arrowHeadMiddleWidth / 2),
         arrowHeadLengthFromShaft / 2);
      // Pfeilspitze
      arrowPoints[4] = new Point(0, 0);
      // Mitte der Pfeilspitze rechts (für eine gekrümmte Pfeilspitze)
      arrowPoints[5] = new Point(arrowHeadMiddleWidth / 2,
         arrowHeadLengthFromShaft / 2);
      // Rechte untere Ecke der Pfeilspitze
      arrowPoints[6] = new Point(arrowHeadWidth / 2,
         arrowHeadLengthFromShaft);
      // Rechtes oberes Ende des Pfeilschafts
      arrowPoints[7] = new Point(arrowPoints[1].X + shaftWidth,
         arrowPoints[1].Y);
      // Rechtes unteres Ende des Pfeilschafts
      arrowPoints[8] = new Point(arrowPoints[0].X + shaftWidth,
         arrowPoints[0].Y);
   }
   else
   {
      arrowPoints = new Point[7];
      // Linkes unteres Ende des Pfeilschafts
      arrowPoints[0] = new Point(widthOffset * -1, virtualStartPoint.Y);
      // Linkes oberes Ende des Pfeilschafts 
      arrowPoints[1] = new Point(arrowPoints[0].X, arrowHeadLength);
      // Linke untere Ecke der Pfeilspitze
      arrowPoints[2] = new Point((arrowHeadWidth / 2) * -1,
         arrowHeadLengthFromShaft);
      // Pfeilspitze
      arrowPoints[3] = new Point(0, 0);
      // Rechte untere Ecke der Pfeilspitze
      arrowPoints[4] = new Point(arrowHeadWidth / 2,
         arrowHeadLengthFromShaft);
      // Rechtes oberes Ende des Pfeilschafts
      arrowPoints[5] = new Point(arrowPoints[1].X + shaftWidth,
         arrowPoints[1].Y);
      // Rechtes unteres Ende des Pfeilschafts
      arrowPoints[6] = new Point(arrowPoints[0].X + shaftWidth,
         arrowPoints[0].Y);
   }

   // StreamGeometry-Instanz erzeugen, die die Geometrie der Form verwaltet
   // und deren StreamGeometryContext holen
   StreamGeometry geometry = new StreamGeometry();
   using (StreamGeometryContext sgc = geometry.Open())
   {
      sgc.BeginFigure(arrowPoints[0], true, true);
      if (arrowHeadMiddleWidth > 0)
      {
         sgc.LineTo(arrowPoints[1], true, true);
         sgc.LineTo(arrowPoints[2], true, true);
         sgc.BezierTo(arrowPoints[2], arrowPoints[3], arrowPoints[4],
            true, true);
         sgc.BezierTo(arrowPoints[4], arrowPoints[5], arrowPoints[6],
            true, true);
         sgc.LineTo(arrowPoints[7], true, true);
         sgc.LineTo(arrowPoints[8], true, true);
      }
      else
      {
         // Aus den Punkten einen Pfad mit gerader Pfeilspitze bilden
         sgc.PolyLineTo(arrowPoints, true, true);
      }
   }

   // Die Transformation anwenden
   geometry.Transform = new MatrixTransform(matrix);

   // Das Geometry-Objekt zeichnen
   dc.DrawGeometry(brush, pen, geometry);
}

Abbildung 1 zeigt einige mit DrawArrow (über Zufallswerte) gezeichnete Pfeile.

291 Transparente Bilder und Grafiken erzeugen

Dieses Rezept habe ich um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In WPF können Sie zum transparenten Zeichnen von Bildern leider keine Transformation verwenden. Sie können aber die Pixel des Bildes einzeln bearbeiten, um die Transparenz jedes einzelnen Pixels zu bestimmen. Listing 59 verwendet diese Technik, um den Hintergrund eines eingelesenen Bildes voll- und die restlichen Pixel halb-transparent zu definieren und das Bild schließlich zu zeichnen.

Das Beispiel läuft in einem WPF-Fenster, das ein Image-Steuerelement enthält. Die Quelle des Steuerelements ist auf eine Ressource der Anwendung gelegt, die Moon.jpg heißt (und die ein Bild des Mondes ist). Das Beispiel erfordert den Import der Namensräume System, System.Threading, System.Windows, System.Windows.Media und System.Windows.Media.Imaging.

public partial class StartWindow : Window
{
   /* DrawingVisual auf dem gezeichnet werden kann */
   private DrawingVisual drawingVisual = new DrawingVisual();

   /* Konstruktor. Erzeugt die Steuerelemente und Komponenten und 
      die Zeichnung in dem DrawingVisual. */
   public StartWindow()
   {
      InitializeComponent();

      // Den DrawingContext für den DrawingVisual holen
      using (DrawingContext dc = this.drawingVisual.RenderOpen())
      {
         // Halb-transparentes Rechteck mit Text zeichnen
         dc.DrawRectangle(new SolidColorBrush(Color.FromArgb(80, 0, 0, 30)),
            null, new Rect(20, 40, this.Width - 40, 40));
         FormattedText formattedText = new FormattedText("Keine Panik",
            Thread.CurrentThread.CurrentCulture, FlowDirection.LeftToRight,
            new Typeface("Tahoma"), 28, new SolidColorBrush(
            Color.FromArgb(150, 0, 0, 255)));
         double x = (this.Width - formattedText.Width) / 2;
         double y = 45;
         dc.DrawText(formattedText, new Point(x, y));

         // Bild einlesen
         BitmapDecoder decoder = BitmapDecoder.Create(
            new Uri("Hitchhiker.gif", UriKind.Relative),
            BitmapCreateOptions.None, BitmapCacheOption.None);
         BitmapSource bitmapSource = decoder.Frames[0];

         // Das Bild so umwandeln, dass die Farbe des ersten Pixels 
         // voll-transparent und der Rest des Bildes halb-transparent 
         // erscheint
         if (bitmapSource.Format != PixelFormats.Bgra32)
         {
            bitmapSource = new FormatConvertedBitmap(bitmapSource,
               PixelFormats.Bgra32, null, 0.0);
         }
         int stride = bitmapSource.PixelWidth *
            ((bitmapSource.Format.BitsPerPixel + 7) / 8);
         byte[] pixelData = new byte[stride * bitmapSource.PixelHeight];
         bitmapSource.CopyPixels(pixelData, stride, 0);
         byte firstPixelBlue = pixelData[0];
         byte firstPixelGreen = pixelData[1];
         byte firstPixelRed = pixelData[2];
         for (int i = 0; i < bitmapSource.PixelHeight * stride;
            i += ((bitmapSource.Format.BitsPerPixel + 7) / 8))
         {
            if (pixelData[i] == firstPixelBlue &&
               pixelData[i + 1] == firstPixelGreen &&
               pixelData[i + 2] == firstPixelRed)
            {
               // Den Alpha-Wert des Pixels auf 0 setzen
               pixelData[i + 3] = 0;
            }
            else
            {
               // Den Alpha-Wert des Pixels auf 160 setzen
               pixelData[i + 3] = 160;
            }
         }

         // Mit den neuen Pixel-Daten ein neues Bild erzeugen 
         BitmapSource transformedBitmap = BitmapSource.Create(
            bitmapSource.PixelWidth, bitmapSource.PixelHeight,
            bitmapSource.DpiX, bitmapSource.DpiY, PixelFormats.Bgra32,
            bitmapSource.Palette, pixelData, stride);

         // Das transformierte Bild zeichnen
         Rect bitmapRect = new Rect((this.Width - 20 -
           transformedBitmap.Width) / 2, 55, transformedBitmap.Width,
           transformedBitmap.Height);
         dc.DrawImage(transformedBitmap, bitmapRect);
      }

      // Den DrawingVisual dem Fenster als visuelles und logisches 
      // Child-Element hinzufügen
      this.AddVisualChild(this.drawingVisual);
      this.AddLogicalChild(this.drawingVisual);
   }

   /* Wird überschrieben, um die Anzahl der visuellen Kind-Elemente 
      um das eigene zu erhöhen */
   protected override int VisualChildrenCount
   {
      get
      {
         return base.VisualChildrenCount + 1;
      }
   }

   /* Wird überschrieben, um das eigene visuelle Kind-Element zurückzugeben */
   protected override Visual GetVisualChild(int index)
   {
      if (index < base.VisualChildrenCount)
      {
         return base.GetVisualChild(index);
      }
      else
      {
         return this.drawingVisual;
      }
   }
}

292 Bilder mit Schatten zeichnen

Dieses Rezept habe ich (wie die meisten Zeichnen-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In WPF können Sie jedem UI-Element (allen Klassen, die von UIElement abgeleitet sind), über die Eigenschaft BitmapEffect (u. a.) einen Schatten zuordnen, indem Sie ein DropShadowBitmapEffect-Objekt in diese Eigenschaft schreiben. Das geht natürlich direkt in XAML:

<Image Margin="10,10,83,123" Name="image1" Stretch="None">
    <Image.Source>
        <BitmapImage UriSource="Hitchhiker.jpg"/>
    </Image.Source>
    <Image.BitmapEffect>
        <DropShadowBitmapEffect Color="Black" Direction="310" Noise="0.1"
           Opacity="0.7" ShadowDepth="10" Softness="0.5" />
    </Image.BitmapEffect>
</Image>

ber die verschiedenen Eigenschaften der DropShadowBitmapEffect-Klasse können Sie den Schatten beeinflussen:

Das folgende Beispiel zeigt das Zeichnen eines Bildes, das als Ressource in der Anwendung gespeichert ist, an dem kompletten Quellcode eines (leeren) Fensters. Der wesentliche Programmcode ist das Erzeugen, Initialisieren und Zuweisen des DropShadowBitmapEffect beim Zeichnen im Konstruktor.

Das Beispiel erfordert, dass eine Bild-Ressource mit dem Namen Hitchhiker.jpg in der Anwendung gespeichert ist. Es erfordert außerdem den Import der Namensräume System, System.Windows, System.Windows.Media, System.Windows.Media.Effects und System.Windows.Media.Imaging.

public partial class StartWindow : Window
{
   /* DrawingVisual erzeugen, auf dem gezeichnet werden kann */
   private DrawingVisual drawingVisual = new DrawingVisual();

   /* Konstruktor. Erzeugt die Steuerelemente und Komponenten. */
   public StartWindow()
   {
      InitializeComponent();

      // Den DrawingContext für den DrawingVisual holen
      using (DrawingContext dc = this.drawingVisual.RenderOpen())
      {
         // Das Bild aus der Ressource lesen
         BitmapDecoder decoder = BitmapDecoder.Create(
            new Uri("pack://application:,,,/Hitchhiker.jpg"),
            BitmapCreateOptions.None, BitmapCacheOption.None);
         BitmapSource bitmapSource = decoder.Frames[0];

         // Den DropShadowBitmapEffect erzeugen und initialisieren
         DropShadowBitmapEffect effect = new DropShadowBitmapEffect {
            Direction = 310, Noise = 0.1, Opacity = 0.7, ShadowDepth = 10,
            Softness = 0.5 };

         // Den DropShadowBitmapEffect dem DrawingContext hinzufügen
         dc.PushEffect(effect, null);

         // Das Bild zeichnen
         dc.DrawImage(bitmapSource, new Rect(200, 10,
            bitmapSource.Width, bitmapSource.Height));

         // Den Effekt wieder entfernen
         dc.Pop();
      }

      // Den DrawingVisual dem Fenster als visuelles und logisches 
      // Child-Element hinzufügen
      this.AddVisualChild(this.drawingVisual);
      this.AddLogicalChild(this.drawingVisual);
   }

   /* Wird überschrieben, um die Anzahl der visuellen Kind-Elemente 
      um das eigene zu erhöhen  */
   protected override int VisualChildrenCount
   {
      get
      {
         return base.VisualChildrenCount + 1;
      }
   }

   /* Wird überschrieben, um das eigene visuelle Kind-Element zurückzugeben */
   protected override Visual GetVisualChild(int index)
   {
      if (index < base.VisualChildrenCount)
      {
         return base.GetVisualChild(index);
      }
      else
      {
         return this.drawingVisual;
      }
   }
}

293 Schräg zeichnen und Zeichenobjekte rotieren

Dieses Rezept habe ich (wie die meisten Zeichnen-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

WPF

Zum Transformieren stehen Ihnen die folgenden Klassen (aus dem Namensraum System.Windows.Media) zur Verfügung:

In XAML können Sie Transformationen über die LayoutTransform-Eigenschaft auch deklarativ anwenden. Das folgende Beispiel deklariert ein Label, das um 270 Grad verdreht wird, ein Rechteck, das um 30 Grad gedreht wird und ein Rechteck, das um 30 Grad in X-Richtung gekippt und auf den Faktor 0,8 skaliert wird:

<!-- Ein um 270 Grad gedrehtes Label -->
<Label Height="28" HorizontalAlignment="Left" Margin="10,10,0,0" 
  Name="rotateTransformDemoLabel" VerticalAlignment="Top"  
  Content="Das ist ein in XAML gedrehter Text">
    <Label.LayoutTransform>
        <RotateTransform Angle="270"/>
    </Label.LayoutTransform>
</Label>

<!-- Ein um 30 Grad gedrehtes Rechteck -->
<Rectangle Width="100" Height="100" Fill="Red" Stroke="Navy" HorizontalAlignment="Left" 
   Margin="50,15,0,0" VerticalAlignment="Top">
    <Rectangle.LayoutTransform>
        <RotateTransform Angle="30"/>
    </Rectangle.LayoutTransform>
</Rectangle>

<!-- Ein um 30 Grad in X-Richtung gekipptes Rechteck -->
<Rectangle Width="100" Height="100" Fill="Red" Stroke="Navy" HorizontalAlignment="Left" 
   Margin="200,15,0,0" VerticalAlignment="Top">
    <Rectangle.LayoutTransform>
        <TransformGroup>
            <!-- Kipp-Transformation -->
            <SkewTransform AngleX="30"/>
            <!-- Skalierungs-Transformation -->
            <ScaleTransform ScaleX="0.8" ScaleY="0.8"/>
        </TransformGroup>
    </Rectangle.LayoutTransform>
</Rectangle>

Das Ergebnis lässt sich am besten im Designer beurteilen, weil dieser die Fläche, die die Objekte ohne Transformation ausfüllen würden, zusätzlich zu den transformierten Objekten darstellt (Abbildung 2).

Transformationen können Sie natürlich auch beim eigenen Zeichnen anwenden. Dazu können Sie einmal die Transform-Eigenschaft des DrawingVisual mit einer Transformations-Instanz (oder mehreren in einer TransformGroup-Instanz) belegen um den gesamten Visual (auf dem Sie zeichnen) zu transformieren.

Das folgende Beispiel zeichnet zunächst einen Text um 45 Grad gedreht. Als Drehpunkt wird die linke obere Ecke des Textes verwendet. Danach wird ein Rechteck um 45 Grad gedreht gezeichnet, dessen Drehpunkt auf die Mitte des Rechtecks gelegt wird. Schließlich wird dasselbe Rechteck noch einmal normal (nicht gedreht) ausgegeben.

Das Programm läuft in einem WPF-Fenster, das ein privates Feld drawingVisual vom Typ DrawingVisual enthält (und das entsprechend zum Zeichnen eingerichtet ist, siehe in Listing 61).

// Den DrawingContext für den DrawingVisual holen
using (DrawingContext dc = this.drawingVisual.RenderOpen())
{
   // Einen Text um 45 Grad verdreht ausgeben. Der Drehpunkt
   // wird dabei auf den Startpunkt des Textes gesetzt.
   FormattedText formattedText = new FormattedText(
      "Das ist selbst gezeichneter, gedrehter Text",
      Thread.CurrentThread.CurrentCulture, FlowDirection.LeftToRight,
      new Typeface("Tahoma"), 14, Brushes.Black);
   dc.PushTransform(new RotateTransform(45, 350, 10));
   dc.DrawText(formattedText, new Point(350, 10));
   dc.Pop(); // Transformationen und Effekte wieder entfernen

   // Ein Rechteck um 45 Grad nach rechts gekippt zeichnen.
   // Als Drekpunkt wird die Mitte des Rechtecks angegeben.
   dc.PushTransform(new RotateTransform(45, 455, 105));
   dc.DrawRectangle(Brushes.Navy, new Pen(Brushes.Red, 2),
      new Rect(450, 100, 10, 10));
   dc.Pop(); // Transformationen und Effekte wieder entfernen

   // Normales Rechteck zeichnen
   dc.DrawRectangle(Brushes.Navy, new Pen(Brushes.Red, 2),
      new Rect(450, 100, 10, 10));
}

Damit sind die Möglichkeiten aber noch nicht erschöpft, denn Sie können auch einige Objekte, die Sie zum Zeichnen verwenden, wie z. B. ein Geometry-Objekt, über deren Transform-Eigenschaft separat transformieren. Andere Typen, wie z. B. die Rect-Struktur, besitzen die Möglichkeit, über ein Matrix-Objekt transformiert zu werden. Ein Matrix-Objekt verwaltet die Daten einer oder mehrerer Transformationen. Über die Methode Translate können Sie eine Verschiebung in X/Y-Richtung bewirken, die Methoden Rotate und RotateAt führen zu einer Rotation. Rotate dreht dabei um die linke obere Ecke, bei RotateAt können Sie den Drehpunkt bestimmen. Ein Matrix-Objekt habe ich mit einer MatrixTransformation auf einem StreamGeometry-Objekt in meinem Pfeil-Rezept eingesetzt. Vergleichen Sie dieses um zu erfahren, wie Sie dies programmieren.

294 Den Drehpunkt eines Rechtecks so ermitteln, dass die Ecke links oben an derselben Position bleibt

Dieses Rezept habe ich (wie die meisten Zeichnen-Rezepte) um die Behandlung von WPF erweitert. Hier ist diee WPF-Version meiner Methode mit dem langen Namen:

public static Point 
   GetCenterOfRotationForRotationWithRetentionOfUpperLeftAngle(
   Rect rect, bool rotateClockwise)
{
   // Rotier-Punkt berechnen
   double offset = 0;
   if (rotateClockwise)
   {
      offset = rect.Height / 2;
   }
   else
   {
      offset = rect.Width / 2;
   }

   // Ergebnis zurückgeben
   return new Point(rect.X + offset, rect.Y + offset);
}

Die Beispiele zu diesem Rezept erläutern die Anwendung dieser Methode.

295 Text an einer definierten Position in 90-Grad-Schritten gedreht ausgeben

Dieses Rezept habe ich (wie die meisten Zeichnen-Rezepte) um die Behandlung von WPF erweitert. Hier ist der komplette neue Text:

Zum Kompilieren des Quelltexts müssen Sie die Namensräume System.Windows, System.Windows.Media und System.Windows.Media.Imaging einbinden.

public static void DrawRotatedText(this DrawingContext dc,
   FormattedText formattedText, Point origin, Rotation rotation)
{
   // Rechteck berechnen, das den Text umfasst
   Rect textRect = new Rect(origin.X, origin.Y, formattedText.Width,
      formattedText.Height);

   // Drehpunkt so berechnen, dass das Rechteck 
   // an der angegebenen Position bleibt
   Point rotationPoint = new Point();
   float rotationAngle = 0;
   double offset = 0;
   switch (rotation)
   {
      case Rotation.Rotate0:
         // Den Text direkt ausgeben
         dc.DrawText(formattedText, origin);
         return;

      case Rotation.Rotate90:
         offset = textRect.Height / 2;
         rotationPoint.X = textRect.X + offset;
         rotationPoint.Y = textRect.Y + offset;
         rotationAngle = 90;
         break;

      case Rotation.Rotate180:
         // Bei einer Drehung um 180 Grad liegt der Drehpunkt in der 
         // Mitte des Rechtecks
         rotationPoint.X = textRect.X + (textRect.Width / 2);
         rotationPoint.Y = textRect.Y + (textRect.Height / 2);
         rotationAngle = 180;
         break;

      case Rotation.Rotate270:
         offset = textRect.Width / 2;
         rotationPoint.X = textRect.X + offset;
         rotationPoint.Y = textRect.Y + offset;
         rotationAngle = 270;
         break;
   }

   // Text gedreht ausgeben
   dc.PushTransform(new RotateTransform(rotationAngle,
      rotationPoint.X, rotationPoint.Y));
   dc.DrawText(formattedText, origin);
   dc.Pop();
}

296 Die Breite und Höhe eines auszugebenden Textes bestimmen

Dieses Rezept habe ich (wie die meisten Zeichnen-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

In WPF ist diese Aufgabe einfach zu lösen, da Sie zum Zeichnen von Texten ein FormattedText-Objekt verwenden. Die Eigenschaft Width liefert die Breite des Textes, die Eigenschaft Height die Höhe. Damit können Sie z. B. mittig auf einem Fenster zeichnen.

Das folgende Beispiel läuft in einem WPF-Fenster, das ein privates Feld drawingVisual vom Typ DrawingVisual enthält (und das entsprechend zum Zeichnen eingerichtet ist, siehe in Listing 61 in Rezept 292).

// Den DrawingContext für den DrawingVisual holen
using (DrawingContext dc = this.drawingVisual.RenderOpen())
{
   // Einen Text zentriert ausgeben
   FormattedText formattedText = new FormattedText("Zentrierter Text",
      Thread.CurrentThread.CurrentCulture, FlowDirection.LeftToRight,
      new Typeface("Tahoma"), 14, Brushes.Black);
   double x = (this.Width - SystemParameters.ResizeFrameVerticalBorderWidth -
      formattedText.Width) / 2;
   double y = (this.Height - SystemParameters.WindowCaptionHeight - 
      SystemParameters.ResizeFrameHorizontalBorderHeight - 
      formattedText.Height) / 2;
   dc.DrawText(formattedText, new Point(x, y));
}

297 Texte zentriert oder rechtsbündig zeichnen

Dieses Rezept habe ich (wie die meisten Zeichnen-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

Listing 67 zeigt nun, die Sie in einem WPF-Fenster Text normal, zentriert und rechtsbündig ausgeben. Der wesentliche Trick dabei ist die Berechnung der inneren Fensterbreite und -höhe, für die ich keine andere Lösung gefunden habe, als die Breite des Fenster-Randes, und bei der Höhe zusätzlich noch die Höhe des Fenster-Titels von der Gesamtbreite bzw. -höhe des Fensters abzuziehen.

Das Beispiel läuft in einem WPF-Fenster, das ein privates Feld drawingVisual vom Typ DrawingVisual enthält (und das entsprechend zum Zeichnen eingerichtet ist).

// Den DrawingContext für den DrawingVisual holen
using (DrawingContext dc = this.drawingVisual.RenderOpen())
{
   // Text normal ausgeben
   const int xMargin = 10;
   FormattedText formattedText = new FormattedText("Beispiel-Text, " +
      "der normal ausgegeben wird", Thread.CurrentThread.CurrentCulture,
      FlowDirection.LeftToRight, new Typeface("Tahoma"), 12,
      Brushes.Black);
   formattedText.MaxTextWidth = this.Width -
      SystemParameters.ThickVerticalBorderWidth - (xMargin * 2);
   dc.DrawText(formattedText, new Point(xMargin, 10));

   // Text zentriert und mittig ausgeben
   formattedText = new FormattedText("Beispiel-Text," +
      Environment.NewLine + "der auf dem Formular horizontal und " +
      "vertikal zentriert ausgegeben wird",
      Thread.CurrentThread.CurrentCulture, FlowDirection.LeftToRight,
      new Typeface("Tahoma"), 12, Brushes.Black);
   formattedText.TextAlignment = TextAlignment.Center;
   formattedText.MaxTextWidth = this.Width -
      SystemParameters.ThickVerticalBorderWidth - (xMargin * 2);
   double x = (this.Width - SystemParameters.FixedFrameVerticalBorderWidth -
      formattedText.Width) / 2;
   double y = (this.Height - SystemParameters.WindowCaptionHeight -
      SystemParameters.FixedFrameHorizontalBorderHeight -
      formattedText.Height) / 2;
   dc.DrawText(formattedText, new Point(x, y));

   // Text rechtsbündig ausgeben
   formattedText = new FormattedText("Beispiel-Text," +
      Environment.NewLine + "der an einer definierten Y-Position " +
      "auf dem Fenster rechtsbündig " + Environment.NewLine +
      "mit einem kleinen Rand ausgegeben wird",
      Thread.CurrentThread.CurrentCulture, FlowDirection.LeftToRight,
      new Typeface("Tahoma"), 12, Brushes.Black);
   formattedText.TextAlignment = TextAlignment.Right;
   formattedText.MaxTextWidth = this.Width -
      SystemParameters.ThickVerticalBorderWidth - (xMargin * 2);
   x = 10;
   y = this.Height - SystemParameters.WindowCaptionHeight -
      SystemParameters.ThickHorizontalBorderHeight - 55;
   dc.DrawText(formattedText, new Point(x, y));
}

298 Strings beim Zeichnen wortgerecht umbrechen

Dieses Rezept habe ich (wie die meisten Zeichnen-Rezepte) um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

Das folgende Beispiel demonstriert den Umgang mit diesen Eigenschaften an einem längeren Text, der mit etwas Rand in einem Fenster ausgegeben wird. Das Beispiel erfordert ein WPF-Fenster, das ein privates Feld drawingVisual vom Typ DrawingVisual enthält (und das entsprechend zum Zeichnen eingerichtet ist, siehe in Listing 61 in Rezept 292).

// Den DrawingContext für den DrawingVisual holen
using (DrawingContext dc = this.drawingVisual.RenderOpen())
{
   // Die Position und die Maße des Text-Rechtecks bestimmen
   const double x = 30;
   const double y = 30;
   double textRectangleWidth = this.Width - 
      SystemParameters.FixedFrameVerticalBorderWidth - (2 * x);
   double textRectangleHeight = this.Height - 
      SystemParameters.WindowCaptionHeight -
      SystemParameters.FixedFrameHorizontalBorderHeight - (2 * y);

   // FormattedText-Instanz für den Text erzeugen
   FormattedText formattedText = new FormattedText("Weit draußen in den " +
      "unerforschten Einoden eines total aus der Mode gekommenen " +
      "Ausläufers des westlichen Spiralarms der Galaxis leuchtet " +
      "unbeachtet eine kleine gelbe Sonne. Um sie kreist in einer " +
      "Entfernung von ungefähr achtundneunzig Millionen Meilen ein " +
      "absolut unbedeutender, kleiner blaugrüner Planet, dessen vom " +
      "Affen stammende Bioformen so erstaunlich primitiv sind, dass " +
      "sie Digitaluhren noch immer für eine unwahrscheinlich tolle " +
      "Erfindung halten.",
      Thread.CurrentThread.CurrentCulture, FlowDirection.LeftToRight,
      new Typeface("Tahoma"), 14, Brushes.Black);
   
   // Die Maximalbreite und -höhe definieren
   formattedText.MaxTextWidth = textRectangleWidth;
   formattedText.MaxTextHeight = textRectangleHeight;

   // Die Art des Abschneidens (auf den Defaultwert) festlegen
   formattedText.Trimming = TextTrimming.WordEllipsis;

   // Den Text zeichnen
   dc.DrawText(formattedText, new Point(x, y));
}

Reflection und Serialisierung

310 Objekte nach XML serialisieren und von XML deserialisieren

Threading

312 In einem Thread sicher auf Steuerelemente zugreifen

Dieses Rezept habe ich um die Behandlung von WPF erweitert. Hier ist der WPF-Text:

Invoke existiert in mehreren Überladungen. Der von mir verwendeten Variante übergeben Sie am ersten Argument einen Wert der DispatcherPriority-Aufzählung (aus dem Namensraum System.Windows.Threading), die die Priorität des Aufrufs bestimmt. Am zweiten Argument übergeben Sie einen Delegaten mit der auszuführenden Methode. Um das Ganze einfach zu halten, können Sie hier eine Instanz einer der passenden Action- oder Func-Varianten verwenden und dieser einen Lambda-Ausdruck übergeben. An den folgenden Argumenten übergeben Sie die Argumente, die der Methode übergeben werden sollen. Falls Sie einen Func-Delegaten verwenden (die Methode also ein Wert zurückgibt) erhalten Sie den Rückgabewert über den Object-Typen, den Invoke zurückgibt.

Um zu überprüfen, ob der (zeitintensive) Aufruf von Invoke überhaupt notwendig ist, rufen Sie die CheckAccess-Methode auf, die true zurückgibt, wenn der direkte Zugriff möglich ist.

Das folgende Beispiel zeigt, wie Sie dies programmieren. Es enthält eine Methode, die in einem Thread ausgeführt werden soll. Diese Methode simuliert eine Bearbeitung in einer Schleife. Innerhalb der Schleife wird ein Label mit einer Information aktualisiert. Invoke wird dazu ein Delegat vom Typ Action<Label, string> übergeben. Der Lambda-Ausdruck für diesen Delegaten erhält eine Referenz auf das zu aktualisierende Label und den neuen Text übergeben.

Das Programm läuft in einem Fenster, das ein Label enthält, das resultLabel heißt. Es erfordert den Import der Namensräume System, System.Threading und System.Windows.Forms. Die Methode muss natürlich über eine Thread-Instanz gestartet werden.

private void DemoThreadMethod()
{
   // Schleife als Demo für die Aktualisierung
   for (int i = 0; i < 100; i++)
   {
      // Sicher auf das Steuerelement zugreifen
      if (this.resultLabel.Dispatcher.CheckAccess())
      {
         // Der Zugriff erfolgt in demselben Tread 
         this.resultLabel.Content = i.ToString();
      }
      else
      {
         // Der Zugriff erfolgt nicht in demselben Tread
         this.resultLabel.Dispatcher.Invoke(
            System.Windows.Threading.DispatcherPriority.Normal,
            new Action<Label, string>(
            (label, content) => label.Content = content),
            this.resultLabel, i.ToString());
     }

      // Kleine Demo-Pause
      Thread.Sleep(50);
   }
}

Datenbanken

317 Datenbanken erzeugen

Dieses Rezept habe ich um die Behandlung von LINQ to SQL erweitert. Hier ist der LINQ-to-SQL-Text:

Im Programm müssen Sie dann lediglich eine Instanz des DataContext-Objekts erzeugen, über die DatabaseExists-Methode abfragen, ob die Datenbank (die über den Verbindungsstring des DataContext-Objekts definiert ist) existiert und im negativen Fall die CreateDatabase-Methode aufrufen um die Datenbank zu erzeugen. Das folgende Beispiel zeigt die an einem DataContext-Objekt, das für die Datenbank erzeugt wurde, die auch im ADO.NET-Abschnitt erzeugt wird:

// Den DataContext erzeugen
BookstoreDataContext dataContext = new BookstoreDataContext();

// Die Datenbank erzeugen falls diese nicht existiert
if (dataContext.DatabaseExists() == false)
{
   dataContext.CreateDatabase();
}

318 Abfragen der automatisch vergebenen Id eines neuen Datensatzes

Dieses Rezept habe ich um die Behandlung von LINQ to SQL erweitert. Hier ist der LINQ-to-SQL-Text:

// DataContext erzeugen
BookstoreDataContext dataContext = new BookstoreDataContext();

// Einen Autoren hinzufügen
Author newAuthor = new Author { FirstName = "Matt", LastName = "Ruff" };
dataContext.Authors.InsertOnSubmit(newAuthor);
dataContext.SubmitChanges();

// Den Id-Wert auslesen
int identityValue = newAuthor.Id;

319 Bilder und andere binäre Daten in einer Datenbank verwalten

Dieses Rezept habe ich um die Behandlung von LINQ to SQL erweitert. Hier ist der LINQ-to-SQL-Text:

In einem BLOB-Feld können Sie beliebige binäre Daten ablegen. Dieses Rezept zeigt, wie Sie das für LINQ to SQL und für ADO.NET programmieren. Die Beispiele basieren auf einer Datenbank mit Namen Persons mit einer Tabelle, die mit SQL folgendermaßen erzeugt werden kann:

CREATE TABLE Persons (
   Id int PRIMARY KEY NOT NULL IDENTITY, 
   FirstName nvarchar(255),
   LastName nvarchar(255), 
   Picture image) 

Das Feld Id wird beim Hinzufügen von Datensätzen automatisch um 1 erhöht. Das Feld Picture ist vom Typ image und verwaltet deswegen binäre Daten.

LINQ to SQL

Das folgende Beispiel basiert auf einer WPF-Anwendung, die ein LINQ-to-SQL-Modell für die Persons-Datenbank enthält, die der oben angegebenen SQL-Anweisung entspricht. Es erfordert den Import der Namensräume System, System.Data.Linq, System.IO, System.Linq und System.Windows.Media.Imaging.

// DataContext erzeugen
PersonsDataContext dataContext = new PersonsDataContext();

// Neue Person erzeugen
Person newPerson = new Person();
newPerson.FirstName = "Zaphod";
newPerson.LastName = "Beeblebrox";

// Das Bild einlesen
string imageFileName = "C:\\Bilder\\Zaphod.jpg";
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imageFileName), 
   BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
BitmapSource bitmapSource = decoder.Frames[0];

// Das Bild in ein Byte-Array konvertieren (das dem PNG-Format entspricht)
PngBitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
byte[] bitmapData = null;
using (MemoryStream imageStream = new MemoryStream())
{
   encoder.Save(imageStream);
   imageStream.Flush();
   bitmapData = imageStream.ToArray();
}

// Das Bild im Person-Objekt ablegen
newPerson.Picture = new Binary(bitmapData);

// Die neue Person speichern
dataContext.Persons.InsertOnSubmit(newPerson);
dataContext.SubmitChanges();

Das Lesen binärerer Daten erfolgt ähnlich einfach:

// DataContext erzeugen
PersonsDataContext dataContext = new PersonsDataContext();

// Die Id der Person definieren
int personId = 1;

// Die Person ermitteln
Person person = dataContext.Persons.Single<Person>(
   p => p.Id == personId);
if (person != null)
{
   // Vorname und Nachname auslesen
   string personName = person.FirstName " " + person.LastName;

   if (person.Picture != null)
   {
      // Die Bilddaten auslesen
      byte[] bitmapData = person.Picture.ToArray();

      // Die Bilddaten in ein BitmapSource-Objekt konvertieren
      BitmapSource bitmapSource = null;
      using (MemoryStream imageStream = new MemoryStream(bitmapData))
      {
         BitmapDecoder decoder = BitmapDecoder.Create(imageStream,
            BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
         bitmapSource = decoder.Frames[0];
      }

      // Das Bild verarbeiten
      ...
   }
}