News

Unser Kurs "Grundlagen der Softwareentwicklung mit .NET" findet statt am

• Freitag, den 21.7.2006 und am
• Montag, den 21.8.2006,

jeweils von 9:00 bis 16:00 in Aachen.
          
Weitere Informationen und Anmeldeformulare finden Sie hier.

WICHTIG
Aufgrund der Ferienzeit bieten wir derzeit ein eingeschränktes Kursprogramm an. Auf Anfrage sind aber jederzeit Firmenschulungen möglich. Wenden Sie sich einfach telefonisch oder per E-Mail an uns.

Das Kursangebot des ZfS Aachen stößt bei Entwicklern, Software-
architekten und IT-Verantwortlichen aus dem Mittelstand auf sehr
positive Resonanz. Dieser Zielgruppe bietet das ZfS die Möglich-
keit, sich ein kompaktes und wissenschaftlich fundiertes Bild
über Innovationen rund um Microsoft-Technologien sowie Best
Practises zu machen.

Dr. Michael Spenke, Chefentwickler des Datenanalysewerkzeugs
InfoZoom von der HumanIT Software GmbH: "Wir überlegen uns
derzeit, ob wir unsere Software zumindest teilweise im .NET-
Framework reimplementieren. Das Envisioning zum Thema
'Softwareentwicklung für serviceorientierte Architekturen'
hat mir sehr geholfen, einen soliden Überblick über die
Möglichkeiten des Frameworks zu bekommen. Eine gute
Entscheidungshilfe! Bei wichtigen Detailfragen werde ich
wieder auf das ZfS zukommen."

Die Qualität der Kurse wurde dabei von den Teilnehmern als
besonders hoch eingeschätzt. Ausdrücklich gelobt wird der
umfassende Überblick, den das ZfS zu Lösungsszenarien mit
moderenen Softwarekonzepten bietet, sowie der wissenschaftlich
fundierte Erfahrungsaustausch zwischen Dozenten und Teilnehmern.

Nach den Sommerferien bietet das ZfS Aachen auch Lehrerinnen und
Lehrern, die sich über .NET-Technologien und Möglichkeiten zur
Stoffvermittlung im Unterricht informieren möchten, ein
bewusst auf die Schulpraxis abgestimmtes Angebot an Seminaren.

Meinen ersten Blogeintrag möchte ich dazu nutzen, alle zu begrüßen, die sich für Sharepoint-Technologien interessieren. Bereits früher hat unsere Arbeitsgruppe Kooperationssysteme unter folgender Adresse zum Thema Sharepoint gebloggt: http://fitforsharepoint.blogspot.com/ . Von nun an wird hier auf den Seiten des ZfS weitergebloggt. Die folgenden Einträge werden sich mit Aktivitäten beschäftigen, mit denen wir in der jungen Vergangenheit Sharepoint-Erfahrungen gesammelt haben.

Im Rahmen des Informatikjahres hat das ZfS Aachen eine interaktive Landkarte der deutschen Informatik entwickelt, die Informationen rund um Informatikforschung und fachbezogene Veran­staltungen darstellt. Die Funktionalität und grobe Architektur der Anwendung haben wir bereits in einer Case Study beschrieben. In einer Reihe von HowTo-Dokumenten werden wir nun die Implementierung der Anwendung beschreiben, die den Microsoft MapPoint Web Service zur Darstellung von Karten und Routenplanung benutzt. Teil 1 der Reihe erläutert die notwendigen Schritte zur Vorbereitung der Daten.

In unserer letzten Schulung ist unter anderem die Frage aufgekommen, wie und ob das .NET-Framework Kompatibilität zu Anwendungen gewährleistet, die aus Zeiten vor der .NET-Ära stammen. Da dieses Thema für viele von zentralem Interesse scheint, möchte ich mit diesem Beitrag am Beispiel eines Win32 API Aufrufs eine einfache Möglichkeit aufzeigen, wie .NET-Anwendungen „unmanaged Code“ in DLL-Bibliotheken aufrufen können.

 

using System.Runtime.InteropServices;

...

    class APICall

    {

        [DllImport("kernel32.dll")]

       

        static extern uint WinExec(string command, uint uCmdShow);

 

        public void callWinAPI(string file)

        {

            WinExec("Notepad.exe " + file, 1);

         }

    }

 

