Montag, 31. Mai 2010

Beep ausgeben

Mit der Funktion Console.Beep() entwickelt sich die erstellte Applikation zwar nicht plötzlich zum DJ - Programm, auf jeden Fall kann diese Funktion aber Piep Töne über die internen oder, falls angeschlossen, externen Lautsprecher ausgeben.
Ein parameterloser Aufruf dieser Funktion erzeugt einen "Standard - Beep", als Parameter sind aber die Tonhöhe in Hertz sowie die Dauer in Millisekunden möglich.
Console.Beep() ist erst ab .Net 2.0 verfügbar.
Die Betriebssystem Windows 98 - Windows ME können die Frequenz- und Dauerparameter nicht interpretieren.

Aktives Formular abfragen

Bei meinen Anwendungen möchte ich manchmal wissen, ob ein bestimmtes Formular gerade aktiv ist, das heißt, den Benutzerfokus hat. Oder bei Anwendungen mit nur einem Formular, ob somit die komplette Anwendung den Fokus hat.
Mit this wird, wie bestimmt schon öfters erwähnt, das aktuelle Formular angesprochen, die Eigenschaft Focused prüft, ob das Formular den Fokus hat.
Folgender kleiner Beispielcode kann in die Tick - Funktion eines Timers kopiert werden und wechselt so periodisch die Hintergrundfarbe des Formulars, je nachdem, ob das Formular zum Aufrufzeitpunkt den Fokus hat oder nicht:
private void timer1_Tick(object sender, EventArgs e)
{
    if (this.Focused)
        this.BackColor = Color.Red; // Rot wenn Formular Fokus hat
    else
        this.BackColor = Color.Green; // Grün wenn nicht
}

Samstag, 29. Mai 2010

Steuerelemente zur Laufzeit hinzufügen

Bei fortgeschrittenen Anwendungen wird man irgendwann an den Punkt kommen, an dem man sich nicht mehr mit statischen Formularen zufrieden gibt, sondern dynamisch die Formulare zur Laufzeit ausbauen möchte.
Steuerlemente (Controls) sind im Grunde genommen nichts anderes als Variablen, zum Beispiel vom Typ Button, TextBox etc ... Wie andere Variablen können Sie also auch zur Laufzeit initialisiert werden und müssen dann nur noch dem Formular hinzugefügt werden.
Folgender selbsterklärender Beispielcode fügt bei Ausführung dem Formular einen neuen Button hinzu:
Button NewButton = new Button(); // Variable vom Typ Button initialisieren
NewButton.Width = 100; // Breite festlegen
NewButton.Height = 20; // Höhe festlegen
NewButton.Left = 10; // Abstand vom linken Formularrand
NewButton.Top = 50; // Abstand vom oberen Formularrand
NewButton.Text = "Klick mich"; // Beschriftung des Buttons setzen
this.Controls.Add(NewButton); // hier wird der neue Button dem Formular hinzugefügt

In der letzten Codezeile wird die Buttonvariable der Liste this.Controls hinzugefügt. Diese Liste speichert alle auf dem Formular platzierten Steuerelemente, wird das neu hinzugefügte Steuerelement dieser Liste nicht hinzugefügt, wird es auch nicht angezeigt.

Bestimmte Zeit warten

Viele kennen wahrscheinlich das Problem, die C# - Anwendung soll einfach für eine bestimmte Zeit angehalten werden und erst dann die Ausführung fortsetzen.
Diesen Zweck hat die Funktion System.Threading.Thread.Sleep(). Sie hält den aktuellen Thread um die in Klammern angegebene Zeit in Millisekunden an.
Ein Thread ist eine Art Unterteilung eines Prozesses. Eine C# - Anwendung wird in einem eigenen Prozess gestartet, auf dem Betriebssystem laufen aber auch andere Prozesse, deshalb schaltet das Betriebssystem fortlaufend zwischen den Prozessen um, der jeweils aktive wird dabei ausgeführt.
In unserer C# - Anwendung können wir nun verschiedene Threads erstellen.
Diese laufen scheinbar unabhängig voneinander ab, bekommt unsere Anwendung vom Betriebssystem den "Fokus" wechselt die Anwendung selber noch zwischen den Threads hin und her, so dass der Eindruck von einer simultanen Abarbeitung dieser entsteht.
Eine gewöhnliche Windows Forms - Anwendung besteht aber nur aus einem Thread, so dass folgender Code das ganze Programm für 1 Sekunde einfriert:
System.Threading.Thread.Sleep(1000);

Tastendruck simulieren

