IT-Republik.de: We live IT!

Als Entwickler ist man schon von Natur aus neugierig und kann es kaum abwarten, die neuen Features einer neuen Version des .NET Framework kennen zu lernen. Gerade die aktuelle Version 2.0 hat hier eine ganze Menge zu bieten. Insbesondere Visual-Basic-Programmierer werden erfreut feststellen, dass sie von den Microsoft-Entwicklern nicht ganz vergessen wurden und sich bei neuen Versionen längst nicht alles um C# dreht. Ein echtes Highlight ist der My-Namespace, der exklusiv für Visual Basic 2005 zur Verfügung steht. Über diesen Namespace werden viele nützliche Funktionen angeboten, die bei .NET 1.1 noch ein wenig umständlich (und gar nicht Visual-Basic-freundlich) in den "Tiefen" der .NET-Klassenbibliothek verborgen waren oder (wie das automatische Instanziieren von Formularklassen) gar nicht zur Verfügung standen. Der My-Namespace bietet seine wirklich umfangreichen Funktionen über verschiedene Objekte an, wie Computer, Application, Forms usw. Innerhalb dieser Objekte kann über leicht verständliche Eigenschaften und Methoden auf für genau dieses Objekt bestimmte Funktionen zugegriffen werden. Ein Beispiel von vielen ist My.Computer.Keyboard, das den Zustand der Tastatur liefert. Ebenso einfach können Sie mit My.Computer.Filesystem auf Eigenschaften und Methoden zum Bearbeiten von Dateien und Laufwerken zugreifen. Die über den My-Namespace zur Verfügung gestellten Funktionalitäten werden auf verschiedene Arten gewonnen. Zum einen fasst My einfach bestehende Instanzen vorhandener und quer über die Klassenbibliothek verteilter Methoden zusammen. Zum anderen haben die Entwickler bei Microsoft einiges dazu programmiert, sodass sich Visual-Basic-Programmierer ab sofort nicht mehr um jedes Detail kümmern müssen und sich statt dessen "intuitiv", sprich per IntelliSense geleitet, an alle wichtigen Systemfunktionen herantasten.

Wie wäre es mit einem Splashscreen?

Der erste Kontakt mit dem My-Namespace ergibt sich beinahe zwangsläufig bei größeren Projekten, die mit einem Splashscreen (oder wie es in der deutschen Version von Visual Studio heißt: "Begrüßungsbildschirm") ausgestattet werden. Bei einem Blick in den von der IDE generierten Quelltext wird deutlich, dass Anwendungstitel und Versionsnummer über My-Application.Info ausgelesen werden. Auch weitere Assembly-Informationen lassen sich um einiges leichter herauslesen als es beim Framework 1.1 möglich war. Listing 1 zeigt, wie sich zum Beispiel Informationen über die eigene Assembly in Erfahrung bringen lassen. Damit überhaupt vernünftige Werte dargestellt werden, muss die Assembly mit den richtigen Informationen "gefüttert" werden. Sie erreichen dies über PROJEKT | MYFUNKTION-EIGENSCHAFTEN | ANWENDUNG | ASSEMBLYINFORMATIONEN.

1. Listing 1
2. My.Application stellt Informationen über die Assembly zur Verfügungt
3. Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
4. ListBox1.Items.Add("Assembleyname: " & My.Application.Info.AssemblyName)
5. ListBox1.Items.Add("Copyright: " & My.Application.Info.Copyright)
6. ListBox1.Items.Add("Produktname: " & My.Application.Info.ProductName)
7. ListBox1.Items.Add("Version: " & My.Application.Info.Version.ToString)
8. ListBox1.Items.Add("Directory: " & My.Application.Info.DirectoryPath)
9. End Sub

Programmparameter abfragen

Viele Anwendungen werden mit Parametern gestartet. Besonders bei Dienstprogrammen oder Shell-Befehlen ist dies der Fall. So können Sie sich beispielsweise mit ipconfig /all detaillierte Informationen über Ihre Netzwerkkonfiguration anzeigen lassen. Diese sog. Befehlszeilenargumente können mithilfe des My-Namespace auf einfache Weise gelesen und ausgewertet werden (Listing 2).

1. Listing 2
2. Über My.Application werden unter anderem Befehlszeilenargumente zur Verfügung gestellt
3. Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
4. If My.Application.CommandLineArgs.Count > 0 Then
5. For Each Parameter As String In My.Application.CommandLineArgs
6. Parameter = Parameter.ToUpper
7. ListBox1.Items.Add(Parameter)
8. If Parameter = "/ALL" Then
9. 'tue etwas
10. End If
11. Next
12. End If
13. End Sub

