Neue Anleitungen und Tools zum Erstellen von Integrated Desktop-Anwendungen

Artikel
09/17/2008

Veröffentlicht: 02. Okt 2006

Von Christian Thilmany, Jim Keane

Der Bereitstellung von Business Intelligence-Tools (BI) für Information Worker wurde viel Aufmerksamkeit gewidmet, sodass sie fundiertere Entscheidungen treffen können. Die meisten dieser BI-Lösungen für Unternehmen stellen Informationen aus einer Vielzahl von Ressourcen bereit. Dabei wird in der Regel eine Form serverseitiger Informationsintegration verwendet. Ob es nun ein Berichtsystem ist, in dem Daten zusammengefasst werden, ein Teamarbeitstool wie Microsoft ® SharePoint ® oder eine benutzerdefinierte EAI-Lösung (Enterprise Application Integration; Unternehmensanwendungsintegration), die Geschäftsprozessverwaltung bereitstellt; es geht hauptsächlich um die Bereitstellung dieser Informationen. Über die Nutzung dieser Informationen wird wenig nachgedacht.

Der Code kann hier heruntergeladen werden: SmartClient2006_09.exe (12394KB)

Bei den meisten Aktivitäten muss der Information Worker mehrere Anwendungen zurate ziehen, wenn er eine Entscheidung fällt: einen Webbrowser, um eine Portalsite anzuzeigen; eine benutzerdefinierte Anwendung, um auf die EAI-Lösung zuzugreifen; einen Berichts-Viewer, um eine Zusammenfassung der Daten zu lesen. Mit der Zeit gewinnt dieser Worker an Arbeitserfahrung, indem er lernt, Daten manuell und über Anwendungsgrenzen hinweg zu sammeln und zu sortieren. Dies wird in der Regel durch das Starten von Microsoft Outlook®, Word, Excel®, Internet Explorer® und unzähliger benutzerdefinierter Anwendungen erreicht, die von der Firma zur Verfügung gestellt werden. Diese Form der „Drehstuhlintegration“ hat unerfreuliche Konsequenzen: die Schulung neuer Benutzer nimmt viel Zeit in Anspruch, das System stellt die richtigen Informationen nicht den richtigen Personen und nicht im richtigen Format zur Verfügung, es kommt zu Problemen aufgrund von Datenfehlern usw. Wäre es nicht effizienter, ein sicheres Integrations- und Hostingsubstrat umgeben von einem Verteilungsmodell zur Verfügung zu stellen, um diese Form der Anwendungsintegration zu vereinfachen?

Die meisten Entwickler sehen dienstorientierte Architekturen (SOAs = service-oriented architectures) als ein Mittel zur Bereitstellung von Informationen, nicht als Möglichkeit zu deren Gebrauch. Doch wie gehen Sie mit all diesen Automatisierungsinseln um? Hier tritt der integrierte Desktop auf den Plan.

Lösungsarchitekten sind bemüht, die sich ständig ausdehnende Landschaft von Geschäftsanwendungen zu vereinfachen und die Benutzerfreundlichkeit zu verbessern. Doch eines der am schwersten erreichbaren Ziele ist die nahtlose Integration einer Lösung, die mehrere Anwendungen umspannt, die auf dem Desktop ausgeführt werden. Techniken wie DDE, OLE, COM, Mailslots und dergleichen wurden alle für die lokale Integration von Anwendungen verwendet. Doch das Ergebnis waren stark gekoppelte, zerbrechliche Desktopanwendungen, die in der Bereitstellung und Wartung in der Regel recht teuer sind.

Integrated Desktop ist die neueste Ausgabe einer verbundenen Systemarchitektur, die sich auf den Desktop konzentriert. Integrated Desktop ist eine lose gekoppelte Hosting-Architektur und zusammengesetzte Benutzeroberfläche, die auf dem Desktop ausgeführt und am Back-End von einer lose gekoppelten Architektur unterstützt wird. Dadurch wird die Anzahl der Anwendungen drastisch reduziert, mit denen der Benutzer umgehen muss; es kommt alles in einen Topf. Alle Technologien, die zum Erstellen von Integrated Desktop-Anwendungen erforderlich sind, sind bereits in .NET Framework vorhanden. Bis jetzt war es jedoch eine große Herausforderung, sie zusammenzufügen.

Der Strategie von Integrated Desktop liegt die Aktivierung von Diensten zugrunde. Für die Architektur ist nicht unbedingt ein Gewebe aus Diensten erforderlich, für eine Strategie zum Erstellen zusammensetzbarer Unternehmensdesktops schon. Die lose Kopplung der Integrated Desktop-Anwendungen passt sich ganz natürlich Back-Ends mit aktivierten Diensten an. Das Beibehalten der Attribute einer lose gekoppelten Architektur wirkt sich auch auf die Bereitstellung aus, bei der bei dieser Art von Architektur häufig Probleme auftreten.

Der neue Composite UI Application Block (CAB) und die Smart Client Software Factory bilden das Fundament der Integrated Desktop-Implementierung von Microsoft. Gemeinsam verwendet sind dies leistungsfähige Tools für Lösungsarchitekten, die ihr eigenes Desktop-Framework sowie benutzerdefinierte Anwendungen erstellen. (Bevor Sie fortfahren, machen Sie sich mit den Begriffen in der Randleiste Grundlegende Terminologie vertraut.)

Auf dieser Seite

Funktionsweise von CAB
Erstellen einer einfachen CAB-Anwendung
Einführung in die Smart Client Software Factory
Wichtige Dienste für intelligente Clients
Funktionsebenen des Integrated Desktop
Integrieren einer Legacy-Webanwendung
Ein Blick in die Zukunft
Die Autoren

Funktionsweise von CAB

CAB ist eine Implementierung der Muster und Konzepte, die zum Erstellen komplexer intelligenter Clientanwendungen verwendet werden. Einfach ausgedrückt bietet er Windows® Forms Grundlagen, mit deren Hilfe Sie Unternehmensdesktopanwendungen erstellen können.

Über CAB ließe sich mit Leichtigkeit ein eigener Artikel verfassen, und es gibt mehrere Komponenten, die den Rahmen dieses Artikels sprengen würden. Hier werden die primären Komponenten von CAB behandelt, doch Sie sollten das Programm herunterladen und selbst gründlich erforschen. Beginnen Sie mit einem Besuch der CAB Community Site.

