Dienstag, 31. August 2010

Youtube Video mit C# abspielen

Um Youtube Videos mit C# abzuspielen, ist das Windows Media Player Control nötig, wie schon im Post zum Abspielen von mp3 - Dateien.
Das Steuerelement lässt sich in die Toolbox hinzufügen, in dem man rechts auf diese klickt und dann Element auswählen ... anwählt, im sich öffnenden Fenster zu COM - Steuerelementen wechselt und Windows Media Player auswählt.
Die abzuspielende Multimediadatei lässt sich über die Eigenschaft URL bestimmen. Im Prinzip kann jetzt einfach die Adresse des Youtube Videos als URL gespeichert werden und der Media Player spielt das Video auf dem C# Formular ab. Allerdings muss der direkte Pfad zum Video angegeben werden und nicht die URL - Adresse, unter der das Video online betrachtet werden kann. Statt dem Infix "watch?v=" ist "/v/" nötig, welches den Ordner bezeichnet, in dem die Youtube Videos liegen.
Im Video darf außerdem die Option Einbetten nicht deaktiviert sein.
Ein Beispiel:
Im Browser lässt sich ein Video unter dem Link "http://www.youtube.com/watch?v=8EbtaLNHluE" öffnen, das Steuerlement benötigt aber den Link "http://www.youtube.com/v/8EbtaLNHluE".
Folgender Code lädt das Video in den Media Player, das Video kann dann per Klick auf "Play" im Video Fenster gestartet werden:

axWindowsMediaPlayer1.URL = "http://www.youtube.com/v/8EbtaLNHluE";

Die folgende Beispielfunktion ändert die URL automatisch, sie nimmt also als Parameter den Online Link zum Youtube Video entgegen und spielt dieses dann ab:

private void PlayVideo(string url)
{
    axWindowsMediaPlayer1.URL = url.Replace("watch?v=", "/v/");
}

Montag, 30. August 2010

VLC Player einbinden