Der Mechanismus, der hier zum Tragen kommt, ist im .NET-Framework als Platform Invocation (oder kurz: PInvoke) bekannt. Das oben dargestellte Code-Schnipsel ruft den Texteditor Notepad über die API-.Funktion WinExec auf. Dieser Funktion wird als Parameter der Name / Pfad der auszuführenden Anwendung übergeben. Mit dem zweiten Parameter des Aufrufs kann die Art und Weise gesteuert werden, wie das Fenster angezeigt werden soll (übergibt man z.B. den Wert „3“, wird das Fenster im Vollbildmodus angezeigt).

Um PInvoke zu nutzen, muss man die Klassen im Namespace System.Runtime.InteropServices importieren. Zum Zweiten muss die DLL, in der die aufzurufende Funktion implementiert ist, über das Attribut DllImport eingebunden werden. Die hier verwendete Funktion zum Starten einer Anwendung liegt in kernel32.dll. Schließlich muss im Quellcode eine Methode definiert sein, mit der auf die aufzurufende Funktion zugegriffen werden kann. Die Argumente, die in der Signatur dieser Methode angegeben sind, müssen mit den Argumenten der Zielfunktion übereinstimmen, da sonst ein Laufzeitfehler auftritt. Des Weiteren muss diese Methode als static und extern deklariert sein.

 

Man sollte aber nach Möglichkeit auf Platform Invocation verzichten, falls das .NET-Framework Klassen zur Verfügung stellt, die die gleiche Funktionalität bieten. Z.B. kann man das Ergebnis des oben präsentierten C#-Fragments auch über die .NET-Klasse Process aus dem Namespace System.Diagnostics erreichen:

 

Process.Start("c:\\windows\\notepad.exe", yourFile);

 

Während für viele Win32-API Aufrufe äquivalente .NET-Funktionen verfügbar sind, muss man für den Aufruf selbst entwickelter COM-Objekte häufig auf die Möglichkeit der Platform Invocation zurückgreifen.

In einem ersten Tutorial zur Programmierung von Managed DirectX mit C# hatten wir gezeigt, wie man eine grundlegende DirectX-Anwendung erstellen kann. In einer Fortsetzung des Tutorials zeigen wir nun, wie man mit DirectX 3D-Text erzeugen, darstellen und rotieren lassen kann. Der Source-Code für die entwickelte Beispielanwendung ist ebenfalls verfügbar.

Wie gestern schon im Beitrag 'Delegates in .NET' angekündigt, möchte ich heute auf das Problem mit GUI-Änderungen in Forms und multi-threaded Anwendungen zu sprechen kommen.

Das Beispiel ist eine Anwendung, die über den seriellen Port Daten erhält und diese sollen in einem Label angezeigt werden. Dazu würde man einen Eventhandler definieren, der bei eingehenden Daten über den seriellen Port aufgerufen wird. Dann wird der Inhalt des Labels mit den empfangenen Daten überschrieben. Das könnte so aussehen:

public SerialPort serialPort = new SerialPort("Com1",19200,0,8,1);
private SerialDataReceivedEventHandler serialDataReceivedEventHandler = null;

private System.Windows.Forms.Label lblSerialValue;

public SerialDataClient()
{
    InitializeComponent();
    serialDataReceivedEventHandler = new SerialDataReceivedEventHandler(SerialPortDataReceived);
    // Attach a method to be called when there is data waiting in the port's buffer
    serialPort.DataReceived += serialDataReceivedEventHandler;
}

private void SerialPortDataReceived(object sender, SerialDataReceivedEventArgs e)
{
    // the received bytes
    byte[] data = new byte[serialPort.BytesToRead];
    lblSerialValue.Text = data.ToString();
}

Das Problem bei der Ausführung ist, dass eine Exception geworfen wird, wenn der Inhalt des Labels gesetzt werden soll ("lblSerialValue.Text = data.ToString();"). Dies hängt damit zusammen, dass GUI-Elemente nur von dem Thread verändert werden können, von dem sie erzeugt wurden.

Das Empfangen der seriellen Daten läuft aber in einem anderen Thread ab. Was kann man nun machen? Man benutzt einen Delegate!

public SerialPort serialPort = new SerialPort("Com1",19200,0,8,1);
private SerialDataReceivedEventHandler serialDataReceivedEventHandler = null;

private System.Windows.Forms.Label lblSerialValue;

// the interface update delegate of the main part of the screen
public delegate void HandleInterfaceUpdateDelegate(String aValue);
public HandleInterfaceUpdateDelegate handleInterfaceUpdateDelegate;

