C# Tipps und Tricks

Drucken mit C#

2012-01-14T12:41:00.003+01:00

In diesem Post möchte ich euch zeigen, wie man mit C# den Drucker ansteuern kann.
Hierfür gibt es bestimmt einige Möglichkeiten, ich benutze hier die Graphics Eigenschaft des Druckereignisses, das auszudruckende Resultat muss dann in dieser gezeichnet werden.

Zuerst muss System.Drawing.Printing eingebunden werden.
Die folgende Zeile initialisiert uns das benötigte Objekt, welches das zu druckende Dokument repräsentiert.

PrintDocument PrintDoc = new PrintDocument();

Installierte Drucker sind in PrinterSettings.InstalledPrinters gespeichert. In dieser Liste liegen die Namen der Drucker als Strings vor, zum Setzen des zu benutzenden Druckers benutzen wir PrintDoc.PrinterSettings.PrinterName = PrinterSettings.InstalledPrinters[Index].
Gedruckt wird das Dokument über den Befehl PrintDoc.Print().
Vorher fügen wir dem Druckdokument allerdings eine Ereignisbehandlung für sein Druckereignis hinzu: PrintDoc.PrintPage += new PrintPageEventHandler(PrintPage).
Hierbei ist PrintPage eine beliebige Funktion mit folgender Signatur: void PrintPage(object sender, PrintPageEventArgs e).
Diese wird nun aufgerufen, wann immer ein Dokument gedruckt wird.
In dieser können wir dann das gewünschte Druckresult erstellen, indem wir es in e.Graphics zeichnen. Es können z.B. auch Bilder eingelesen werden und dort hinein gezeichnet werden.
Zum Abschluss der komplette Quellcode, welcher eine Linie und einen String druckt:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.Drawing.Printing;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Print()
        {
            PrintDocument PrintDoc = new PrintDocument();

            List<string> Printers = new List<string>();
            foreach (string p in PrinterSettings.InstalledPrinters)
                Printers.Add(p);

            // Alle verfügbaren Drucker sind in Printers gespeichert, man könnte den Benutzer daraus auswählen lassen.
            // In diesem Beispiel wird einfach immer Drucker 0 gewählt.
            PrintDoc.PrinterSettings.PrinterName = PrinterSettings.InstalledPrinters[0];

            PrintDoc.PrintPage += new PrintPageEventHandler(PrintPage);
            PrintDoc.Print();
        }

        void PrintPage(object sender, PrintPageEventArgs e)
        {
            e.Graphics.DrawLine(new Pen(Color.Black), new Point(0, 0), new Point(100, 100));
            e.Graphics.DrawString("Ich kann jetzt mit C# drucken", new Font("Times New Roman", 12), new SolidBrush(Color.Black), new Point(45, 45));

        }
    }

}

String mit Zeichen füllen

2012-01-05T01:19:00.002+01:00

Es gibt einen netten kleinen Trick, mit dem man schnell einen String mit einem beliebigen Zeichen auffüllen kann.
Die Klasse string stellt nämlich den folgenden Konstruktor bereit:
new string(meinzeichen, anzahl).
Hierdurch wird ein neuer String bestehend aus anzahl Zeichen mit dem Wert meinzeichen angelegt.
Folgendes Beispiel erzeugt einen String bestehend aus 30 Trennstrichen:

string filled = new string('-', 30);

Ein gutes Jahr 2012!

2011-12-30T22:53:00.005+01:00

Ich wünsche allen Lesern einen guten Rutsch und ein frohes neues Jahr 2012.
In C# ausgedrückt:

Form1.Designer.cs:

namespace WindowsFormsApplication1
{
    partial class Form1
    {
        /// <summary>
       /// Erforderliche Designervariable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
       /// Verwendete Ressourcen bereinigen.
        /// </summary>
        /// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Vom Windows Form-Designer generierter Code

        /// <summary>
       /// Erforderliche Methode für die Designerunterstützung.
       /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
        /// </summary>
        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            this.textBox1 = new System.Windows.Forms.TextBox();
            this.timer1 = new System.Windows.Forms.Timer(this.components);
            this.textBox2 = new System.Windows.Forms.TextBox();
            this.SuspendLayout();
            //
            // textBox1
            //
            this.textBox1.Location = new System.Drawing.Point(12, 12);
            this.textBox1.Multiline = true;
            this.textBox1.Name = "textBox1";
            this.textBox1.ReadOnly = true;
            this.textBox1.Size = new System.Drawing.Size(374, 328);
            this.textBox1.TabIndex = 0;
            //
            // timer1
            //
            this.timer1.Enabled = true;
            this.timer1.Interval = 300;
            this.timer1.Tick += new System.EventHandler(this.timer1_Tick);
            //
            // textBox2
            //
            this.textBox2.Location = new System.Drawing.Point(433, 346);
            this.textBox2.Name = "textBox2";
            this.textBox2.Size = new System.Drawing.Size(12, 20);
            this.textBox2.TabIndex = 1;
            //
            // Form1
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(393, 349);
            this.Controls.Add(this.textBox2);
            this.Controls.Add(this.textBox1);
            this.Name = "Form1";
            this.Text = "Grüße vom C# Blog";
            this.Load += new System.EventHandler(this.Form1_Load);
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.TextBox textBox1;
        private System.Windows.Forms.Timer timer1;
        private System.Windows.Forms.TextBox textBox2;
    }
}

Form1.cs:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {

        public Form1()
        {
            InitializeComponent();
        }

        string[] images = new string[22];
        private void init()
        {
            images[0] = NewLine(23) + "".PadLeft(60, ' ') + "|";

            for (int j = 1; j < 14; j++)
            {
                images[j] = NewLine(23 - j) + "".PadLeft(60, ' ') + "|" + NewLine(1);
                images[j] += "".PadLeft(60, ' ') + "|";
            }

            images[14] = NewLine(9) + "".PadLeft(60, ' ') + ".";
            images[15] = NewLine(8) + "".PadLeft(58, ' ') + "....." + NewLine(1) + "".PadLeft(58, ' ') + "....." + NewLine(1) + "".PadLeft(58, ' ') + ".....";

            images[16] = Explode(7, 54, 7);
            images[17] = Explode(9, 52, 5);
            images[18] = Explode(11, 50, 3);
            images[19] = Explode(13, 48, 1);
            images[20] = Explode(7, 54, 7);
            images[21] = "Frohes Neues!";
        }

        private string Explode(int size, int left, int height)
        {
            string result = "";
            result += NewLine(height);
            result += "".PadLeft(left + 2 + (size - 5) + 1, ' ') + "|" + NewLine(1);

            for (int j = 5; j <= size; j++)
            {
                result += "".PadLeft(left + 2 + (size - 5) + 1 - (j - 4) - 1, ' ');
                for (int z = 0; z < 5  + (j - 5) * 2; z++)
                {
                    result += ".";
                }
                result += NewLine(1);
            }

            result += "".PadLeft(left, ' ') + "-";
            for (int j = 0; j <= 5 + (size - 5) * 2; j++)
            {
                result += ".";
            }
            result += "-";
            result += NewLine(1);

            for (int j = size; j >= 5; j--)
            {
                result += "".PadLeft(left + 2 + (size - 5) + 1 - (j - 4) - 1, ' ');
                for (int z = 0; z < 5 + (j - 5) * 2; z++)
                {
                    result += ".";
                }
                result += NewLine(1);
            }

            result += "".PadLeft(left + 2 + (size - 5) + 1, ' ') + "|" + NewLine(1);

            return result;
        }

        private string NewLine(int nr)
        {
            string result = "";
            for (int i = 0; i < nr; i++)
            {
                result += Environment.NewLine;
            }
            return result;
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            if (i < images.Length)
            {
                textBox2.Focus();
                textBox1.Text = images[i];
                i++;
            }
        }

        int i = 0;
        private void Form1_Load(object sender, EventArgs e)
        {
            init();
        }
    }
}

(mein grafisches Vorstellungsvermögen ist nicht sehr gut)

Danke

2011-12-16T17:26:00.001+01:00

Wie aufmerksame wie unaufmerksame Leser sicherlich schon bemerkt haben, erscheinen leider seit längerem keine Posts mehr von mir und auch die Antworten auf eure Kommentare dauern leider sehr lange, da ich ziemlich viel zu tun habe im Moment.

Ich versuche jedoch, wenigstens die Kommentare so gut ich kann zu beantworten und freue mich auch definitiv über jeden Eintrag und jedes Interesse an diesem Blog.

Dafür möchte ich mich hier herzlich bei allen Lesern bedanken, ich hoffe dieser Blog hilft ein wenig und bereitet ein bisschen Freude beim Lesen.

Maus steuern

2011-07-01T19:17:00.004+02:00

Auf User Anfragen erscheint heute ein Post zum Thema, wie man mit C# die Maus steuern kann, sie also komplett auf dem ganzen Bildschirm bewegen und z.B. Klicks simulieren kann.
Ich habe schon einen Post zum Simulieren von Tastendrücken geschrieben, welches ganz einfach mit der Funktion SendKeys() umgesetzt werden kann.
Die Maus zu steuern ist nicht mehr ganz so einfach, es gibt (noch) keine eingebaute .Net Funktion, wir müssen auf nicht verwaltete System Funktionen zurückgreifen.
Kernstück ist die P/Invoke Funktion SendInput(). Mit dieser Funktion können verschiedene Kommandos an den ausführenden Computer gesendet werden, zum Beispiel direkte Hardwareeingaben, Tastatur- und eben Mausereignisse (im folgenden Inputs genannt).
Die Funktion erwartet 3 Parameter: Der 1. beschreibt die Anzahl der übergebenen Inputs, der 2. enthält eine Referenz auf die tatsächlichen Inputdaten, der 3. speichert die Größe eines einzelnen Inputs.
Den 2. Parameter muss vom Typ einer Struktur sein, welche mindestens den Typ des Inputs (also Hardware, Tastatur, Maus ...) sowie die Daten des Inputs enthält.
Die Struktur habe ich Input genannt.
Mausinputdaten selber haben mehrere Daten, wie die X - und Y - Koordinate, welche ich in der Struktur MouseInput zusammengefasst habe.

Zuerst möchte ich nun das Bewegen der Maus beschreiben: Wir brauchen also eine Instanz der Struktur Input mit den gewünschten Zielmauskoordinaten.
Als Typ des Inputs setzen wir 0, welches ein Mausereignis symbolisiert.
Die Mausdaten repräsentiert durch eine Instanz von MouseInput lassen wir uns über die Funktion CreateMouseInput() erstellen.
Diese erhält alle benötigten Parameter und setzt diese im zurückgegeben Mausereignis.
Zum Bewegen der Maus sind nur die Werte für X und Y wichtig (Zielkoordinaten) sowie für DwFlags. Dieses Feld kann bestimmte Flags aufnehmen, wie zum Beispiel den Druck eines Mausbuttons.
In diesem Fall übergeben wir aber 2 vorher definierte Konstanten (so haben wir leicht zu merkende Namen anstatt Zahlen), MOUSEEVENTF_ABSOLUTE und MOUSEEVENTF_MOVE, um anzuzeigen, dass wir die Maus bewegen wollen. Erstere sagt aus, dass wir ein Mausereignis nicht nur im aktuellen Fenster herbeiführen wollen, sondern auf dem ganzen Bildschirm, zweite zeigt die gewünschte Bewegung der Maus an.

Das Simulieren eines (Links-)Klicks funktioniert ähnlich.
Wir müssen wieder einen Input mit den entsprechenden Daten erstellen, verwenden diesmal aber ein Array der Länge 2, da wir zuerst das Drücken der linken Maustaste und anschließend das Loslassen dieser simulieren wollen.
Über die Funktion CreateMouseInput() lassen wir uns dafür 2 MouseInputs erstellen und übergeben für den Wert von DwFlags die entsprechenden Konstanten.

Ich hoffe, diese kurze Erläuterung sowie der folgende Code helfen:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.Runtime.InteropServices;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        // P/Invoke Funktion u.a. zum Steuern der Maus
        [DllImport("user32.dll", SetLastError = true)]
        private static extern uint SendInput(uint nInputs, Input[] pInputs, int cbSize);

        /// <summary>
       /// Struktur für Mausdaten
        /// </summary>
        struct MouseInput
        {
            public int X; // X - Koordinate
            public int Y; // Y - Koordinate
            public uint MouseData; // Mausdaten, z.B. für Mausrad
            public uint DwFlags; // weitere Mausdaten, z.B. für Mausbuttons
            public uint Time; // Zeit des Events
            public IntPtr DwExtraInfo; // weitere Informationen
        }

        /// <summary>
       /// Oberstruktur für InputDaten der Funktion SendInput
        /// </summary>
        struct Input {
            public int Type; // Typ des Inputs, 0 für Maus
            public MouseInput Data; // Mausdaten
        }

        // Konstanten für Mausflags
        const uint MOUSEEVENTF_LEFTDOWN = 0x0002; // linken Mausbutton drücken
        const uint MOUSEEVENTF_LEFTUP = 0x0004; // linken Mausbutton loslassen
        const uint MOUSEEVENTF_ABSOLUTE = 0x8000; // ganzen Bildschirm ansprechen, nicht nur aktuelles Fenster
        const uint MOUSEEVENTF_MOVE = 0x0001; // Maus bewegen

        private MouseInput CreateMouseInput(int x, int y, uint data, uint time, uint flag)
        {
            // aus gegebenen Daten Objekt vom Typ MouseInput erstellen, welches dann gesendet werden kann
            MouseInput Result = new MouseInput();
            Result.X = x;
            Result.Y = y;
            Result.MouseData = data;
            Result.Time = time;
            Result.DwFlags = flag;
            return Result;
        }

        private void SimulateMouseClick()
        {
            // Linksklick simulieren: Maustaste drücken und loslassen
            Input[] MouseEvent = new Input[2];
            MouseEvent[0].Type = 0;
            MouseEvent[0].Data = CreateMouseInput(0, 0, 0, 0, MOUSEEVENTF_LEFTDOWN);

            MouseEvent[1].Type = 0; // INPUT_MOUSE;
            MouseEvent[1].Data = CreateMouseInput(0, 0, 0, 0, MOUSEEVENTF_LEFTUP);

            SendInput((uint)MouseEvent.Length, MouseEvent, Marshal.SizeOf(MouseEvent[0].GetType()));
        }

        private void SimulateMouseMove(int x, int y) {
            Input[] MouseEvent = new Input[1];
            MouseEvent[0].Type = 0;
            // Maus bewegen: Flags ABSOLUTE (ganzen Bildschirm verfügbar machen) und MOVE (bewegen)
            MouseEvent[0].Data = CreateMouseInput(x, y, 0, 0, MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE);
            SendInput((uint)MouseEvent.Length, MouseEvent, Marshal.SizeOf(MouseEvent[0].GetType()));
        }

         private void button1_Click(object sender, EventArgs e)
         {
             // Maus testweise bewegen
             SimulateMouseMove(0, 0);
             // und anschließend klicken
             SimulateMouseClick();
         }
    }
}

Quine Wettbewerb: Finde das kürzeste

2011-05-14T14:32:00.002+02:00

Anlässlich des 150. Posts habe ich mir wieder einen kleinen "Wettbewerb" ausgedacht.
Ziel ist es, ein möglichst kurzes Quine zu schreiben, welches eine bestimmte Anweisung ausführt.
Zur Erinnerung: Ein Quine ist ein Programm, welches seinen eigenen Quellcode komplett ausgibt, auf diesem Blog gibt es auch einen Post darüber.
Aufgabe ist es nun, aus folgendem Programm ein Quine zu machen:

class Quine
{
    static void Main(string[] args)
    {
        System.Diagnostics.Process.Start(System.Environment.SystemDirectory + "\\shutdown.exe", "-s -t 120");
    }
}

Der Wettbewerb soll über 3 Wochen laufen, also bis Samstag den 4.5. Wer bis dahin den kürzesten Code gepostet hat, gewinnt ;-)
Ich lege vor.
Das Quine soll natürlich exakt den Programmcode drucken, hierbei sind Zeileneinrückungen aber nicht wichtig.
Ein kleiner Tipp, wie man die Ausgabe leicht überprüfen kann:
Mit Console.SetOut() lässt sich die Ausgabe der Konsole in einen Stream umleiten, so kann z.B. in eine Datei geschrieben werden, also einfach die entsprechenden Befehle in das Programm schreiben (sie zählen nicht zum Quine dazu).
Mit Programmen wie Beyond Compare kann dann die Gleichheit überprüft werden (also definiere, alles was Beyond Compare als gleich ansieht gilt) und mit z.B. Word kann leicht die Länge der Datei gezählt werden.
Mein Quine Code lautet:

class Quine
{
    static void Main(string[] args)
    {
        // Zählt nicht dazu, auskommentieren um Ausgabe umzuleiten: System.IO.StreamWriter sw = new System.IO.StreamWriter(@"C:\Users\User\Desktop\Neues Textdokument (2).txt");
        // ", System.Console.SetOut(sw);
        System.Diagnostics.Process.Start(System.Environment.SystemDirectory + "\\shutdown.exe", "-s -t 120");
        string s = "class Quine {3} {0} {3} static void Main(string[] args) {3} {0} {3} System.Diagnostics.Process.Start(System.Environment.SystemDirectory + {2}{5}{5}shutdown.exe{2}, {2}-s -t 120{2}); {3} string s = {2}{1}{2}; {3} System.Console.WriteLine(s, System.Convert.ToChar(123), s, System.Convert.ToChar(34), System.Environment.NewLine, System.Convert.ToChar(125), System.Convert.ToChar(92)); {3} {4} {3} {4}";
        System.Console.WriteLine(s, System.Convert.ToChar(123), s, System.Convert.ToChar(34), System.Environment.NewLine, System.Convert.ToChar(125), System.Convert.ToChar(92));
        // ", sw.Close();
    }
}

Die Länge hiervon beträgt 763 Zeichen.

Und jetzt, viel Glück und viel Spaß.

PS: Speichert vorher alle Dokumente bzw. schaut euch an, wie man das Herunterfahren von Windows abbrechen kann (Stichwort: shutdown -a).

Anwendung mit Administratorrechten neu starten (Windows Vista / 7)

2011-05-07T11:52:00.005+02:00

In einem älteren Post habe ich gezeigt, wie man mit C# eine Anwendung mit Administratorechten ausstatten und starten kann.
Hierfür wurde jedoch eine eigene Datei, die Anwendungsmanifestdatei, benötigt.
Auf Anfrage eines Lesers möchte ich heute einen kleinen Trick vorstellen, wie man eine Anwendung nur durch reinen Code mit diesen Rechten ausstattet.
Entscheidend ist hierbei die Klasse System.Diagnostics, welche einen beliebigen Process mit bestimmten Argumenten starten kann.
Wenn die Anwendung also normal gestartet wird, wird sie über diese Klasse mit Administratorrechten neugestartet.
Damit das Programm nicht unendlich oft aufgerufen wird, geben wir dem Programm zur Prüfung beim Aufrufen ein neues Befehlszeilenargument mit.
Der folgende Code sollte das Beispiel erläutern:

private void Form1_Load(object sender, EventArgs e)
{
    string[] CommandLineArgs = Environment.GetCommandLineArgs(); // Befehlszeilenargumente auslesen
    if (CommandLineArgs.Length <= 1 || CommandLineArgs[1] != "restarted") // ist das 2. Argument (das 1. ist immer der Dateipfad) != restarted, wurde das Programm noch nicht neugestartet
    {
        ProcessStartInfo ProcessInfo = new ProcessStartInfo(Application.ExecutablePath, "restarted"); // Prozessinformationen festlegen, Anwendungspfad und unser eigenes Argument "restarted"
        ProcessInfo.Verb = "runas"; // Befehl zum Ausführen als Administrator
        Process.Start(ProcessInfo); // Prozess mit den eingestellten Informationen starten
    }
    else
        Environment.Exit(0); // wurde das Argument "restarted" übergeben, wurde das Programm bereits gestartet, um die Endlosrekursion zu verhindern, nicht erneut aufrufen
}

Befehlszeilenargumente auslesen

2011-05-06T22:47:00.004+02:00

Programme können unter Windows grundsätzlich mit verschiedenen Argumenten aufgerufen werden, welche Befehlszeilenargumente heißen.
Zum Beispiel können einige Programme direkt mit zu öffnenden Dateien als Argument aufgerufen werden.
In Konsolenanwendungen in C# stehen diese Kommandozeilenargumente direkt als Parameter der Funktion Main() zur Verfügung.
In Windows Forms-Anwendungen stehen diese so nicht bereit, dafür gibt es aber die Funktion Environment.GetCommandLineArgs(), welche die Befehlszeilenargumente als Array vom Typ String zurückgibt.
Folgender Code liest die übergebenen Parameter beim Programmstart aus:

string[] CommandLineArgs = Environment.GetCommandLineArgs();

Wie man sieht, wird als 1. Parameter immer der Pfad und der Name des ausgeführten Programmes übergeben.

Windows 7 Features: Eine JumpList erstellen

2011-04-01T14:51:00.009+02:00

Die JumpList bezeichnet unter Windows 7 das Kontextmenü einer Anwendung in der Taskleiste, welches durch Rechtsklick auf das Applikationssymbol sichtbar wird.
In diesem Menü befinden sich z.B. häufig geöffnete Dateien der Anwendung und mögliche Programmoptionen.
Für das C# Studio sieht meine JumpList beispielsweise so aus:

In C# können wir nun für unsere eigenen Anwendungen JumpLists erstellen und bearbeiten.
Obwohl es im Umfang des .Net Frameworks schon eine JumpList Klasse gibt, brauchen wir für Windows Forms Anwendungen doch das Windows API Code Pack, denn die vorhandene Klasse ist nur für WPF Anwendungen geeignet.
Die Installation des Windows API Code Packs habe ich hier beschrieben, die 2 entstandenen dll - Dateien müssen anschließend noch eingebunden werden (Projekt - Verweis hinzufügen - Durchsuchen). Die benötigten Dateien heißen "Microsoft.WindowsAPICodePack.dll" und "Microsoft.WindowsAPICodePack.Shell.dll", sie befinden sich im Installationsordner des Code Packs unter Shell\bin\Debug.
Die für diesen Post verwendete Klasse JumpList befindet sich schließlich in der Klasse Microsoft.WindowsAPICodePack.Taskbar.
In einer JumpList sind standardmäßig 2 Kategorien vorhanden: "Aufgaben" und "Häufig" (geöffnete Dateien).
Diesen Kategorien können wir durch die Funktionen AddUserTasks() bzw. AddToRecent() Einträge hinzufügen.
Als Einträge verwende ich in diesem Post Objekte der Klasse JumpListLink, welche einen Namen und ein Ziel erhalten, welches ein ausführbares Programm oder eine Datei sein kann.
Die Kategorie "Recent" lässt sich allerdings nicht so einfach befüllen, denn Windows lässt nur Dateien mit einer Endung zu, die für das entsprechende Programm registriert sind.
Mit einem kleinen Trick kann man sich allerdings die Schwierigkeit der Registrierung umgehen, es gibt nämlich die Möglichkeit, in den JumpLists eigene Kategorien anzulegen - legt man dann z.B. die Kategorie "Häufig" an, ist das Ergebnis das gleiche.
Der Beispielcode legt in der JumpList des Programms 2 Einträge unter "Aufgaben" an - einen Eintrag zu Paint und einen zum Windows Taschenrechner.
Für diese Programme werden ebenfalls Icons bereitgestellt, welche als IconReference direkt aus den Originalprogrammen referenziert werden.
Weiterhin legt der Code eine neue Kategorie an und erstellt in dieser einen Link zu einer Datei auf meinem Desktop.
Das anschließende Refresh() ist wichtig, damit die Änderungen übernommen werden.
Die JumpList des Programms ist auch beim nächsten Programmstart - sofern sie nicht gelöscht bzw. geändert wurde - noch in der gleichen Form erhalten!
Das Ergebnis sieht so aus:

Jetzt nun der Code, am Anfang ist ein
using Microsoft.WindowsAPICodePack.Taskbar;
erforderlich:

            JumpList CustomJumpList = JumpList.CreateJumpList(); // neue JumpListe erzeugen

            // Link zu Paint unter Aufgaben hinzufügen
            JumpListLink EntryPaint = new JumpListLink(@"C:\Windows\System32\mspaint.exe", "Paint");
            EntryPaint.IconReference = new Microsoft.WindowsAPICodePack.Shell.IconReference(@"C:\Windows\System32\mspaint.exe", 0);
            CustomJumpList.AddUserTasks(EntryPaint);

            // Link zum Taschenrechner unter Aufgaben hinzufügen
            JumpListLink EntryCalc = new JumpListLink(@"C:\Windows\System32\calc.exe", "Rechner");
            EntryCalc.IconReference = new Microsoft.WindowsAPICodePack.Shell.IconReference(@"C:\Windows\System32\calc.exe", 0);
            CustomJumpList.AddUserTasks(EntryCalc);

            // eigene Kategorie anlegen
            JumpListCustomCategory CustomCategory = new JumpListCustomCategory("Neue Kategorie");
            // in diese Link zu einer Datei anlegen
            CustomCategory.AddJumpListItems(new JumpListLink(@"C:\Users\User\Desktop\C#.txt", "C# Links"));
            CustomJumpList.AddCustomCategories(CustomCategory);

            // Änderungen übernehmen
            CustomJumpList.Refresh();

Spracherkennung Part 2: Command Mode

2011-03-23T08:00:00.002+01:00

Wie angekündigt, ist dieser Post eine Fortsetzung des vorigen, es geht um Spracherkennung, insbesondere um den Command Mode.
Wie der Name schon andeutet, wird aufgenommene Sprache damit auf vordefinierte Befehle untersucht.
Man könnte natürlich auch über den im vorigen Post beschriebenen Dictation Mode einen Text aufnehmen und diesen auf bestimmte Begriffe hin untersuchen - der Command Mode bietet dafür allerdings ein paar Vorteile.
Denn einerseits ermöglicht er leicht eine dauerhafte Prüfung, ob Befehle gesagt wurden, und andererseits ist die Erkennung besser, da das Programm nur die Befehlswörter kennt und sich bei der Erkennung nur zwischen diesen entscheiden muss.
Nun direkt zum Code: Die Vorraussetzungen (das Einbinden der Ressource etc.) sind die gleichen wie im vorigen Post.
Zum Erkennen der Befehle benutzen wir jetzt allerdings eine Instanz der Klasse SpeechRecognizer.
Diese erwartet auch eine Grammatik, welche wir aber jetzt manuell mit Wörtern befüllen, die erkannt werden sollen.
Über die Eigenschaft Enabled kann die Spracherkennung aktiviert werden.
Beim Erkennen von Befehlen tritt das Ereignis SpeechRecognized auf, diesem weisen wir eine Funktion zu, welche das Ereignis behandeln soll.
Wird ein SpeechRecognizer initialisiert, öffnet sich unter Windows ein Fenster zur Spracherkennung - hier muss der Benutzer auf den großen Mikrofonknopf drücken, um die Erkennung zu starten.
Das Drücken des Knopfes hat nichts mit der Eigenschaft Enabled zu tun - beide Dinge müssen aktiviert sein.
Einen Weg, die Spracherkennung nur per Code zu starten und das Fenster zu verstecken habe ich nicht gefunden. Mich würde aber interessieren ob das möglich ist, falls jemand eine Idee hat, bitte kommentieren!
Der Code:

        private void StartListening()
        {
            SpeechRecognizer SR = new SpeechRecognizer();
            // die Befehle registrieren
            Choices Commands = new Choices();
            Commands.Add("Stop");
            Commands.Add("Los");
            GrammarBuilder GB = new GrammarBuilder(Commands); // die Befehle mit einem GrammerBuilder laden
            Grammar CommandGrammar = new Grammar(GB); // eine Grammatik über den GrammarBuilder erstellen
            SR.LoadGrammar(CommandGrammar); // die Grammatik laden
            SR.SpeechRecognized += CommandRecognized; // Funktion zur Behandlung des Ereignisses
            SR.Enabled = true;
        }

        private void CommandRecognized(object sender, SpeechRecognizedEventArgs e)
        {
            string Command = e.Result.Text;
            // hier weiterer Verarbeitungscode ...
        }

Spracherkennung Part 1: Dictation Mode

2011-03-22T08:00:00.003+01:00

Im vorigen Post ging es um die Sprachausgabe mit .Net, dieses Mal widmen wir uns der Umkehrung, nämlich der Spracherkennung.
Diese ist für Computer viel schwieriger als die Ausgabe, das .Net Framework bietet über die Klasse System.Speech.Recognition allerdings wieder fertige Funktionen an, die mit wenig Codeaufwand zur Spracherkennung eingesetzt werden können.
Generell gibt es 2 Modi, in welchen die Spracherkennung betrieben werden kann: In diesem Post geht es um den Dictation Mode, im nächsten um den Command Mode.
Der Dictation Mode eignet sich, wie der Name schon sagt, zum Diktieren von Texten.
Der aufgezeichnete Ton wird wie ein Diktat verstanden und das Programm versucht, die gesprochenen Wörter zu erkennen.
Wie bei der Sprachausgabe muss zuerst ein Verweis auf die Komponente System.Speech eingebunden werden.
Die benötigte Unterklasse heißt nun allerdings Recognition, und so benutzen wir am Anfang folgende using - Direktive:

using System.Speech.Recognition;

Zur Spracherkennung benutzen wir eine Instanz der Klasse SpeechRecognitionEngine.
Diese benötigt eine Grammatik, also eine Art Anweisungssammlung, wie die Sprache interpretiert werden soll.
Als Grammatik übergeben wir der SpeechRecognitionEngine eine Instanz der Klasse DictationGrammar, um anzuzeigen, dass wir den Diktiermodus benutzen wollen.
Das Erkennen von gesprochenen Wörtern geschieht nun mit Aufruf der Funktion Recognize(). Diese setzt die Spracherkennung in Bereitschaftsmodus und beginnt, wenn das Mikrofon Töne vernimmt.
Macht der Sprecher eine bestimmte Zeit Pause (einstellbar), wird die Spracherkennung beendet und das Programm versucht nun, den Ton als Wörter zu interpretieren (eine asynchrone Aufnahme ist auch möglich).
Zum Schluss wird das Diktierergebnis zurückgegeben.
Hier der Code:

            SpeechRecognitionEngine SRE = new SpeechRecognitionEngine();
            SRE.LoadGrammar(new DictationGrammar()); // Diktiergrammatik laden
            SRE.SetInputToDefaultAudioDevice(); // Aufnahmequelle auf Standard setzen

            RecognitionResult Result = SRE.Recognize(); // Ton aufzeichnen und erkennen
            string ResultString = "";
            // alle erkannten Wörter aus dem Ergebnis dem Ergebnisstring hinzufügen
            foreach (RecognizedWordUnit w in Result.Words)
            {
                ResultString += w.Text;
            }

Sprachausgabe mit C#

2011-03-21T08:00:00.000+01:00

Die Überschrift hört sich wahrscheinlich ziemlich kompliziert an, allerdings ist in C# die Realisierung einer Sprachausgabe in nur 2 Zeilen möglich!
Denn die schon mit Windows mitgelieferte Sprachsynthese ist auch im .Net Framework nutzbar, die benötigte Komponente ist die Klasse System.Speech.Synthesis. Um sie nutzen zu können, muss sie zuerst eingebunden werden: Projekt - Verweis hinzufügen - (Reiter .Net) System.Speech.
Um den Code zu vereinfachen, binden wir die Klasse mittels using ein:

using System.Speech.Synthesis;

Zur Sprachausgabe benötigen wir eine Instanz der Klasse SpeechSynthesizer, welcher über die Funktion Speak() der auszugebende Text übergeben werden kann.
Natürlich gibt es aber noch viele weitere Eigenschaften, mit denen herumexperimentiert werden darf.
Ein paar in der Übersicht:
- Rate: Wertebereich von -10 bis 10, Geschwindigkeit der Textausgabe
- Volume: Wertebereich 0 - 100, Lautstärke
- Voice: Stimme
Die letzte Eigenschaft ist schreibtgeschützt, ihr kann direkt nichts zugewiesen werden, sie kann allerdings über Funktionen geändert werden.
Nützlich ist die Funktion SelectVoiceByHints(), über die "Hinweise" gegeben werden können, nach denen eine passende Stimme gesucht werden soll.
Solche Kriterien sind zum Beispiel Geschlecht, Alter und sogar Kulturkreis.
So sucht zum Beispiel folgende Anweisung nach einem Stimmtyp, welcher weiblich und erwachsen klingt und legt diese Stimme bei Erfolg als Ausgabestimme fest:

Speaker.SelectVoiceByHints(VoiceGender.Female, VoiceAge.Adult);

Allerdings wird auf vielen Windows Rechnern nur eine Stimme vorinstalliert sein (bei mir z.B. nur "Microsoft Anna").
Dann hat eine Stimmsuche keinerlei Auswirkung.
Die installierten Stimmen kann man über die Funktion Speaker.GetInstalledVoices() auslesen.
Die einzelnen Stimmen liegen als Objekt vom Typ Voice vor, folgendes Beispiel liest alle Stimmen aus und fügt ihren Namen zu der Liste InstalledVoices hinzu:

List<string> InstalledVoices = new List<string>();
foreach (InstalledVoice voice in Speaker.GetInstalledVoices())
{
InstalledVoices.Add(voice.VoiceInfo.Name);
}

Speicherauslastung eines Prozesses ermitteln

2011-03-18T15:52:00.003+01:00