CAB ist dafür ausgelegt, viele Anwendungsszenarien wie z. B. OLTP-Front-Ends (Online Transaction Processing), Clientportale und Anwendungen von Information Workern zu unterstützen. Aufgrund seines modularen Aufbaus und geringen Speicherbedarfs kann CAB nicht nur für umfangreiche integrierte Desktops, sondern auch für einfache intelligente Clients verwendet werden.

CAB ermöglicht die Freigabe von Entwicklungsaufgaben einer einzelnen Benutzeroberfläche eines intelligenten Clients, indem die Bausteine der Benutzeroberfläche sauber entkoppelt werden. Letztendlich verbessert CAB die Wiederverwendung und kann einfach zur Aktivierung von Konzepten wie Workflows innerhalb von Anwendungen verwendet werden. Um die Wiederverwendung zu ermöglichen, wird eine mithilfe des CAB-Frameworks erstellte zusammengesetzte Benutzeroberfläche in mehrere funktionsfähige Komponenten zerlegt. Die Shell ist der Treiber der Anwendung, die sowohl als ausführbare Datei des Hosts als auch als Bootstrap zum Laden der Komponenten Ihrer zusammengesetzten Benutzeroberfläche dient. Wenn die Elemente der Benutzeroberfläche geladen sind und von der Shell angezeigt werden, bieten sie den Benutzern „Berührungspunkte“ wie z. B. Menüs und andere Navigationskomponenten. Shells sind selbst lose an die Anwendungskomponenten gekoppelt und bieten dadurch einen flexiblen Ansatz für die Entwicklung von Benutzeroberflächen. Die Shell und die CAB-Dienste fahren den Wagen, doch Sie müssen den Motor in Form einer oder mehrerer Anwendungen bereitstellen, die von der Shell verwaltet werden.

Neben der Bereitstellung eines Frameworks für die Verwaltung wieder verwendbarer Komponenten bietet CAB außerdem einen Basissatz intelligenter Clientdienste für Aufgaben wie das Laden von Modulen, Austauschen von Meldungen, Beibehalten des Status usw. Diese können als Code oder über die .config-Datei Ihrer Anwendung hinzugefügt werden. Diese Basisdienste umfassen:

Modullader und Modulaufzählungsdienste sind anbieterbasierte Dienste, mit denen das Lesen und Laden von Modulen gesteuert wird, die im Katalog konfigurierbarer Programme aufgeführt sind.

Der Ereignismaklerdienst gibt Meldungen zwischen den Komponenten und Unteranwendungen weiter, die von einer zusammengesetzten Oberfläche verwaltet werden.

Der Authentifizierungsdienst ist ein anbieterbasierter Dienst, der dafür verantwortlich ist, Benutzer zur Eingabe ihrer Anmeldeinformationen aufzufordern, auf Zertifikate zuzugreifen und mit Back-End-Datenprovidern Kontakt aufzunehmen.

Der Statusbeibehaltungsdienst ist ein anbieterbasierter Speicherdienst, der den Status von Arbeitselementen für die Freigabe von Kontextdaten speichert und ermöglicht, Arbeitselemente anzuhalten und später erneut zu aktivieren.

Wenn Sie das Modul für eine CAB-Anwendung erstellen, beginnen Sie in der Regel mit der Erstellung eines CAB-Moduls. Module stellen einen bereitstellbaren Einstiegspunkt für Ihre individuelle Featureliste zur Verfügung, was manchmal auch als verwaltete Anwendung bezeichnet wird. Module sind in ihren eigenen DLL-Dateien enthalten und werden zur Laufzeit von der Shell geladen. Welche Module verfügbar und geladen sind, kann vollständig konfiguriert werden und wird von einem umfassenden Programmkatalog gestützt. Wenn Sie mit der Microsoft Enterprise Library vertraut sind, erkennen Sie dasselbe Providermodell in CAB. Module benötigen im Shell-Projekt in Visual Studio® keine direkten Verweise und sind niemals direkt an die ausführbare Datei gebunden. Stattdessen werden sie zur Laufzeit vom Modullader geladen.

Innerhalb einer Modulassembly stellen Sie die Arbeitselemente, Ansichten, Controller und Daten bereit, die dafür erforderlich sind, diese Featureliste mit der Hilfe von CAB- und Smart Client Software Factory-Typen wie Presenter, SmartPart und State zu steuern. Insbesondere diese drei Elemente bilden das Muster Modell-Ansicht-Presenter/Modell-Ansicht-Controller (MVP/MVC), auf dem die CAB-Anwendungen basieren. Dienste werden ggf. von der Anwendungslogik eingefügt. Dadurch kann der Entwickler dynamisch neue Objektinstanzen erstellen bzw. Objekte zurückgeben, die bereits innerhalb eines Containers erstellt wurden. Bei CAB ist dieser Container das Arbeitselement, und das ist eines der ersten Elemente, die ein Modulentwickler erstellt. CAB-Komponenten wie clientseitige Dienste und Arbeitsbereiche können mit AddNew ausdrücklich dem Container hinzugefügt werden:

_rootWorkItem.WorkItems.AddNew<WorkItemA>();

Dies kann auch durch Konfiguration oder deklarativ geschehen: 

[CreateNew]
public ShipNewOrderViewPresenter Presenter
{
    set
    {
        _presenter = value;
        _presenter.View = this;
    }
}

Im Umfang des Containers (Arbeitselements) können diese Komponenten also bei Bedarf deklarativ dereferenziert werden. Dadurch erhalten Sie die lose gekoppelte Möglichkeit, Zugriff auf jedes Element in einem Container zu erhalten, das von CAB verwaltet wird, bzw. dieses einzufügen. Dies wird im Folgenden dargestellt:

[ServiceDependency]
public WorkItem WorkItem
{
    set { _workItem = value; }
}

Eine Schlüsselkomponente von CAB ist Object Builder, der auch von der neuen Version der Enterprise Library verwendet wird. Durch die Bereitstellung einer Implementierung dieser Dependency Injection aktiviert Object Builder eine Reihe nützlicher Features. Er kann neue konkrete Klasseninstanzen erstellen oder ggf. vorhandene zurückgeben; er kann den geeigneten Konstruktor auswählen, wenn eine Klasse mehr als einen offen legt; er kann auf Attribute reagieren, die von Eigenschaften und Methoden deklariert werden und die die Erstellung und Benennung des neuen Objekts beeinflussen; und er kann eine Löscheinrichtung bereitstellen, die Einstellungen von vorhandenen Objekten entfernt, indem die Kette der Vorgänge rückgängig gemacht wird.