public SerialDataClient()
{
    InitializeComponent();
    serialDataReceivedEventHandler = new SerialDataReceivedEventHandler(SerialPortDataReceived);
    // Attach a method to be called when there is data waiting in the port's buffer
    serialPort.DataReceived += serialDataReceivedEventHandler;
    handleInterfaceUpdateDelegate = new HandleInterfaceUpdateDelegate();
}

private void SerialPortDataReceived(object sender, SerialDataReceivedEventArgs e)
{
    // the received bytes
    byte[] data = new byte[serialPort.BytesToRead];
    this.Invoke(handleInterfaceUpdateDelegate, new String[] {data.ToString()});
}

private void UpdateLblSerialValue(String aValue) {
    lblSerialValue.Text = aValue;
}

Mit dem Aufruf "this.Invoke()" veranlasst man den Hauptthread dieses Forms, den Delegate auszuführen und somit wird die Änderung von dem "richtigen" Thread durchgeführt. Nun wird keine Exception mehr geworfen.

Um sicherzustellen, dass selbst erstellte Software-Komponenten auch tatsächlich in anderen .NET-Sprachen verwendet werden können, ist es notwendig, dass diese Komponenten nur Typen und Konstrukte verwenden, die in der Common Language Specification (CLS) definiert sind. Manchmal ist es aber nicht immer klar, ob ein verwendetes Konstrukt tatsächlich CLS kompatibel ist. Zu diesem Zweck kann das Assembly-Attribut [CLSCompliant(true)] eingesetzt werden, das den C#-Compiler anweist, den Quelltext auf CLS-Kompatibilität zu prüfen.

 

Der C#-Compiler würde z.B. für folgende Klassendefinition einen Hinweis ausgeben, dass die CLS-Kompatibilität nicht gewährleistet ist:

 

using System;

namespace MyTestApplication

{

    [CLSCompliant(true)]

    class NonCLSCompliant

    {

        public uint ComplianceTest(uint a, uint b) { return (a + b); }

    }

}

 