Der heute Post wird nach den etwas längeren vorhergenden Posts wieder etwas kürzer, ich möchte euch zeigen, wie man mit C# die Speicherauslastung eines Prozesses ermittelt.
Die dafür erforderliche Eigenschaft heißt WorkingSet64 aus der Klasse System.Diagnostics.Process. Sie gibt die Anzahl an Bytes an, die von dem jeweiligen Prozess im Arbeitsspeicher belegt sind - korreliert also in etwa mit der Spalte "Arbeitsspeicher" im Taskmanager.
Um die Speicherbenutzung eines bestimmten Prozesses zu ermitteln, muss dieser zuerst "abgegriffen" werden, zum Beispiel über die Funktion Process.GetProcessesByName() (ein paar Hintergrundinfos zu dieser gibt's in diesem Post).
Die Funktion sucht nach Prozessen mit dem übergebenen Namen und speichert alle diese im Ergebnisarray.
Der folgende Code ermittelt die Speicherauslastung des angegeben Prozesses, in dem er oben geannten Eigenschaft des ersten Eintrags im Array abfragt - falls mehrere Proezsse mit gleichem Namen vorhanden sind, müssen ggf. weitere Maßnahmen ergriffen werden.
Im Beispiel wird die Auslastung des ersten geöffneten Editorprozesses abgefragt:

Process[] Application;
Application = Process.GetProcessesByName("notepad");
long MemorySize = Application[0].WorkingSet64;

Wave Dateien zusammenmischen (überblenden)

2011-03-14T22:01:00.007+01:00

In den vorigen beiden Posts wurde das Wave Format auseinander genommen, es wurde gezeigt, wie mit C# Wave Dateien eingelesen und geschrieben werden können.
In diesem Post möchte ich eine "coole" Anwendung zeigen, und zwar, wie man ein Programm erstellt, welches 2 Lieder ineinander übermischt.
Das Zusammenmischen entsteht hier durch Überblenden (Fading) der Lieder, das erste Lied wird gegen Ende hin immer leiser während das zweite Lied immer lauter wird.
Viele wünschen sich wahrscheinlich eine Anwendung, die das selbe mit MP3 - Dateien macht - allerdings ist das MP3 Format um Längen komplizierter als das Wave Format.
Es lassen sich aber beliebige MP3s mit dem in den vorigen Posts erwähnten Programm Audacity in Wave Dateien umwandeln und dann bearbeiten.
Der in diesem Post verwendete Code baut immer noch auf die Klasse WaveFile auf, die in den beiden vorigen Posts angefangen wurde.
Ein Beispielaufruf der benötigten Zeilen zum Mischen 2er Wave Dateien könnte so aussehen:

            WaveFile WF1 = new WaveFile();
            WF1.LoadWave(@"C:\Users\User\Desktop\101-die_atzen_-_disco_pogo-ysp.wav");

            WaveFile WF2 = new WaveFile();
            WF2.LoadWave(@"C:\Users\User\Desktop\StroboPopDieAtzenFeatNena.wav");

            WaveFile.StoreMixWave(@"C:\Users\User\Desktop\mixed.wav", WF1, WF2, 10);

Es werden also zuerst 2 Wave Dateien eingelesen und schließlich wird die statische Funktion StoreMixWave() aufgerufen, welche als Parameter den Pfad zur Ergebnisdatei, die zu mischenden WaveFiles sowie die Überblendezeit erwartet.
Der Funktionscode sieht so aus:

public static void StoreMixWave(string path, WaveFile wf1, WaveFile wf2, int fadeTime)
{
WaveFile Mixed = MixWave(wf1, wf2, fadeTime); // Ergebnisdatei mischen
Mixed.StoreWave(path); // Ergebnisdatei auf Festplatte speichern
}

Der Ergebniswavefile wird also in der Funktion MixWave() zusammengemischt, und dieser WaveFile dann mit der bekannten Funktion StoreWave() geschrieben.
Nun betrachten wir direkt einmal den Code der Funktion MixWave():

        private static WaveFile MixWave(WaveFile wf1, WaveFile wf2, int fadeTime)
        {
            int FadeSamples = fadeTime * wf1.ByteRate / wf1.NumChannels; // Anzahl an aus-/ einzublenden Samples
            int FadeBytes = fadeTime * wf1.ByteRate; // Anzahl an aus-/ einzublendenden Bytes

            WaveFile Result = new WaveFile(); // Ergebnis Wave Datei
            Result.FileSize = wf1.FileSize + wf2.DataSize - 2 * FadeBytes; // neue Dateigröße
            Result.Format = "WAVE";

            // Informationen aus dem fmt Chunk übernehmen
            Result.FmtChunkSize = wf1.FmtChunkSize;
            Result.AudioFormat = wf1.AudioFormat;
            Result.NumChannels = wf1.NumChannels;
            Result.SampleRate = wf1.SampleRate;
            Result.ByteRate = wf1.ByteRate;
            Result.BlockAlign = wf1.BlockAlign;
            Result.BitsPerSample = wf1.BitsPerSample;

            Result.DataSize = wf1.DataSize + wf2.DataSize - 2 * FadeBytes; // neue Größe des Data Chunks
            Result.Data = new int[wf1.NumChannels][]; // Anzahl an Kanälen übernehmen
            int NumSamples = Result.DataSize / (Result.NumChannels * ( Result.BitsPerSample / 8)); // Anzahl an Samples ausrechnen, die sich in de Ergebnisdatei ergeben

            // Die Data Arrays für alle Kanäle auf die Anzahl der Samples dimensionieren.
            for (int i = 0; i < Result.Data.Length; i++)
            {
                Result.Data[i] = new int[NumSamples];
            }

            int PosCounter = 0; // Position des aktuellen Samples in der Ergebnisdatei

            // die Samples aus der ersten Wave Datei in das Data Feld der Ergebnisdatei kopieren
            for (int i = 0; i < wf1.Data[0].Length; i++)
            {
                // das aktuelle Sample in allen Kanälen übernehmen
                for (int j = 0; j < wf1.NumChannels; j++)
                {
                    // fällt das aktuelle Sample in die Zeit, die überblendet werden soll, den Amplitudenwert der 1. Datei mit dem Amplitudenwert aus der 2. Datei mischen
                    if (i > wf1.Data[0].Length - FadeSamples)
                       Result.Data[j][PosCounter] = (int)(wf1.Data[j][i] * Factor(i - (wf1.Data[0].Length - FadeSamples), FadeSamples, 0) + wf2.Data[j][i - (wf1.Data[0].Length - FadeSamples)] * Factor(i - (wf1.Data[0].Length - FadeSamples), FadeSamples, 1));
                    else
                       Result.Data[j][PosCounter] = wf1.Data[j][i];
                }
                PosCounter++;
            }

            // die restlichen Samples in die Ergebnisdatei übernehmen
            for (int i = FadeSamples; i < wf2.Data[0].Length; i++)
            {
                for (int j = 0; j < wf1.NumChannels; j++)
                {
                    Result.Data[j][PosCounter] = wf2.Data[j][i];
                }
                PosCounter++;
            }
            return Result;
        }

Am Anfang dieser wird die Anzahl der Samples berechnet, die überblendet werden sollen.
Zur Erinnerung: Eine Wave Datei ist im Groben eine Sammlung von Luftdruckamplituden. Mit einer bestimmten Abtastrate werden in bestimmten Zeitabständen diese Amplituden gemessen und in der Datei gespeichert. Diese einzelnen Werte sind die Samples.
Um 2 Audiodateien übereinander zu legen, kann man z.B. einfach die Amplituden addieren.
Die Anzahl an zu überblenden Samples berechnet sich demnach als Produkt der Überblendzeit in Sekunden und Byterate (Anzahl der Bytes pro Sekunde, die beim Abspielen bearbeitet werden), dividiert durch die Anzahl der Kanäle (da die Byterate die Anzahl an Bytes von allen Kanälen angibt).
Dann werden die Dateien zusammengemischt:
Die ersten beiden Blöcke ("RIFF" und "fmt ") werden einfach aus der ersten übergebenen Wave Datei übernommen - allerdings wird natürlich die Dateigröße angepasst.
Die neue Dateigröße ergibt sich als Summe der alten Dateigrößen, abzüglich 2mal der Anzahl an Bytes, die überblendet werden.
Damit das Ergebnis auch nach etwas klingt, ist hier also Vorraussetzung, dass beide Wave Dateien einen ähnlichen fmt Block haben, sprich die selbe Abtastrate, Anzahl an Kanälen etc. Das ist aber eh der Fall, wenn man die Wave Dateien mit Audacity erstellt.
Das Mischen der Data Chunks gestaltet sich nun als etwas komplizierter.
Zuerst wird die Größe des resultierende Data Blocks berechnet und daraus dann die Anzahl an Samples, die in jedem Kanal gespeichert werden, um das Data Array für alle Kanäle auf diesen Wert zu dimensionieren.
Diese Anzahl berechnet sich laut Spezifikation des Wave Formats laut der Formel (Größe des Data Blocks) / (Anzahl Kanäle * BitsPerSample / 8).
Die Variable PosCounter zählt im folgenden die Position im Data Array der Ergebnisdatei.
Mit 2 Schleifen werden nun alle Samples der ersten Wave Datei durchgegangen und hierbei in jeder Iteration alle Kanäle dieser.
Die entsprechenden Daten aus dem Data Array werden an die Position PosCounter im Data Array der Ergebnisdatei geschrieben.
Hat die Schleife eine Position erreicht, die näher als die Anzahl der zu überblenden Bytes am Ende der ersten Datei liegt, werden nicht einfach die Daten der 1. Datei kopiert, sondern nun mit denen der 2. Datei gemischt.
Damit das 1. Lied langsam ausgeblendet während das 2. langsam eingeblendet wird, bestimmt die Funktion Factor() den Anteil der jeweiligen Lieder an der Gesamtamplitude.
Anschließend werden die noch nicht betrachteten Samples aus der 2. Datei in die Ergebnisdatei übernommen - fertig ist die Mischung!
Schlussendlich noch eine Übersicht über den Code der kompletten Klasse WaveFile, welchen alle 3 Posts zu diesem Thema benutzen:

    public class WaveFile
    {
        int FileSize; // 1
        string Format; // 2
        int FmtChunkSize; // 3
        int AudioFormat; // 4
        int NumChannels; // 5
        int SampleRate; // 6
        int ByteRate; // 7
        int BlockAlign; // 8
        int BitsPerSample; // 9
        int DataSize; // 10

        int[][] Data; // 11

        #region Einlesen
        public void LoadWave(string path)
        {
            System.IO.FileStream fs = System.IO.File.OpenRead(path); // zu lesende Wave Datei öffnen
            LoadChunk(fs); // RIFF Chunk einlesen
            LoadChunk(fs); // fmt Chunk einlesen
            LoadChunk(fs); // data Chunk einlesen
        }

        private void LoadChunk(System.IO.FileStream fs)
        {
            System.Text.ASCIIEncoding Encoder = new ASCIIEncoding();

            byte[] bChunkID = new byte[4];
            /* Die ersten 4 Bytes einlesen.
            Diese ergeben bei jedem Chunk den jeweiligen Namen. */
            fs.Read(bChunkID, 0, 4);
            string sChunkID = Encoder.GetString(bChunkID); // den Namen aus den Bytes dekodieren

            byte[] ChunkSize = new byte[4];
            /* Die nächsten 4 Bytes ergeben bei jedem Chunk die Größenangabe. */
            fs.Read(ChunkSize, 0, 4);

            if (sChunkID.Equals("RIFF"))
            {
                // beim Riff Chunk ...
                // die Größe in FileSize speichern
                FileSize = System.BitConverter.ToInt32(ChunkSize, 0);
                // das Format einlesen
                byte[] Format = new byte[4];
                fs.Read(Format, 0, 4);
                // ergibt "WAVE" als String
                this.Format = Encoder.GetString(Format);
            }

            if (sChunkID.Equals("fmt "))
            {
                // beim fmt Chunk die Größe in FmtChunkSize speichern
                FmtChunkSize = System.BitConverter.ToInt32(ChunkSize, 0);
                // sowie die anderen Informationen auslesen und speichern
                byte[] AudioFormat = new byte[2];
                fs.Read(AudioFormat, 0, 2);
                this.AudioFormat = System.BitConverter.ToInt16(AudioFormat, 0);
                byte[] NumChannels = new byte[2];
                fs.Read(NumChannels, 0, 2);
                this.NumChannels = System.BitConverter.ToInt16(NumChannels, 0);
                byte[] SampleRate = new byte[4];
                fs.Read(SampleRate, 0, 4);
                this.SampleRate = System.BitConverter.ToInt32(SampleRate, 0);
                byte[] ByteRate = new byte[4];
                fs.Read(ByteRate, 0, 4);
                this.ByteRate = System.BitConverter.ToInt32(ByteRate, 0);
                byte[] BlockAlign = new byte[2];
                fs.Read(BlockAlign, 0, 2);
                this.BlockAlign = System.BitConverter.ToInt16(BlockAlign, 0);
                byte[] BitsPerSample = new byte[2];
                fs.Read(BitsPerSample, 0, 2);
                this.BitsPerSample = System.BitConverter.ToInt16(BitsPerSample, 0);
            }

            if (sChunkID == "data")
            {
                // beim data Chunk die Größenangabe in DataSize speichern
                DataSize = System.BitConverter.ToInt32(ChunkSize, 0);

                // der 1. Index von Data spezifiziert den Audiokanal, der 2. das Sample
                Data = new int[this.NumChannels][];
                // Temporäres Array zum Einlesen der jeweiligen Bytes eines Kanals pro Sample
                byte[] temp = new byte[BlockAlign / NumChannels];
                // für jeden Kanal das Data Array auf die Anzahl der Samples dimensionalisieren
                for (int i = 0; i < this.NumChannels; i++)
                {
                    Data[i] = new int[this.DataSize / (NumChannels * BitsPerSample / 8)];
                }

                // nacheinander alle Samples durchgehen
                for (int i = 0; i < Data[0].Length; i++)
                {
                    // alle Audiokanäle pro Sample durchgehen
                    for (int j = 0; j < NumChannels; j++)
                    {
                        // die jeweils genutze Anzahl an Bytes pro Sample und Kanal einlesen
                        if (fs.Read(temp, 0, BlockAlign / NumChannels) > 0)
                        {   // je nachdem, wie viele Bytes für einen Wert genutzt werden,
                            // die Amplitude als Int16 oder Int32 interpretieren
                            if (BlockAlign / NumChannels == 2)
                                Data[j][i] = System.BitConverter.ToInt16(temp, 0);
                            else
                                Data[j][i] = System.BitConverter.ToInt32(temp, 0);
                        }
                        /* else
                         * andere Werte als 2 oder 4 werden nicht behandelt, hier bei Bedarf ergänzen!
                        */
                    }
                }
            }
        }
        #endregion

        #region Schreiben
        public void StoreWave(string path)
        {
            System.IO.FileStream fs = System.IO.File.OpenWrite(path); // zu schreiben Wave Datei öffnen / erstellen
            StoreChunk(fs, "RIFF"); // RIFF Chunk schreiben
            StoreChunk(fs, "fmt "); // fmt Chunk schreiben
            StoreChunk(fs, "data"); // data Chunk schreiben
        }

        private void StoreChunk(System.IO.FileStream fs, string chunkID)
        {
            System.Text.ASCIIEncoding Decoder = new ASCIIEncoding();
            // den Namen in Bytes konvertieren und schreiben
            fs.Write(Decoder.GetBytes(chunkID), 0, 4);

            if (chunkID == "RIFF")
            {
                // im RIFF Chunk, FileSize als Größe und das Audioformat schreiben
                fs.Write(System.BitConverter.GetBytes(FileSize), 0, 4);
                fs.Write(Decoder.GetBytes(Format), 0, 4);
            }
            if (chunkID == "fmt ")
            {
                // beim fmt Chunk die Größe dieses sowie die weiteren kodierten Informationen schreiben
                fs.Write(System.BitConverter.GetBytes(FmtChunkSize), 0, 4);
                fs.Write(System.BitConverter.GetBytes(AudioFormat), 0, 2);
                fs.Write(System.BitConverter.GetBytes(NumChannels), 0, 2);
                fs.Write(System.BitConverter.GetBytes(SampleRate), 0, 4);
                fs.Write(System.BitConverter.GetBytes(ByteRate), 0, 4);
                fs.Write(System.BitConverter.GetBytes(BlockAlign), 0, 2);
                fs.Write(System.BitConverter.GetBytes(BitsPerSample), 0, 2);
            }
            if (chunkID == "data")
            {
                // beim data Chunk die Größe des Datenblocks als Größenangabe schreiben
                fs.Write(System.BitConverter.GetBytes(DataSize), 0, 4);
                // dann die einzelnen Amplituden, wie beschrieben Sample für Sample mit jeweils allen
                // Audiospuren, schreiben
                for (int i = 0; i < Data[0].Length; i++)
                {
                    for (int j = 0; j < NumChannels; j++)
                    {
                        fs.Write(System.BitConverter.GetBytes(Data[j][i]), 0, BlockAlign / NumChannels);
                    }
                }
            }
        }
        #endregion

        #region Mischen
        private static WaveFile MixWave(WaveFile wf1, WaveFile wf2, int fadeTime)
        {
            int FadeSamples = fadeTime * wf1.ByteRate / wf1.NumChannels; // Anzahl an aus-/ einzublenden Samples
            int FadeBytes = fadeTime * wf1.ByteRate; // Anzahl an aus-/ einzublendenden Bytes

            WaveFile Result = new WaveFile(); // Ergebnis Wave Datei
            Result.FileSize = wf1.FileSize + wf2.DataSize - 2 * FadeBytes; // neue Dateigröße
            Result.Format = "WAVE";

            // Informationen aus dem fmt Chunk übernehmen
            Result.FmtChunkSize = wf1.FmtChunkSize;
            Result.AudioFormat = wf1.AudioFormat;
            Result.NumChannels = wf1.NumChannels;
            Result.SampleRate = wf1.SampleRate;
            Result.ByteRate = wf1.ByteRate;
            Result.BlockAlign = wf1.BlockAlign;
            Result.BitsPerSample = wf1.BitsPerSample;

            Result.DataSize = wf1.DataSize + wf2.DataSize - 2 * FadeBytes; // neue Größe des Data Chunks
            Result.Data = new int[wf1.NumChannels][]; // Anzahl an Kanälen übernehmen
            int NumSamples = Result.DataSize / (Result.NumChannels * ( Result.BitsPerSample / 8)); // Anzahl an Samples ausrechnen, die sich in de Ergebnisdatei ergeben

            // Die Data Arrays für alle Kanäle auf die Anzahl der Samples dimensionieren.
            for (int i = 0; i < Result.Data.Length; i++)
            {
                Result.Data[i] = new int[NumSamples];
            }

            int PosCounter = 0; // Position des aktuellen Samples in der Ergebnisdatei

            // die Samples aus der ersten Wave Datei in das Data Feld der Ergebnisdatei kopieren
            for (int i = 0; i < wf1.Data[0].Length; i++)
            {
                // das aktuelle Sample in allen Kanälen übernehmen
                for (int j = 0; j < wf1.NumChannels; j++)
                {
                    // fällt das aktuelle Sample in die Zeit, die überblendet werden soll, den Amplitudenwert der 1. Datei mit dem Amplitudenwert aus der 2. Datei mischen
                    if (i > wf1.Data[0].Length - FadeSamples)
                       Result.Data[j][PosCounter] = (int)(wf1.Data[j][i] * Factor(i - (wf1.Data[0].Length - FadeSamples), FadeSamples, 0) + wf2.Data[j][i - (wf1.Data[0].Length - FadeSamples)] * Factor(i - (wf1.Data[0].Length - FadeSamples), FadeSamples, 1));
                    else
                       Result.Data[j][PosCounter] = wf1.Data[j][i];
                }
                PosCounter++;
            }

            // die restlichen Samples in die Ergebnisdatei übernehmen
            for (int i = FadeSamples; i < wf2.Data[0].Length; i++)
            {
                for (int j = 0; j < wf1.NumChannels; j++)
                {
                    Result.Data[j][PosCounter] = wf2.Data[j][i];
                }
                PosCounter++;
            }
            return Result;
        }

        /// <summary>
       /// Diese Funktion dient zur Berechnung der Gewichtung der Amplituden bei Übermischung.
        /// </summary>
        /// <param name="pos">Position in Datei relativ zum Anfang der Überblendezeit</param>
        /// <param name="max">Ende der Überblendung, relativ zu pos</param>
        /// <param name="song">Kann die Werte 0 (auszublendender Song) oder 1 (einzublender Song) annehmen</param>
        /// <returns></returns>
        private static double Factor(int pos, int max, int song)
        {
            if (song == 0)
                return 1 - Math.Pow((double)pos / (double)max, 2);
            else
                return Math.Pow((double)pos / (double)max, 2);
        }

        public static void StoreMixWave(string path, WaveFile wf1, WaveFile wf2, int fadeTime)
        {
            WaveFile Mixed = MixWave(wf1, wf2, fadeTime); // Ergebnisdatei mischen
            Mixed.StoreWave(path); // Ergebnisdatei auf Festplatte speichern
        }

        #endregion
    }

Wave Dateien schreiben

2011-03-10T16:04:00.000+01:00

Im vorigen Post wurde gezeigt, wie man Wave Dateien byteweise einlesen kann. Jetzt möchte ich zeigen, wie man die Audiodateien erstellt.
Hierbei beschränke ich mich nur auf die Umkehrung des vorher beschriebenen Lesens, ich zeige in diesem Post also wie man eine vorher eingelesene Wave Datei wieder als Datei auf die Festplatte schreibt.
Im vorigen Post wurde der Aufbau von Wave Dateien und allerlei anderes Grundlegendes erläutert, deshalb poste ich hier nur kurz den Quellcode von 2 Funktionen, um die die Klasse WaveFile erweitert werden muss, damit Wave Dateien auch geschrieben werden können.
Das Prinzip ist analog zur Implementierung des Lesens, nacheinander werden die 3 Blöcke "RIFF", "fmt " und "data" in eine Datei geschrieben.

        public void StoreWave(string path)
        {
            System.IO.FileStream fs = System.IO.File.OpenWrite(path); // zu schreiben Wave Datei öffnen / erstellen
            StoreChunk(fs, "RIFF"); // RIFF Chunk schreiben
            StoreChunk(fs, "fmt "); // fmt Chunk schreiben
            StoreChunk(fs, "data"); // data Chunk schreiben
        }

        private void StoreChunk(System.IO.FileStream fs, string chunkID)
        {
            System.Text.ASCIIEncoding Decoder = new ASCIIEncoding();
            // den Namen in Bytes konvertieren und schreiben
            fs.Write(Decoder.GetBytes(chunkID), 0, 4);

            if (chunkID == "RIFF")
            {
                // im RIFF Chunk, FileSize als Größe und das Audioformat schreiben
                fs.Write(System.BitConverter.GetBytes(FileSize), 0, 4);
                fs.Write(Decoder.GetBytes(Format), 0, 4);
            }
            if (chunkID == "fmt ")
            {
                // beim fmt Chunk die Größe dieses sowie die weiteren kodierten Informationen schreiben
                fs.Write(System.BitConverter.GetBytes(FmtChunkSize), 0, 4);
                fs.Write(System.BitConverter.GetBytes(AudioFormat), 0, 2);
                fs.Write(System.BitConverter.GetBytes(NumChannels), 0, 2);
                fs.Write(System.BitConverter.GetBytes(SampleRate), 0, 4);
                fs.Write(System.BitConverter.GetBytes(ByteRate), 0, 4);
                fs.Write(System.BitConverter.GetBytes(BlockAlign), 0, 2);
                fs.Write(System.BitConverter.GetBytes(BitsPerSample), 0, 2);
            }
            if (chunkID == "data")
            {
                // beim data Chunk die Größe des Datenblocks als Größenangabe schreiben
                fs.Write(System.BitConverter.GetBytes(DataSize), 0, 4);
                // dann die einzelnen Amplituden, wie beschrieben Sample für Sample mit jeweils allen
                // Audiospuren, schreiben
                for (int i = 0; i < Data[0].Length; i++)
                {
                    for (int j = 0; j < NumChannels; j++)
                    {
                        fs.Write(System.BitConverter.GetBytes(Data[j][i]), 0, BlockAlign / NumChannels);
                    }
                }
            }
        }

Eine beispielhafte Implementierung, welche eine Wave Datei einliest und diese schließlich wieder als Datei auf die Festplatte schreibt, könnte so aussehen:

WaveFile WF1 = new WaveFile();
WF1.LoadWave(@"C:\Users\User\Desktop\mix.wav");
WF1.StoreWave(@"C:\Users\User\Desktop\stored.wav");

Wave Dateien einlesen

2011-03-07T20:37:00.005+01:00

In diesem Post möchte ich zeigen, wie man mit der Programmiersprache C# Wave Dateien einliest. Es geht hier allerdings nicht um das Abspielen etc., sondern um die genaue Analyse des Dateiformats, also wie eine Wave Datei aufgebaut ist und wie man sie byteweise einlesen kann (zum Abspielen geht's hier).
Eine Wave Datei ist eine Audiodatei, die somit Schallfrequenzen speichert.
Aufgebaut ist sie auf Datenebene aus mehreren Chunks (Blöcken). Mit diesen lässt sich einiges anstellen, ich werde mich in diesem Post allerdings nur auf die einfachste Form (aber zugleich auch der Standard) des Wave Formats beschränken (dieses wird auf dieser Seite erläutert), welches aus 3 Chunks besteht.
Auf der eben genannten Seite (und auf vielen anderen auch) wird das Wave Format sehr schön erklärt, ich fasse diese Infos hier nur kurz zusammen und lasse einiges weg.
Ein kleiner Tipp noch: Wave Dateien, mit exakt dem Aufbau wie sie hier beschrieben werden, können sehr gut mit dem kostenlosen Programm Audacity erzeugt werden (zum Beispiel aus MP3 - Dateien).

Die ersten 2 Einträge eines Chunks sind immer die gleichen: Mit jeweils 4 Byte werden Name des Chunks und eine Größenangabe codiert.
Der 1. Chunk trägt den Namen "RIFF". Die folgende Größenangabe (1) bezeichnet die Größe der gesamten Wavedatei in Bytes - 8, da der Name und die Größe nicht mitgezählt werden.
An 3. Position im 1. Block steht die Zeichenkette "WAVE" (2).
Nun folgt der 2. Chunk, mit Namen "fmt " (das Leerzeichen ist wichtig).
Die Größenangabe (3) speichert den Wert 16, sie bezeichnet die Größe dieses Blocks.
In den nächsten 2 Bytes wird das Audioformat (4) gespeichert: 1 bedeutet normale Speicherung, andere Werte zeigen eine Kompression an.
Mit den nächsten 2 Bytes werden die Anzahl der Audiospuren (5) kodiert.
Die nächsten 4 Bytes speichern die Abtastrate pro Sekunde (6), also wie viele Werte des Audiosignals pro Sekunde gespeichert werden.
In den nächsten 4 Bytes wird die Byterate (7) gespeichert, das heißt wie viele Bytes pro Sekunde zum Abspielen des Audiosignals abgerufen werden müssen.
Die nächsten 2 Bytes geben die Anzahl an Bytes an, die zur Beschreibung eines einzelnen Abtastwerts (unter Betrachtung aller Audiospuren) genutzt werden (8).
Die letzten 2 Bytes dieses Blocks geben schließlich die Anzahl an Bits (kleine Erinnerung: 1 Byte = 8 Bit) an, die zur Speicherung eines einzelnen Abtastwerts (bezüglich nur eines Kanals) genutzt werden (9).
Nun folgt der 3. Block, der Datenblock.
Am Anfang dieses befinden sich wieder mit je 4 Bytes der Name ("data") und die Größe (10) dieses.
Danach folgen die eigentlichen Daten (11) der Wave Datei, die ja im Prinzip Luftdrücke sind, also Audioamplituden.
Die Samples sind nacheinander abgespeichert, die verschiedenen Audiospuren stehen dabei direkt hintereinander. In dem "data" Block steht also zuerst Sample 1, wobei in diesem Abschnitt erst Audiokanal 1, dann ggf. Kanal 2 ... etc. steht, dann Sample 2 mit Kanal 1 als erstem und ggf. den anderen, usw.
Die entsprechende Anzahl Bytes pro Sample und Kanal ergeben als Integer interpretiert die Amplitude an der aktuellen Abtaststelle.

Damit wäre meine kleine Beschreibung des Wave Formats fertig, jetzt folgt der Code eines C# Programms, welches Wave Dateien einlesen kann, die nach obiger Beschreibung aufgebaut sind.
Kern des Programms ist die Klasse WaveFile, sie stellt eine Funktion zum Einlesen von Wave Dateien dar und speichert als Instanz die Informationen einer Datei.
Die oben beschriebenen Angaben zum Dateiinhalt (Anzahl der Kanäle etc.) sind im Quellcode mit den oben benutzten Nummern gekennzeichnet.
Oberfunktion zum Einlesen einer Wave Datei ist LoadWave(), der der Pfad zur Datei übergeben werden muss.
In dieser Funktion wird dann 3mal die Funktion LoadChunk() aufruft, welche einen Block ausliest.
Zuerst wird der Name des Blocks analysiert und dann das weitere Vorgehen angepasst.
Ich hoffe der Rest des Quellcodes ist aus den Kommentaren etc. verständlich.
Wie für alle Programme hier gilt: Das Programm ist nur eine erste Anregung zur weiteren Arbeit, eine Fehlerbehandlung o.ä. gibt es nicht.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            WaveFile WF1 = new WaveFile();
            WF1.LoadWave(@"C:\Users\User\Desktop\mix.wav");
        }
    }

    public class WaveFile
    {
        int FileSize; // 1
        string Format; // 2
        int FmtChunkSize; // 3
        int AudioFormat; // 4
        int NumChannels; // 5
        int SampleRate; // 6
        int ByteRate; // 7
        int BlockAlign; // 8
        int BitsPerSample; // 9
        int DataSize; // 10

        int[][] Data; // 11

        public void LoadWave(string path)
        {
            System.IO.FileStream fs = System.IO.File.OpenRead(path); // zu lesende Wave Datei öffnen
            LoadChunk(fs); // RIFF Chunk einlesen
            LoadChunk(fs); // fmt Chunk einlesen
            LoadChunk(fs); // data Chunk einlesen
        }

        private void LoadChunk(System.IO.FileStream fs)
        {
            System.Text.ASCIIEncoding Encoder = new ASCIIEncoding();

            byte[] bChunkID = new byte[4];
            /* Die ersten 4 Bytes einlesen.
            Diese ergeben bei jedem Chunk den jeweiligen Namen. */
            fs.Read(bChunkID, 0, 4);
            string sChunkID = Encoder.GetString(bChunkID); // den Namen aus den Bytes dekodieren

            byte[] ChunkSize = new byte[4];
            /* Die nächsten 4 Bytes ergeben bei jedem Chunk die Größenangabe. */
            fs.Read(ChunkSize, 0, 4);

            if (sChunkID.Equals("RIFF"))
            {
                // beim Riff Chunk ...
                // die Größe in FileSize speichern
                FileSize = System.BitConverter.ToInt32(ChunkSize, 0);
                // das Format einlesen
                byte[] Format = new byte[4];
                fs.Read(Format, 0, 4);
                // ergibt "WAVE" als String
                this.Format = Encoder.GetString(Format);
            }

            if (sChunkID.Equals("fmt "))
            {
                // beim fmt Chunk die Größe in FmtChunkSize speichern
                FmtChunkSize = System.BitConverter.ToInt32(ChunkSize, 0);
                // sowie die anderen Informationen auslesen und speichern
                byte[] AudioFormat = new byte[2];
                fs.Read(AudioFormat, 0, 2);
                this.AudioFormat = System.BitConverter.ToInt16(AudioFormat, 0);
                byte[] NumChannels = new byte[2];
                fs.Read(NumChannels, 0, 2);
                this.NumChannels = System.BitConverter.ToInt16(NumChannels, 0);
                byte[] SampleRate = new byte[4];
                fs.Read(SampleRate, 0, 4);
                this.SampleRate = System.BitConverter.ToInt32(SampleRate, 0);
                byte[] ByteRate = new byte[4];
                fs.Read(ByteRate, 0, 4);
                this.ByteRate = System.BitConverter.ToInt32(ByteRate, 0);
                byte[] BlockAlign = new byte[2];
                fs.Read(BlockAlign, 0, 2);
                this.BlockAlign = System.BitConverter.ToInt16(BlockAlign, 0);
                byte[] BitsPerSample = new byte[2];
                fs.Read(BitsPerSample, 0, 2);
                this.BitsPerSample = System.BitConverter.ToInt16(BitsPerSample, 0);
            }

            if (sChunkID == "data")
            {
                // beim data Chunk die Größenangabe in DataSize speichern
                DataSize = System.BitConverter.ToInt32(ChunkSize, 0);

                // der 1. Index von Data spezifiziert den Audiokanal, der 2. das Sample
                Data = new int[this.NumChannels][];
                // Temporäres Array zum Einlesen der jeweiligen Bytes eines Kanals pro Sample
                byte[] temp = new byte[BlockAlign / NumChannels];
                // für jeden Kanal das Data Array auf die Anzahl der Samples dimensionalisieren
                for (int i = 0; i < this.NumChannels; i++)
                {
                    Data[i] = new int[this.DataSize / (NumChannels * BitsPerSample / 8)];
                }

                // nacheinander alle Samples durchgehen
                for (int i = 0; i < Data[0].Length; i++)
                {
                    // alle Audiokanäle pro Sample durchgehen
                    for (int j = 0; j < NumChannels; j++)
                    {
                        // die jeweils genutze Anzahl an Bytes pro Sample und Kanal einlesen
                        if (fs.Read(temp, 0, BlockAlign / NumChannels) > 0)
                        {   // je nachdem, wie viele Bytes für einen Wert genutzt werden,
                            // die Amplitude als Int16 oder Int32 interpretieren
                            if (BlockAlign / NumChannels == 2)
                                Data[j][i] = System.BitConverter.ToInt16(temp, 0);
                            else
                                Data[j][i] = System.BitConverter.ToInt32(temp, 0);
                        }
                        /* else
                         * andere Werte als 2 oder 4 werden nicht behandelt, hier bei Bedarf ergänzen!
                        */
                    }
                }
            }
        }
    }
}