In diesem Beispiel wird geprüft, ob überhaupt Parameter beim Programmstart mitgegeben werden. Ist dies der Fall, wird in einer For Each-Schleife jeder Parameter auf die Großschreibung umgestellt und auf seinen Inhalt überprüft. Zu Prüfzwecken wird jeder Parameter in der ListBox angezeigt. Unter PROJEKT | MYFUNKTION-PROJEKT | DEBUGGEN können Sie zum Testen der Funktion beliebig viele Befehlszeilenargumente setzen.

Einfacher Zugriff auf Ressourcen

Auch beim Zugriff auf Ressourcendateien leistet Ihnen der My-Namespace gute Dienste. Dank der My.Ressource-Funktionalität können Sie mit wenigen Zeilen Code auf die im Projekt vorhanden Ressourcen zugreifen. Dabei spielt es keine Rolle, ob es sich um einen einfachen String, ein Icon, Bilder oder sonstige Dateien handelt. Fügen Sie die Ressourcen über Projekt MYFUNKTION-EIGENSCHAFTEN | RESSOURCEN hinzu. Dies können einfache Strings sein, um Meldungen für Messageboxen zentral zu verwalten, oder auch Icons, die in Toolstrips Ihren Dienst verrichten. Auch Sounddateien können als Ressourcen hinzugefügt werden, um der eigenen Applikation den gewissen "Pep" mitzugeben. Kombiniert mit der My.Computer.Audio.Play-Methode greifen Sie mit einer Zeile Quellcode auf eine Wav -Ressource zu und lassen diese wahlweise einmalig oder als Dauerberieselung im Hintergrund laufen (Listing 3). Natürlich können Sie auch auf eine als Datei vorhandene Wave-Datei zugreifen:

1. My.Computer.Audio.Play("C:\Baby.wav", AudioPlayMode.BackgroundLoop)

1. Listing 3
2. Über eine Listenauswahl in der ToolStrip werden Ressourcen ausgewählt
3. Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
4. With ListBox1
5. .Items.Add(My.Resources.String1)
6. .Items.Add(My.Resources.String2)
7. .Items.Add(My.Resources.String2)
8. End With
9. ToolStripButton1.Image = My.Resources._3D_Stuff.ToBitmap
10. My.Computer.Audio.Play(My.Resources.Baby, AudioPlayMode.Background)
11. End Sub

Programmeinstellungen speichern

In jeder größeren Anwendung werden Einstellungen zur Anwendung gespeichert, damit diese beim Neustart der Anwendung wieder zur Verfügung stehen. Diese Anwendungseinstellungen können auf Applikations- oder Benutzerebene gespeichert werden. Meist handelt es sich bei diesen Einstellungen um so simple Dinge wie die zuletzt benutzen Dateien oder Zugangsdaten zu einem SQL Server. Aber auch Fensterpositionen und Fenstergröße sind Werte die nach einem Neustart das arbeiten in einer gewohnten Umgebung gewährleisten. Das Anlegen solcher Einstellungsdaten kann entweder über die Ressourcen oder aber auch durch den Eigenschaftsinspektor über die Eigenschaft Applicationsetting gesetzt werden. Entscheiden Sie sich die jeweilige Einstellung "benutzerorientiert" zu sichern, so können diese Werte auch zur Laufzeit verändert werden. Bei applikationsbezogenen Einstellungen ist das nicht der Fall. Das kleine Beispiel in Listing 4 benutzt die gespeicherte Fensterposition, um das Formular nach dem Start wieder an seine letzte Position zu bringen. Die Position und Größe des Hauptfensters wird in die Variablen MainPosition und MainSize geschrieben. Die Anfangswerte können Sie in den Projekteigenschaften und dort im Register Einstellungen hinterlegen.

1. Listing 4
2. Nach dem Start werden Fenstergröße und Fensterposition aus den Einstellungen gelesen
3. Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
4. If My.Settings.WertBoolean = True Then
5. CheckBox1.Checked = True
6. Else : CheckBox1.Checked = False
7. End If
8. TextBox1.Text = My.Settings.WertInteger.ToString
9. TextBox2.Text = My.Settings.WertString
10. Me.Size = My.Settings.MainSize
11. Me.Location = My.Settings.MainPosition
12. End Sub