Object Builder ist ein einfaches Dienstprogramm, mit dem Sie in den meisten Fällen nicht direkt interagieren. Es ist jedoch von entscheidender Bedeutung, das Konzept der Dependency Injection zu kennen, um zu verstehen, wie Dienste in Ihr Modul integriert werden. Dieses Wissen ist beim Debuggen sehr nützlich. Weitere Informationen zur Dependency Injection und anderen in CAB verwendeten Mustern finden Sie in der CAB-Dokumentation.

Sie können das Modul beliebig aufteilen. Pro Modul sollte mindestens ein Arbeitselement vorhanden sein, und ein Arbeitselement muss als Treiber für das Modul dienen. Arbeitselemente können wie jede andere Anwendung oder Unteranwendung so genau oder grob gefasst sein, wie Sie es wünschen. In einer CAB-Anwendung sieht die Reihenfolge der Ereignisse in der Regel wie folgt aus:

Der Benutzer klickt doppelt auf die EXE-Datei, woraufhin die Shell angezeigt wird.
Die Shell startet den Desktop, lädt und konfiguriert CAB-Dienste, zeigt ihre Benutzeroberflächenelemente an, und lädt alle konfigurierten Module.
Sobald es geladen ist, fügt jedes Modul dem übergeordneten Arbeitselement ein Arbeitselement hinzu, um diese Unteranwendung zu steuern, und fordert das Arbeitselement auf, seinen gesamten Inhalt in dem bereitgestellten Arbeitsbereich anzuzeigen.
Wenn der Benutzer im Menü ein Benutzeroberflächenelement auswählt, wird der damit verknüpfte Befehl ausgelöst.
Ein Befehlshandler reagiert auf den Befehl, indem er ein untergeordnetes Arbeitselement hinzufügt, das eine weitere Unteranwendung steuert und deren Ansichten anzeigt.
Das Arbeitselement zeigt seine Ansicht durch ein Smart Part an.
Der Benutzer interagiert mit der Benutzeroberfläche der Ansicht, die wiederum einen Controller (oder Presenter) weitergibt.
Der Controller ändert die freigegebenen Daten (Status) und tauscht sich über den Ereignismakler mit dem Host aus.
Der Ereignismakler sendet diese relevanten Informationen (Kontext) an andere Module oder Komponenten.>

CAB-Module können eigenständig oder Teil eines größeren Satzes von Modulen sein, die von der Shell verwaltet werden. Bei den intelligenten Clients mit mehreren Modulen kann CAB wirklich mit seiner Flexibilität und seinem Design glänzen. Diese Flexibilität ist hauptsächlich dem Umstand zu verdanken, dass Sie in dem Shell-Projekt, das Ihre Modulassemblys lädt, niemals direkt darauf verweisen müssen, da sie zur Laufzeit von CAB geladen werden. Außerdem können einzelne Komponenten eines einzelnen Moduls miteinander kommunizieren, ebenso wie Komponenten, die in externen Modulen ausgeführt werden und die sich in ihren eigenen, separaten Assemblys befinden.

Erstellen einer einfachen CAB-Anwendung

Erstellen Sie jetzt eine Anwendung mit einem Modul. Zunächst wird in allgemeinen Begriffen erläutert, wie Sie einen einfachen intelligenten Client erstellen. (Im weiteren Verlauf dieses Artikels wird ein komplexerer integrierter Desktop erläutert.)

Die meisten integrierten Desktops verfügen über ein sichtbares Startformular, also beginnen Sie in der Regel mit einer Windows Form-Shell. Zu Beginn erben Sie Ihre Klasse von FormShellApplication, instanziieren sie, und rufen von der Methode Main Ihrer Anwendung deren Methode Run auf. Dadurch wird die CAB-Anwendung initialisiert, die die weiter oben erörterten Dienste lädt und konfiguriert. Zu den nächsten Schritten gehört das Außerkraftsetzen von Methoden, die von FormShellApplication bereitgestellt werden, wie etwa AfterShellCreated, um Menüs auszufüllen und alle sichtbaren Ansichten anzuzeigen. (Smart Parts, bei denen es sich um Benutzersteuerelemente mit SmartPartAttribute handelt, sind optional.)

Um bei der Implementierung von AfterShellCreated Ihre Benutzeroberfläche zu initialisieren, registrieren Sie eine Erweiterungssite, wie sie in CAB genannt wird. Dadurch wird ein Benutzeroberflächenelement-Manager bereitgestellt, sodass jedes Modul später jederzeit untergeordnete Benutzeroberflächenelemente, wie z. B. Menüeinträge oder Symbolleistenelemente, hinzufügen kann. Schließlich beginnen Sie damit, Ihre Ansichten entweder dann anzuzeigen, wenn die Shell geladen wird, oder aber in Reaktion auf Befehle von Benutzeroberflächenelementen, die in der Regel ebenfalls im Verlaufe dieser Initialisierung hinzugefügt werden. Befehle gehen zu Befehlshandlern, sodass Ihr Code auf jeden Befehl reagieren kann, der zur Laufzeit von einem beliebigen generischen Benutzeroberflächenelement ausgelöst wird. Dies ähnelt dem Hinzufügen normaler Ereignishandler, ist jedoch abstrakter.

Ansichten können mit SmartPartPlaceHolder-Klassen angezeigt werden, oder durch einen Arbeitsbereich, wie es in CAB heißt. Dies sind einfache Layoutcontainer, mit denen Ihre Ansichten in einer vorgegebenen Anordnung angezeigt werden. Wenn Sie schon einmal mit dem Java Abstract Windows Toolkit (AWT) gearbeitet haben, sollten Sie mit diesem Konzept vertraut sein.