Lieder mit iTunes abspielen, in Wiedergabelisten navigieren

2011-02-24T15:42:00.002+01:00

Im vorigen Post wurde gezeigt, wie man bestimmte Lieder in iTunes suchen kann, heute möchte ich nocheinmal explizit darauf eingehen, wie man Lieder abspielt und wie man in Wiedergabelisten navigiert, ein Lied vor etc ...
Zum Abspielen eines Lieds ist die Funktion Play() nötig, die von einem Objekt vom Typ IITTrack aufgerufen werden muss.
Wie im vorigen Post beschrieben kann also nach einem bestimmten Lied in der gesamten Musikbibliothek gesucht werden, bei Sucherfolg kann dieses dann mittels Play() abgespielt werden.
Folgendes Beispiel spielt das 10. Lied aus der Musikbibliothek ab:

foreach (IITTrack track in iTunesPlayer.LibraryPlaylist.Tracks)
{
    if (counter++ > 10)
    {
        track.Play();
        break;
    }
}

Eine ganze Wiedergabe kann über die Funktion PlayFirstTrack() abgespielt werden, die passenderweise von einer Wiedergabeliste aus (von einem Objekt vom Typ IITPlaylist) aufgerufen wird.
Die folgende Funktion sucht nach einer Playlist, dessen Namen dem übergebenen Parameter entspricht, und gibt diese dann zurück:

private IITPlaylist SuchePlayList(iTunesApp iTunesPlayer, string name)
{
    foreach (IITPlaylist playlist in iTunesPlayer.LibrarySource.Playlists)
        if (playlist.Name == name)
            return playlist;
    return null;
}

Wenn wir nun eine bestimmte Wiedergabeliste abspielen wollen, rufen wir die Suchfunktion mit dem Namen dieser auf und rufen dann die Funktion PlayFirstTrack() auf:

IITPlaylist Techno = SuchePlayList(iTunesPlayer, "Techno");
if (Techno != null)
Techno.PlayFirstTrack();

Zum vorigen / nächsten Lied springen kann man über die Funktionen NextTrack() und PreviousTrack(), die über das iTunes Player Objekt aufgerufen werden:

iTunesPlayer.NextTrack();

iTunesPlayer.PreviousTrack();

Bestimmte Titel in iTunes suchen

2011-02-23T08:00:00.000+01:00

Nachdem im vorigen Post gezeigt wurde, wie man die komplette iTunes Mediathek durchläuft, möchte ich nun eine Möglichkeit zeigen, wie man nach bestimmten Titeln suchen kann.
Hierzu durchläuft man wie beschrieben die Mediathek oder bestimmte Playlists und prüft, ob die Suchkriterien erfüllt sind.
Die unten stehende Funktion sucht nach Interpret und Titel und gibt anschließend den gewünschten Track zurück.
Bei einer kompletten Suche kann es natürlich vorkommen, dass mehrere Ergebnisse gefunden werden, als Ergebnis würde sich dann eine Liste anbieten.

private IITTrack Suche(iTunesApp iTunesPlayer, string artist, string title)
{
    foreach (IITTrack track in iTunesPlayer.LibraryPlaylist.Tracks)
    {
        if (track.Artist == artist && track.Name == title)
            return track;
    }
    return null;
}

So könnte die Suchfunktion beispielsweise eingebunden werden, folgende Codezeilen suchen nach dem Lied "Saturday" von "Basshunter" und spielen dieses dann ab:

IITTrack Ergebnis = Suche(iTunesPlayer, "Basshunter", "Saturday");
if (Ergebnis != null)
Ergebnis.Play();

iTunes Mediathek durchlaufen

2011-02-17T23:44:00.002+01:00

In diesem Post möchte ich euch zeigen, wie man in C# die komplette iTunes Mediathek bzw. einzelne Wiedergabeliste durchlaufen kann.
Voraussetzung hierfür ist der vorige Post (Einbinden von iTunes in C#).
Sei iTunesPlayer nun wieder ein Objekt vom Typ iTunesApp, welches auf iTunes referenziert.
Dann liefert die Eigenschaft iTunesPlayer.LibraryPlaylist.Tracks alle in iTunes geladenen Mediendateien als Objekte vom Typ IITTrack.
Folgender Beispielcode schreibt alle Titel in eine Textbox (diese heißt textBox1, Multiline muss auf true stehen und Scrollbars sollten aktiviert sein):

iTunesApp iTunesPlayer = new iTunesApp();
foreach (IITTrack track in iTunesPlayer.LibraryPlaylist.Tracks)
{
textBox1.Text += track.Artist + " - " + track.Name + Environment.NewLine;
}

Es können aber auch gezielt einzelne Wiedergabelisten (Playlists) angesprochen werden.
Über die Eigenschaft iTunesPlayer.LibrarySource.Playlists kann auf alle angelegten Playlists zugegriffen werden.
Jede Playlist hat dann wieder die Eigenschaft Tracks, worin die Mediendateien der Liste gespeichert sind.
Der folgende Beispielcode schreibt in eine Textbox alle Wiedergabelisten aus iTunes samt Titeln (als 1. Wiedergabeliste erscheint die Wiedergabeliste "Mediathek", welche die gesamte Bibliothek enthält):

foreach (IITPlaylist playlist in iTunesPlayer.LibrarySource.Playlists)
{
    textBox1.Text += "Wiedergabeliste: " + playlist.Name + Environment.NewLine + Environment.NewLine;
    foreach (IITTrack track in playlist.Tracks)
    {
        textBox1.Text += track.Artist + " - " + track.Name + Environment.NewLine;
    }
    textBox1.Text += "--------------" + Environment.NewLine + Environment.NewLine;
}

iTunes einbinden

2011-02-17T22:11:00.007+01:00

Die nächste Postreihe wird sich mit dem Musikprogramm iTunes von Apple beschäftigen.
Hierzu werde ich mehrere Posts veröffentlichen, die verschiedene Funktionen der Anbindung zeigen.
In diesem ersten Post zeige ich, wie man iTunes grundsätzlich in ein C# - Programm einbindet - hierfür ist gar keine zusätzliche Software wie das iTunes SDK nötig, schon bei der "normalen" Installation von iTunes wird das benötigte COM - Objekt mitinstalliert.
Um nun in einem bestehnden C# - Projekt eine Referenz zu diesem einzufügen, ist der Menüaufruf Projekt - Verweis hinzufügen nötig.
Dann wechselt man zur Spalte COM und wählt dort das Objekt iTunes 1.13 Type Library aus (die Versionsnummer kann natürlich anders lauten). Und schon ist iTunes fertig zur Nutzung!
Der Einfachkeit halber importieren wir die entsprechende Bibliothek mittels using:

using iTunesLib;

Im Programm kann dann eine Instanz des iTunes Players beispielsweise so instanziert werden:

iTunesApp iTunesPlayer = new iTunesApp();

Wird diese Zeile im Programm ausgeführt, öffnet sich iTunes (wenn nicht bereits offen), und die Player Instanz wird mit dem Objekt im C# - Programm verknüpft.
Im nächsten Post beschreibe ich das Durchlaufen aller Lieder der Musikbibliothek / verschiedener Wiedergabelisten.

Google Earth einbinden

2011-02-17T01:29:00.005+01:00

So hallo, nach längerer Pause erscheint heute (endlich) mal wieder ein Post.
Tut mir Leid für die lange Zeit ohne, ich bin ziemlich beschäftigt im Moment, aber der Blog wird auf jeden Fall weiter gehen.

Der heutige Post ist eigentlich auch nur ein kurzer, allerdings dürfte er recht interessant werden.
Und zwar möchte ich kurz zeigen, wie man Google Earth in eine C# Anwendung einbinden kann.
Wie für viele Sachen gibt es von Google hierzu eine Programmbibliothek, die Google Earth API. In diesem Post hier geht's allerdings nur um eine erste Bereitstellung von Google Earth, dazu wird diese API gar nicht benötigt, denn online stellt Google ein Plugin für Desktopanwendungen bereit, welches sich im Browser betrachten lässt.
Dieses Plugin ist erreichbar unter der URL http://earth-api-samples.googlecode.com/svn/trunk/demos/desktop-embedded/pluginhost.html, wir müssen diese Seite nur noch in einem Webbrowser Steuerelement auf einem Formular unterbringen und schon haben wir den von Google Earth gewohnten bedienbaren Globus!
Ein kleines Manko ist, dass die Endnutzer das Plugin installieren müssen, allerdings wird das Fehlen dieses auch im Webbrowser Control angezeigt und kann mit einem Klick heruntergeladen werden.
Heißt das auf dem Formular platzierte Steuerlement webBrowser1, ruft folgender Code das Plugin auf:

private void Form1_Load(object sender, EventArgs e)
{
webBrowser1.Navigate(@"http://earth-api-samples.googlecode.com/svn/trunk/demos/desktop-embedded/pluginhost.html");
}

So könnte dann eine beispielhafte Anwendung aussehen:

Youtube durchsuchen

2010-12-30T12:53:00.000+01:00

In diesem Post möchte ich euch zeigen, wie man mit C# Youtube durchsuchen, also auf der Plattform nach bestimmten Videos suchen kann.
Hierfür benötigen wie die Google Data API, insbesondere das Youtube SDK. Mit diesen Programmierbibliotheken funktioniert der Zugriff auf Youtube & Co ganz einfach.
Zum Herunterladen gibt's die Google Data API auf dieser Seite, zum Zugriff auf Youtube brauchen wir aber nur diese Datei, das Youtube SDK.
Damit wir es später in das Projekt einbinden können, muss es installiert werden.
Das Durchsuchen von Youtube läuft über sogenannte Feeds.
Feeds sind so etwas wie Inhalte einer Website in Kurzform, meistens in reinem Textformat, so können sich Leser schnell über neueste Themen informieren, außerdem lesen viele Programme diese Textdateien (Suchmaschinen benutzen sie beispielsweise zur Indizierung).
Auch dieser Blog hat einen Feed, den man sogar abonnieren kann ;-)
Mit dem Youtube SDK können wir Feeds mit einem C# Programm auslesen, zum Durchsuchen von Youtube benutzen wir den Feed unter http://gdata.youtube.com/feeds/videos?q=Suchbegriff.
Dieser Feed wird von Youtube bereitgestellt und liefert die zu Suchbegriff passenden Ergebnisse in textueller Form, der Feed lässt sich auch im Browser betrachten.

