Heute möchte ich euch zeigen, wie man mit minimalem Aufwand und wenigen Zeilen C#-Code Webcams ansteuern/nutzen kann.
Es gibt zwar schon einiges an Material zu diesem Thema, jedoch sind die meisten der Beiträge ziemlich lang und kompliziert oder verwenden WIA Scripting welches in der häufig vorgestellten Form nur auf Windows XP richtig rund läuft.
Meine Lösung  basiert auf dem AForge.NET Framework. Benötigt werden die beiden folgenden Dlls.

• AForge.Video.dll
• AForge.Video.DirectShow.dll

Diese findet ihr im jeweils aktuellsten “libs only” .zip-Archiv auf der AForge Downloadseite.

Designer

Wenn ihr euch die Dlls besorgt habt, kann es auch schon losgehen. Zuerst erstellt ihr ein neues WinForms-Projekt im Visual Studio und fügt bei den Verweisen die beiden AForge Dlls hinzu.  (Rechtsklick auf “Verweise” >> “Verweis hinzufügen” und dann im “Durchsuchen”-Tab die Dlls auswählen.)

 

Nun fügen wir unserem Form noch eine PictureBox hinzu und konfigurieren diese im “Eigenschaften”-Fenster des VS wie folgt. (Eigenschaft >> Wert)

• (Name) >> pictureBoxVideo
• BackgroundImageLayout >> Zoom
• Dock >> Fill

Nun legen wir noch zwei Methoden für das FormClosed- und das Load-Event unseres Forms an.
Das war’s auch schon, was wir im Designer zu verrichten hatten. Nun fehlt nur noch der Code. Das dieser ziemlich kurz ist, bauen ich ihn hier im Blog nicht Schritt für Schritt auf, sondern poste ihn, gut kommentiert, im ganzen.

Code

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;
//Einbinden der AForge Librarys
using AForge.Video;
using AForge.Video.DirectShow;

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

        //Unser Webcam Objekt
        VideoCaptureDevice videoSource;

        private void Form1_Load(object sender, EventArgs e)
        {
            //Auflistung aller Webcam/Videogeräte
            FilterInfoCollection videosources = new FilterInfoCollection(FilterCategory.VideoInputDevice);

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

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

                        //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
            pictureBoxVideo.BackgroundImage = (Bitmap)eventArgs.Frame.Clone();
        }

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

    }
}

 

Das war’s auch schon. Abschließend könnt ihr das Demo-Projekt auch hier downloaden. Solltet ihr noch Fragen, Kritik oder Verbesserungsvorschläge haben, dann schreibt mir einfach einen Kommentar.

 

Viele Grüße,
Raffi

Mal schnell ein kleiner Tipp aus der C# Ecke. Popups nerven – vor allem, wenn das Webbrowsercontrol unsichtbar ist und eine Anwendung, dem User völlig unersichtlich, eben diese generiert/zulässt.
Nach endlosem googlen und herum probieren musste ich mal wieder feststellen, wie simpel und einfach das Leben Mit C# und Visual Studio doch ist.

Also – wie blockt man Popups, die von einem Webbrowser Control ausgehen?

Um die Popups zu blocken muss dem Webbrowser Control zuerst ein NewWindow Eventhandler hinzugefügt werden. Ob ihr dies von Hand, oder über die Property Box macht, ist ja bekannter weise egal.

Im zweiten Schritt reicht dann schon eine einzige Zeile Code, um die Popups in die ewigen Jagdgründe zu schicken.

private void webBrowser2_NewWindow(object sender, CancelEventArgs e)
{
e.Cancel = true;
}

Also – Popups ade!

Viele Grüße,
Raffi

NotifyIcon ContextMenu ohne Rechtsklick öffnen

Wieder mal ein Beispiel aus der Kategorie “Kleiner Code, großer Effekt”.
Hat man eine Tray-Anwendung und möchte, dass das ContextMenu zum Beispiel auch über einen Doppelklick aufgerufen werden kann, so wird man schmerzlich feststellen, dass ein Aufruf alá ContextMenuStrip.Show() im DoubleClick-Event des NotifyIcon leider auch ein Anzeigen des ContextMenuStrips in der Taskleiste mit sich bringt.

Um das ContextMenu über einen beliebigen beliebigen Click-Eventhandler eines NotifyIcon anzuzeigen, ohne dass es zusätzlich in der Taskbar angezeigt wird, ist folgender Code notwendig:

private void ShowContextMenu(NotifyIcon nI, MouseEventArgs e)
        {
            if (e.Button != MouseButtons.Right)
            {
                nI.GetType().InvokeMember(
                "ShowContextMenu",
                BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.NonPublic,
                null,
                nI,
                null
                );
            }
        }

 

Am Beispiel eines Doppelklicks auf mein NotifyIcon TrayIcon sähe das dann wie folgt aus:

private void TrayIcon_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            ShowContextMenu((NotifyIcon)sender, e);
        }

Ich hoffe es hilft dem ein oder anderen von euch!