Schließlich registrieren Sie eine Benutzeroberfläche und zeigen ein Smart Part an, um die Shell zu erstellen. In der Randleiste „Erstellen eines einfachen intelligenten Clients: detaillierte Anweisungen“ wird ausführlich erklärt, wie Sie einen einfachen und dennoch modular aufgebauten, intelligenten Client erstellen können. Um die tatsächliche Leistungsfähigkeit von CAB zu offenbaren, kapseln Sie Ihre Komponenten mit Modulen in separate Assemblys ein. Dadurch erhalten Sie Entwurfszeitabstraktionen, ebenso wie eine Laufzeitabstraktion, die dem ähneln, was COM bereitstellt, jedoch ohne die Komplexität.

In Modulen können Sie unabhängige Featurelisten verwalten, die über ihre eigenen Assemblys bereitgestellt werden. Das bedeutet, dass eine Organisation einzelne Module bereitstellen, verbessern und deren Versionen kontrollieren kann, ohne dass sich dies auf den gesamten Integrated Desktop auswirkt. Modulassemblydateien, auf die in der EXE nicht direkt verwiesen wird, werden zur Laufzeit durch den Modullader und die Aufzählungsdienste geladen. Mit dem Profilkatalog der CAB und der Anwendungskonfigurationsdatei können Sie festlegen, welche Module geladen, bereitgestellt und mit der Shell verbunden werden. Die Randleiste „Erstellen eines Moduls und Modulinitialisierers“ führt Sie schrittweise durch den Prozess bei der Erstellung eines Moduls und dessen Initialisierer. In den von mir skizzierten Schritten sind alle Funktionen beschrieben, die mit dem Erstellen einer einfachen CAB-Anwendung zusammenhängen. Doch beachten Sie, dass hier lediglich an der Oberfläche gekratzt wurde.

Das Schnellstart-Beispiel „Kassierer“, das mit CAB installiert wird, ist eine fertige CAB-Anwendung mit einem Modul. Dadurch erhalten Sie eine Einführung in alle Schlüsselkomponenten, die ich hier zusammengefasst habe.

Wenn ein richtiger Integrated Desktop für Unternehmen erstellt wird, gehört selbstverständlich viel mehr dazu als die Komponente der zusammengesetzten Benutzeroberfläche. Sie müssen sich um eine Unmenge komplexer Fragen kümmern, z. B.: Wie können Informationen von Modulen gemeinsam genutzt werden, wie lassen sich nicht-CAB-Anwendungen in das Desktop integrieren, wie wird die Sicherheit gehandhabt und wie das Layout gesteuert.

Einführung in die Smart Client Software Factory

Neben den von CAB bereitgestellten Basisdiensten gibt es eine weitere Klasse von Foundation-Diensten, die Sie beim Erstellen einer fertigen Anwendung für Unternehmen benötigen. Diese Dienste umfassen Möglichkeiten zum Verwalten Ihres Desktop in den Bereichen Bereitstellung und Sicherheit. Unter Umständen benötigen Sie auch Dienste wie Protokollierung, Workflow, Konfiguration und Zwischenspeicherung, um sicherzustellen, dass alle Komponenten in dieser lose gekoppelten Umgebung reibungslos zusammenarbeiten.

Die Smart Client Software Factory kann Sie unterstützen, indem sie Anleitung und Referenzimplementierungen anbietet. Die Smart Client Software Factory ist mehr als nur ein Toolkit. Sie stellt ein Starterset fundamentaler Dienste für intelligente Clients bereit, mit deren Hilfe sie fertige Integrated Desktops für Unternehmen erstellen können.

Alle Dienste können sowohl als optional als auch als erweiterbar angesehen werden. Die Smart Client Software Factory baut auf CAB und der Enterprise Library auf und nutzt die vorhandenen Anwendungsblöcke. In Abbildung 1 wird die Architektur von Diensten für intelligente Clients dargestellt, wenn diese mithilfe der Smart Client Software Factory erstellt wurden.

Abbildung 1: Dienste für intelligente Clients

Da die meisten Unternehmen einen Satz üblicher Dienste benötigen, hat Microsoft eine Sammlung verwandter Anlagen in die Smart Client Software Factory integriert. Diese werden von zwei Referenzimplementierungen hervorgehoben, die typische Erlebnisse den Diensten in der Smart Client Software Factory zuordnen. Die Referenzimplementierung 1 ahmt einen Desktop zur Beurteilung eines Darlehensantrags nach und nutzt Offlinefunktionen, Endbenutzerbenachrichtigung und andere ähnliche Features. Die Referenzimplementierung 2 ahmt einen Desktop eines Bankbeamten (eine Version des Beispiels „Kassierer“, jedoch mit mehreren Modulen) nach, um Sicherheit, Bereitstellung und Themendienste zu demonstrieren.

Anleitungspakete bieten ebenfalls wertvolle Hilfe zum Erstellen von Unternehmensanwendungen. Sie werden mit dem relativ neuen Guidance Automation Toolkit (GAT) erstellt, einer Erweiterung von Visual Studio 2005. Mit GAT können Team Developer Starterkits (oder SDKs) bereitstellen, sodass andere Entwickler Module und weitere ID-Komponenten hinzufügen können. Die Smart Client Software Factory enthält ein wesentliches Element, das Visual Studio-Anleitungspaket für die Entwicklung von intelligenten Clients. Hierbei handelt es sich um eine integrierte Sammlung von Tools, Mustern, Quellcode und vorschreibenden Anweisungen, die ID-Entwickler durch den CAB-Entwicklungszyklus leiten. Weitere Informationen zu GAT finden Sie unter msdn.microsoft.com/vstudio/teamsystem/Workshop/gat/default.aspx (möglicherweise in englischer Sprache). Dort können Sie das Toolkit auch herunterladen.

Wichtige Dienste für intelligente Clients

Der Integrated Desktop sitzt oben auf der Smart Client Software Factory und CAB. Er sollte die Form eines wieder verwendbaren Satzes von CAB-Erweiterungen, Implementierungen der Smart Client Software Factory, generischer Foundation-Dienste und Bibliotheken annehmen, die ganz oder teilweise einer vorhandenen zusammengesetzten Benutzeroberfläche hinzugefügt werden können. Dadurch wird das Integrated Desktop-Framework gebildet, das einige wichtige Dienste umfasst.