Im Folgenden werde ich den Code erläutern, über den dieser Feed in C# ausgewertet werden kann.
Zuerst müssen die heruntergeladenen Bibliotheken Google.GData.Client.dll und Google.GData.Extensions.dll eingebunden werden.
Diese befinden sich im Redist Verzeichnis des Installationsordners (bei mir C:\Program Files (x86)\Google\Google YouTube SDK for .NET\Redist).
Das Einbinden lässt sich über Projekt - Verweis hinzufügen - Durchsuchen erledigen.
Zum benutzen im Projekt sind dann die Codezeilen

using Google.GData.Client;
using Google.GData.Extensions;

nötig.
Wichtig ist auch, dass unter Projekteigenschaften - Anwendung das Zielframework auf .Net Framework 4 und nicht etwa .Net Framework 4 Client Profile gestellt wird, denn für ersteres wurden die dlls kompilliert und nur hiermit funktioniert der Code.

Ich denke, der kommentierte Code ist eigentlich selbsterklärend, wesentlich hierbei ist, dass die Suchergebnisse letztendlich in Form eines Feeds (beim Programmieren als Objekt vom Typ AtomFeed) vorliegen, wessen Einträge dann ausgelesen werden können.

Das folgende Konsolenprogramm sucht auf Youtube nach dem Begriff "VLC einbinden" und gibt die ersten 10 Ergebnisse auf der Konsole aus:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Google.GData.Client;
using Google.GData.Extensions;

namespace YoutubeToolkit
{
    class YoutubeQuery
    {
        static void Main(string[] args)
        {
            FeedQuery Abfrage = new FeedQuery(); // Objekt zur Handhabung von Feeds
            Abfrage.Uri = new Uri("http://gdata.youtube.com/feeds/videos?q=VLC+einbinden"); // Feed URL
            Abfrage.StartIndex = 0; // Index, ab welchem die Suchergebnisse angezeigt werden sollen
            Abfrage.NumberToRetrieve = 10; // maximale Anzahl an anzuzeigenden Suchergebnissen

            Service Service = new Service(); // Objekt zur Durchführung der Suchabfrage über das FeedQuery Objekt
            AtomFeed Feed = Service.Query(Abfrage); // Ergebnis der Suchabfrage als Feed

            // für jedes Ergebnis den Titel des Videos ausgeben
            foreach (AtomEntry Ergebnis in Feed.Entries)
            {
                Console.WriteLine(Ergebnis.Title.Text);
            }
        }
    }
}

Ton ausschalten (Windows XP / Vista / 7)

2010-12-27T15:08:00.003+01:00

Im Post Ton ausschalten / Lautstärke einstellen stellte ich vor, wie man den PC stumm stellen und die Lautstärke anpassen kann. Die vorgestellte Methode funktioniert allerdings nur mit Windows XP.
Deswegen zeige ich in diesem Post kurz, wie man unter Windows Vista und 7 (aber auch XP kompatibel) den PC stummschalten (muten) kann.
Die Lösung führt uns wieder über die WinAPI,
weswegen folgende using - Direktive nötig ist: using System.Runtime.InteropServices;.
Die benötigte P/Invoke Methode heißt SendMessageW und hat die Signatur IntPtr SendMessageW(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam).
Diese Funktion schickt eine Nachricht an ein bestimmtes Programm oder Fenster.
Um den Ton am PC auszuschalten, schicken wir den richtigen Befehl an einen Systemprozess.
Und so sieht der Code im Ganzen aus:
Der Deklarationsteil:

        [DllImport("user32.dll")]
        public static extern IntPtr SendMessageW(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);

        private const int APPCOMMAND_VOLUME_MUTE = 0x80000;
        private const int WM_APPCOMMAND = 0x319;

Und die Funktion:

private void Mute()
{
SendMessageW(this.Handle, WM_APPCOMMAND, this.Handle, (IntPtr)APPCOMMAND_VOLUME_MUTE);
}

Weihnachtspost

2010-12-24T14:29:00.000+01:00

using System;
using System.Text;

namespace Weihnachtsprogramm
{
    class Frosty
    {
        static void Main(string[] args)
        {
            Console.WriteLine("{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}{14}{15}{16}{17}", (char)70, (char)114, (char)111, (char)104, (char)101, (char)32, (char)87, (char)101, (char)105, (char)104, (char)110, (char)97, (char)99, (char)104, (char)116, (char)101, (char)110, (char)33);
        }
    }
}

Menüs und Untermenüs dynamisch hinzufügen

2010-12-07T07:00:00.002+01:00

In diesem Post widme ich mich den Menüsteuerelementen in C# und zeige, wie man Menüs und Untermenüs zur Laufzeit hinzufügen kann.
Wie ich feststellen musste, ist diese Funktion nämlich nicht ganz klar ersichtlich.
Ich zeige hier meine Methode die über ein paar Umwege läuft, wer also direkteren Code kennt bitte Bescheid sagen.
Ziel des Beispielprogramms soll es sein, folgende Menüstruktur zu erzeugen:

Wir ziehen nun erstmal mit dem Designer ein Steuerelement vom Typ menuStrip auf das Formular (kann natürlich auch dynamisch gemacht werden, siehe Steuerelemente zur Laufzeit hinzufügen).
Nun wird lediglich oben im Formular eine noch unsichtbare Menüleiste bereitgestellt, die aber noch leer ist.
Im Designer kann man jetzt in diese schreiben, um Menüs zu erstellen, wir beschränken uns jedoch auf den dynamischen Teil.
Obermenüs, also Menüs auf höchster Ebene in der Menüleiste (im Beispiel "Obermenü 1" und "Obermenü 2") können über das Attribut Items der Klasse menuStrip bearbeitet werden.
Folgende Codezeilen legen die 2 Obermenüs an:

menuStrip1.Items.Add("Obermenü 1");
menuStrip1.Items.Add("Obermenü 2");

Über einen Index (z.B. über menuStrip1.Items[0]) können wir nun auf die Menüeinträge zugreifen, in diesen aber keine Untermenüs anlegen.
Dafür müssen wir das Objekt explizit in ein Objekt vom Typ ToolStripMenuItem konvertieren. Dieses hat nun die Eigenschaft DropDownItems, über die wir Untermenüs anlegen können.
Um beispielsweise die Untermenüs "Untermenü 1" und "Untermenü 2" zu erzeugen, führen wir folgenden Code aus:

((ToolStripMenuItem)menuStrip1.Items[0]).DropDownItems.Add("Untermenü 1");
((ToolStripMenuItem)menuStrip1.Items[0]).DropDownItems.Add("Untermenü 2");

Diese Untermenüs sind nun so ersteinmal nicht mehr greifbar. Wir brauchen sie jedoch, wenn wir weitere Untermenüs anlegen wollen, die nach rechts aufklappen (im Beispiel "rechtes Untermenü 1" und "rechtes Untermenü 2").
Deswegen speichern wir einfach beim Anlegen des Untermenü dieses in einem Objekt vom Typ ToolStripMenuItem, z.B. so:

ToolStripMenuItem Untermenue1 = (ToolStripMenuItem)((ToolStripMenuItem)menuStrip1.Items[0]).DropDownItems.Add("Untermenü 1");

(Vor der Zuweisung muss wieder eine explizite Typumwandlung stehen.)
Nun haben wir über die Variable dauerhaft Zugriff auf das gewünschte Untermenü, und können diesem über DropDownItems.Add() eigene Untermenüs hinzufügen.
Hier zum Abschluss der komplette Beispielcode:

            menuStrip1.Items.Add("Obermenü 1");
            menuStrip1.Items.Add("Obermenü 2");

            ToolStripMenuItem Untermenue1 = (ToolStripMenuItem)((ToolStripMenuItem)menuStrip1.Items[0]).DropDownItems.Add("Untermenü 1");
            ((ToolStripMenuItem)menuStrip1.Items[0]).DropDownItems.Add("Untermenü 2");

            Untermenue1.DropDownItems.Add("rechtes Untermenü 1");
            Untermenue1.DropDownItems.Add("rechtes Untermenü 2");

Tastendruck von mehreren Tasten gleichzeitig prüfen

2010-12-05T13:48:00.004+01:00

In den Methoden KeyDown() und KeyPress(), die nahezu jedes Steuerelement implementiert, können Tastaturereignisse untersucht werden.
Der Parameter e vom Typ KeyEventArgs stellt die hierfür benötigten Methoden und Eigenschaften bereit.
So kann z.B. über e.KeyCode geprüft werden, welche Taste gedrückt wurde.
Werden mehrere Tasten (gleichzeitig) gedrückt, wird für jede Taste ein Ereignis aufgerufen, was aber nicht hilft, wenn man den Druck von Tastenkombinationen abfragen möchte.
In diesem Post beschreibe ich, wie man diese Fälle mittels der Eigenschaft KeyData bzw. Flags abdeckt, wobei diese Methoden nur funktionieren, wenn die Kombinationen nur aus Alt und / oder Shift und / oder Strg und / oder maximal einer anderen Taste besteht.
Zuerst über KeyData:
Diese Eigenschaft wird in 4 Bytes gespeichert, die unteren beiden geben die gedrückte Taste wieder, die oberen beiden die gedrückten Funktionstasten (Alt, Shift, Strg (Control)).
Werden mehrere Tasten drückt, werden die Byte - Werte Oder verknüpft.
Drückt man nun nur die Zustandstasten und maximal eine andere Taste, erhält man in KeyData eine eindeutige Bitkombination. Es sollte allerdings klar sein, dass die Eindeutigkeit beim Drücken von mehreren "normalen" Taste nicht mehr gewährleistet ist, da die Bits sich dann überschneiden können.
Zum Prüfen der gedrückten Kombination wird der Wert aus e.KeyData mit einer bitweisen Oder - Verknüpfung des gewünschten Wertes verglichen.
Folgendes Beispiel beendet das Programm, wenn die Tastenkombination Strg + Shift + Alt + "E" gedrückt wurde.

private void Form1_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyData == (Keys.Shift | Keys.Alt | Keys.Control | Keys.E))
this.Close();
}

Das gleiche Ergebnis lässt sich aber auch erreichen, wenn man über e.KeyCode die gedrückte Taste abfragt und zusätzlich noch die Eigenschaften e.Shift, e.Alt und e.Control überprüft (diese Eigenschaften sind sogenannte Flags), die angeben, ob die entsprechenden Funktionstasten gedrückt sind:

if (e.KeyCode == Keys.E && e.Shift && e.Alt && e.Control)
this.Close();

Status eines Netzwerkadapters überprüfen

2010-12-03T14:25:00.001+01:00

Im vorigen Post wurde gezeigt, wie man prüfen kann, ob der Computer mit einem Netzwerk verbunden ist, ob also ein beliebiger Netzwerkadapter eine Verbindung hat.
In diesem Post untersuchen wir den Status von nur einer Netzwerkschnittstelle, und das etwas genauer. Wir möchten nun nicht mehr nur zwischen "verbunden" und "nicht verbunden" unterscheiden, sondern mehr Informationen erhalten.
Wir benutzen wieder die Klasse System.Net.NetworkInformation, fragen aber dieses Mal die Eigenschaft OperationalStatus ab.
Diese kann folgende Werte annehmen:

Dormant - Die Schnittstelle wartet auf ein externes Ereignis, sie kann keine Daten übertragen.
Down - Keine Verbindung.
LowerLayerDown - Die Schnittstelle kann keine Daten übertragen, da sie auf "tieferliegende" Schnittstellen zugreift und mindestens eine dieser nicht in Betrieb ist.
NotPresent - Nicht funktionsfähig, meistens wegen einem Hardwaredefekt.
Testing - Die Schnittstelle führt Tests aus.
Unknown - Unbekannter Status.
Up - Die Schnittstelle ist in Betrieb.

Ein kleines Beispiel, es listet alle Netzwerkverbindungen auf, die in Betrieb sind:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            foreach (System.Net.NetworkInformation.NetworkInterface n in System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces())
            {
                if (n.OperationalStatus == System.Net.NetworkInformation.OperationalStatus.Up)
                    Console.WriteLine(n.Name + " ist Up.");
            }
        }
    }
}

Verfügbare Netzwerkadapter auflisten und weitere Informationen anzeigen

2010-12-03T14:13:00.004+01:00

Wie im vorigen Post benutzen wir wieder die Klasse System.Net.NetworkInformation. Die Methode NetworkInterface.GetAllNetworkInterfaces() liefert ein Array vom Typ System.Net.NetworkInformation.NetworkInterface zurück, wobei jeder Eintrag eine Netzwerkschnittstelle bzw. einen Netzwerkadapter repräsentiert.
Über dieses Array können wir nun iterieren und so alle verfügbaren Netzwerkadapter auflisten.
Das folgende Beispiel gibt den Namen sowie den Status (wird im nächsten Post näher erläutert) jedes einzelnen aktivierten Netzwerkadapters aus:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            foreach (System.Net.NetworkInformation.NetworkInterface n in System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces())
            {
                Console.WriteLine("Name: " + n.Name + " Status: " + n.OperationalStatus.ToString());
            }
        }
    }
}

Prüfen ob Netzwerkverbindung besteht

2010-11-28T14:12:00.005+01:00

Wir benutzen die Klasse System.Net.NetworkInformation.NetworkInterface um zu prüfen, ob der Computer eine Verbindung zu einem Netzwerk hat.
Die hierzu benötigte Methode heißt GetIsNetworkAvailable(). Sie prüft nur, ob der Computer sich über einen beliebigen Adapter in ein Netzwerk eingewählt halt, nicht, ob dieses auch funktioniert oder eine Verbindung zum Internet besteht.
Folgendes Codebeispiel prüft die Konnektivität:

bool NetworkAvailable = System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable();

Assertions

2010-11-25T11:37:00.002+01:00

Assertions sind eine Methode zur Kontrolle der Programmkorrektheit.
Sie stellen eine Bedindung dar, die bei Verletzung eine Fehlermeldung ausgibt.
Assertions stehen meistens vor Programmbereichen, die ohne Erfülltsein der Bedingung nicht funktionieren würden. Wird eine Assertion geworfen, weiß der Programmierer, dass er in diesem Bereich den Fehler abzufangen hat.
Der Ausdruck System.Diagnostics.Debug.Assert() kann in der Debug - Konfiguration verwendet werden, System.Diagnostics.Trace.Assert() in der Release - Version.
Als Beispiel eine Methode zur Division, die beim Versuch, durch 0 zu teilen, mittels Assert() dazwischengeht:

public double divide(double divident, double divisor)
{
System.Diagnostics.Debug.Assert(divisor != 0);
return (divident / divisor);
}

String - Repräsentation einer Klasse durch Überladen von ToString()

2010-11-23T15:53:00.002+01:00

Alle Klassen und Strukturen in C# erben implizit von der Überklasse Object.
Diese stellt einige grundlegende Methoden wie Equals() (prüft auf Gleichheit) und ToString() (stellt die Klasse als Zeichenkette dar) zur Verfügung.
Alle Klassen und Strukturen implementieren somit standardmäßig diese Methoden.
Jedem wird die Schreibweise Console.WriteLine(x.ToString()); bekannt sein, wobei x beispielsweise eine Integer - Variable ist. Auch diese Klasse besitzt die Methode ToString(), sie gibt den Wert der Ganzzahl als String aus.
Vom Programmierer angelegte Klassen erben auch von Object, haben also somit auch die Methode ToString() vordefiniert, hier liefert diese aber wahrscheinlich nicht das gewünschte Ergebnis.
Der Compiler druckt einfach den Typnamen der Klasse als Zeichenkette aus, woher sollte er auch wissen, wie der Programmierer eine Instanz der Klasse als Zeichenkette darstellen möchte.
Deswegen bietet es sich an, bei eigenen Klassen die Methode ToString() zu überschreiben. Beim Überschreiben (engl. overriding) von Methoden wird in der Kindsklasse eine Methode mit der gleichen Signatur (d.h. Name und Parameterliste gleich) wie eine Methode aus der Vaterklasse angelegt.
Wird nun die Methode der Kindsklasse aufgerufen, wird der Aufruf nicht mehr auf die Methode der Basisklasse weitergeleitet, sondern direkt in der Kindsklasse verarbeitet.
Das folgende Konsolenprogramm implementiert eine kleine Klasse Employee, in welcher die Methode ToString() überladen wird.
In der modifizierten Version werden Name und Gehalt des Mitarbeiters ausgegeben:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

class Program
{
    static void Main(string[] args)
    {
        Employee TestEmployee = new Employee("Hans Meier", 1000);
        Console.WriteLine(TestEmployee.ToString());
    }
}

class Employee
{
    public string Name;
    public int Salary;

    public Employee(string name, int salary)
    {
        Name = name;
        Salary = salary;
    }

    public override string ToString()
    {
        return "Name: " + Name + ", Gehalt: " + Salary + ".";
    }
}

Ein Quine mit C#

2010-11-21T12:32:00.004+01:00