viele Grüße,
euer Raffi

Klassen generieren mit der XSD.exe

Bis vor kurzer Zeit schrieb ich mir sämtlichen Code für den Zugriff auf XML Dateien mit Hilfe der vom .Net Framework bereitgestellten Klassen mühselig von Hand zusammen. Wie gesagt – bis vor kurzem.

Da ich zu Hause nur mit der kostenlosen Express Edition des Visual Studio arbeite lief mir die xsd.exe bisher nicht über den Weg. Dabei erspart sie einem bei dem Zugriff auf XML-Dateien eine Menge Arbeit. So lässt sich mittels dieser .exe im Handumdrehen eine Klasse aus einer beliebigen XML-Datei generieren, die den Zugriff auf eben diese um Welten erleichtert. Wie das funktioniert möchte ich euch im folgenden anhand des ARD Tagesschau Feeds zeigen. (Bilder zum Vergrößern einfach anklicken. )

1 – Feed speichern

Als erstes speichern wir den besagten Feed als XML Datei ab. Dazu öffnet ihr den Feed einfach in eurem Browser und klickt im Menü auf “Seite speichern unter”.
In manchen Browsern, wie zum Beispiel im Firefox, müsst ihr beim Speichern noch die Datei Endung auf .xml anpassen.

2a – Konsole öffnen (Visual Studio Express Edition)

Öffnet die Konsole
(Start >> Ausführen >> cmd)
und wechselt in den “bin”-Ordner
des Microsoft SDKs.
Normalerweise findet ihr
diesen an folgender Stelle:

“C:\Programme\Microsoft SDKs\Windows\{version}\bin”

2b – Konsole öffnen (Visual Studio Professional, Enterprise, etc. Edition)

Öffnet die Visual Studio Tools Konsole.

3 – XML-Datei –> XSD Schema –> Klasse

(Um elendig langen Pfadangaben aus dem Weg zu gehen habe ich die in Schritt 1 gespeicherte XML-Datei in einen hierfür angelegten Ordner “xml” auf Laufwerk C:\ abgelegt.)
Als nächstes generieren wir ein XSD Schema aus unserer XML-Datei. Hierfür geben wir folgenden Befehl in die Konsole ein.

xsd c:\xml\index.xml /outputdir:c:\xml

Um aus der soeben erstellen .xsd-Datei unsere gewünschte Klasse zu generieren ist nun nur noch folgender Aufruf nötig.

xsd c:\xml\index.xsd /outputdir:c:\xml /classes

Das war es eigentlich schon. Nun haben wir aus unserer XML-Datei ein XSD Schema und daraus eine Klasse für die Verwendung in C#.Net erstellt. Was genau man damit anstellen kann folgt im nächsten Schritt.

4 – Verwendung und Aufruf der generierten Klasse

Um euch zu demonstrieren, wie und an welcher Stelle man die generierte Klasse sinnvoll nutzen kann habe ich eine kleine Testapplikation erstellt.
Da wir uns in diesem Tutorial als Test-XML an dem RSS Feed der Tagesschau vergriffen haben, liegt es nahe einen kleinen Nachrichtenleser zu basteln.

Legt also ein neues Windows Forms Projekt an und stattet eurer Main Form mit den folgenden vier Controls aus:

• ListBox
• Label
• RichTextBox
• Linklabel

Im nächsten Schritt binden wir die generierte Klasse ein. Hierzu reicht ein Rechtsklick im Projektexplorer auf unserer Projekt und dann ein Linksklick auf “vorhandenes Element hinzufügen”. Nun nur noch schnell die erstelle Klasse auswählen und mit Ok bestätigen.
Jetzt binden wir den Namespace System.Net ein, definieren 2 Variablen, einen String namens Link, sowie ein rss object unserer generierten Klasse und legen das Load Event unseres Main Forms, das Click Event der ListBox und das LinkClicked Event des LinkLabels an. Der Code eures Main Forms sollte nun wie folgt aussehen.

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.Net;

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

 private rss rssbase;
 private string link;

 private void Form1_Load(object sender, EventArgs e)
 {

 }

 private void listBoxPosts_Click(object sender, EventArgs e)
 {

 }

 private void linkLabelPost_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
 {

 }
 }
}