Kontextdienste Dies ist eines der wichtigsten Elemente beim Erstellen eines integrierten Desktop. Wahrscheinlich ist es auch das am häufigsten missverstandene. Wenn Sie mit CAB-Anwendungen arbeiten, die aus mehreren Modulen bestehen, verwenden Sie in der Regel eine Form der Informationsfreigabe. So besteht Ihre CAB-Anwendung z. B. aus einer Shell, einem Modul zum Anzeigen von Kundeninformationen, einem Headermodul zum Anzeigen von zusammenfassenden Daten, einem Suchmodul und weiteren aufgabenspezifischen Modulen. Jedes dieser Module kann separat entwickelt, bereitgestellt und gewartet werden. CAB bietet die Grundlagen, um dies zu ermöglichen; das „Wie“, wenn Sie so wollen. Doch Sie müssen immer noch das „Was“ liefern, also die Informationen, die von diesen Modulen gemeinsam genutzt werden. Dies könnte eine einfache Kunden-ID sein. Der Ereignismakler teilt global mit, dass der Kontext geändert wurde, und alle Module zeigen zur entsprechenden Zeit die entsprechenden Informationen an. Der Umstand, dass Sie die Kunden-ID übertragen, sagt aus, dass diese Informationen freigegeben werden. Dies bildet die Voraussetzung von „Kontext“.

Kontextdienste werden ausschließlich zum Übertragen und Abrufen dieser freigegebenen Informationen verwendet. Dabei werden die Richtlinien beachtet, die im Unternehmensdesktop festgelegt wurden. Sie sollten einen Basissatz von Kontexttypen und deren entsprechenden Schemaverträgen verwenden, bevor Sie auf Ihrem Desktop einen anderen Dienst bereitstellen. Dies ähnelt der in SOA verwendeten Entwurfspraxis „Vertrag zuerst“. Statt an den Verträgen festzuhalten, die an den Endpunkten von Webdiensten definiert wurden, definieren Sie diese Verträge zwischen den Komponenten des Desktop selbst. Tatsächlich sehen Sie sich beim Erstellen einer Integrated Desktop-Anwendung denselben Herausforderungen gegenüber wie bei einem EAI- oder SOA-Projekt.

Bereitstellungsdienste Diese Dienste versorgen das Integrated Desktop mit seinen Komponenten, indem sichergestellt wird, dass einzelne Module dem Desktop zur Laufzeit bereitgestellt werden können. Eine Option ist das Erstellen von Bereitstellungsdiensten auf der ClickOnce-API. Diese Dienste sollen eine serverseitige Steuerung bestimmter optionaler Module bereitstellen, die auf den Desktop heruntergeladen werden. Wenn die Shell startet, stellen die Authentifizierungsdienste den Bereitstellungsdiensten Beweise zur Verfügung, dass bestimmte Module für den Benutzer aktiviert sind und daher auf den Desktop heruntergeladen werden müssen, falls sie nicht bereits präsent sind. Module werden heruntergeladen, vom Modullader geladen und dem Benutzer bei Bedarf angezeigt. In CAB können Sie dem Profilkatalog Benutzerrollen hinzufügen. Der Implementierer der Bereitstellungsdienste kann den normalen Modulladedienst einfach erweitern, um diese Funktion zu nutzen, da CAB nur Module per Aufruf in die Modulladeerweiterung lädt, deren Ausführung autorisiert wurde und die über Rollen verfügen, die aktuell dem ausgeführten Prinzipal angefügt sind.

Sicherheitsdienste Im Gegensatz zu Kontextdiensten sind Sicherheitsdienste leicht zu verstehen. Sie können auf den bereitgestellten Authentifizierungsdiensten aufbauen, die Sie bereits in CAB haben. Dadurch erhalten Sie einen Ausgangspunkt für die Verwendung benutzerdefinierter Authentifizierungsdienste sowie eine Möglichkeit, Autorisierungslogik einheitlich zu Ihrer integrierten Desktopanwendung hinzuzufügen. Wenn Sie die von CAB und der Smart Client Software Factory bereitgestellten Dienste und Anleitungen verwenden, können Sie einzelnen Modulen Rollen hinzufügen, um zu kennzeichnen, dass diese Module mit bestimmten Rollen verbunden sind. Dadurch können Sie auf der Grundlage der angemeldeten Benutzer steuern, welche Module geladen werden. Außerdem können andere Einrichtungen wie z. B. Ihre Bereitstellungsdienste steuern, welche Module tatsächlich auf dem Desktop bereitgestellt werden.

Integrationsdienste Die Bereitstellung eines einzelnen Unternehmensdesktop wäre nicht sehr nützlich, wenn verwaltete Windows Forms-Anwendungen die einzigen Kandidaten für die Integration in den intelligenten Client wären. In der Regel gibt es zahlreiche vorgefertigte (Legacy-) Anwendungen, die integriert werden müssen, sodass sie autonom bleiben und dennoch ein Teil des Desktoperlebnisses sein können. Dazu gehören Webanwendungen, die ohne .NET erstellt wurden, ASP.NET-Webanwendungen, COM-Anwendungen und sogar Green Screens.

Integrationsdienste in der Smart Client Software Factory bieten Anleitungen zum Integrieren einiger dieser Dienste in Ihren integrierten Desktop. In diesem Artikel wird eine Art der Integration von Legacy-Desktopanwendungen behandelt: die Webanwendungen. Hier wird gezeigt, wie CAB und die Smart Client Software Factory (zusammen mit ihren Anleitungspaketen) Sie beim Erstellen eines Webmoduls unterstützen können, das jede Webanwendung aufnehmen und mit wenig Aufwand verwalten kann.

Funktionsebenen des Integrated Desktop

Ein Integrated Desktop besteht aus drei Ebenen: Fundament, Plattform und Anwendung. Es ist sehr wichtig, diese Ebenen zu kennen und zu wissen, auf welche Ebenen sie sich auswirken, wenn Sie eine ID-Lösung entwickeln. In Abbildung 2 werden die Beziehungen dargestellt, die diese Ebenen mit verschiedenen Ebenen der Integrated Desktop-Architektur haben.

Neue_fig02
Abbildung 2: Architektur des Integrated Desktop