Ein Quine ist ein Programm, welches seinen kompletten eigenen Quellcode als Ausgabe ausgibt.
Lautet der Quellcode also beispielsweise

class Quine
{
    static void Main()
    {
        System.Console.WriteLine("Dies ist (noch) kein Quine.");
    }
}

müsste das Programm genau diesen Text ausgeben.
Je nachdem, wie erfahren man mit Problemen aus diesem Bereich ist, wird einem die Aufgabe, ein Quine zu schreiben, vielleicht als einfach, schwer oder sogar unmöglich vorkommen.
(Für theoretisch interessierte: In allen "höheren" Programmiersprachen, also C, C#, Java etc. ist sogar garantiert, dass Quines existieren müssen. Denn all diese Sprachen sind Turing - vollständig, und in Turing - vollständigen Sprachen lässt sich ein Quine realisieren.)
Geht man ganz naiv an die Sache ran, könnte man vielleicht vermuten, das Problem wäre ganz schnell gelöst.
Man druckt zuerst den Code bis zur Zeile mit WriteLine(), dann diese Zeile und schließlich den Rest bis zur abschließenden Klammer.
Aber Moment! Die Aufgabenstellung besagt, dass der komplette Quellcode gedruckt werden soll, es müssen also auch alle WriteLine() Anweisungen gedruckt werden.
Schreibt man beispielsweise

string test = "abc";

und gibt diese Zeile dann mittels WriteLine() aus

WriteLine("string test = \"abc\";");

, muss im nächsten Schritt dann auch diese Zeile ausgedruckt werden.
Damit so keine Endlosrekursion entsteht, besteht der Trick darin, den auszugebenden Code in einem String zu speichern und dann nur diesen String auszugeben.
Weiterhin wird noch ausgenutzt, dass in C# in der WriteLine() - Methode Platzhalter benutzt werden können, welche dann später ersetzt werden.
Ich zeige jetzt einfach den Code eines von mir geschriebenen funktionierenden Quines, die abstrakten Forderungen von oben werden so vielleicht am besten deutlich:

class Quine
{
    static void Main(string[] args)
    {
        string s = "class Quine {3} {0} {3} static void Main(string[] args) {3} {0} {3} string s = {2}{1}{2}; {3} System.Console.WriteLine(s, System.Convert.ToChar(123), s, System.Convert.ToChar(34), System.Environment.NewLine, System.Convert.ToChar(125)); {3} {4} {3} {4}";
        System.Console.WriteLine(s, System.Convert.ToChar(123), s, System.Convert.ToChar(34), System.Environment.NewLine, System.Convert.ToChar(125));
    }
}

In das Windows Ereignisprotokoll schreiben

2010-11-13T18:23:00.003+01:00

Im Windows Ereignisprotokoll zeichnet Windows viele systemrelevante Informationen (z.B. das Starten / Beenden von Diensten, um nur eins von unzähligen Anwendungsgebieten zu nennen) auf.
Mit C# können wir in dieses Protokoll ganz leicht eigene Einträge über die Klasse System.Diagnostics.EventLog schreiben, um beispielsweise den Programmfluss zu überwachen.
Zuerst müssen wir hierfür (sofern noch nicht vorhanden) eine neue Quelle im Ereignisprotokoll anlegen.
Die Quelle gibt an, durch welche Anwendung etc. der Eintrag geschrieben wurde.
Gibt es noch keine Einträge von der Anwendung, wird die Quelle also neu angelegt, müssen wir spezifizieren, zu welcher Kategorie das Programm zählt. Im Ereignisprotokoll gibt es beispielsweise die Kategorien "Anwendung", "Sicherheit", "Installation" etc.
Das letztendliche Schreiben des Ereignisses führt die Methode WriteEntry() durch. Diese erwartet als 1. Parameter die Quelle, als 2. die Kategorie und optional als 3. den Typ des Ereignisses (z.B. Warnung, Information, Fehler ...).
Zum Schreiben in das Ereignisprotokoll wird das Programm wahrscheinlich (unter Windows Vista und 7) Administratorrechte benötigen, wie man die eigene Anwendung damit ausstattet könnt ihr hier lesen.
Das folgende Codebeispiel schreibt einen kurzen Informationstext in die Windows Ereignisanzeige (using System.Diagnostics; wird vorrausgesetzt):

        private void Form1_Load(object sender, EventArgs e)
        {
            string Source;
            string LogType;
            string LogEvent;

            Source = "Ereignisprotokoll C# Demo";
            LogType = "Application";
            LogEvent = "Diesen C# Blog finde ich super.";

            if (!EventLog.SourceExists(Source))
                EventLog.CreateEventSource(Source, LogType);

            EventLog.WriteEntry(Source, LogEvent, EventLogEntryType.Information);
        }

Herunterfahren von Windows verhindern / verzögern

2010-11-08T18:00:00.000+01:00

Im vorigen Post wurde gezeigt, wie man erkennen kann, ob der PC heruntergefahren wird.
In diesem Post geht es darum, wie man das Herunterfahren abbricht bzw. verzögert um z.B. vorher Daten zu sichern.
Im vorigen Post wurde die Methode FormClosing() benutzt, in welcher beim Schließen des Formulars der Beendigungsgrund abgefragt wurde.
In dieser Methode können wir nun ebenfalls über den Parameter e das Herunterfahren einfach unterbinden, in dem wir e.Cancel = true setzen.
Das Herunterfahren des Rechners wird damit nicht vollständig abgebrochen, sondern nur solange verzögert, wie das Programm läuft - nun hat die Anwendung beispielsweise Zeit, ungesicherte Daten zu speichern.
In Windows Vista und 7 erscheint dabei ein Wartungsfenster mit dem Hinweis: "Folgendes Programm verhindert das Herunterfahren des Computers."

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
if (e.CloseReason == CloseReason.WindowsShutDown)
e.Cancel = true;
}

Eine andere Möglichkeit, das Herunterfahren von Windows zu verzögern, besteht in der Verwendung des Microsoft.Win32.SystemEvents.SessionEnding Ereignisses, welches bei Herunterfahren des Systems eintritt.
Diesem Ereignis kann man wie anderen Ereignissen (z.B. Klick auf einen Button) eine Methode zuweisen, die aufgerufen wird, wenn es eintritt.
Folgender Codeausschnitt zeigt ein Beispiel unter Verwendung des Systemereignisses:

        private void Form1_Load(object sender, EventArgs e)
        {
            Microsoft.Win32.SystemEvents.SessionEnding += new Microsoft.Win32.SessionEndingEventHandler(this.WinShutdown);
        }

        private void WinShutdown(object sender, Microsoft.Win32.SessionEndingEventArgs e)
        {
            e.Cancel = true;
        }

C# erkennen ob System heruntergefahren wird

2010-11-06T16:21:00.004+01:00

Eine häufig durchgeführte Suchanfrage, bei welcher Surfer auf diesem Blog landeten, war die Frage, wie man feststellen kann, ob der PC gerade heruntergefahren wird.
Deswegen gibt es die Lösung jetzt hier als Post (warum siehe hier).
Wird das System heruntergefahren, werden logischerweise alle laufenden Prorgamme beendet. Das können wir ausnutzen, in dem wir in der Methode FormClosing() des Hauptformulars, welche aufgerufen wird, wenn das Formular geschlossen wird, den Grund des Schließens abfragen.
Dieser kann über die Eigenschaft CloseReason des Parameters e ermittelt werden.
Im Falle des Herunterfahrens lautet dieser Grund CloseReason.WindowsShutDown.
Der folgende Codeausschnitt aus einer Windows Forms-Anwendung implementiert diese Möglichkeit und gibt eine Meldung aus, wenn der PC heruntergefahren wird:

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
if (e.CloseReason == CloseReason.WindowsShutDown)
MessageBox.Show("PC wird heruntergefahren.");
}

Die Verwendung des Ereignisses Microsoft.Win32.SystemEvents.SessionEnding, welches nur eintritt wenn der PC heruntergefahren wird, wird im nächsten Post kurz erwähnt.

C# .txt Datei bereits vorhanden

2010-11-05T07:46:00.003+01:00

In einem vorigen Post wurde allgemein beschrieben, wie man prüfen kann, ob eine Datei / ein Ordner bereits vorhanden ist.
Im Rahmen der "Posts für häufige Suchbegriffe" zeige ich in diesem Post explizit den Code zum Prüfen, ob eine Textdatei bereits vorhanden ist.
Wer den Code nicht versteht sei auf den allgemeineren Post verwiesen, ich poste hier nur kurz die Lösung:

        private void Form1_Load(object sender, EventArgs e)
        {
            bool test = TxtFileExisting(@"C:\Users\User\Desktop\c#");
        }

        private bool TxtFileExisting(string path)
        {
            bool TxtDateiExistiert = System.IO.File.Exists(path + ".txt");
            return TxtDateiExistiert;
        }

Aus der Methode Form_Load() wird die Methode TxtFileExisting() mit dem Pfad zur prüfenden Datei (ohne Endung) aufgerufen.
In dieser Methode wird an den Pfad ".txt" angehängt und mittels System.IO.File.Exists() geprüft, ob die entsprechende Textdatei existiert. Falls ja, wird true zurückgegeben, andernfalls false.

C# Textdatei zufällige Zeile auslesen

2010-11-02T11:16:00.006+01:00

In diesem Post möchte ich zeigen, wie man mit C# eine zufällige Zeile aus einer Textdatei liest.
(Diesen Post schreibe ich im Rahmen der Posts für häufige Suchbegriffe.)
Leider gibt es in C# keine direkte Möglichkeit, auf eine bestimmte Zeile einer Textdatei zuzugreifen.
Denn die Inhalte von Dateien werden als Folgen von Bits gespeichert, verschiedene Zeilen sind erst in einer höheren Abstraktionsebene sichtbar.
Um nun eine zufällige Zeile aus einer Textdatei auszulesen, lesen wir zuerst alle Zeilen ein und geben dann eine zufällige Zeile aus.
Das Auslesen der Textdatei erfolgt über die Klasse StreamReader, die Methode ReadToEnd() liest den kompletten Inhalt der Textdatei aus und gibt diesen als String zurück.
Diesen String kann man mit der Methode Split() aufteilen, als Trennzeichen übergeben wir Environment.NewLine.
Diese Konstante gibt das auf dem aktuellen System verwendete Trennsymbol für Zeilenumbrüche zurück.
Unter Windows ist dieses Symbol "\r\n", da dieses quasi aus 2 verschiedenen Symbolen besteht wird der String zuoft gesplittet, jede 2. Zeile ist leer und wir setzen die Option StringSplitOptions.RemoveEmptyEntries
um diese leeren Zeilen zu löschen.

Zur Erzeugung von Zufallszahlen, was zur Rückgabe einer zufälligen Zeile benötigt wird, habe ich diesen Post geschrieben.

Und nun der Code für eine fertige Funktion, welche den Pfad zu der zu lesenden Textdatei als Parameter entgegen nimmt und als Ergebnis eine zufällige Zeile der Textdatei als String zurückgibt (oben im Projekt muss die Anweisung using System.IO; eingebunden sein):