Ein Kommentar vom Benutzer Tingel regte mich zum Schreiben dieses Posts an.
Er wollte nämlich, zum Abspielen einer Audiodatei mit C#, statt dem Windows Media Player wie hier beschrieben, einen guten OpenSource Player verwenden.
Der beste kostenlose Player ist meiner Meinung nach der VLC Player, also durchforstete ich das Internet nach Wegen, diesen in eine C# Anwendung einzubinden.
Das ist auch tatsächlich möglich, es geht wahrscheinlich auch mit anderen Playern, diese müssen nur eine öffentliche Schnittstelle zur Einbindung anbieten.
Beim VLC Player ist diese in Gestalt einer ActiveX Komponente vorhanden, welche als .dll Datei ausgeliefert wird.
So ist gleich bei der Installation des Players wichtig, dass der Menüpunkt "ActiveX Komponente" ausgewählt wird (ist aber standardmäßig eh schon aktiviert).
Nun wird bei der Installation das ActiveX - Steuerelement installiert und am Computer registriert.
Das Steuerelement kann nun schon in .Net eingebunden werden: Mittels Rechtsklick auf die Toolbox, Elemente auswählen öffnet sich ein Fenster zum Hinzufügen von neuen Steuerelementen zur Toolbox. Wir wechseln nun zur Reiterkarte "COM-Steuerelemente" und aktivieren dort den Haken vor dem Eintrag VideoLAN VLC ActiveX Plugin v1.
Ist dieser Eintrag nicht vorhanden, muss die .dll Datei manuell registriert werden. Die besagte Datei heißt axvlc.dll und liegt im VideoLAN Verzeichnis.
ActiveX Steuerlemente können über den Befehl regsvr32 registriert werden, angenommen dem Pfad C:\Program Files (x86)\VideoLAN\VLC\axvlc.dll sind folgende Schritte nötig: Start - Ausführen regsvr32 "C:\Program Files (x86)\VideoLAN\VLC\axvlc.dll".
Wurde das VLC Control erfolgreich zur Toolbox hinzugefügt, kann es wie jedes andere auch auf das Formular gezogen werden.
Zum Abspielen eines beliebigen Videos oder einer Audiodatei (in C# können über das VLC Steuerelement alle Dateiformate abgespielt werden, die auch der "normale" VLC Player spielen kann - also quasi fast alle) muss das Multimediaobjekt zuerst zur Playlist hinzugefügt werden, was durch die Methode addTarget() erreicht werden kann. Diese erwartet 4 Parameter, der erste gibt den Pfad zum abzuspielenden Objekt an. Als zweiten Parameter können Optionen übergeben werden (wie zum Beispiel das Seitenverhältnis). Der 3. Parameter ist der Abspielmodus und der 4. der Einstiegspunkt in der aktuellen Playlist.
Zum Abspielen muss dann nur noch die Methode play() aufgerufen werden.
pause() hält das Abspielen an, über einen erneuten Aufruf der Methode play() wird das Video / die Audiodatei an der gleichen Stelle fortgesetzt.
Die Lautstärke des Audiosignals kann über den Parameter Volume gesetzt werden, 0 bedeutet kein Ton, 100 volle Lautstärke.
Das folgende Beispiel spielt das Video "Matrix" auf meinem Desktop bei 50% Lautstärke ab.
Der Methode addTarget() wurden keine Optionen übergeben, der Abspielmodus ist wohl selbsterklärend und -666 als letzter Parameter bezeichnet den letzten Eintrag in der aktuellen Playlist.
Achtung: Bei neueren VLC Versionen muss dem Dateipfad ein "file:///" vorgestellt werden, sonst wird die Datei nicht abgespielt!

axVLCPlugin1.Volume = 50;
axVLCPlugin1.addTarget(@"C:\Users\User\Desktop\matrix.mp4", null, AXVLC.VLCPlaylistMode.VLCPlayListAppendAndGo, -666);
axVLCPlugin1.play();


Nachtrag: Über diesen Post habe ich nun auch ein Video auf Youtube hochgeladen: http://www.youtube.com/watch?v=Bh4qsHrk910

Sonntag, 29. August 2010

Farbtiefe herausfinden

Ganz leicht lässt sich mit C# die Farbtiefe des Monitors auslesen. Die Farbtiefe ist pro Monitor einstellbar, deswegen muss zuerst der entsprechende Bildschirm ausgewählt werden. Screen.PrimaryScreen beispielsweise bezeichnet den primären Bildschirm, über Screen.AllScreens[Nr] kann Monitor [Nr] ausgewählt werden.
Die Farbtiefe ist in der Eigenschaft BitsPerPixel gespeichert, da die Farbtiefe angibt, durch wie viele Bits pro Pixel die Farbe dieses dargestellt wird. Es gibt 16 und 32 Bit, heutzutage ist fast ausschließlich 32 Bit im Einsatz.
Folgender Befehl schreibt die Farbtiefe des primären Monitors in die Variable ColorDepth:
int ColorDepth = Screen.PrimaryScreen.BitsPerPixel;

Samstag, 28. August 2010

Anzahl an angeschlossenen Bildschirmen ermitteln

Im .Net Framework werden alle am PC angeschlossenen Bildschirme im Array Screen.AllScreens hinterlegt.
Über die Eigenschaft Length kann die Anzahl dieser ausgelesen werden,
in C# ermittelt also folgende Anweisung die Anzahl der angeschlossenen Bildschirme:

int NrOfScreens = Screen.AllScreens.Length;

Freitag, 27. August 2010

Standard Emailprogramm öffnen

Im vorigen Post wurde beschrieben, wie man eine URL mit dem Standardbrowser öffnet. In diesem Post geht es um das Öffnen einer Emailvorlage mit dem als Standard eingetragenen Emailclient.
Wie im vorigen Post führt auch hier die Funktion System.Diagnostics.Process.Start() zum Erfolg. Dem Parameter muss dieses mal nur der String "mailto:" vorgestellt werden, ganz wie beim Öffnen eines Emailfensters beim Klick auf einen Hyperlink.
Die Syntax ist zum HTML - Mailto gleich: Nach "mailto" wird die Emailadresse des Empfängers erwartet, zusätzlich können noch optionale Parameter angehangen werden. Der erste Parameter wird durch ein Fragezeichen ("?") von der Empfängeradresse getrennt, die restlichen durch "&".
Folgende Parameter sind möglich:
  • cc: Carbon Copy, eine Kopie der Email wird an diese Adresse geschickt, der erste Empfänger sieht diese Adresse.
  • bcc: Blind Carbon Copy, eine Kopie der Email wird an diese Adresse geschickt, der erste Empfänger sieht diese Adresse nicht.
  • subject: Betreff der Nachricht.
  • body: Inhalt der Nachricht

Mit dem String "%0A" kann im Body eine neue Zeile eingefügt werden.
Aber Achtung: Es ist nicht gesagt, dass alle Emailprogramme andere Parameter außer dem Empfänger zulassen!
Folgendes Beispiel öffnet ein Fenster des Standardemailprogramms mit einer Nachricht an mich:

System.Diagnostics.Process.Start("mailto:bloggeroliver@web.de");

Nächste Anweisung öffnet ein neues Emailfenster, alle oben beschriebenen Parameter wurden im mailto - Link benutzt:
System.Diagnostics.Process.Start("mailto:bloggeroliver@web.de?bcc=bloggeroliver@web.de&cc=bloggeroliver@web.de&subject=Testmail&body=Hallo Oliver,%0Adiese Mail ist von deinem Beispielprogramm erzeugt worden.");

Donnerstag, 26. August 2010

Link mit Standardbrowser öffnen

Um mittels C# einen Link zu einer beliebigen Webseite mit dem Standardbrowser zu öffnen, ist einfach ein Aufruf der Funktion System.Diagnostics.Process.Start() mit der Ziel - URL als Parameter nötig.
Es öffnet sich dann automatisch der Standardbrowser mit der gewünschten Internetseite.
Folgendes Beispiel öffnet diesen Blog:

System.Diagnostics.Process.Start("http://csharp-tricks.blogspot.com/");

Mittwoch, 25. August 2010

Registry Tutorial

So, heute möchte ich euch mal zeigen, wie man mit C# die Registrierung (Registry) verwaltet. In dieser speichert Windows Informationen zu Programmen etc., sie lässt sich standardmäßig über den Registrierungseditor (Start - Ausführen - regedit) verwalten.
In C# läuft die Bedienung über die Klasse RegistryKey, welche in Microsoft.Win32 vorhanden ist. Für alle folgenden Codebeispiele setze ich daher
using Microsoft.Win32;
voraus.
Die Registry ist in verschiedene Kategorien eingeteilt, auf oberster Stufe der Hierarchie gibt es zum Beispiel die Gruppen HKEY_CURRENT_USER (speichert Einstellungen des aktuellen Benutzers) oder HKEY_LOCAL_MACHINE (speichert Einstellungen des kompletten Computers).
Zum "Bedienen" der Registrierung muss zuerst die Klasse RegistryKey mit einer dieser Kategorien initialisiert werden, z.B. über:

RegistryKey SampleKey = Registry.CurrentUser;

Tiefer in den Baun hinein kann mit der Funktion OpenSubKey() manövriert werden:

RegistryKey DeeperKey = SampleKey.OpenSubKey("Software\\7-Zip", true);

Der 2. Parameter vom Typ Boolean gibt an, ob der Schlüssel mit Schreibrechten geöffnet werden soll.
In DeeperKey ist dann der ausgewählte Pfad gespeichert.
Zur elementaren Bedienung gibt es nun eigentlich nur noch 5 Methoden anzugeben, ich zeige alle direkt im Beispiel:
DeeperKey.CreateSubKey("Testschlüssel");
Erstellt einen Unterschlüssel, falls dieser schon existiert wird selbiger geöffnet.
Object TestValue = DeeperKey.GetValue("Lang");
Liest den Wert "Lang" aus dem Schlüssel DeeperKey aus.
DeeperKey.SetValue("NewValue", "randomdata");
Schreibt "randomdata" in den Wert "NewValue". Existiert der Wert noch nicht, wird er angelegt.
DeeperKey.DeleteValue("NewValue");
Löscht den Wert "NewValue".
DeeperKey.DeleteSubKey("Testschlüssel");
Löscht den Unterschlüssel "Testschlüssel".
Zuguterletzt sollte, wenn die verwendeten Objekte nicht mehr verwendet werden, wie auch bei Dateien etc., die Ressource wieder freigegeben werden, was mittels der Funktion Close() aus der Klasse RegistryKey erfolgt.

Montag, 23. August 2010

C# Blog goes Youtube

Um C# auch über andere Medien populärer zu machen, habe ich heute mal ein Youtube Konto eingerichtet.
Auf dieses möchte ich von nun an einige Videos hochladen, ebenfalls mit kleinen Tutorials oder ähnlichem über die Programmiersprache C#, passend zu diesem Blog.
Das erste Video ist oben, es zeigt den Matrix Screensaver, den ich in diesem Post vorgestellt habe.
Würde mich freuen wenn ihr mal vorbeischaut, Tipps, Wünsche und Kritik sind jederzeit willkommen!
Das Video findet ihr unter folgendem Link: http://www.youtube.com/watch?v=CTMwMkZjHJg

Sonntag, 22. August 2010

Bildschirmschoner starten

Heute möchte ich euch zeigen, wie man mittels C# den aktuellen Bildschirmschoner (Screensaver) des Computers startet.
Hierfür benötigen wir eine WinAPI - Funktion, um diese einbinden zu können, brauchen wir als erstes folgende using - Direktive:

using System.Runtime.InteropServices;

Die zum Laden des Bildschirmschoners benötigte Funktion heißt SendMessage(), sie wird folgendermaßen eingebunden:

[DllImport("User32.DLL")]
public static extern int SendMessage(IntPtr hWnd, UInt32 Msg, Int32 wParam, Int32 lParam);

Diese Funktion ist allgemein dazu da, eine Meldung an ein bestimmtes Fenster zu senden. Das Zielfenster wird über den Parameter hWnd spezifiziert.
der 2. Parameter, Msg, beschreibt die zu sendene Nachricht.
Die letzten beiden Parameter ermöglichen die Übergabe von bestimmten Parametern neben der Nachricht.
Um den aktuellen Screensaver aufzurufen, sind folgende Parameter nötig:

SendMessage(this.Handle, 0x112, 0xF140, 0);

Donnerstag, 19. August 2010

Mauszeiger ändern

Mit der Programmiersprache C# kann man ganz leicht das Aussehen des Cursors ändern, also zum Beispiel statt dem standardmäßigen Pfeilzeiger eine Sanduhr o.ä. anzeigen.
Die dafür zu ändernde Eigenschaft heißt Cursor, eine große Auswahl an Mauszeigersymbolen gibt es in der Klasse Cursors.
Ändert man den Mauszeiger über die Methode, gilt dies jedoch nur für den Bereich des Formulars.
Um beispielsweise eine Sanduhr (oder in Windows Vista und höher einen Kringel als Wartesymbol) als Cursorsymbol auszuwählen, ist folgender Code nötig:

Cursor = Cursors.WaitCursor;


Ich möchte hier noch ein paar sinnvolle Symbole zeigen:

Cursor = Cursors.AppStarting;




Cursor = Cursors.Arrow;




Cursor = Cursors.Default;

Standardsymbol


Cursor = Cursors.Hand;




Cursor = Cursors.Help;




Cursor = Cursors.No;




Cursor = Cursors.SizeAll;




Cursors.WaitCursor

Mittwoch, 18. August 2010

Computer sperren

In einem früheren Post gab's Infos, wie man den Computer mit C# herunterfährt oder den Benutzer ausloggt.
Heute möchte ich euch zeigen, wie man mittels C# den Computer sperrt (hat den gleichen Effekt wie Strg + Alt + Entf - Computer sperren oder Windows - Taste + L).
Diese Aktion durchzuführen ist mit einer API - Funktion im Prinzip ganz einfach. Wie immer ist zum Einbinden von API - Funktionen folgende using - Direktive nötig:
using System.Runtime.InteropServices;

Mit folgendem Code wird dann die benötigte Funktion eingebunden:

[DllImport("user32.dll")]
public static extern bool LockWorkStation();

LockWorkStation() kann dann an einer beliebigen Stelle des Quellcodes aufgerufen werden, der Computer wird dabei gesperrt.

Montag, 16. August 2010

InputBox in C#

Viele Programmierer, die von Visual Basic kommen, vermissen vielleicht die gute alte InputBox aus dieser Sprache. Für diese und andere Leute, die eine einfache Möglichkeit suchen, den Benutzer Daten eingeben zu lassen, zeige ich heute, wie man die InputBox aus Visual Basic benutzt.
Diese ruft ein modales Fenster auf, einen Eingabedialog, in den der Benutzer Eingaben tätigen kann.
Zuerst ist ein Verweis auf die Visual Basic Bibliothek erforderlich, welchen ihr über Projekt - Verweis hinzufügen - Reiterklasse .Net - Microsoft.VisualBasic einbinden könnt.
Nun kann der Eingabedialog über die Funktion Microsoft.VisualBasic.Interaction.InputBox() im Projekt benutzt werden.
Die Parameter sollten eigentlich selbsterklärend sein, nur der erste ist Pflicht, die letzten beiden sind globale Positionsangaben. Die Funktion liefert die Eingabe als String - Wert zurück:

string Response = Microsoft.VisualBasic.Interaction.InputBox("Beispieldialogtext", "Titel", "Vorgabeantwort", 0, 0);

Obiger Code erzeugt folgende InputBox:

Samstag, 14. August 2010

Ping ausführen

Viele kennen wahrscheinlich den Befehl ping aus der Windowskonsole. Mit diesem können testweise Datenpakete an eine bestimmte Adresse, an einen Computer im Netzwerk oder einen Server im Internet, gesendet werden.
Können die Datenpackete erfolgreich gesendet werden ist die Zieladresse erreichbar und eine entsprechende Antwort wird zurückgegeben.
Mit der Programmiersprache C# lässt sich solch eine Anfrage ebenfalls ganz leicht senden. Zuerst müssen wir im Projekt die dafür benötigte Klasse mittels using einbinden:
using System.Net.NetworkInformation;

Über die Funktion Send() der Klasse Ping kann ein Ping ausgeführt werden, die hier verwendete Überladung mit nur einem Parameter gibt die Zieladresse an (127.0.0.1 bezeichnet den lokalen Computer). Optional können weitere Parameter benutzt werden, gibt man einen 2. Parameter an, bezeichnet dieser beispielsweise das Zeitintervall in Millisekunden, in welchem auf Rückantwort gewartet werden soll.

Ping Sender = new Ping();
PingReply Result = Sender.Send("127.0.0.1");
if (Result.Status == IPStatus.Success)
    MessageBox.Show("Erfolg");
else
    MessageBox.Show("Fehler");

Mittwoch, 11. August 2010

Wortbreite des Systems herausfinden

Mit der Überschrift können vielleicht nicht viele Leute etwas anfangen, umgangssprachlich geht es in diesem Post darum, mit C# abzufragen, ob "der Computer 32-Bit oder 64-Bit ist".
Diese Angabe, 32- oder 64-Bit, bezeichnet aber informatisch gesehen die Wortbreite der Systemarchitektur, also die Grundgröße der Datenverarbeitung.
Bei einer n-Bit Architektur besteht die Wortbreite aus n-Bit, das System teilt alle Informationen in Wörter aus n-Bit und führt mit diesen Operationen durch. Je größer die Wortbreite ist, desto mehr Informationen können pro Zeiteinheit verarbeitet werden.
Aber genug der Theorie, in C# reicht eine Zeile zum Auslesen dieser Systeminformation:

bool Is64Bit = System.Environment.Is64BitOperatingSystem;

Montag, 9. August 2010

Anzahl an Prozessoren ermitteln

Möchte man mit C# die Anzahl der im Computer befindlichen Prozessorenkerne herausfinden, reicht ein Befehl aus der Klasse Environment, die Eigenschaft ProcessorCount gibt diesen Wert zurück:

int NrOfProcessors = Environment.ProcessorCount; // ermittelt die Anzahl der im PC verfügbaren Prozessoren

Samstag, 7. August 2010

Overlay Icons in der Taskleiste einblenden

Basierend auf den vorigen Posts bleiben wir bei netten Funktionen des Windows API Codepacks. Eine weitere neue Funktion von Windows 7 ist das Einblenden von sogenannten Overlay Icons in der Taskleiste. Diese werden über das eigentliche Programmicon eingeblendet und können so Statusinformationen anzeigen, wie z.B. das rote "X" im Beispiel:

Um Icons dieser Art einblenden zu können, ist die Einbindung des Windows API Code Pack nötig, wie im vorigen Post beschrieben.
Dann führt folgender Code zur Einblendung eines Overlay Icons in der Taskleiste:

TaskbarManager tm = TaskbarManager.Instance;
Icon OverlayIcon = new Icon("error.ico");
tm.SetOverlayIcon(OverlayIcon, "Fehler");

Die Funktion SetOverlayIcon() legt hierbei schließlich das anzuzeigende Icon fest, als ersten Parameter kann ein beliebiges Icon übergeben werden, als zweiten einen Text, der alternativ zum Icon angezeigt wird, falls dieses nicht verfügbar ist.
Folgender Code blendet das Overlay Icon wieder aus:

tm.SetOverlayIcon(null, null);

Donnerstag, 5. August 2010

Art des Programmicons in der Taskleiste bei Windows 7 ändern

Im vorigen Post ging es um das Anzeigen eines Fortschrittbalkens in der Taskleiste, in diesem Post möchte ich die Verwendung einer ähnlichen Funktion zeigen, die neu in Windows 7 ist.
Windows 7 zeigt nicht nur Fortschrittsbalken in der Taskleiste an, sondern die Programmicons geben auch Aussage über den Zustand der Programme. Am nützlichsten finde ich die beiden Statusse "Fehler" und "keine Rückmeldung", folgender Code zeigt deren Verwendung (wie im vorigen Post beschrieben, wird die Einbindung des Windows API Code Packs vorrausgesetzt):


TaskbarManager tm = TaskbarManager.Instance;
tm.SetProgressState(TaskbarProgressBarState.Error);

Wird obiger Code ausgeführt, zeigt das Programm einen Fehler an, das entsprechende Icon wird leicht rot gefärbt:
Ebenfalls kann das Programm als "hängend" deklariert werden, dann bewegt sich ein grüner Balken über das Programmicon, was vielen sicherlich bekannt vorkommmen sollte:

TaskbarManager tm = TaskbarManager.Instance;
tm.SetProgressState(TaskbarProgressBarState.Indeterminate);

Fortschrittsbalken in der Taskleiste bei Windows 7 anzeigen

Windows 7 bringt viele nette Features mit, eines davon sind die dynamischen Logos in der Taskleiste, die Auskunft über den Status der Programme geben können.
In diesem Post möchte ich euch zeigen, wie man in der Taskleiste eine Fortschrittsanzeige im Programmicon einblendet, was ungefähr so aussieht:



Um den Fortschrittsbalken zu erstellen, muss das Windows Windows API Code Pack installiert sein.
Ist das der Fall, müssen wir in das gewünschte Zielprojekt 2 Verweise einfügen:
Projekt - Verweis hinzufügen, zur Registerkarte Durchsuchen wechseln und dort in das Verzeichnis wechseln, in dem das Code Pack liegt.
Weiter in der Ordnerstruktur geht es in das Unterverzeichnis WindowsAPICodePack\Shell. Hier liegen unsere benötigten .dll - Dateien, und zwar müssen Microsoft.WindowsAPICodePack.dll und Microsoft.WindowsAPICodePack.Shell.dll eingebunden werden.
Dann binden wir in unserem Projekt die Taskbar - Klasse ein:

using Microsoft.WindowsAPICodePack.Taskbar;

Der folgende Code erstellt dann einen halb gefüllten Fortschrittsbalken wie oben im Bild ersichtlich:

TaskbarManager tm = TaskbarManager.Instance;
tm.SetProgressState(TaskbarProgressBarState.Normal);
tm.SetProgressValue(50, 100);

SetProgressState() legt den Stil des Programmicons fest, mit dem hier gewählten befehlen wir dem Prorgamm, das Logo ganz "normal" aussehen zu lassen, sodass wir einen Fortschrittsbalken darüber legen können.
SetProgressValue() legt schließlich den Fortschritt der Anzeige fest, der erste übergebene Parameter ist der aktuelle Wert der Anzeige, der zweite der maximale Wert.

Mittwoch, 4. August 2010

Windows API Code Pack einbinden

Das Windows API Code Pack ist eine Sammlung vieler nützlicher Funktionalitäten, die es alle noch nicht im .Net Framework gibt. Viele der Funktionen werden in der nächsten Version des .Net Frameworks übernommen, mit dem Codepack können sie jetzt schon eingesetzt werden.
Besonders für Windows 7 sind viele interessante Sachen dabei (im nächsten Post zeige ich beispielsweise, wie man eine Statusanzeige im Taskleistenlogo einbaut), das Code Pack bietet aber noch viele andere Funktionen wie z.B. DirectX Anbindung.
Das Projekt ist OpenSource, d.h. der Quellcode ist frei einsehbar und kann verändert werden, außerdem muss er selber kompiliert werden.
Deswegen möchte ich hier eine kurze Installationsanleitung bieten:
Das Windows API Code Pack kann man zum Beispiel auf dieser Seite herunterladen, hier bitte die .zip Datei auswählen.
Diese nun entpacken und das C# - Projekt WindowsAPICodePack.sln im Ordner WindowsAPICodePack öffnen.
Bei mir kam dann die Aufforderung, das Projekt in die 2010er Version zu konvertieren, was automatisch abläuft.
Nun muss das Projekt mittels Debuggen - Projektmappe erstellen erstellt werden (Bei mir fehlte dazu ein Verweis, Rechtsklick auf die Projektmappe Shell, Verweis einfügen, im Reiter .Net System.Xaml auswählen hat das Problem behoben).
Nun werden aus dem Projekt die .dlls in die entsprechenden bin - Verzeichnisse kopiert. Diese Bibliotheken können dann in das eigene Projekt eingebunden und benutzt werden.

Dienstag, 3. August 2010

Zeit seit dem Hochfahren ermitteln

Das folgende Snippet zeigt, wie man mit C# die Zeit auslesen kann, die der Computer schon läuft, sprich die Zeit seit dem Starten des PCs.
Über System.Environment.TickCount kann diese Angabe in Millisekunden ausgelesen werden.
Das Beispiel wandelt die Millisekundenanzahl dann in ein Objekt des Typs TimeSpan um. Diese Klasse verwaltet Zeitdifferenzen, so kann die Millisekundenanzahl leicht in Stunden, Minuten und Sekunden umgewandelt werden:

int MsSinceStartup = System.Environment.TickCount; // Zeitintervall seit Hochfahren in Millisekunden
TimeSpan TimeDifference = new TimeSpan(0,0,0,0, MsSinceStartup); // Erstellung einer TimeDifference zur Umwandlung in Stunden, Minuten und Sekunden
MessageBox.Show("Zeit seit Hochfahren: " + TimeDifference.Hours + "h " + TimeDifference.Minutes + "min " + TimeDifference.Seconds + "s"); // Ausgabe