Mit einfachen Zugriffen über My.Setting werden die Einstellungswerte ausgelesen und können direkt dem jeweiligen Steuerelement zugeordnet werden. Auch mehrere Werte, wie sie für die Position oder Größe des Hauptfensters gebracht werden, sind ohne Probleme lesbar und zuordbar. Das Speichern funktioniert natürlich auf dem umgekehrten Weg.

1. Listing 5
2. Programmeinstellungen lassen sich bei .NET 2.0 auch speichern
3. Private Sub Form1_FormClosed(ByVal sender As System.Object, ByVal e As System.Windows.Forms.FormClosedEventArgs) Handles MyBase.FormClosed
4. If CheckBox1.Checked Then
5. My.Settings.WertBoolean = True
6. Else : My.Settings.WertBoolean = False
7. End If
8. My.Settings.WertInteger = TextBox1.Text
9. My.Settings.WertString = TextBox2.Text
10. My.Settings.MainSize = Me.Size
11. My.Settings.MainPosition = Me.Location
12. End Sub

Möchten Sie die Benutzereinstellungen nicht nur beim Beenden, sondern auch innerhalb des Programms speichern, können Sie das mit My.Settings.Save tun. Das neue Einlesen der Einstellungen lässt sich mit My.Settings.Reload bewerkstelligen.

Einfacher Zugriff auf das Dateisystem

Das Dateisystem wurde von Visual Basic schon immer ein wenig stiefmütterlich behandelt (dem unbekannten "Helden", der das FileSystemObject-Objekt programmiert hat, sei an dieser Stelle noch einmal gedankt). Die .NET-Klassenbibliothek enthielt in 1.1 zwar zahlreiche Klassen im Namespace System.IO, so richtig intuitiv war der Umfang mit Dateien und Verzeichnissen jedoch nicht. Dank dem My-Namespace ist das Vergangenheit. Listing 5 zeigt, wie einfach sich eine Datei in ein Verzeichnis kopieren lässt, das, sollte es nicht vorhanden sein, zuerst angelegt wird. Das Sichern von Dateien lässt sich damit schnell und automatisch verwirklichen. Mit der Methode CopyFile kann sogar der von Windows bekannte Fortschrittsdialog angezeigt werden.

1. Listing 6
2. Eine Datei wird nach dem Programmstart gesichert
4. Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
5. Dim Sicherungspfad As String = "C:\Sicherung" & Date.Now.ToShortDateString
6. Dim Sicherungsdatei As String = "\Win.ini"
7. If Not My.Computer.FileSystem.DirectoryExists(Sicherungspfad) Then
8. My.Computer.FileSystem.CreateDirectory(Sicherungspfad)
9. End If
10. My.Computer.FileSystem.CopyFile("C:\WINDOWS\win.ini", Sicherungspfad + Sicherungsdatei, True)
11. End Sub

Registry-Hacks

Selbst die gute, alte Registry lässt sich über My bequem ansprechen. Obwohl es nicht mehr gerne gesehen wird, auf diese zuzugreifen, da Sie ihre Anwendungseinstellungen bitteschön in einer plattformübergreifend lesbaren XML-Datei speichern sollten, ist es mit wenigen Zeilen möglich einen Schlüssel anzusprechen und Werte zu speichern und auch wieder auszulesen (Listing 6). Die beliebten "Tweak-Tools" für Windows XP, die praktisch ausschließlich auf "Registry-Hacks" basieren, lassen sich in Visual Basic 2005 damit so einfach wie nie zuvor umsetzen.

1. Listing 7
2. Ein neuer Schlüssel in der Registry wird angelegt
3. Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
4. My.Computer.Registry.CurrentUser.CreateSubKey("MyFunktion")
5. If My.Computer.Registry.CurrentUser.GetValue("Testwert") = False Then
6. My.Computer.Registry.CurrentUser.SetValue("Testwert", "Hier steht der Testtext")
7. End If
8. End Sub

Und was bietet das Compact Framework für die Entwickler mobiler Endgeräte? Hier sind aus dem Pott der vielen My -Funktionen leider nur die drei Features My.Resources, My.WebServices sowie My.Forms enthalten. Aber selbst mit diesen sollte Ihre Entwicklungsaufwand bei der richtigen Nutzung um einiges niedriger sein.
Marco Rey y Sander ist ERP-Berater in einem Hamburger Systemhaus und befasst sich unter anderem auch mit der Software-Entwicklung mobiler Endgeräte. Sie erreichen den Autor unter marco@reysander.de.