Fundamentebene: Diese Ebene besteht aus allen wichtigen, clientseitigen Diensten, die von CAB zur Verfügung gestellt werden, außerdem aus Diensten wie Sicherheit und Bereitstellung, die von jedem Modul oder Smart Part genutzt werden können. Sie stellen die verbundenen horizontalen Komponenten des Desktops dar. Sowohl CAB als auch die Smart Client Software Factory liefern einen großen Teil der Fundamentebene. Diese Ebene und die entsprechenden clientseitigen Dienste müssen beim Erstellen eines Integrated Desktop Framework zuerst behandelt werden.

Plattformebene: Diese Ebene ist den Diensten gewidmet, die plattform- bzw. technologiespezifische Elemente bereitstellen, z. B. jene, die von Legacy-Diensten verarbeitet werden. Sie besteht aus Komponenten, mit denen ein Modul- oder Smart Part-Entwickler Komponenten integrieren kann, die die Plattform berücksichtigen, von der sie stammen. Wenn Sie über mehrere Webanwendungen verfügen, die in den Desktop integriert werden müssen, kann die Bereitstellung wieder verwendbarer clientseitiger Webanwendungen als Bestandteil Ihres Integrated Desktop-Frameworks Sie bei der Verwaltung dieser Anwendungen unterstützen. Unter Umständen möchten Sie z. B. eine vorhandene Warenkorbanwendung verwenden, die in der Produktion bereits ausgeführt wird. Mit den Diensten der Plattformebene kann diese Anwendung in dem Desktop verwaltet werden, wo sie wie jedes andere verwaltete Modul agiert. Die Smart Client Software Factory bietet als Teil dieser Ebene einen Satz von Legacy-Diensten an.

Anwendungsebene: Diese Ebene besteht ausschließlich aus Anwendungen und wieder verwendbaren, clientseitigen Unternehmensfunktionen und stellt clientseitige Dienste bereit, die für das Unternehmen spezifisch sind. Diese Ebene besteht aus den Modulen, mit denen Sie in der Regel interagieren, wie z. B. „Suche“, „Kundeninformationen“ und „Warenkorb“.

Integrieren einer Legacy-Webanwendung

Wenn Sie eine vorhandene Webanwendung in Ihrer CAB-Anwendung verwalten möchten, ist dazu mehr erforderlich, als lediglich ein Browsersteuerelement zu einem Smart Part hinzuzufügen. Der Sinn clientseitiger Integration ist, dass alle Anwendungen bzw. Module vollständig integriert sind. Das bedeutet, dass sie Informationen in beide Richtungen kommunizieren und freigeben können. Bevor CAB zur Verfügung stand, war diese Funktion möglich, doch die Lösungen waren vorschreibend und alles andere als wieder verwendbar.

Doch wie bereits erwähnt, können Sie jetzt ein Webmodul erstellen, um jede beliebige Webanwendung zu verwalten. Und dies können Sie erreichen, ohne dass ein anderes Modul den Unterschied bemerkt. Vorhandene Module müssen niemals die Art und Weise ändern, in der sie Informationen freigeben.

Im Folgenden wird schrittweise das Erstellen eines einfachen Webmoduls (ähnlich wie das in Abbildung 3 dargestellte) anhand der vom Smart Client Software Factory-Team bereitgestellten Anleitung erklärt. Dabei werden die CAB-Dienste und die neuen Anleitungspakete verwendet, die von der Smart Client Software Factory bereitgestellt werden.

Abbildung 3 Von einem Webmodul verwaltete Webanwendung

Zunächst müssen Sie eine neue Webanwendung erstellen oder eine vorhandene verbessern. In diesem Beispiel werden die Schritte zum Erstellen einer neuen ASP.NET-Webanwendung skizziert. Sie können sie auch als Vorlage zum Ändern vorhandener Webanwendungen verwenden. Der hier verwendete Prozess ist ein wenig invasiv; Sie müssen JScript® zu der Anwendung hinzufügen und das Objektmodell verwenden, um mit der Webanwendung zu kommunizieren, indem Sie zur Entwurfszeit Code hinzufügen.

Sobald die Beispielwebseite erstellt ist, die wie eine typische Webanwendung agiert, erstellen Sie ein Webmodul. Doch bevor Sie dies tun, müssen Sie die folgenden erforderlichen Komponenten herunterladen:

Guidance Automation Extensions (GAX)
Composite UI Application-Anleitungspaket (stellen Sie sicher, dass dieses in der aktuellen Anwendung aktiviert ist)
Composite UI Application Block (in englischer Sprache)
Einfache Shellanwendung mit den entsprechenden Verweisen auf die CAB-Bibliothek und die Smart Client Software Factory
Bibliotheksprojekt mit dem gesamten gemeinsamen Code, der in einigen anderen Modulen und Anwendungsbibliotheken wieder verwendet werden kann

Klassen wie Microsoft.Practices.SmartClient.Web.WebPresenter und Microsoft.Practices.SmartClient.Web.WebView, die Teil der Smart Client Software Factory sind, stellen die Grundlagen für die automatische Zuordnung von Ereignissen bereit, die mit dem Ereignismakler von CAB auf Ihrer Webseite ausgelöst werden. Dadurch kann jedes Webmodul die in CAB integrierten standardmäßigen Kommunikationsmechanismen nutzen und automatisch alle Ereignisse mit der Webseite austauschen (in beide Richtungen). Microsoft.Practices.SmartClient.Web.WebView erbt von einem Browsersteuerelement und kann in Ihrem Webmodul wieder verwendet werden.

Beachten Sie, dass das Anleitungspaket optional ist und nur Teile des Vorlagencodes automatisch in Ihrem Projekt bereitstellt, wie etwa die von der Smart Client Software Factory bereitgestellten Dienste. Alternativ können Sie die Beispielwebseite und das -webmodul aus diesem Artikel herunterladen.

Schritt 1: Erstellen einer Webseite Erstellen Sie zunächst eine Webseite, die als Legacy-Webanwendung dienen wird.

Erstellen Sie ein neues Webprojekt oder fügen Sie eine neue Seite zu einem vorhandenen Webprojekt hinzu.
Sie können auch einen Verweis auf eine beliebige gemeinsame Bibliothek hinzufügen, die unter Umständen Konstanten enthält, die von der Webanwendung verwendet werden.
Fügen Sie eine HTML-Schaltfläche mit dem Text-Eigenschaftenwert „Fire Context Changed Event“ (aus JavaScript) hinzu.
Fügen Sie eine ASP.NET-Schaltfläche mit dem Text-Eigenschaftenwert „Fire Context Changed Event“ (vom ASP.NET-Server) hinzu.
Fügen Sie ein HTML-Textfeld mit der ID „txtCustomerName“ hinzu.