Im nächsten Schritt befüllen wir die Events. Die Erklärungen hierzu entnehmt ihr bitte den Kommentaren im Code. Sollten sich Fragen auftun, dann schreibt bitte einen Kommentar!

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.Net;

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

 private rss rssbase;
 private string link;

 private void Form1_Load(object sender, EventArgs e)
 {
 //Erstelle HttpWebRequest für den Taggeschau Feed
 HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create("http://www.tagesschau.de/xml/tagesschau-meldungen/");
 HttpWebResponse res = (HttpWebResponse)req.GetResponse();

 //Lege Kodierung fest, damit Sonderzeichen richtig angezeigt werden.
 //Der passende Encoding String ist dem Header des Feeds zu entnehmen.
 //(Im Browser: Rechtsklick >> Quelltext anzeigen)
 Encoding encode = System.Text.Encoding.GetEncoding("ISO-8859-1");

 //Öffne einen Streamreader mit dem Response Stream, der den Feed enthält
 //und lege Kodierung fest.
 System.IO.StreamReader str = new System.IO.StreamReader(res.GetResponseStream(), encode);

 //Initialisiere einen XMLSerializer mit dem Schema (typeof(rss)) unseres Feeds.
 System.Xml.Serialization.XmlSerializer xSerializer = new System.Xml.Serialization.XmlSerializer(typeof(rss));

 //Deserialisiere unsere Feed nach dem Schema.
 rssbase = (rss)xSerializer.Deserialize(str);

 //Gibt an ob es sich um das erste Objekt in der folgenden Schleife handelt.
 bool first = true;

 //Durchlaufe alle Items. Jedes Item enthält die Elemente
 //(Titel, Beschreibung, etc.) einer Nachricht des Feeds
 foreach (rssChannelItem item in rssbase.channel[0].item)
 {
 if (first)
 {
 //Weise die Daten des ersten Items unseren
 //Controls zu.
 first = false;
 labelTitel.Text = item.title;
 richTextBoxMessage.Text = item.description;
 link = item.link;
 }
 //Füge der ListBox einen Eintrag mit dem Titel
 //der aktuellen Nachricht hinzu.
 listBoxPosts.Items.Add(item.title);
 }
 str.Close();
 }

 private void listBoxPosts_Click(object sender, EventArgs e)
 {
 //Durchlaufe alle Items/Nachrichten des Feeds
 foreach (rssChannelItem item in rssbase.channel[0].item)
 {
 if (item.title == listBoxPosts.SelectedItem.ToString())
 {
 //Entspricht die aktuelle Nachricht der in der Listbox
 //angeklickten, so weise den Controls die entsprechenden
 //Werte zu.
 labelTitel.Text = item.title;
 richTextBoxMessage.Text = item.description;
 link = item.link;
 }
 }
 }

 private void linkLabelPost_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
 {
 //Rufe den angeklickten Link im Standard Browser auf
 System.Diagnostics.Process.Start(link);
 }
 }
}

An dieser Stelle sind wir eigentlich schon fertig. Wenn nichts schief gelaufen ist, dann sollte sich euch nach einem Druck auf die F5-Taste ein ähnlicher Anblick, wie auf dem Bild, bieten.

Durch klicken auf die Überschriften in der ListBox könnt ihr euch eine Vorschau der jeweiligen Nachricht anzeigen lassen. Mit einem Klick auf das Linklabel – ich habe ihm den Text “weiterlesen…” gegeben – gelangt ihr zur Originalversion der Nachricht.

Soweit alles klar? Kamt ihr zurecht? Hinterlasst mir einen Kommentar!

Liebe Grüße,
Raffi

p.s.: Leider weist die xsd.exe einen kleinen Bug auf, was verschachtelte Elemente beziehungsweise JaggedArrays angeht. Solltet ihr bei euren Versuchen darüber stolpern, schaut die Tage noch mal rein. Ein kleines Workaround diesbezüglich wird folgen!

Online RegEx Pattern Generator

Heute geht’s um RegEx (Regular Expressions –> Reguläre Ausdrücke). Der eine mag sie, der andere wohl eher nicht. Aber eines ist klar, wenn das Pattern/die Pattern erst mal stehen, dann ersparen sie einem eine Menge Arbeit.
Bis dahin ist es manchmal jedoch ein recht beschwerlicher Weg und auch ich, obwohl ich mich eigentlich zu den Leuten zähle die RegEx mögen, habe schon das ein oder andere Mal fürchterlich geflucht, wenn das Pattern auch beim 50ten Mal noch nicht richtig gematched hat.

Deshalb möchte ich euch heute auf eine Webseite hinweisen, auf der ihr euch euer passendes Pattern zusammenklicken könnt. Auf txt2re gebt ihr euren zu untersuchenden String ein und könnt danach anklicken, welche Teile davon gematched (schreibt man das eigentlich so und wie heißt das deutsche Pendant dazu?) werden sollen.

Habt ihr alles konfiguriert könnt ihr euch mit einem Klick das passende Pattern wahlweise in C#.Net, Perl, PHP, Python, Java, Javascript, ColdFusion, C, C++, Ruby, VB, VBScript, J#, C++.Net, oder VB.net anzeigen lassen.

Ok, zugegeben die Patterns sind nicht gerade schlank, aber dazu kann man das ganze zum Beispiel ja noch mit dem Regex-Lab von herbivore testen und optimieren.

Wer generell noch Lesebedarf hat, oder sein Wissen um die Verwendung in C# und den Grundlegenden Aufbau noch etwas auffrischen mag, kann sich zum Beispiel das Tutorial von webstarg zu Gemüte führen.

Wie sieht das eigentlich bei euch aus? Mögt ihr RegEx und wie oft benötigt ihr sie überhaupt?

Liebe Grüße,
Raffi