Der Datentyp uint (vorzeichenlose 32-Bit-Ganzzahl) ist zwar im Common Type System (CTS) definiert und kann damit in einigen .NET-Sprachen verwendet (z.B. in C#) und von der Common Language Runtime (CLR) in Maschinencode übersetzt werden, eine Definition in der CLS aber fehlt.

Entwickler, die Komponenten bewusst mit dem Ziel der Wiederverwendung respektive Vererbung in allen .NET-Sprachen implementieren, sollten dieses Assembly-Attribut nutzen, um die geforderte CLS-Kompatibilität sicher zu stellen.

Was ist eigentlich ein Delegate?

Ein Delegate ist ein Objekt, welches auf eine Methode zeigt, die dann zu einem späteren Zeitpunkt aufgerufen werden kann. Ein Delegate wird definiert über die Parameter-Signatur und den Rückgabewert und beim Erzeugen des Delegate-Objektes gibt man den Methodennamen an. Hier ein Beispiel:

private delegate int SumDelegate(int a, int b);

private SumDelegate _sumOfInts;

public void ExampleSumUp()
{
_sumOfInts = new SumDelegate(this.sumInts);

Console.WriteLine("Summe von 1 und 2 ist: " + _sumOfInts(1, 2));
}

private int sumInts(int x, int y)
{
return x + y;
}

Zuerst wird ein Delegate namens 'SumDelegate' definiert. Danach wird ein Objekt definiert, welches den Typ des gerade angelegten Delegates besitzt. In der Example-Methode wird eine Instanz für den 'SumDelegate' erzeugt, wobei diese auf die Methode 'sumInts' zeigt. Danach wird der Delegate wie eine normale Methode aufgerufen und liefert ein Ergebnis zurück.

Was ist jetzt das Besondere an einem Delegate? Im obigen Beispiel könnte man die Methode 'sumInts' auch direkt aufrufen.

Zum einen legt man über die Delegate-Definition fest, welche Methoden-Parameter in der Methode vorhanden sein müssen und das wichtigste Argument ist, dass man Delegates synchron wie auch asynchron aufrufen kann.

Im obigen Beispiel wird der Delegate synchron aufgerufen. Ein asynchroner Aufruf eines Delegates sieht so aus:

Console.WriteLine("Summe von 2 und 3 ist: ");

IAsyncResult iaResult = _sumOfInts.BeginInvoke(2, 3, null, null);
// do more work
Console.WriteLine("jetzt wird gerechnet");
// output result
int theSum = _sumOfInts.EndInvoke(iaResult);
Console.WriteLine(theSum);

Den asynchronen Aufruf benutzt man dann, wenn man während der Ausführung einer lange dauernden Methode weiterarbeiten kann und erst später auf das Ergebnis angewiesen ist.

Auf die Problematik mit Delegates und dem Ändern von GUI-Komponenten bei der Ausführung von mehreren Threads gehe ich demnächst ein.

Für die Erstellung der Aibo-Programme haben wir uns auch mit der 3D-Programmierung mit DirectX und .NET beschäftigt. Seit DirectX 9 gibt es auch eine verwaltete Erweiterung namens Managed DirectX, mit der DirectX auch in .NET-Anwendungen einfach und effizient genutzt werden kann. In einem Tutorial zeigen wir Ihnen, wie man mit Hilfe von Managed DirectX eine einfache 3D-Anwendung in C# erstellen kann. Der Source-Code der Beispielanwendung ist ebenfalls verfügbar.

Das Wissenschaftsjahr 2006 steht im Zeichen der Informatik und ihrer Anwendungen. In zahlrei­chen Veranstaltungen zeigen Forschungs- und Lehreinrichtungen, Institutionen, Medien und Unternehmen in einer für den interessierten Laien verständlichen Weise, wie Informatik unseren Alltag durchdringt. Doch wer ist eigentlich die deutsche Informatik? Und was macht sie wann und wo im Informatikjahr? Wie komme ich als interessierter Bürger am einfachsten zu meiner Lieb­lingsveranstaltung?

Um diese Fragen zu beantworten hat das Zentrum für Softwarekonzepte Aachen eine interaktive Landkarte der deutschen Informatik auf Basis von MapPoint entwickelt, die Informationen rund um die Informatik­forschung und fachbezogene Veranstaltungen darstellt.

In unserem Downloadbereich finden Sie nun auch eine Lösungsbeschreibung in Form einer Case Study, die Ihnen hilft, ähnliche Konzepte für Ihre eigenen Anwendungen zu realisieren. Neben einer kompakten Beschreibung des Anwendungskonzeptes berichtet die Case Study über die Lösungsarchitektur der interaktiven Landkarte der Informatik, die Sie auch gleich auf unseren ZfS-Seiten ausprobieren können.

Der AIBO, die Roboter-Hunde von Sony, sind gerade während der Roboter-Weltmeisterschaft in Bremen (Robocup 2006) wieder ins Gespräch gekommen. Auch das ZfS Aachen hat sich mit den Aibos schon beschäftigt. Zur Präsentation auf Messen, Konferenzen, und Tagungen stehen den Zentren für Softwarekonzepte (ZfS) zwei Aibos zur Verfügung. Zur Steuerung dieser Aibos hat das ZfS Aachen zwei Programme mit dem .NET Framework von Microsoft entwickelt, die Sie bei uns im Download-Bereich finden können.

Die Aibos sind gerade übrigens bei unseren Kollegen in Karlsruhe im Einsatz, die momentan auf der Midvision 06 ausstellen.

Im Downloadbereich ist ab sofort ein neues HowTo-Dokument verfügbar: „Iteration von Objekteigenschaften mittels Reflection in C#“.

Inhalt dieses Dokuments ist der Einsatz der Reflection-Klasse PropertyInfo zur generischen Ermittlung und Verarbeitung von Objekteigenschaften.

Dieses Dokument ist nur registrierten Anwendern zugänglich. Eine Registrierung kann über das Registrierungs-Formular vorgenommen werden.

Im .NET Framework und C# Blog werden wir in Zukunft Interessantes, Neues und Wissenswertes rund um das .NET Framework und die .NET-Sprache C# veröffentlichen und diskutieren.

 

Zusätzlich soll dieses Weblog zur Beantwortung typischer C#-FAQs beitragen.

Wer kennt es nicht, dass man manchmal relativ viel Zeit darauf verschwendet, Lösungen für immer wiederkehrende und eigentlich leicht lösbare Programmieraufgaben zu finden. Wir  möchten diese Plattform deshalb auch dazu nutzen, typische C#-Copy&Paste-Schnipsel im Laufe der Zeit zusammenzutragen und der C#-Community als schnelles Nachschlagewerk zur Verfügung zu stellen. Klassische FAQ-Beiträge werden z.B. die Konvertierung einfacher Datentypen oder die Formatierung von Fließkommazahlen darstellen.

 

Wir hoffen, damit dem einen oder anderen Entwickler dabei zu helfen, lästige Suchzeiten zu verkürzen und einen schnelleren Projektabschluss zu finden.