private string ReadRandomTextLine(string path)
{
    StreamReader sr = new StreamReader(new FileStream(path, FileMode.Open)); // StreamReader zum Lesen der Datei im Pfad path
    string[] Lines = sr.ReadToEnd().Split(new string[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries); // kompletten Inhalt der Datei auslesen und nach Zeilen splitten
    Random rnd = new Random(); // den Zufallsgenerator initialisieren
    return Lines[rnd.Next(Lines.Length)]; // eine zufällige Zeile zurückgeben
}

Posts für häufige Suchbegriffe

2010-11-02T10:17:00.004+01:00

Ich benutze Google Analytics zur Analyse des Besucherverhaltens dieses Blogs. Mit Analytics kann man u.a. sehen, wie oft die eigene Seite für welche Suchbegriffe in den Ergebnisseiten von Suchmaschinen auftaucht und wie oft sie angeklickt wird.
In diesen Statistiken finden sich einige interessante Begriffe betreffend C# Fragen, die häufig gesucht werden. In den nächsten Tagen werde ich Posts zu genau den gesuchten Themen veröffentlichen. Erfahrenen C# Nutzern werden sie vielleicht komisch oder überflüssig vorkommen, aber ich hoffe, einige Programmierer finden genau die Lösung ihres Problems und ich erhalte nebenbei noch den ein oder anderen Besucher ;-)

Liste der Posts aus dieser Reihe:
C# Textdatei zufällige Zeile auslesen
CSharp txt Datei bereits vorhanden

Allgemeiner Fehler in GDI+

2010-10-30T13:32:00.000+02:00

Die Fehlermeldung "Allgemeiner Fehler in GDI+." ist ganz schön fies in C# - sie tritt sporadisch auf und die Ursache ist oft auf den ersten Blick nicht ersichtlich. Deswegen werde ich diesen Post der Fehlermeldung und ihren Ursachen widmen und die meiner Meinung nach 2 häufigsten Quellen des Grafikfehlers beschreiben.
Der oben genannte Fehler kann auftreten wenn ein Bild (Image) über die Methode Save() in einen nicht existierenden Pfad gespeichert werden soll.
Folgender Code versucht, den Inhalt der pictureBox als Bild zu speichern und wirft dabei die Fehlermeldung, sofern der angegebene Pfad nicht vorhanden ist:

pictureBox1.Image.Save("C:\\NichtExistierenderPfad\\test.jpg");

Beim Laden eines Bildes führt ein falscher Pfad dagegen zu einer FileNotFoundException.
Eine weitere sehr häufige Ursache des leidigen Fehlers "Allgemeiner Fehler in GDI+." ist die Nichtfreigebung eines Bildobjekts.
Lädt man ein Bild z.B. über die Methode Image.FromFile(), bleibt dieses solange im Speicher geöffet, bis es nicht freigegeben wird. Insbesondere ist vor dem Freigeben kein Speichern über Save() möglich.
Das folgende Codebeispiel lädt ein Bild in die pictureBox und versucht dann, dieses zu speichern - doch es tritt der "Allgemeiner Fehler in GDI+." Fehler auf, da das Bild nicht freigegeben wurde.

pictureBox1.Image = Image.FromFile("C:\\test\\test1.jpg");
pictureBox1.Image.Save("C:\\test\\test2.jpg");

Das Bild muss zur korrekten Funktionsweise des Codes intern "umkopiert" werden:

pictureBox1.Image = Image.FromFile("C:\\test\\test1.jpg");
Image Copy = pictureBox1.Image;
Copy.Save("C:\\test\\test2.jpg");

Ich hoffe, der Post hat die grundlegende Problematik dieses Fehlers deutlich gemacht, über weitere Ursachen, Besonderheiten etc. bin ich jederzeit dankbar!

Bild in byte - Array speichern

2010-10-28T18:53:00.002+02:00

Um mit C# ein Bild (Image) in ein byte - Array zu konvertieren, speichern wir das Bild zuerst in einen Stream und kopieren den Inhalt dieses Streams dann in ein byte - Array.
Prinzipiell kann jeder Streamtyp dazu verwendet werden, am einfachsten ist jedoch die Verwendung eines MemoryStreams, welcher lediglich temporär Daten in den Arbeitsspeicher schreibt bzw. daraus liest.
Ein Bild vom Typ Image kann über die Methode Save() in den als 1. Parameter spezifizierten Stream geschrieben werden, als 2. Parameter kann das Format angegeben werden, in welchem das Bild gespeichert werden soll (also z.B. Gif oder Bmp).
Der folgende Beispielcode speichert den Inhalt der pictureBox auf dem Formular in einem byte - Array:

            MemoryStream TempStream = new MemoryStream();
            byte[] ImageInBytes;

            pictureBox1.Image.Save(TempStream, System.Drawing.Imaging.ImageFormat.Gif);
            ImageInBytes = TempStream.ToArray();

Code mit #region gliedern

2010-10-26T17:21:00.006+02:00

Bei größeren Codeprojekten kann die Codeansicht schnell unübersichtlich werden, sind alle Methoden etc. erweitert ist ganz schön Scrollarbeit nötig, um von oben im Quellcode bis nach unten zu kommen.
Doch Codeblöcke lassen sich mit C# auch ganz einfach gliedern, und zwar mit dem Schlüsselwort #region.
Dieses Schlüsselwort beginnt einen Block welcher durch #endregion beendet werden muss.
Die definierten Regionen können dann z.B. wie Methoden ein- oder ausgeklappt werden, die folgenden 2 Bilder zeigen dies:

"Normal" (ausgeklappt):

Eingeklappt:

Komprimierung mit C#, Teil 3 - Archive erstellen und wieder entpacken

2010-10-20T00:38:00.000+02:00

Im 3. und (vorerst) letzten Teil zur Reihe "Komprimierung in C#" möchte ich euch eine Möglichkeit zeigen, mehrere Dateien auf einmal in einem Archiv zu komprimieren und dieses wieder zu entpacken.
Um diesen Post hier zu verstehen, ist ein Verständnis der Techniken aus Teil 1 und 2 hilfreich.
Mehrere Dateien in ein Archiv zu verpacken, geht in C# nur über einen kleinen Umweg, denn das verwendete gzip - Format unterstützt standardmäßig nur die Komprimierung von einzelnen Dateien.
Sammlungen von mehreren Dateien werden so meistens zuerst mit tar und dann mit gzip komprimiert, sie erhalten dann die Endung .tar.gz.
Obwohl uns das tar - Format in .Net nicht zur Verfügung steht, lässt sich eine Komprimierung von mehreren Dateien doch umsetzen: Wir fassen die einzelnen Dateien einfach zu einer großen Datei zusammen, in welcher die Dateien durch besondere Zeichen voneinander getrennt sind. Diese große Datei wird dann komprimiert und beim Dekomprimieren wieder anhand der Sonderzeichen in die einzelnen Dateien aufgeteilt.

Die Technik:
Als Kennzeichnung zwischen den Dateien schrieb ich folgenden Header vor jede Datei in den Stream:
|*START*OF*HEADER*|*||GRÖSSE_DER_DATEI||NAME_DER_DATEI*|*END*OF*HEADER*|
Probleme könnte es also in dem unwahrscheinlichen Fall geben, wenn der Inhalt einer Datei der Struktur gleichen würde.

Die Komprimierung / Erstellung eines Archivs:
Der Methode zur Komprimierung werden die zu komprimierenden Dateien als String - Array übergeben sowie der Name und Pfad des Archivs.
Die Dateien werden nun durchlaufen und der jeweilige Header sowie anschließend der Inhalt der Datei wird zuerst in einen MemoryStream geschrieben.
Die Daten aus diesem werden anschließend in ein byte - Array kopiert und dieses wird dann mit einem GZipStream in die Archivdatei geschrieben.
Dadurch, dass die Dateien erst zusammengefasst und dann mit dem GZipStream geschrieben werden und nicht jede Datei nacheinander in das Archiv geschrieben wird, kann das Archiv viel stärker komprimiert werden, da auch Redundanzen zwischen den einzelnen Dateien ausgenutzt werden können.
Der Code:

        private void CreateArchive(string[] files, string archiv)
        {
            GZipStream CompressStream = new GZipStream(new FileStream(archiv, FileMode.Create), CompressionMode.Compress);
            FileStream NormalFileStream;
            byte[] Content;

            ASCIIEncoding encoder = new ASCIIEncoding();
            byte[] HeaderStart = encoder.GetBytes("|*START*OF*HEADER*|*");
            byte[] HeaderEnd = encoder.GetBytes("*|*END*OF*HEADER*|");
            byte[] FileSize; // Größe der aktuellen Datei
            byte[] Separator = encoder.GetBytes("||");
            byte[] FileName; // Name der aktuellen Datei

            MemoryStream TempStream = new MemoryStream();

            foreach (string file in files)
            {
                NormalFileStream = new FileStream(file, FileMode.Open);
                FileSize = encoder.GetBytes(NormalFileStream.Length.ToString());
                FileName = encoder.GetBytes(file.Substring(file.LastIndexOf('\\') + 1));

                TempStream.Write(HeaderStart, 0, HeaderStart.Length);
                TempStream.Write(Separator, 0, Separator.Length);
                TempStream.Write(FileSize, 0, FileSize.Length);
                TempStream.Write(Separator, 0, Separator.Length);
                TempStream.Write(FileName, 0, FileName.Length);
                TempStream.Write(HeaderEnd, 0, HeaderEnd.Length);

                Content = new byte[NormalFileStream.Length];
                NormalFileStream.Read(Content, 0, Content.Length);
                NormalFileStream.Close();
                TempStream.Write(Content, 0, Content.Length);
            }

            byte[] BigFileContent = new byte[TempStream.Length];
            TempStream.Position = 0;
            TempStream.Read(BigFileContent, 0, BigFileContent.Length);
            CompressStream.Write(BigFileContent, 0, BigFileContent.Length);
            CompressStream.Close();
        }

Die Dekomprimierung / Entpackung eines Archivs:
Die Komprimierung war der einfache Part, die Dekomprimierung gestaltet sich etwas schwieriger.
Die Methode zur Dekomprimierung erhält den Pfad und Namen des Archivs sowie den Pfad, in den die Dateien anhand ihrer ursprünglichen Namen entpackt werden sollen.
Zuerst müssen die Daten aus der Archivdatei dekomprimiert werden, hierzu wird diese mit einem GZipStream ausgelesen.
Der Inhalt dieses wird anschließend in einen MemoryStream kopiert und dieser schreibt seinen Inhalt in ein byte - Array (ist leichter über einen MemoryStream, deswegen der Umweg).
Das byte - Array wird mit einer Instanz der Klasse ASCIIEncoder in einen String umgewandelt.
Das Auswerten des Inhalts erfolgt in einer Endlosschleife, in jedem Durchlauf wird eine Datei behandelt.
Es gibt 2 Zeiger, die auf eine Position im String zeigen.
Der erste speichert die aktuelle Position, der zweite die aktuelle Suchposition.
Der erste steht immer auf der Position, an der der Header der aktuellen Datei anfängt, der zweite auf eine um 22 höhere Position (da wo die Dateigröße anfängt).
Da die Struktur des Headers bekannt ist (z.B. die Größe der ersten Datei beginnt ab Position 22 und geht bis zum ersten Vorkommen von "||" - deshalb steht die Suchposition auf einer um 22 höheren Position als die aktuelle Position, nach der Suchposition markiert das erste Vorkommen von "||" das Ende der Dateigröße, davor taucht noch ein "||" vor der Dateigröße aus.), können Dateigröße und Name ausgelesen werden.
Die aktuelle Position wird nun um die Länge des Headers inkrementiert.
Mit einem FileStream wird nun das byte - Array, welches den Inhalt der großen Datei speichert, von der aktuellen Position bis zur Position aktuelle Position zuzüglich aktueller Dateilänge, in eine neue Datei geschrieben, diese wird im übergebenen Verzeichnis angelegt und trägt den Namen der ursprünglichen Datei.
Die Positionszeiger werden anschließend um die Größe der aktuellen Datei erhöht.
Der Code:

        private void OpenArchive(string archiv, string decompressPath)
        {
            GZipStream DecompressStream = new GZipStream(new FileStream(archiv, FileMode.Open), CompressionMode.Decompress);
            FileStream NormalFileStream;
            MemoryStream TempStream = new MemoryStream();

            ASCIIEncoding decoder = new ASCIIEncoding();
            ASCIIEncoding Encoder = new ASCIIEncoding();

            string StringFromBytes; // String - Darstellung der eingelesenen Bytes
            int EndSize; // Position im Header, an welcher die Bezeichnung der Dateigröße zu Ende ist
            long FileLength; // Größe der aktuellen Datei
            int StartFileName; // Position im Header, an welcher die Bezeichnung des Dateinamens anfängt
            int EndFileName; // Position im Header, an welcher die Bezeichnung des Dateinamens aufhört
            string FileName; // Name der aktuellen Datei
            string EmptyHeader = "|*START*OF*HEADER*|*||||*|*END*OF*HEADER*|"; // "Prototyp" des Headers
            byte[] EmptyHeaderBytes = Encoder.GetBytes(EmptyHeader); // Prototyp als Bytes

            long CurrentPosition = 0; // aktuelle Position im Inhalt der Datei
            long CurrentSearchPosition = 22; // aktuelle Suchposition im Inhalt der Datei

            DecompressStream.CopyTo(TempStream);
            byte[] BigFileContent = new byte[TempStream.Length];
            TempStream.Position = 0;
            TempStream.Read(BigFileContent, 0, BigFileContent.Length);

            StringFromBytes = decoder.GetString(BigFileContent);

            while (true)
            {
                EndSize = StringFromBytes.IndexOf("||", (int)CurrentSearchPosition);
                FileLength = long.Parse(StringFromBytes.Substring((int)CurrentSearchPosition, EndSize - (int)CurrentSearchPosition)); // die Bezeichnung der Dateigröße geht von Position 22 im Header bis Position EndSize

                StartFileName = EndSize + 2;
                EndFileName = StringFromBytes.IndexOf("*|*", StartFileName);
                FileName = StringFromBytes.Substring(StartFileName, EndFileName - StartFileName); // Dateinamen auslesen

                CurrentPosition += EmptyHeaderBytes.Length + Encoder.GetBytes(FileLength.ToString()).Length + Encoder.GetBytes(FileName).Length;

                NormalFileStream = new FileStream(decompressPath + "\\" + FileName, FileMode.Create);
                NormalFileStream.Write(BigFileContent, (int)CurrentPosition, (int)FileLength);

                CurrentPosition += FileLength;
                CurrentSearchPosition = CurrentPosition + 22;
                NormalFileStream.Close();

                if (CurrentSearchPosition > BigFileContent.Length)
                    break;
            }

            DecompressStream.Close();
        }

Komprimierung mit C#, Teil 2 - Dateien komprimieren

2010-10-18T00:42:00.000+02:00

Heute setzte ich das Tutorial zu Komprimierungsmethoden in C# aus dem vorigen Post fort.
Während es im selbigen um das Grundprinzip und die Komprimierung / Dekomprimierung von einfachen Zeichenketten ging, zeige ich jetzt eine etwas fortgeschrittenere Anwendung dieser Prinzipien zum Komprimieren / Dekomprimieren von ganzen Dateien.

Die Kompression:
Wie bei der Komprimierung von Zeichenketten legen wir eine neue Instanz der Klasse GZipStream an und übergeben dieser im Konstruktor einen FileStream, der auf die Zieldatei zeigt.
Wir legen weiterhin einen anderen FileStream an, der auf die Quelldatei zeigt.
Mit diesem lesen wir nun den Inhalt der alten Datei in ein byte - Array.
Schreiben wir dieses nun mit der Methode Write() des GZipStreams, schreibt dieser den komprimierten Inhalt der Quelldatei in die Zieldatei - wir haben eine Datei komprimiert, fast so, als hätten wir sie per WinZip oder einem ähnlichen Programm zu einem Archiv hinzugefügt.
Öffnet man die komprimierte Datei mit einem Entpackungsprorgamm (z.B. WinZip), kann man das ursprüngliche Bild extrahieren und öffnen.
Der entsprechende Code dazu:

        private void CompressFile(string normalFile, string compressedFile)
        {
            GZipStream CompressStream = new GZipStream(new FileStream(compressedFile, FileMode.Create), CompressionMode.Compress);

            FileStream NormalFileStream = new FileStream(normalFile, FileMode.Open);
            byte[] Content = new byte[NormalFileStream.Length];
            NormalFileStream.Read(Content, 0, Content.Length);
            NormalFileStream.Close();

            CompressStream.Write(Content, 0, Content.Length);
            CompressStream.Close();
        }

Nun die Dekompression:
Hierfür wird im Konstruktor des GZipStreams ein FileStream, der auf die auszulesende, komprimierte Datei zeigt, übergeben.
Außerdem wird ein neuer FileStream angelegt, welcher auf die zu schreibende, dekomprimierte Datei zeigt.
Wie im vorigen Post auch zur Dekomprimierung benutzt, wird nun eine Endlosschleife eingesetzt, um die komprimierte Datei auszulesen.
Hierfür wird die Methode Read() des GZipStreams verwendet, welche die übergebene Anzahl an Bytes einliest und dabei dekomprimiert. Das Ergebnis wird in einem Buffer gespeichert, welcher dann über den FileStream in die neue Datei geschrieben wird.
Wurde das Ende der Datei erreicht, liest die Methode Read() weniger Bytes als in den Buffer passen würden, woran das Programm das Ende erkennt.
Die komprimierte Datei wurde nun entpackt und wieder als lesbare Datei angelegt.
Der Code dazu lautet:

        private void DecompressFile(string compressedFile, string normalFile)
        {
            GZipStream DecompressStream = new GZipStream(new FileStream(compressedFile, FileMode.Open), CompressionMode.Decompress);

            FileStream NormalFileStream = new FileStream(normalFile, FileMode.Create);

            int BytesReadCount = 0;
            byte[] Buffer = new byte[4096];

            while (true)
            {
                BytesReadCount = DecompressStream.Read(Buffer, 0, Buffer.Length);
                if (BytesReadCount != 0)
                {
                    NormalFileStream.Write(Buffer, 0, BytesReadCount);
                }
                if (BytesReadCount < Buffer.Length)
                    break;
            }

            NormalFileStream.Close();
            DecompressStream.Close();

        }

Webcam Chat

2010-10-17T16:22:00.001+02:00

Auf Anfrage eines Lesers habe ich mich kürzlich der Realisierung eines etwas aufwendigeren Projekts gewidmet, der Entwicklung eines in C# implementierten Webcam Chats.
Diesen möchte ich in diesem Post vorstellen, zum Verständnis sind einige Vorkenntnisse hilfreich:
- Den Code zur Einbindung einer Webcam habe ich mit Erlaubnis vom net-blog übernommen.
- Die Verbindung der Partner wird über TCP / IP hergestellt, hierzu gibt es eine Einführung auf diesem Blog (hier).
- Viele möchten sich sicherlich über das Internet mit Freunden vernetzen, wie die Verbindung darüber läuft und insbesondere welche IPs zu verwenden sind, findet ihr hier (und auch noch allgemeine Infos zur Vernetzung im LAN).
- Wie in Bild "gestreamt" werden kann wird in diesem Post erklärt.
- Und schließlich gibt's hier allgemeine Infos zum Fehler "Allgemeiner Fehler in GDI+", welcher sporadisch bei Grafikanwendungen auftritt.

Hier die Oberfläche des Programms:

In der linken PictureBox wird das Bild der eigenen Kamera angezeigt, in der rechten das des Chat Partners.
Der Chat Partner muss natürlich auch das gleiche Programm laufen haben.

Zur Funktionsweise:
Beim Klick auf den Button "Verbinden" werden 2 Threads gestartet, einer davon dient zum Senden des eigenen Bildes und der andere zum Empfangen des Bildes des anderen.
Der Senden - Thread läuft auf dem unter "eigener Port" angegebenen Port, der Empfangs - Thread über den unter "Partner Port".
Zum Verbinden müssen also logischerweise beide Partner die IP - Adresse des jeweiligen Partners eingeben sowie passende Ports, also Partner A den Port x unter "eigener Port" und Port y unter "Partner Port", Partner B muss diese Daten andersherum eingeben.
Im Senden - Thread wird ein Server erstellt, auf welchen sich der Client aus dem Empfangs - Thread des Clients verbindet.
In jeder Instanz des Programms gibt es also 2 Server - Client Verbindungen, die jeweils über einen Netzwerkstream kommunizieren.
In dem Senden - Thread wird in einer Endlosschleife versucht, das Bild der eigenen PictureBox über die Methode WriteImage() zu senden.
In dieser wird zuerst das Bild über einen temporären Stream in ein byte - Array geschrieben. Dann wird die Größe dieses Arrays in einen 20-stelligen String geschrieben, wobei die restlichen Stellen mit dem Buchstaben "x" aufgefüllt werden.
Die Größe und der eigentliche Inhalt des Bildes werden dann über den Netzwerkstream gesendet.
In dem Empfangs - Thread wird in einer Endlosschleife versucht, diesen Stream über die Methode ReadImage() auszulesen.
Als erstes werden hier in jedem Zyklus die ersten 20 Bytes ausgelesen, welches die Größe des Bildes sein sollten.
Kann der erhaltene String in eine sinnvolle Zahl g konvertiert werden, werden die nächsten g Bytes aus dem Netzwerkstream gelesen und daraus das Bild reproduziert.
Können die 20 Bytes nicht konvertiert werden, gab es einen Übertragungsfehler. Damit Server und Client sich wieder synchronisieren, muss der Stream gelöscht werden. Hierzu werden einfach so lange Bytes aus dem Stream herausgelesen, bis dieser leer ist.
Allgemein stellte sich die Realisierung der Datenübertragung als ziemlich schwer heraus, Server und Client wurden immer wieder asynchron und es traten viele Übertragungsfehler aus.
In der hier veröffentlichten Version werden bei Erfolg beim Senden und Empfangen eines Bildes die jeweiligen Bilder in einer Variablen gespeichert. Tritt an einer Stelle ein Fehler auf, wird das gespeicherte Bild wiederverwendet.
So, das sollte als Ablaufbeschreibung reichen, wie gesagt, die einzelnen Programmteile sollten bei Verständnis der oben erwähnten Themen leicht verständlich sein.
Ich weiß, diese Version hier ist nur ein erster Anfang, sie soll lediglich zu Demozwecken zeigen, wie ein solcher Webcam - Chat realisiert werden kann und kann beliebig erweitert werden.
Für Hinweise und Verbesserungsvorschläge bin ich aber immer dankbar.
Viel Spaß mit dem Programm!

Ein Setup, mit der sich der Webcam Chat installieren lässt, ist über diesen Link erreichbar.
Das komplette Projekt inklusive Quelldateien gibt es hier.
Und nun der Quellcode, zuerst der Inhalt der Datei Form1.cs und dann auch der Inhalt der Datei Form1.Designer.cs, kopiert ihr auch letztere in euer Projekt, habt ihr genau die gleiche Oberfläche wie ich.

Form1.cs:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

// für Webcam
using AForge.Video;
using AForge.Video.DirectShow;

// für Netzwerk
using System.IO;
using System.Net.Sockets;
using System.Net;

using System.Threading;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        #region Webcam

        //Unser Webcam Objekt
        VideoCaptureDevice videoSource;

        void InitWebCam(int nr)
        {
            //Auflistung aller Webcam/Videogeräte
            FilterInfoCollection videosources = new FilterInfoCollection(FilterCategory.VideoInputDevice);

            //Überprüfen, ob mindestens eine Webcam gefunden wurde
            if (videosources != null)
            {
                //Die Webcam "nr" an unser Webcam Objekt binden
                videoSource = new VideoCaptureDevice(videosources[nr].MonikerString);

                try
                {
                    //Überprüfen ob die Webcam Technische-Eigenschaften mitliefert
                    if (videoSource.VideoCapabilities.Length > 0)
                    {
                        string lowestSolution = "10000;0";
                        //Das Profil mit der niedrigsten Auflösung suchen
                        for (int i = 0; i < videoSource.VideoCapabilities.Length; i++)
                        {
                            if (videoSource.VideoCapabilities[i].FrameSize.Width < Convert.ToInt32(lowestSolution.Split(';')[0]))
                                lowestSolution = videoSource.VideoCapabilities[i].FrameSize.Width.ToString() + ";" + i.ToString();
                        }
                        //Dem Webcam Objekt die niedrigstmögliche Auflösung übergeben
                        videoSource.DesiredFrameSize = videoSource.VideoCapabilities[Convert.ToInt32(lowestSolution.Split(';')[1])].FrameSize;
                    }
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.ToString());
                }

                //Dem Webcam Objekt den NewFrame Eventhandler zuweisen.
                //Dieser schlägt bei jedem eingehenden Bild der Webcam an
                videoSource.NewFrame += new AForge.Video.NewFrameEventHandler(videoSource_NewFrame);

                //Die Webcam aktivieren
                videoSource.Start();
            }
        }

        void videoSource_NewFrame(object sender, AForge.Video.NewFrameEventArgs eventArgs)
        {
            //Jedes ankommende Bild von der Webcam der Picturebox zuweisen
            pictureBoxVideoSelf.BackgroundImage = (Image)eventArgs.Frame.Clone();
        }

        #endregion

        Image LastImageSent = null; // zuletzt korrekt gesendetes Bild
        Image LastImageReceived = null; // zuletzt korrekt empfangenes Bild

        Thread Sender; // Thread zum Senden von Bildern
        Thread Receiver; // Thread zum Empfangen von Bildern

        bool Closing = false; // true wenn Formular beendet werden soll
        String ClosingString = "FORM#CLOSING"; // Nachricht, die bei Beendigung geschickt wird
        byte[] ClosingBytes; // Byte - Darstellung der Nachricht
        ASCIIEncoding ByteConverter = new ASCIIEncoding(); // Objekt zur Konvertierung von Strings in byte - Arrays und umgekehrt

        private void button1_Click(object sender, EventArgs e)
        {
            // Thread zum Senden des eigenen Bildes starten
            Sender = new Thread(new ParameterizedThreadStart(this.Send));
            Sender.Start(int.Parse(textBox4.Text));

            // Thread zum Empfangen des Partnerbildes starten
            Receiver = new Thread(new ParameterizedThreadStart(Receive));
            Receiver.Start(textBox2.Text + "-" + textBox1.Text);

            ClosingBytes = ByteConverter.GetBytes(ClosingString);
        }

        private void Send(object port)
        {
            InitWebCam(int.Parse(textBox3.Text)); // Webcam starten

            TcpListener Server = new TcpListener(int.Parse(port.ToString()));
            Server.Start();

            TcpClient Client = Server.AcceptTcpClient();

            NetworkStream ClientStream = Client.GetStream();

            while (true)
            {
                if (Closing)
                    break; // Beendigung
                try
                {
                    // probieren, das aktuelle Bild an den Partner zu senden, dieses dann als Backupbild speichern
                    WriteImage((Image)pictureBoxVideoSelf.BackgroundImage.Clone(), ClientStream);
                    LastImageSent = (Image)pictureBoxVideoSelf.BackgroundImage.Clone();
                    Thread.Sleep(100);
                }
                catch
                {   // konnte das aktuelle Bild nicht gesendet werden, das Backupbild senden
                    WriteImage(LastImageSent, ClientStream);
                }
            }

            try
            {
                ClientStream.Write(ClosingBytes, 0, ClosingBytes.Length);
            }
            catch { };
        }

        private void Receive(object portip)
        {
            // portip hat die Form "port-ip"
            string[] Parameter = portip.ToString().Split('-');
            System.Net.IPAddress IP = System.Net.IPAddress.Parse(Parameter[1]);

            TcpClient Exchange = new TcpClient();
            NetworkStream ExchangeStream = null;

            Image TempImage;

            // alle 3 Sekunden versuchen eine Verbindung herzustellen
            while (true)
            {
                try
                {
                    Exchange.Connect(IP, int.Parse(Parameter[0]));
                    ExchangeStream = Exchange.GetStream();
                    break;
                }
                catch
                {
                    Thread.Sleep(3000);
                }
            }

            while (true)
            {
                if (Closing)
                    break; // Beendigung

                try
                {
                    // versuchen, das empfangene Bild zu lesen darzustellen
                    // bei Erfolg
                    TempImage = ReadImage(ExchangeStream);
                    if (TempImage == null)
                        throw new Exception();

                    pictureBoxVideoPartner.BackgroundImage = TempImage;
                    LastImageReceived = (Image)pictureBoxVideoPartner.BackgroundImage.Clone();
                    Thread.Sleep(100);
                }
                catch
                {
                    try
                    {   // bei Fehler das Backupbild darstellen
                        pictureBoxVideoPartner.BackgroundImage = LastImageReceived;
                    }
                    catch { }
                }
            }
        }

        private void WriteImage(Image image, NetworkStream stream)
        {
            ASCIIEncoding Encoder = new ASCIIEncoding();
            MemoryStream TempStream = new MemoryStream();
            byte[] Buffer;

            try
            {
                // das übergebene Bild in den aktuellen Stream schreiben
                image.Save(TempStream, System.Drawing.Imaging.ImageFormat.Gif);
            }
            catch
            {
            }

            Buffer = TempStream.ToArray();

            // die Größe des Bildes als 20-stelligen String darstellen, mit "x" auffüllen
            string ImageSize = Buffer.Length.ToString();
            while (ImageSize.Length < 20)
                ImageSize += "x";

            // die Größe plus die Daten des Bildes in ein Array schreiben
            byte[] FittedImageSize = Encoder.GetBytes(ImageSize);
            byte[] ImagePlusSize = new byte[FittedImageSize.Length + Buffer.Length];
            Array.Copy(FittedImageSize, ImagePlusSize, FittedImageSize.Length);
            Array.Copy(Buffer, 0, ImagePlusSize, FittedImageSize.Length, Buffer.Length);

            try
            {
                // das zusammengefasste Array schreiben
                stream.Write(ImagePlusSize, 0, ImagePlusSize.Length);
                stream.Flush();
            }
            catch
            {
                // kann der Stream nicht mehr beschrieben werden, hat der Partner beendet
                Closing = true;
            }
        }

        private Image ReadImage(NetworkStream stream)
        {
            Image Result;
            int BytesRead;

            // die ersten 20 Bytes des Streams einlesen, denn in diesen ist die Größe kodiert
            byte[] ImageSize = new byte[20];
            BytesRead = stream.Read(ImageSize, 0, 20);

            /* konnten nur 12 Bytes gelesen werden und haben diese den Inhalt des
            Closing Strings, so soll beendet werden */
            if (BytesRead == 12)
            {
                if (ByteConverter.GetString(ImageSize, 0, 12) == "FORM#CLOSING")
                {
                    Closing = true;
                    return null;
                }
            }

            byte[] ErrorBuffer = new byte[100000000];

            ASCIIEncoding Decoder = new ASCIIEncoding();
            string ImageSizeString = Decoder.GetString(ImageSize).Replace("x", "");

            int TestSize;

            if (!int.TryParse(ImageSizeString, out TestSize))
            {
                stream.Read(ErrorBuffer, 0, ErrorBuffer.Length);
                return null;
            }

            byte[] ImageFile = new byte[int.Parse(ImageSizeString)];

            stream.Read(ImageFile, 0, ImageFile.Length);

            MemoryStream temps = new MemoryStream();

            try
            {
                temps.Write(ImageFile, 0, ImageFile.Length);
                Result = Image.FromStream(temps);
                return Result;
            }
            catch
            {
                return null;
            }
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            //Webcam beim Schließen des Programms wieder freigeben
            if (videoSource != null && videoSource.IsRunning)
            {
                videoSource.SignalToStop();
                videoSource = null;
            }

            Closing = true;

            Thread.Sleep(3000);

            if (Sender != null && Sender.IsAlive)
                Sender.Abort();

            if (Receiver != null && Receiver.IsAlive)
                Receiver.Abort();
        }
    }
}