Auch um Tastendrucke zu simulieren, gibt es in C# eine einfache Funktion.
Die Klasse SendKeys stellt entsprechende Möglichkeiten zur Verfügung.
Es existieren die Funktionen Send() und SendWait(). Beiden Funktionen wird ein String übergeben und dieser an das gerade aktive Programm sendet, so als hätte der Benutzer die entsprechenden Tasten auf der Tastatur gedrückt.
SendWait() wartet im Gegenzug zu Send() auf die Verarbeitung der Eingabe.
Folgender Beispielcode kann z.B. auf das Click - Event eines Buttons gelegt werden.
Wird der Code ausgeführt, wartet das Programm noch 3 Sekunden, der Benutzer wechselt zum entsprechenden Programm (rein zufällig einem Chatclient) und die Applikation feuert 100mal die Nachricht "WICHTIG!" ab:
System.Threading.Thread.Sleep(3000);
for (int i = 0; i < 100; i++)
{
    SendKeys.Send("WICHTIG! \n");
}

"\n" fügt einen Zeilenumbruch dem Text hinzu, Tastendrücke auf Spezialtasten, wie z.B. die Enter - Taste können aber auch simuliert werden, Enter beispielsweise mit "{ENTER}" (als String, d.h. mit Anführungszeichen wie ein normaler Text).

Es gibt auch einen Post zum Simulieren von Mausklicks etc.

Freitag, 28. Mai 2010

Anwendung beenden

Die eigene C# - Anwendung per Programmcode zu beenden, ist ganz leicht, der Befehl aber einigen nicht bekannt.
Deshalb gibt's diesen als heutigen Beitrag.
Bei Windows Forms - Anwendungen führt der Befehl
System.Windows.Forms.Application.Exit();
zur Beendigung des Programms.
In Konsolenanwendungen ist dieser Befehl jedoch nicht verfügbar. Bei einer solchen kann man jedoch den Befehl return in der Hauptfunktion void Main() aufrufen, um die Anwendung vorzeitig zu beenden.

Donnerstag, 27. Mai 2010

Computer herunterfahren

Um den Computer durch ein C# - Programm herunterzufahren, rufen wir einfach das Windows eigene Programm "shutdown" auf.
Denn gibt man in der Eingabeaufforderung (cmd.exe) diesen Befehl ein, z.B. mit den Parametern shutdown -s -t 60, wird der PC nach Ablauf von 60 Sekunden heruntergefahren.
Der Befehl "shutdown" ruft in Wirklichkeit das Programm "shutdown.exe" auf, welches sich im Verzeichnis system32 befindet.
Um den PC nun aus einem selber geschriebenen Programm aufzurufen, starten wir shutdown.exe mit den richtigen Parametern.
Zum Starten eines externen Programms dient die Funktion System.Diagnostics.Process.Start().
Im Programm geben wir jetzt beispielsweise
System.Diagnostics.Process.Start(System.Environment.SystemDirectory + "\\shutdown.exe", "-s -t 60");

ein.
Wird dieser Code ausgeführt, erscheint eine Meldung, dass das System nach Ablauf von 60 Sekunden heruntergefahren wird.
So einfach ist die Sache!
Abschließend noch einige mögliche Parameter für die "shutdown.exe":
  • -l: Abmelden (für log out)
  • -s: Herunterfahren (für shutdown)
  • -r: Neustart (für restart)
  • -a: Herunterfahren abbrechen (für abort)
  • -t XX: Zeitlimit (für time)
  • -c: Gibt einen Kommentar beim Herunterfahren aus (für comment)
  • -f: Erzwingt das Herunterfahren (auch wenn Programme geschlossen werden müssen) (für force)

Mittwoch, 26. Mai 2010

Prozess starten mit C#

Mit dem .Net Framework ist das Starten eines externen Prozesses / Programmes im Handumdrehen erledigt.
Der Befehl System.Diagnostics.Process.Start() startet die .exe - Datei, dessen Pfad als Argument angegeben wurde.
Um beispielsweise den Editor zu öffnen gibt man folgendes ein:
System.Diagnostics.Process.Start(System.Environment.SystemDirectory + "\\notepad.exe");

System.Environment.SystemDirectory gibt den Pfad des Systemverzeichnisses zurück (bei mir C:\Windows\system32).
Außerdem stehen vor \\notepad.exe zwei Backslashes, da "\" "escaped" werden muss.
Mit nur einem "\" würde der Compiler "\n" als Sonderzeichen ansehen, "\\" sagt ihm, hier ist wirklich ein normaler "\" gemeint.
Der Funktion Process.Start() können nach dem Pfad zum ausführbaren Programm auch noch Argumente übergeben werden, mit denen das Programm gestartet werden soll.
Soll beim obigen Beispiel der Editor mit der Textdatei Beispiel.txt, die bei mir auf dem Desktop liegt, aufgerufen werden, ist der Befehl wie folgt abzuändern:
System.Diagnostics.Process.Start(System.Environment.SystemDirectory + "\\notepad.exe", "C:\\Users\\Oliver\\Desktop\\Beispiel.txt");