Fügen Sie der Methode Page_Load der Seite folgenden Code hinzu (dies ist nur erforderlich, wenn Sie ASP.NET-Serversteuerelemente verwenden):

ClientScript.RegisterOnSubmitStatement(cstype, Common.Events.        
        ContextChanged, BuildRaiseEvent(Common.Events.ContextChanged));

Fügen Sie folgende private Methode hinzu (dies ist ebenfalls nur dann erforderlich, wenn Sie ASP.NET-Serversteuerelemente verwenden):

private string BuildRaiseEvent(string topic) 
    { 
        StringBuilder sb = new StringBuilder(); 
        sb.Append("window.external.FireEvent(\""); 
        sb.Append(topic); 
        sb.Append("\",0);"); 
        return sb.ToString(); 
    }

Doppelklicken Sie auf die erste Schaltfläche, und fügen Sie dem Ereignis onclick folgenden Code hinzu:
```
window.external.FireEvent("ContextChangedEvent","Param1");
```
Dieser Code löst durch die Smart Client Software Factory ein Ereignis aus der Webseite in den Webbrowsercode und in den intelligenten Client aus, der den Ereignismakler verwendet.
Fügen Sie nach dem Ereignishandler onclick im vorherigen Schritt folgenden Code hinzu:
```
function EventBroker_Subscribe() 
    { 
        window.external.SubscribeEvent("ContextChangedEvent");
        window.external.SubscribeEvent("CustomerContextChangedEvent");  
    } 

    function EventBroker_ContextChangedEvent() 
    { 
        window.alert("Context changed event: Hello from Web App"); 
    }
```
Der Ereignishandler Subscribe ermöglicht es dem intelligenten Client, der Webseite mitzuteilen, wann die Ereignisabonnements eingerichtet werden sollen; dies geschieht in der Regel, nachdem die Webseite sich selbst in das Browsersteuerelement geladen hat. Die Webseite wiederum löst ein Ereignis auf dem Host aus und ruft SubscribeEvent auf (ein Ereignis, das die Webseite abonniert). Dadurch können alle globalen Ereignisse in CAB von dem intelligenten Client an die Webseite fließen, wenn dieses Ereignis ausgelöst wird. Dies wird von den Ereignishandlern EventBroker_XXX in JScript aufgefangen.

Fügen Sie diese JScript-Funktion hinzu:

function EventBroker_CustomerContextChangedEvent(eventData) 
{ 
    document.getElementById('txtCustomerName').value = eventData.Name;
}

Dadurch wird gezeigt, wie Ereignisdaten von dem intelligenten Client an die Webseite weitergegeben und dort verwendet werden.

Schritt 2: Erstellen eines Webmoduls Wenn Sie ein Webmodul erstellen möchten, klicken Sie zuerst mit der rechten Maustaste auf die Lösung, und wählen Sie Hinzufügen | CompositeUI | Modul aus. Geben Sie im Dialogfeld Neues Projekt hinzufügen den Namen Ihres eigenen Moduls an. Klicken Sie dann auf OK, wählen Sie das Shell-Projekt aus, und klicken Sie auf Fertig stellen.

Sie werden feststellen, dass eine ganze Reihe neuer Elemente erstellt wurde. Ein neues Webmodul-Projekt wird der Lösung hinzugefügt. Erforderliche Verweise, einschließlich der Bibliotheksverweise von CAB und der Smart Client Software Factory, werden dem Webmodul-Projekt hinzugefügt. Ein Ordner namens WorkItems wird innerhalb des neuen Projekts erstellt, ebenso wie eine Datei und eine Klasse namens ModuleInit.cs.

Schritt 3: Erstellen eines neuen WorkItems Das Erstellen eines neuen WorkItems ist genau so einfach. Klicken Sie zuerst mit der rechten Maustaste auf den Ordner WorkItems in dem soeben erstellten Modul, und wählen Sie Hinzufügen | CompositeUI | WorkItem aus. Ändern Sie den Namen in WebWorkItem.cs. Wählen Sie das Shell-Projekt aus, und klicken Sie auf die Schaltfläche Fertig stellen.

Jetzt werden Sie feststellen, dass eine Datei und eine Klasse namens WebWorkItem.cs erstellt wurden. Außerdem wurden die Using-Direktiven und die erforderlichen Verweise für CAB und die Smart Client Software Factory hinzugefügt.

Fügen Sie in der Klasse Load from ModuleInit folgenden Code hinzu:

WorkitemCatalog.RegisterWorkItem<WebWorkItem>();

Fügen Sie außerdem folgende Using-Direktive am Anfang der Datei ModuleInit.csB hinzu:

using WebModule.WorkItems.WebWorkItem;

Schritt 4: Erstellen einer neuen Ansicht In diesem Schritt wird der Datenaustausch zwischen der Webseite und der intelligenten Clientanwendung behandelt, in diesem Fall dem Webmodul.

Klicken Sie mit der rechten Maustaste auf den Ordner WebWorkItem.
Wählen Sie Hinzufügen | CompositeUI | Ansicht aus.
Ändern Sie den Namen in WebView, und klicken Sie auf die Schaltfläche Fertig stellen. Dadurch werden die Benutzeroberfläche IWebView interface, die Klasse WebPresenter und das Benutzersteuerelement WebView erstellt. Diese implementieren ein typisches MVP-Muster, das in der gesamten Smart Client Software Factory verwendet wird.
Navigieren Sie zu der Klasse WebWorkItem, und fügen Sie den folgenden Code hinzu:
```
public void ShowInView(IShellView view) 
    { 
        WebView webView = this.Items.AddNew<WebView>(); 
        view.MainWorkspace.Show(webView); 
    }
```
Dadurch wird der WebView (ein Smart Part) zu der Elementsammlung der Smart Part-Arbeitselemente hinzugefügt und angezeigt, wenn das Arbeitselement startet.
Öffnen Sie das WebView UserControl im Entwurfsmodus.
Fügen Sie ein Microsoft.Practices.SmartClient.Web.WebView-Steuerelement aus der Smart Client Software Factory hinzu.
Legen Sie die „Url“-Eigenschaft des Steuerelements Microsoft.Practices.SmartClient.Web.WebView fest, um die soeben erstellte Webseite zu testen.
Navigieren Sie zu der Datei WebWorkItem.cs, und fügen Sie diese Using-Direktive hinzu:
```
using Microsoft.Practices.SmartClient.UI.Themes;
```