Form1.Designer.cs:

namespace WindowsFormsApplication1
{
    partial class Form1
    {
        /// <summary>
       /// Erforderliche Designervariable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
       /// Verwendete Ressourcen bereinigen.
        /// </summary>
        /// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Vom Windows Form-Designer generierter Code

        /// <summary>
       /// Erforderliche Methode für die Designerunterstützung.
       /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
        /// </summary>
        private void InitializeComponent()
        {
            this.pictureBoxVideoSelf = new System.Windows.Forms.PictureBox();
            this.button1 = new System.Windows.Forms.Button();
            this.pictureBoxVideoPartner = new System.Windows.Forms.PictureBox();
            this.label1 = new System.Windows.Forms.Label();
            this.label2 = new System.Windows.Forms.Label();
            this.label3 = new System.Windows.Forms.Label();
            this.label4 = new System.Windows.Forms.Label();
            this.textBox1 = new System.Windows.Forms.TextBox();
            this.textBox2 = new System.Windows.Forms.TextBox();
            this.textBox3 = new System.Windows.Forms.TextBox();
            this.textBox4 = new System.Windows.Forms.TextBox();
            this.label5 = new System.Windows.Forms.Label();
            ((System.ComponentModel.ISupportInitialize)(this.pictureBoxVideoSelf)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.pictureBoxVideoPartner)).BeginInit();
            this.SuspendLayout();
            //
            // pictureBoxVideoSelf
            //
            this.pictureBoxVideoSelf.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch;
            this.pictureBoxVideoSelf.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.pictureBoxVideoSelf.Location = new System.Drawing.Point(47, 26);
            this.pictureBoxVideoSelf.Name = "pictureBoxVideoSelf";
            this.pictureBoxVideoSelf.Size = new System.Drawing.Size(331, 210);
            this.pictureBoxVideoSelf.TabIndex = 0;
            this.pictureBoxVideoSelf.TabStop = false;
            //
            // button1
            //
            this.button1.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.button1.Location = new System.Drawing.Point(326, 263);
            this.button1.Name = "button1";
            this.button1.Size = new System.Drawing.Size(154, 46);
            this.button1.TabIndex = 1;
            this.button1.Text = "Verbinden";
            this.button1.UseVisualStyleBackColor = true;
            this.button1.Click += new System.EventHandler(this.button1_Click);
            //
            // pictureBoxVideoPartner
            //
            this.pictureBoxVideoPartner.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch;
            this.pictureBoxVideoPartner.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.pictureBoxVideoPartner.Location = new System.Drawing.Point(398, 26);
            this.pictureBoxVideoPartner.Name = "pictureBoxVideoPartner";
            this.pictureBoxVideoPartner.Size = new System.Drawing.Size(319, 210);
            this.pictureBoxVideoPartner.TabIndex = 3;
            this.pictureBoxVideoPartner.TabStop = false;
            //
            // label1
            //
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(25, 281);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(0, 13);
            this.label1.TabIndex = 4;
            //
            // label2
            //
            this.label2.AutoSize = true;
            this.label2.Location = new System.Drawing.Point(47, 249);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(54, 13);
            this.label2.TabIndex = 5;
            this.label2.Text = "Partner IP";
            //
            // label3
            //
            this.label3.AutoSize = true;
            this.label3.Location = new System.Drawing.Point(47, 273);
            this.label3.Name = "label3";
            this.label3.Size = new System.Drawing.Size(63, 13);
            this.label3.TabIndex = 6;
            this.label3.Text = "Partner Port";
            //
            // label4
            //
            this.label4.AutoSize = true;
            this.label4.Location = new System.Drawing.Point(47, 321);
            this.label4.Name = "label4";
            this.label4.Size = new System.Drawing.Size(73, 13);
            this.label4.TabIndex = 7;
            this.label4.Text = "Webcam - Nr.";
            //
            // textBox1
            //
            this.textBox1.Location = new System.Drawing.Point(128, 249);
            this.textBox1.Name = "textBox1";
            this.textBox1.Size = new System.Drawing.Size(158, 20);
            this.textBox1.TabIndex = 8;
            //
            // textBox2
            //
            this.textBox2.Location = new System.Drawing.Point(128, 273);
            this.textBox2.Name = "textBox2";
            this.textBox2.Size = new System.Drawing.Size(158, 20);
            this.textBox2.TabIndex = 9;
            //
            // textBox3
            //
            this.textBox3.Location = new System.Drawing.Point(128, 321);
            this.textBox3.Name = "textBox3";
            this.textBox3.Size = new System.Drawing.Size(158, 20);
            this.textBox3.TabIndex = 10;
            this.textBox3.Text = "0";
            //
            // textBox4
            //
            this.textBox4.Location = new System.Drawing.Point(128, 297);
            this.textBox4.Name = "textBox4";
            this.textBox4.Size = new System.Drawing.Size(158, 20);
            this.textBox4.TabIndex = 10;
            //
            // label5
            //
            this.label5.AutoSize = true;
            this.label5.Location = new System.Drawing.Point(47, 297);
            this.label5.Name = "label5";
            this.label5.Size = new System.Drawing.Size(64, 13);
            this.label5.TabIndex = 11;
            this.label5.Text = "eigener Port";
            //
            // Form1
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(758, 370);
            this.Controls.Add(this.textBox4);
            this.Controls.Add(this.label5);
            this.Controls.Add(this.textBox3);
            this.Controls.Add(this.textBox2);
            this.Controls.Add(this.textBox1);
            this.Controls.Add(this.label4);
            this.Controls.Add(this.label3);
            this.Controls.Add(this.label2);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.pictureBoxVideoPartner);
            this.Controls.Add(this.button1);
            this.Controls.Add(this.pictureBoxVideoSelf);
            this.Name = "Form1";
            this.Text = "C# Webcam Chat";
            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.Form1_FormClosing);
            ((System.ComponentModel.ISupportInitialize)(this.pictureBoxVideoSelf)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.pictureBoxVideoPartner)).EndInit();
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.PictureBox pictureBoxVideoSelf;
        private System.Windows.Forms.Button button1;
        private System.Windows.Forms.PictureBox pictureBoxVideoPartner;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.Label label3;
        private System.Windows.Forms.Label label4;
        private System.Windows.Forms.TextBox textBox1;
        private System.Windows.Forms.TextBox textBox2;
        private System.Windows.Forms.TextBox textBox3;
        private System.Windows.Forms.TextBox textBox4;
        private System.Windows.Forms.Label label5;
    }
}

Komprimierung mit C#, Teil 1 - einfache Strings

2010-10-15T19:52:00.004+02:00

Das .Net Studio bringt standardmäßig eine Klasse zur Komprimierung und Dekomprimierung von Daten im gzip Format mit sich, System.IO.Compression.GZipStream.
gzip ist ein gutes, offen verfügbares Format, welches, für technisch Interessierte, zur Komprimierung, ähnlich wie das ZIP - Format, den Deflate Algorithmus verwendet.
Die Klasse GZipStream ist ein Stream, wie herkömmliche Streams können mit ihr Daten geschrieben und gelesen werden, nur werden diese dabei direkt komprimiert bzw. dekomprimiert.
Als erstes Anwendungsbeispiel werde ich eine einfache Möglichkeit zur (De-)Komprimierung von Zeichenketten in (bzw. aus) einer Datei zeigen.
Für alle folgenden Codebeispiele werden die Anweisungen

using System.IO.Compression;
using System.IO;

benötigt.

Zuerst zur Komprimierung: Die Klasse GZipStream erwartet einen Stream im Konstruktor, in den die Daten hinein komprimiert werden sollen sowie den Komprimiermodus (hier CompressionMode.Compress).
Als Stream geben wir einen FileStream an, der auf die Datei zeigt, in welche der komprimierte String geschrieben werden soll.
Die Klasse GZipStream kann nur Bytes lesen und schreiben, daher muss der zu komprimierende String in ein byte - Array umgewandelt werden, was die Klasse ASCIIEncoding erledigt.
Das erhaltene Array wird dann mittels Write() geschrieben, der GZipStream komprimiert die Byte - Folge und schreibt sie über den FileStream in eine Datei.
Und so sieht der dazu passende Code aus:

private void CompressString(string uncompressedString)
{
    GZipStream CompressStream = new GZipStream(new FileStream(Application.StartupPath + "\\CompressedString.gz", FileMode.Create), CompressionMode.Compress);
    ASCIIEncoding Encoder = new ASCIIEncoding();
    byte[] UncompressedStringInBytes = Encoder.GetBytes(uncompressedString);
    CompressStream.Write(UncompressedStringInBytes, 0, UncompressedStringInBytes.Length);
    CompressStream.Close();
}

Der der Methode CompressString übergebene String wird in die Datei "CompressedString.gz" im Anwendungsverzeichnis geschrieben, .gz ist die Dateiendung für gzip - Dateien.
Die Datei kann mit herkömmlichen Entpackungsprogrammen (z.B. WinZip) entpackt werden, öffnet man die entpackte Datei mit einem Texteditor findet man den ursprünglichen String wieder.

Nun zum umgekehrten Fall, der Dekomprimierung des Strings aus der Datei:
Die Klasse GZipStream erwartet im Konstruktor wieder einen Stream, dieses Mal den Stream, aus welchem die komprimierten Daten gelesen werden sollen, und den Komprimiermodus (hier CompressionMode.Decompress).
Wir übergeben als Stream wieder einen FileStream.
Das Auslesen der Datei erfolgt nun durch eine Endlosschleife, in dieser wird jedes Mal über die Methode Read() des GZipStreams ein byte - Array in einen Buffer gelesen.
Die gelesenen Bytes werden über die Klasse ASCIIEncoding in einen String umgewandelt, wurden in einem Durchlauf weniger Bytes gelesen als der Buffer groß ist, ist die Datei offensichtlich zu Ende und die Schleife wird beendet.
Der Code:

        private string DecompressString(string compressedFile)
        {
            GZipStream DecompressStream = new GZipStream(new FileStream(Application.StartupPath + "\\CompressedString.gz", FileMode.Open), CompressionMode.Decompress);
            byte[] Buffer = new byte[4096];
            ASCIIEncoding Decoder = new ASCIIEncoding();
            int BytesReadCount = 0;
            string DecompressedString = "";

            while (true)
            {
                BytesReadCount = DecompressStream.Read(Buffer, 0, Buffer.Length);
                if (BytesReadCount != 0)
                {
                    DecompressedString += Decoder.GetString(Buffer, 0, BytesReadCount);
                }
                if (BytesReadCount < Buffer.Length)
                    break;
            }

            DecompressStream.Close();
            return (DecompressedString);
        }

Der Aufruf der beiden Methoden könnte zum Beispiel so aussehen:

CompressString("Dies ist ein Test 123456.");
string DecompressedString = DecompressString(Application.StartupPath + "\\CompressedString.gz");

Startseite des Internet Explorers auslesen / ändern

2010-10-13T17:34:00.000+02:00

Die Startseite des Internet Explorers wird in der Registry gespeichert, und zwar im Schlüssel HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main\Start Page.
Diese Information kann nun einfach mit C# ausgelesen und beliebig verändert werden.
Ein kleines Tutorial zur Benutzung der Registry mit C# gab es hier.
Da so die benutzten Methoden bekannt sein sollten, poste ich hier nur kurz den Programmcode.
Zuerst eine Methode, die die Startseite des Internet Explorers ausliest und als String zurückgibt:

private string GetIEStartPage()
{
RegistryKey StartPageKey = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Internet Explorer\Main"); // entsprechenden Pfad in der Registry öffnen
return StartPageKey.GetValue("Start Page").ToString(); // den Wert aus dem Schlüssel "Start Page" auslesen und zurückgeben
}

Nun noch die Methode zum Ändern der Startseite, diese erwartet die neue Startseite als String - Parameter:

private void SetIEStartPage(string newStartPage)
{
RegistryKey StartPageKey = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Internet Explorer\Main", true); // entsprechenden Pfad in der Registry mit Schreibrechten öffnen
StartPageKey.SetValue("Start Page", newStartPage); // den neuen Wert in den Schlüssel "Start Page" schreiben
}

Computername herausfinden

2010-10-11T08:00:00.000+02:00

Um mit C# den Namen des eigenen Computers herauszufinden, gibt es 2 einfache Möglichkeiten:
Über die Klasse Dns (using System.Net wird benötigt):

string ComputerName = Dns.GetHostName();

Und über die Klasse SystenInformation:

string ComputerName = System.Windows.Forms.SystemInformation.ComputerName.ToString();

HTML - Seiten mit dem Webbrowser Steuerlement aufrufen

2010-10-08T08:00:00.005+02:00

In C# gibt es ein fertiges Steuerelement, mit dem sich Internetseiten wie im Browser aufrufen lassen.
Das Steuerelement heißt WebBrowser und befindet sich standardmäßig schon in der Toolbox.
Zieht man es auf ein Formular, erstreckt es sich wahrscheinlich standardmäßig über dessen ganze Breite, ist dieses nicht gewünscht, kann man die Eigenschaft Dock ändern.
So sieht ein Teil dieses Blogs im WebBrowser aus:

Nun möchte ich ein paar Methoden dieses Steuerlements beschreiben:

Navigate(): Dieses ist wohl die wichtigste Methode, mit ihr kann man Seiten im WebBrowser Steuerelement aufrufen. Sie erwartet in einer Überladung einen String als Parameter, welcher dann als Zieladresse interpretiert wird.

GoHome(): Navigiert zur Startseite des aktuellen Benutzers.

GoSearch(): Navigiert zur Seite der Standardsuchmaschine des aktuellen Benutzers.

Print(): Druckt die aktuelle Seite des Browsersteuerelements mit den aktuellen Druckeinstellungen des Systems.

ShowPrintDialog(): Ruft den "Drucken" Dialog des Internet Explorers auf, um die aktuelle Seite zu drucken.

ShowSaveAsDialog(): Öffnet den Dialog "Seite speichern", um die aktuelle Seite als HTML - Dokument zu speichern.

Zum Schluss noch ein Link zu einer meiner Meinung nach sehr informativen Seite zum Thema Webbrowser, auf der auch ein kostenlos E-Book zu diesem Thema verfügbar ist:
readup.de