C# Anwendung mit Administratorrechten starten under Windows Vista / 7

In den Windowsversionen Vista und 7 legt die User Account Control (UAC) fest, dass der angemeldete Benutzer, auch wenn er Administrator ist, standardmäßig nicht als Administrator fungiert. Bei Aktionen, die das Betriebssystem beeinträchtigen könnten, wird deshalb der wohl bekannte Dialog "Möchten Sie zulassen, dass durch das folgende Programm Änderungen an diesem Computer vorgenommen werden?" angezeigt.
Für uns bedeutet das, dass Anwendungen, auch wenn sie vom Administrator gestartet werden, standardmäßig nicht als Administrator laufen. Sollen diese Programm dann Code ausführen, der höhere Befugnisse braucht, zeigt die Ausführung keine Wirkung.
Um dem Programm diese höheren Befugnisse zu erteilen, fügen wir ihm in der C# - Entwicklungsumgebung eine Anwendungsmanifestdatei über Projekt - Neues Element hinzufügen - Anwendungsmanifestdatei hinzu.
Der Inhalt dieser sollte ungefähr so aussehen:



Die Zeile < requestedExecutionLevel level="asInvoker" uiaccess="false"> interessiert uns.
Als requestedExecutionLevel kann asInvoker, highestAvailable oder requireAdministrator eingetragen werden.
Mit requireAdministrator erscheint bei Programmstart der bekannte Dialog, nach eimem Klick auf Ja hat die Anwendung volle Administratorrechte.

Um die Anwendung ohne die Manifestdatei mit Administratorrechten auszustatten, siehe diesen Post.

Dienstag, 25. Mai 2010

Anwendung nicht als Task sondern als Prozess anzeigen

Damit eine C# Anwendung vom Betriebssystem nicht als Task, sondern als Prozess betrachtet werden soll, genügt es einfach, die Anwendung zu "verstecken", d.h. unsichtbar zu machen.
Betrachten wir eine Windows-Forms Anwendung als Beispiel. Setzen wir die Eigenschaft Visible des Formulars auf false, z.B. mittels
this.Visible = false;
(mit this ist immer das aktuelle Formular gemeint), wird das aktuelle Formular unsichtbar und demzufolge im Taskmanager nur noch als Prozess angezeigt.
Im laufenden Betrieb, z.B. nach Klicken eines Buttons kann dieser Code problemlos ausgeführt werden.
Etwas schwieriger gestaltet sich die Sache jedoch, wenn das Formular direkt beim Start unsichtbar gemacht werden soll.
In Form1_Load zeigt der Code keine Wirkung, da nach dieser Funktion Show() des Formulars aufgerufen wird und das Formular somit wieder eingeblendet wird.
Die meiner Meinung nach beste Methode besteht im Überschreiben der Funktion void OnShown(EventArgs e) des Formulars, welche beim Aufruf von Show() aufgerufen wird.
Die vollständige Deklaration der Funktion lautet:
protected override void OnShown(EventArgs e)
{
    base.OnShown(e);
    this.Visible = false;
}
base.OnShown(e); fügt der Compilter automatisch hinzu, diese Zeile sorgt dafür, dass die Funktion OnShown() der Vaterklasse von Form aufgerufen wird.
Natürlich habe ich die 2. Zeile, this.Visible = false;, eingefügt, womit das Formular von Anfang an und dauerhaft unsichtbar wird.

Montag, 24. Mai 2010

C# kostenlos downloaden

Wer bei kostenlos downloaden gleich an illegale Sachen denkt - nein, sowas gibt es hier auf diesem Blog nicht. C# kann man ganz legal von Microsoft herunterladen!
Denn neben der professionellen Versionen der .Net Sprachen gibt es die Express Versionen.
Mittlerweile gibt es Visual Basic, Visual C++ und natürlich Visual C# 2010 Express, erhältlich hier.
Die Expressversionen haben nicht zu 100% die gleichen Funktionen wie, aber wirklich: Vor allem als Einsteiger merkt man davon überhaupt nichts!
Wer die Software also noch nicht hat, sollte mal einen Blick drüber werfen, es ist eine super Möglichkeit in die Welt der modernen, objektorientierten Programmierung einzusteigen.

Los geht's!

In diesem Blog werde ich demnächst (wenn ich's denn durchhalte ;-)) regelmäßig kleine Artikel mit Tipps und Tricks für die Sprache C# .Net veröffentlichen.
Die Schwierigkeit soll ganz verschieden sein, von leicht bis schwer, für Anfänger bis Fortgeschrittene ist hoffentlich immer was dabei.
Wenn ihr Wünsche, Fragen, Anregungen für neue Posts habt - schreibt mir einfach!
Entweder als Kommentar oder über meine Email: bloggeroliver[ät]web.de.
Und jetzt viel Spaß mit dem Blog, ich hoffe einigen gefällt's.