Öffnen Sie die Klasse WebPresenter, und fügen Sie den folgenden Code hinzu:

[EventSubscription(Common.Events.ContextChanged,
                    Thread=ThreadOption.UserInterface)] 
    public void OnContextChange(object sender, EventArgs e) 
    { 
        System.Windows.Forms.MessageBox.Show( _
            "Context changed: Hello from Rich UI component"); 
    }

Dies wird von der Webseite durch den CAB-Ereignismakler in Ihren WebView-Code ausgelöst.

Fügen Sie die folgende Using-Direktive hinzu:

using Microsoft.Practices.CompositeUI.EventBroker;

Öffnen Sie die IWebView-Schnittstelle, und fügen Sie den folgenden Code hinzu:
```
event WebBrowserDocumentCompletedEventHandler DocumentCompleted;
```
Öffnen Sie die Klasse WebPresenter, und fügen Sie den in Abbildung 4 gezeigten Code hinzu. Dadurch kann die Smart Client Software Factory auf das Laden der Webseite reagieren, indem sie die Abonnements einbaut. Wenn die Webseite geladen ist, wird ein CustomerContextChangedForWebPage-Ereignis ausgelöst. Dieses wird der Webseite mithilfe des Ereignismaklers als CustomerContextChanged (in JavaScript) mitgeteilt. Das sind die Auswirkungen, wenn beim Starten des Webmoduls im intelligenten Client Kontext oder Informationen von dem intelligenten Client an die Webseite weitergegeben werden. Dadurch kann jede Webanwendung in Reaktion auf das Laden alle Informationen aus dem intelligenten Client anzeigen. Beachten Sie, dass für den Sendevorgang keine Überschreibungen erforderlich sind und lediglich das spezifische Ereignis ausgelöst wird, wenn es geladen wird.

Fügen Sie folgende Using-Direktiven hinzu:

using System.Threading; 
    using System.Security.Principal; 
    using Microsoft.Practices.CompositeUI.Utility;

Fügen Sie folgenden Code der Klasse WebView (die IWebView-Implementierung) hinzu:

public event WebBrowserDocumentCompletedEventHandler    DocumentCompleted 
    { 
        add { this.webView1.DocumentCompleted += value; } 
        remove { this.webView1.DocumentCompleted -= value; } 
    }

Schritt 5: Erstellen und testen Sie die Datei Solution Place WebModule.dll in demselben Verzeichnis wie die Shellanwendung, und fügen Sie das Modul der Datei ProfileCatalog.xml hinzu, sodass sie vom Modulladedienst in CAB geladen werden kann.

Zum Schluss folgen Sie demselben Muster, mit dem Sie mithilfe des Ereignismaklers Meldungen an andere Module weitergeben. Starten Sie dieses Webmodul wie jedes andere Webmodul. Alle globalen Ereignisse sollten jetzt vom intelligenten Client zum Webmodul fließen und umgekehrt.

Ein Blick in die Zukunft

In diesem Beispiel kommunizierte ein kleiner Block JavaScript durch das Dokumentobjektmodell (DOM) mit der Hostanwendung. Mit dieser Technik veranlasst InfoPath® den HTML-basierten Aktionsbereich, auf das DOM zuzugreifen, um das XML-Dokument abzurufen.

Für vorhandene webbasierte Anwendungen ist dies eine recht invasive Vorgehensweise. Dadurch wird die Webanwendung geändert, erneut kompiliert und anschließend erneut bereitgestellt. Unser Ziel ist eine weniger invasive Technik, die es jedem Smart Part ermöglicht, den erforderlichen Integrationscode in das DOM der HTML-Seite einzufügen. Die Einbindung erfolgt dann zur Laufzeit und nicht zur Kompilierungszeit. Selbstverständlich müssen die Auswirkungen auf die Sicherheit besonders berücksichtigt werden. Außerdem müssen den Zuordnungsmethoden des Ereignismaklers der Smart Client Software Factory weitere Funktionen hinzugefügt werden, damit Kontext des intelligenten Clients den HTML-Seitenelementen zugeordnet werden kann.

Die Zukunft von fertigen Modulen für Unternehmen ist faszinierend. Stellen Sie sich ein auf Windows Workflow Foundation basierendes Workflow-Modul vor, das eine saubere Hosting-Architektur für desktopbasierte Workflowszenarios bietet. Workflow wird sofort in vorhandene, vom Integrated Desktop verwaltete Anwendungen integriert. Dadurch wird dem Information Worker ein zusätzliches entscheidungsfähiges Integrationssubstrat und eine strukturierte Aufgabenliste zur Verfügung gestellt. Können vollständige Lösungen in Dienstinseln umstrukturiert werden, die durch einen Satz an Workflowmodulen aneinander gekoppelt sind?

Diese Architektur entwickelt sich weiter, und neue Fähigkeiten der Plattform müssen ständig in die Architektur eingearbeitet werden. Diese Langlebigkeit ist eine der wahren Prüfungen für Lösungsarchitekturen der Unternehmensklasse. Die Woge neuer Funktionen, die Windows Vista™ mit sich bringt, wird definitiv unser Denken über Lösungsansätze herausfordern. Integrated Desktop befindet sich in einer guten Position, um diese Welle auszunutzen.

Die Autoren

Christian Thilmany ist Technologiearchitekt mit mehr als 16 Jahren Erfahrung in Architektur, Entwicklung und Beratung für eine Vielzahl von Fortune 500-Unternehmen. Bei Microsoft spezialisiert er sich auf die Muster und Technologien in Bezug auf Integration, Portale und intelligente Clients.

Jim Keane ist Technology Director in Austin, Texas. Er ist seit mehr als 20 Jahren Architekt in der Computerindustrie und verfügt über Erfahrung in den Bereichen kleine Unternehmen, Luft- und Raumfahrt, Halbleiter, Versicherungen und Prozessleitsysteme.

Aus der Ausgabe vom September 2006 des MSDN-Magazins.