Download (3265Kb) - HSR Hochschule für Technik Rapperswil
Download (3265Kb) - HSR Hochschule für Technik Rapperswil
Download (3265Kb) - HSR Hochschule für Technik Rapperswil
Erfolgreiche ePaper selbst erstellen
Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.
1. Management Summary2. Technischer Bericht3. Projekt undZeitplanung/Zeiterfassung4. Anforderungen5. Architektur und Design6. Erfahrungsbericht
verfügbar gemacht werden.Vorgehen/TechnologienFür die Lösung der Aufgabe wurden folgende Schritte durchgeführt: Umfassende Analyse der Anforderungen Analyse der Machbarkeit Konzeptioneller Design und ArchitekturAls wichtiger Teil der Aufgabe wurde die Integration eines HTML-Editors inWindows Phone 7, um Email in HTML-Format versenden zu können.Folgende Technologien und Tools wurden eingesetzt: Visual Studio 2010 C#, .Net 4.o Silverlight for Windows Phone Model v View ViewModel Windows Communication Foundation(WCF Service)ResultatDie Entwickelte Windows Phone 7 App macht folgende Funktionalitätenverfügbar: Verfügbare Documenttyps aus der Datenbank laden und im WP7anzeigen Wenn der Nutzer einen Documenttyp auswählt, werden automatisch diedazugehörigen Parameter aus der Datenbank angezeigt Parameter in zwei Gruppen unterteilen :- CheckboxParameter
- DropDownParameter- Parameterwerte für die DropDownParameter anzeigen, wenn einDropDownParameter ausgewählt wird.- Document anhand ID des gewählten Documenttyps und die gewählteSprache aus der Datenbank laden und im Editor anzeigen.- HMTL-Document per Email versenden.Technischer BerichtEMAIL CLIENT DYNAMIC DOCUMENT CREATIONStudienarbeit : Integration eines Dynamic Document Creation Systemin einen Windows Phone 7 Mail ClientAutor :Ba Mohamedou MoustaphaVerantwortlicher : Prof. Hansjörg HuserBetreuer: Prof. Hansjörg HuserHerr Simon BaerIndustriepartner: Sevitec AG, Eschlikon TG
DokumentinformationenÄnderungsgeschichteDatum Version Änderung Autor30.05.2011 0.1 Dokument erstellt mba10.06. 2011 1.0 End Version für Abgabe mba
Inhalt0 Dokumentinformationen .................................................................................................0.1 Änderungsgeschichte .................................................................................................0.2 Inhalt ........................................................................................................................1 Einführung .....................................................................................................................1.1 Umfeld ......................................................................................................................Unternehmen und Produkte .........................................................................................Windows Phone 7 Email Client.....................................................................................Inbetriebnahme.............................................................................................................1.2 Problemstellungen bei der Inbetriebnahme..................................................................1.3 Abgrenzung ...............................................................................................................1.4 Aufgabenstellung.......................................................................................................2 Analyse der Machbarkeit ................................................................................................3 Systemübersicht ..............................................................................................................3.1 Physikalische Systemarchitektur.................................................................................4 Anforderungen................................................................................................................4.1 Funktionale Anforderungen........................................................................................4.2 Anwendungsfälle (Use Cases) ....................................................................................4.3 Nichtfunktionale Anforderungen ................................................................................5 Architektur und Design ...................................................................................................5.1 Kommunikation ................................................................................................... ErrÜbersicht .....................................................................................................................EWebservice-Schnittstelle ...............................................................................................Datenübertragungsformat (JSON) ...............................................................................Datenübertragungsformat (SOAP) ...............................................................................6 Entwicklung von WMD2C (WP7 App)............................................................................6.1 Einleitung..................................................................................................................6.2 Installation Datenbank & Entity Datenmodell .............................................................Datenbank .....................................................................................................................6.2.1.1 Datenbank-Tabellen ......................................................................................Entity Framework Datenmodell ...................................................................................6.3 Business Layer ..........................................................................................................6.4 Service Layer ............................................................................................................6.5 Windows Phone 7 Client ............................................................................................7 Einführung in die Entwicklung für Windows Phone 7 ......................................................7.1 Kurze Faktenübersicht ...............................................................................................7.2 Entwicklungsumgebung .............................................................................................7.3 App auf echtem Gerät testen (App Hub Account)........................................................7.4 App Hub Account für Studenten.................................................................................7.5 Verteilung der Apps über Windows Phone Marketplace ..............................................7.6 Zusätzliche Tools und Libraries..................................................................................Asynchrone Service-Architektur ..................................................................................Internationalisierung (I18N) .........................................................................................
Leistungsfähigkeit (Performance) ....................................................................................7.7 Windows Phone Ausführungsmodell (Execution Model) .............................................7.8 Benutzeroberfläche (UI).............................................................................................Application Bar .............................................................................................................Kontextmenü.................................................................................................................Windows Phone Themes ...............................................................................................List Picker .....................................................................................................................8 Schlussfolgerung ............................................................................................................8.1 Zusammenfassung .....................................................................................................8.2 Beurteilung der Resultate ...........................................................................................8.3 Ausblick ....................................................................................................................
EinführungUmfeldUnternehmen und ProdukteDie Firma Sevitec AG in Eschlikon (Kanton Thurgau) stellt Software-Produkterep. Individuelle Software-Produkte nach Mass her. Für die anspruchsvollenKunden wird immer erstklassige Individualsoftware für alle MicrosoftPlattformen entwickelt. Sevitec zählt heute rund zwanzig hoch qualifizierteMitarbeitende.Kompetenzen der Firma SevitecMicrosoft Windows Vista, XP, 2000, NT, CE auf Basis objektorientierterProgrammierung mit den Sprachen C#, Visual C++, Visual Basic undXMLInternet, Extranet oder Intranet mit Microsoft-Technologien wie C#, Java,SOAP, XML, COM+, Visual C++, Visual Basic, Java-Script, VB-Scriptund SQL ServerSQL Datenbanken Microsoft und OracleMicrosoft Office SharePoint Server / WSS / WebpartsIndividuelle, massgeschneiderte SoftwareGarantierte PauschalpreiseGünstige StundensätzeUnabhängigkeit durch Abgabe des QuellcodesUmfassendes und bewährtes Know-howFachmännische Begleitung von der Beratung über die Integration bis zumBetriebRationelles, zuverlässiges und termintreues ProjektmanagementVerwendung modernster Microsoft-TechnologienUser Interface Design, Web-Design und UsabilitySource: http://www.sevitec.ch/sites/xr/aspx/rx/home.htm#Produkte
Microsoft SharePoint Server 2010 (Microsoft SharePoint Server 2010 )SharePoint Server 2010 stellt Funktionen bereit, mit denen unverzichtbareAnforderungen erfüllt werden können. Beispielsweise werden Inhalte undGeschäftsprozesse verwaltet, das Suchen und Freigeben von Informationen überGrenzen hinweg vereinfacht und fundierter Entscheidungen ermöglicht.SharePoint Server 2010 unterstützt alle Intranets, Extranets undWebanwendungen im gesamten Unternehmen mit Hilfe einer einzigenintegrierten Plattform. Das mühsame Arbeiten mit getrennten Systemen gehörtsomit der Vergangenheit an. OFFIXX (OFFIXX: Ein Mausklick - und Word setzt Ihr CorporateDesign um)Offixx ist ein Microsoft Word-Zusatzprogramm, welches jedes Dokumentautomatisch Corporate Design-konform formatieren kann. Content Management System SEVIWARE.NET(Content ManagementSystem SEVIWARE.NET)SEVIWARE.NET ermöglicht eine bessere Handhabung vontagesaktueller Informationsbereitstellung im Unternehmen.PREMIUM HOSTING für WebSolution(PREMIUM HOSTING fürWebSolutions)Die Wartung firmenspezifischer WebSolution sowie Internet Auftritt mitSEVIWARE.NET wird mit PREMIUM HOSTING für WebSolutiongewährleistet.Source : http://www.sevitec.ch/sites/xr/aspx/m.4_1/rx/standard.htmWindows Phone 7 Email ClientDiese Studienarbeit befasst sich mit dem Versenden von Emails in HTML-Format in einem Windows Phone 7 (WP7). Die HTML-Dokumente sollen
automatisch aus der Datenbank in einen HTML-Editor im WP7 Client geladen,bearbeitet und anschließend per Email verschickt werden können.InbetriebnahmeZum Zweck der Entwicklung und des Testens können nach erfolgreicherRegistrierung eine Anzahl von Geräten( 3 pro Entwickler, für Studenten 1 proAccount) freigeschaltet werden, auf die dann ein direktes Deployment vomDesktop aus erfolgen kann. Es können über USBnur maximal 10 (Studenten 3) Applikationen(Apps) auf ein freigeschaltetesGerät geladen werden. Die fertig entwickelte Apps werden bei Microsoft zurZertifizierung eingereicht, wobei diese nach technischen, rechtlichen undinhaltlichen Kriterien auf die Einhaltung der veröffentlichen Markplace-Richtlinien geprüft werden (siehe veröffentlichten Marketplace-Richtlinien ).Fertige Produkte können dann nach erfolgreichem Test im lokalen Katalog oderinternational veröffentlicht werden und stehen dann für jeden Windows Phone7-Nutzer zum Erwerb zur Verfügung.Windows Phone 7-Anwendungen wie auch jeglicher Client-seitiger Codekönnen mit ausreichendem Aufwand einem Reverse Engineering unterzogenwerden. Um dies zu verhindern, trifft Microsoft geeignete Vorkehrungen. Aberes wird Entwicklern geraten im Zweifelsfall wichtige Routinen als Webdiensteauszulagern und somit die eigene sogenannte „Intellectual Property“ besser zuschützen. (z.B Tools wie . RunTime Intelligence for Windows Phone ).Problemstellungen bei der InbetriebnahmeAbgrenzungZiel dieser Studienarbeit ist die Entwicklung einer Windows Phone 7Applikation, welche ein dynamisches Erstellen von Dokumenten unterstützenkann.HerausforderungenDie Herausforderungen dieser Studienarbeit finden sich in folgenden Punkten:
Umfassende Analyse der Anforderungen und der zur Verfügungstehenden Technologien Konzeptioneller Design, Architektur und Schnittstellenspezifikation derLösung. Umfassende Machbarkeitsanalyse Realisierung eines Funktions-Prototyps bestehend aus verschiedenenTeilsystemen(Serverseitig, Client-seitig und ev. Webservice)AufgabenstellungEs soll eine Client/Server –Anwendung für Windows Phone 7(WP7) entwickeltwerden, welche mit einem zu realisierendem Webservice in(C#)Kommunizieren kann, der auf eine bestehende Datenbank zugreifen kannund Daten für den WP7 Client dynamisch zu Verfügung stellen kann. Die WP7Applikation soll mindestens folgende Funktionalitäten verfügbar machen: Dokumenttyps laden und anzeigen und auswählbare machen Parameter zu dem gewählten Dokumenttyp anzeigen und auswählbarmachen. Parameter Values zu den gewählten Parametern anzeigen undauswählbar machen. Dokument in HTML-Editor laden und darstellen können. Dokument per Email verschicken.Die Wichtigsten Resultate der Studienarbeit stellen folgende Artefakte dar: Anforderungen mit Use Cases Realisierung eines WebServices für die Bereitstellung der Daten.
Client/Server –Funktionalität mit Datenzugriff per Entity Framework undDataService. Machbarkeitsnachweise für einen WP7 Mail Client mit HTML-Editor. (optional) Vergleich von Webtechnologien :REST/SOAP/ODATA/WCF/Thrift etc..Analyse der MachbarkeitBestehender WP7 Email Client erweiternDiese Variante wäre die Beste Möglichkeit für die Realisierung des Projektes.Für die Entwicklung könnte viel Zeit erspart werden. Aber es gibt leider keineMöglichkeit für uns einen WP7 Email Client zu finden. Da WP7 Email Client injedem WP7-Gerät integriert ist, wird jeder Email-Client als Bestendteil desBetriebssystems betrachtet. Daher ist die Betriebssystemebene allein denGerätehersteller vorbehalten. Dies ist allerdings für Softwareentwickler alsonicht zugänglich.Diese Variante ist leider auszuschliessen.Eigenen WP7 Email Client EntwickelnDiese Variante wäre viel aufwendiger, aber die Möglichkeit einen eigenen WP7Email Client zu entwickeln besteht schon. Grundsätzlich werden Anwendungenfür WP7 in einem Framework entwickelt, welches auf .NET basiert undStabilität, Performance und Sicherheit garantiert. In diesem Framework stehteine UI-Technologie zur Verfügung: Silverlight.„Silverlight for Windows Phone 7“ besonders stellt ein vollwertigesAnwendungsframwork für eigenständige Apps dar. Es basiert auf Silverlight 3mit folgenden Erweiterungen:• Höchste Performance• Input-Integration• HW-, Medien- & Sensor- Integration• Adaption für WP7-App-Modell
• Weniger enge Sandbox• Web ähnliche UI Entwicklung
Um eine eigene Email-App zu entwickeln stellt Microsoft eine API für dieSensorenansteuerung Verfügung. Unter Windows Phone 7 werden alle Sensorenüber sehr mächtige Klassen gekapselt, die auf einfache Art und Weise überstandardmäßigen C#-Code angesprochen werden können. Der teilweise sehrumfangreiche und komplexe Umgang mit API-Calls, wie bei anderenPlattformen, entfällt daher komplett. Zusätzlich ermöglicht Microsoft unterWindows Phone 7 dem Entwickler aber auch noch den Zugriff auf eine Vielzahlvon weiteren Funktionen der Windows Phone 7 Hubs. Das Mittel zur Nutzungder Funktionen aus dem Hub sind die sogenannten Launcher- und Chooser-Tasks. Ein Launcher-Task dient dabei dazu eine bestimmte Funktion auszulösen(z.B. einen Telefonanruf starten), ein Chooser-Task liefert zusätzlich einErgebnis zurück, z.B. ein Bild aus der Gallery auswählen. Die KlasseEmailComposeTask ermöglicht das Senden von Email mit dem eigenen Email-Client.
SystemübersichtPhysikalische SystemarchitekturAnforderungenFunktionale AnforderungenKurze Auflistung der Funktionalen Anforderungen: Alle verfügbaren Dokumenttypen aus der Datenbank anzeigen lassen Pro. Dokumenttyp dazugehörigen Parameter aus der Datenbank anzeigenlassen Parameter in zwei Gruppen teilen : CheckBoxParameter undDropDownParameter
Pro. DropDownParameter dazugehörigen Werte aus der Datenbankanzeigen lassen. HTML-Dokument aus der Datenbank im Editor anzeigen lassen HTML-Dokument bearbeiten und per Email verschicken Konfigurationsseite für Email und WebService erstellen Benutzer-Login sollen einmalig eingegeben werdenAnwendungsfälle (Use Cases)Die folgenden Anwendungsfälle wurden erfolgreich implementiert und getestet: Documenttyp wählen Parameter wählen Parameter-Werte wählen HTML-Document erstellen HTML-Document im Editor laden HTML-Document per Email senden.Nichtfunktionale AnforderungenAllgemeine Überlegungen und daraus resultierende Anforderungen: Gute Benutzerführung und eine möglichst einfache Bedienung. Jede Benutzeroberfläche ist schlicht und zeigt nur das WesentlicheBedienbarkeitDie Bedienung soll sich soweit möglich an der in Entwicklung stehendenKonfigurationswebseite orientieren.Trotzdem sollen die Designprinzipien für Windows Phone 7 Applikationenberücksichtig werden.DatenschutzDie Windows Phone 7 Applikationen soll durch eine Benutzername/Passwort-Kombination geschützt werden. DieVerbindung zwischen dem Smartphone und dem Gateway soll vor Sniffing-Attacken geschützt werden.
DatensicherheitDatensicherheit oder Backupstrategien sind für dieses Projekt nicht relevant.Alle Informationen kommen aus der Datenbank und unterliegen strengeZugriffsrechte.WartbarkeitDie Software soll einfach erweiterbar sein und das Hinzufügen von neuen Funktionen erlauben.Architektur und DesignWebservice-SchnittstelleFolgende Anforderungen stellen sich an eine Webservice Architektur fürSmartphone(mobile Geräte): Plattformunabhängig: Applikationen für weitere mobile Plattformen wieAndroid oder iPhone sollenentwickelt werden können. Schlank und einfach: Auf mobilen Geräten ist es wichtig dieeingeschränkten Ressourcen nicht zuverschwenden.Keine Bibliotheken notwendig: Sobald Bibliotheken benötigt werden,müssten diese für jede mobilePlattform zur Verfügung stehen.REST erfüllt die erwähnten Anforderungen. REST ist nicht direkt eineSoftwarearchitektur, es ist mehr einArchitekturstil. Wenn REST im Kontext von HTTP verwendet wird, beschreibtes einige Basisprinzipien wieWebservices aussehen sollen und wie Client und Server kommunizieren,basierend auf den Konzepten des „WorldWide Web“ (WWW). Heute wird REST von vielen grossen Webapplikationenwie z.B. Facebook, Flickr usw. für ihreWebservice-Schnittstelle nach aussen benutzt.
Der Unterschied zwischen REST und anderen Webservice Architekturen wiez.B. SOAP liegt darin, dass REST mit dembestehenden Vokabular und Konzepten des „World Wide Web“, wie z.B. URIs,Fehler-Codes (404, 500, …),Methoden (GET, POST, PUT, …) arbeitet, während in SOAP für jedeApplikation eigene Konzepte (Methoden)definiert werden müssen. REST ist ein Architekturstil zum Erstellen von Client /Server-Anwendungen. SOAP ist eine Protokollspezifikation für denDatenaustausch zwischen zwei Endpunkten.Für die Abfrage einer Benutzerlistewürde zum Beispiel in SOAP eine neue Methode‚getAllUsers()„ definiert werden, während in REST für dieselbe Aufgabe dasexistierende HTTP URI Konzept benutzen wird ‚GETUsers/All‘.Damit ein Client fähig ist REST-Webservice zu benutzen, muss er nur in derLage sein über HTTP zu kommunizieren. Weil eine HTTP-Kommunikation aufallen Mobile- und Desktop-Plattformen möglich ist, wird mit REST auf einfacheWeise ein plattformunabhängiger Webservice bereitgestellt. Die Entwicklungeines REST-Webservice auf Server Seite gestaltet sich z.B. mit .NET sehreinfach. Die WCFBibliothek in .NET bietet die Möglichkeit REST-Webservicesbereitzustellen. Auf Client Seite ist keine Bibliothek vorhanden, um REST-Webservice zu konsumieren. Dass ist aber nicht weiter ein Problem, weil garkeine Bibliothek benötigt wird. Die Basisfunktionen für eine HTTP-Kommunikation reichen völlig aus und existieren auf jeder Plattform.Vergleichen von REST mit dem remote Procedure Call (RPC)-Stil des Client /Server-Anwendungen erstellen werden genauer. RPC ist eine Formatvorlage(anstelle eines Protokolls, ist SOAP) Erstellen von Client / Server-Anwendungen in der ein Proxy (im Allgemeinen aus Metadaten generiert) wirdim Adressbereich des Clients verwendet, um mit dem Server zu kommunizierenund die Proxyschnittstelle imitiert Schnittstelle des Servers. Obwohl SOAP-RPC-Format nicht erforderlich ist, werden die meisten modernen SOAP-Toolkits in Richtung ausgerichtet (mindestens diese Standardeinstellung um)mithilfe von RPC.Im Gegensatz zu RPC, REST verfügt nicht über den Proxy Metadaten generiertd. h., die der Client weniger auf den Dienst gekoppelt. Da REST auf dieSemantik des HTTP-basiert, können auch Anforderungen für Daten (GET-Anforderungen) zwischengespeichert. RPC-Systeme verfügen im Allgemeinenkeine solche Infrastruktur (und sogar bei RPC mit SOAP über HTTP, können
nicht SOAP-Antworten zwischengespeichert, da SOAP das Verb HTTP POSTverwendet, das als unsicher betrachtet wird). SOAP-eschews absichtlich HTTP,insbesondere damit SOAP, über andere Protokolle zu arbeiten, so dass Sietatsächlich etwas disingenuous SOAP-basierte Dienste Webdienste aufrufen.Meiner Sicht ist, dass REST und SOAP verwendet werden, können um ähnlicheFunktionalität zu implementieren, aber im Allgemeinen SOAP verwendet, wennein bestimmtes Feature von SOAP erforderlich ist und die Vorteile von REST esandernfalls die beste Option machen.Datenübertragungsformat (JSON)Als Datenübertragungsformat für die REST-Webservices wird JSON verwendet.JSON steht für JavaScript ObjektNotation und ist ein kompaktes, textbasiertes Dateiformat, welches einfach undschnell lesbar undinterpretierbar ist. Es wird häufig für den Datenaustauch zwischen Applikationverwendet.Eine Alternative wäre XML, doch XML hat strukturbedingt einen viel grösserenOverhead als JSON und das Interpretieren von XML ist um einiges langsamer.Datenübertragungsformat (SOAP)Das „Simple Objekt Access Protokoll“ (SOAP) bildet eine Basis für den XMLbasiertenInformationsaustausch zwischen Applikationen. Derzeit wird die Ideedurch das World Wide Web Konsortium weiterentwickelt und standardisiert.Mögliche Anwendungsszenarien von SOAP stellen sowohl einfacheunidirektionale Benachrichtigungsdienste als auch komplexeInteraktionsszenarien, wie entfernte Methodenaufrufe, dar.Da SOAP selbstkeine eigenen Sicherheitsmechanismen vorsieht, erfordert die Verwendung imsicherheitsrelevanten Umfeld den Einsatz zusätzlicher Mechanismen. IhrenEinsatz und ihr Zusammenspiel beschreibt dieser Beitrag. SOAP ermöglichtdurch seine Nutzung für Web Services im Zusammenspiel mit WSDL undanderen Technologien, neue, dynamische Ansätze zur Interaktion zwischenkommerziellen und/oder wissenschaftlichen Anwendungen. Ein Problem vonSOAP ist allerdings die Performanz. SOAP-Nachrichten werden in XML kodiertund verbrauchen somit erheblich mehr Speicherplatz, als herkömmlicheBinärformate. Die gute Interoperabilität und universelle Einsetzbarkeit stehenim Gegensatz zu Ansprüchen hoher Performanz. Dies liegt vor allem an demprimär textbasierten Ansatz von XML. Eine typische SOAP-Nachricht kann 4-10-mal so gross sein, wie eine entsprechende Binärkodierung der Daten.
Source : http://www2.cs.uni-paderborn.de/cs/agengels/ag_dt/Courses/Lehrveranstaltungen/WS0405/PSWebservices/finals/gretencord.pdfEntwicklung von WMD2C (WP7 App)EinleitungDie Windows Mobile Dynamic Document Creation SystemApplikation(WMD2C) wurde realisiert nach dem Client-Server-Prinzip mitEntity Framework Datenmodell als Access Layer, Windows CommunicationFoundation(WCF) als Service Access Layer. Die Service Access Layer(Servicezugriffsschicht) wird von einem Windows Phone 7 Client benutzt, umauf den SQL –Server 2008 zuzugreifen. Die Aufgabe der Servicezugriffsschichtist es, von einer konkreten Kommunikationsschnittstelle zu abstrahieren(indiesem Fall der Web Service).In diesem Kapitel werden die drei wichtigsten Schritte für die Entwicklung vonWMD2C beschrieben. Zuerst werden die Installation der Datenbank und dasEntity Framework Datenmodell beschrieben, danach folgt die Beschreibung desWCF Services und anschliessend wird der WP7 Client beschrieben.Installation Datenbank & EntityDatenmodellDatenbankDatenbank-TabellenDie Datenbank(WMD2CDatabase) für das WMD2C-Projekt besteht aus 4Tabellen: Documenttyps, Documents, Parameters und ParameterValues. MitHilfe von Microsoft SQL Server Management Studio wurde die notwendigeDatenbank (WMD2CDatabase) erzeugt.Datenbank Erzeugen
1. SQL Server Management Studio starten und mit dem Server verbinden2. Datenbank erzeugen (Rechtsklick auf Database und New Database auswählen)
3. Name für die Datenbank eingeben und auf Ok drücken ( Hier WMD2Databae)
4. Datenbank ist nun ersichtlich (WMD2CDatabase)
5. Nun Tabelle kann erzeugt werden (Rechtsklick auf Table und New Table auswählen)
Nun haben wird Documenttyps-Tabelle bestehend aus zwei Spalten erzeugt.
ooDocumentID (Primary Key) [nvarchar(50)]DocumentName [nvarchar(50)]
6. Documenttyps-Tabelle mit TestDaten füllen (Rechtsklick auf die Tabelle und Edit Top200 Rows auswählen)7. Documenttyps-Tabelle mit TestDaten füllen (Rechtsklick auf die Tabelle und Edit Top200 Rows auswählen)
Wir haben nun die erste Tabelle mit TestDaten gefüllt: EmailSevitec EmailOneOffixx NewsletterSevitec NewsletterOneOffixxDie Tabellen Documents, Parameters und ParameterValueswerden mit genauso erzeugt.Tabelle : Documents
oooooDocID (Primary Key) [nvarchar(50)]DocumentID (Foreign key) [nvarchar(50)]Sprache [nvarchar(50)] allow NullDocName[nvarchar(50)]Content [ntext]Tabelle: ParametersooooParameterID (Primary Key) [nvarchar(50)]DocumentID (Foreign key) [nvarchar(50)]ParameterName [nvarchar(50)]ParameterType[nvarchar(50)]Tabelle: ParameterValuesooParameterValueID (Primary Key) [nvarchar(50)]ParameterID (Foreign key) [nvarchar(50)]oParamValueName [nvarchar(50)]Die SQL Server Datenbank ist einfach gehalten mitfolgender Struktur:
Ein Parameter besitzt die Spalte „ParameterType“, welche 2 Wertehaben kann: ParameterType = 10 ParameterType = 20CheckBoxParameterDropDownParameterEntity Framework DatenmodellFür das Erzeugen eines Entity Datenmodells sind folgende Schritte erforderlich:In Visual Studio 2010
New Solution erstellen (Projektmappe) Ein Projekt von Type „Class Library“ in die Solution hinzufügen (WCFEntityData)Im WCFEntityData –Projekt Referenzieren die Bibliothek (.dll) EF4CTP, welche in C:\Program Files(x86)\Microsoft ADO.NET Entity Framework 4.1 RC\Binaries zu findensein sollte. Die automatisch erzeugte Klasse Class1.cs entfernen. Folgende Projekt-Ordner hinzufügen :- Model- Entities- Interfaces- Repositories- SmtpMailIm Ordner ModelDer Data Access Layer wird mit dem ADO.NET Entity Frameworkimplementiert. Dieser Layer beinhaltet eigentlich das *.edmx Datenmodell (z.B.WP7MailClientModel.edmx), welches den Datenzugriff auf diedarunterliegende SQL Server Datenbank ermöglicht. Add new „ADO.Net Entity Data Model“ mit dem Namen(WP7MailClientModel)
Auf „Next“ drücken und die erzeugte Datenbank für das Projekt auswählen(WMD2CDatabase)
Auf „Next“ drücken und „Tables“ auswählen, um alle Tabellen in derDatenbank(WMD2CDatabase) auszuwählen
.Auf „Finish“drücken und Das Datenmodell wird automisch im Projekt erzeugt.
Für die Lösung mit der Verwendung von Enumeratoren bezüglichParameterType sieht das erweiterte Datenmodell folgend aus:
Im Datenmodell müssen überflüssige „Navigation Properties“ entfernt werden,um eine zirkuläre Abhängigkeit zwischen den Entitäten zu vermeiden. Diezirkuläre Abhängigkeit kann Probleme bei der Serializierung mittels WCFverursachen.Die Entitätstypen entsprechen den im konzeptionellen Modell definiertenEntitäten. In Entity Framework werden Entitäten und Beziehungen zugeordnet,die in einem konzeptionellen Modell für eine Datenquelle definiert werden.Entity Framework stellt Funktionen bereit, mit denen die folgenden Schrittedurchgeführt werden können: Materialisieren der von der Datenquelle alsObjekte zurückgegebenen Daten, Nachverfolgen von Änderungen an denObjekten, Behandeln der Parallelität, Zurückgeben von Objektänderungen an dieDatenquelle und Binden von Objekte an Steuerelemente.
Folgende „Navigation Properties“ wurden deswegen entfernt:o Documents ( in der Entität Document)o Documents(in der Entität Parameter)o Parameters(in der Entität ParameterValue)In den „Propreties“ des Models muss „Code Generation Strategy“ auf„None“ gesetzt werden, um zu verhindern, dass die Entity Klassen vom EntityFramework automatisch erzeugt werden.Jedem Property des Models muss den Concurrency Mode auf „Fixed“ gesetztwerden, um OptimisticConcirrency zu aktivieren.Im Ordner Model Eine neue Klasse einfügen (WCFEntityContext), welche dieObjektContext-Klasse erweitern muss. using System.Data.Objects;
using WCFEntityData.Entities; namespace WCFEntityData.Model { public class WCFEntityContext: ObjectContext {• //Entitäten definieren (POCO) public ObjectSet Documenttyps {get;set;} public ObjectSet Parameters {get;set;} public ObjectSet ParameterValues {get;set;} public ObjectSet Documents { get; set; }• //ConnectionString in AppConfig setzenpublic WCFEntityContext():this("name=DB1Entities"){}public WCFEntityContext(stringstringConnection):base(stringConnection ,"DB1Entities"){ }Documenttyps = CreateObjectSet();Parameters = CreateObjectSet();ParameterValues = CreateObjectSet();Documents = CreateObjectSet();//Turned off to avoid problems with serializationContextOptions.ProxyCreationEnabled = false;ContextOptions.LazyLoadingEnabled = false;Die Klasse WCFEntityContext soll dem Entity Framework sagen, wie es dasMapping zwischen den Entitäten und den Objekten im Entity Model machensoll.Mit Entity Framework (EF) können Daten in Form von typisierten CLR-Objekten (Common Language Runtime), bei denen es sich um Instanzen vonEntitätstypen handelt, abfragen, einfügen, aktualisieren und löschen.Bei der ObjectContext-Kalsse( siehe ObjectContext-Klasse) handelt es sich umdie primäre Klasse für die Interaktion mit Entitätsobjekten. Eine Instanz derObjectContext-Klasse kapselt folgende Elemente: eine Verbindung zurDatenbank, Metadaten, mit denen das Modell beschrieben wird, und einObjectStateManager-Objekt ( siehe ObjectStateManager-Objekt )das Objekte
ei Erstellungs-, Aktualisierungs- und Löschvorgängen nachverfolgt. EntityFramework stellt Tools für das automatische Erstellen einer Objektebeneentsprechend dem konzeptionellen Modell zur Verfügung. Die Objektebenebeinhaltet Entitätstypen und Objektkontextdefinitionen. DieObjektkontextdefinition enthält eine vom ObjectContext abgeleitete Klasse, diein der Regel über eine Reihe von Eigenschaften verfügt, die eine Auflistung vonEntitäten des angegebenen Typs zurückgeben. Um den Code auf Objektebene zugenerieren, wird den Entity Designer( siehe Entity Data Model Designer) oderdas Befehlszeilentool EdmGen.exe. verwendet.Im Ordner Entitieso Entitäten oder POCO (Plain Old CLR Object) definieren.o Wir müssen dann 4 Klassen definieren: Documenttyps, Document,Parameter und ParameterValues.Das Entity Framework kann uns ermöglichen, vorhandeneDomänenobjekte zusammen mit dem Datenmodell zu verwenden, ohneÄnderungen an den Datenklassen vornehmen zu müssen. Diese POCO-Datenklassen unterstützen meist das gleiche Afrage-, Einfüge-,Aktualisierungs- und Löschverhalten wie die mit den Entity Data Model-Tools erstellten Entitätstypen.Bei der Verwendung von POCO-Typen werden am Objektdiagrammvorgenommene Änderungen von Entity Framework nicht automatisch inEchtzeit nachverfolgt. Mithilfe von Momentaufnahmen stellt EntityFramework Änderungen an den Objekten fest. Wenn Lazy Loadingverwendet werden soll, muss die Lazy Loading-Proxyerstellung aktiviertwerden.//Turned off to avoid problems with serialization//Lazy Loading Proxyerstellung deaktiviert
ContextOptions.ProxyCreationEnabled = false;ContextOptions.LazyLoadingEnabled = false;//Lazy Loading-Proxyerstellung aktivierenContextOptions.ProxyCreationEnabled = true;ContextOptions.LazyLoadingEnabled = true;Documenttyp[DataContract]public class Documenttyp{[DataMember]public string DocumentID { get; set; }[DataMember]public string DocumentName { get; set; }[DataMember]public virtual IList Parameters { get; set; }[DataMember]public virtual IList Documents { get; set; }
Document[DataContract]public class Document{[DataMember]public string DocID {get; set;}[DataMember]public string DocumentID { get; set; }[DataMember]public string Sprache { get; set; }[DataMember]public string DocName { get; set;[DataMember]public string Content {get; set; }}Parameter
[DataContract]public class Parameter{[DataMember]public string ParameterID {get; set; }[DataMember]public string DocumentID {get; set; }[DataMember]public string ParameterName {get; set; }[DataMember]public int ParameterType {get; set; }[DataMember]public virtual IList ParameterValues { get; set; }}ParameterValue[DataContract]public class ParameterValue{[DataMember]public string ParamValueID {get; set ;}
[DataMember]public string ParamValueName {get; set ;}[DataMember]}public string ParameterID {get; set;}[DataContract] und [DataMember] ermöglichen es dem Entity Framework, dieObjekte zu verwenden. Die Documenttyp-Klasse und die Parameter-Klassehaben als DataMember auch eine Liste von Objekten. Diese Liste ist mit demSchlüsselwort virtual, damit Entity Framework Lazy-Loading machen kann.Windows Communication Foundation (WCF) kann Proxys nicht direktserialisieren oder deserialisieren, da der DataContractSerializer (sieheDataContractSerializer )nur bekannte Typen serialisieren und deserialisierenkann, und Proxytypen sind keine bekannten Typen. Wenn POCO-Entitätenserialisiert werden müssen, so muss die Proxyerstellung deaktiviert werden.Oder die ProxyDataContractResolver-Klasse verwenden (sieheProxyDataContractResolver-), um Proxyobjekte als ursprüngliche POCO-Entitäten zu serialisieren. Um die Proxyerstellung zu deaktivieren, muss dieProxyCreationEnabled-Eigenschaft auf false festgelegt werden. POCO-Proxyssollen verwendet werden, wenn eine hocheffiziente und unmittelbareÄnderungsnachverfolgung sowie Lazy Loading erforderlich ist. GleicheFunktionen stehen bei der Verwendung von Proxys zur Verfügung wie bei vonEntittyObjekt abgeleiteten Typen.Die Domänenklassen werden jedoch weiterhinvon Entity Framework getrennt. Um einen Lazy Loading-Proxy und /oder dieProxyerstellung für die sofortige Änderungsnachverfolgung zu aktivieren,müssen jedoch die POCO-Klasse die Anforderungen für die Erstellung vonPOCO-proxys erfüllen. (siehe Anforderungen für die Erstellung von POCO-Proxys (Entity Framework) ).Im Odrner InterfacesIn diesem Ordner sind zwei wichtigen Klassen für den WCF Servicedefiniert: IDocumentService ( Seviceschnittstelle)Das Service-Interface IDocumentService definiert die Funktionalität fürden Service-Layer. Für jede Entität- Documenttyp, Document, Parameter
und ParameterValue – müssen folgende CRUD-Operationen(Create,Read, Update, Delete) unterstützt werden:o Alle Entitäten leseno Eine Entität anhand des Primärschlüssel leseno Einfügeno Updateo Löschen[ServiceContract]Der Rückgabewert der beschriebenen Methoden - wenn vorhanden – ist immerein DTO(Data Transfer Object) /oder Poxy-Object respektive eine Liste davon,nie eine Entität des Data Access Layers.public interface IDocumentService{[OperationContract][ApplyProxyDataContractResolver]IList DocumenttypGetAll();[OperationContract][ApplyProxyDataContractResolver]IList GetDocParamAll(string docType);[OperationContract][ApplyProxyDataContractResolver]IList GetParamValues(string p);[OperationContract][ApplyProxyDataContractResolver]IList GetParamVal();
Document Methods.[OperationContract][ApplyProxyDataContractResolver]IList GetDocById(Documenttyp doctype);[OperationContract][ApplyProxyDataContractResolver]IList GetAllDocument();[OperationContract][ApplyProxyDataContractResolver]string GetDocBySpr(string id, string sprache);[OperationContract][ApplyProxyDataContractResolver]Void SendMailClient(string usr,string pwd,string from, string to, stringCC,string host, string port, string subject, string body);Damit WCF die Serialisierung/Deserialisierung von Objekten korrektdurchführen kann, wird die ProxyDataContractResolver-Klasse als Attribute fürdie Service-Methoden markiert. ProxyDataContractResolver ( Für die Serializierung/Deserializierungvon POCO-Entitäten).Wenn POCO-Entitäten serialisiert werden müssen, wird dieProxyDataContractResolver-Klasse verwendet, um Proxy-Objekte alsursprüngliche POCO-Entitäten zu serialisieren.
Im Odrner SmtpMail WCFMailer-Klasse (Definiert die SendMail-Methode)Das Versenden von Emails erfolgt über WCF-Service, da der WP7-Email-Clientkeine HTML-Email unterstützen kann.using System.Net.Mail;using System.Net.Mime;namespace WCFEntityData.Entities{public class SmtpSendMail{/// /// Sends an mail message/// /// Sender address/// Recepient address/// Bcc recepient/// Cc recepient/// Subject of mail message/// Body of mail message/////Zum testen haben wir meinen GMX-Account verwendet!//SMTP-SERVER und SMTP-PORTprivate static string smtPServer = "mail.gmx.net";private static int serverPort = 25;
public static void SendMailMessage(string from, string fromName, stringto, string toName, string cc, string ccName, string subject, string body){//Create objects of MailMessage and SmtpClient –//MailMessage-Objekt und SmtpClient-Objekt erzeugenMailMessage m = new MailMessage();SmtpClient sc = new SmtpClient();//Add – From, To, CC, BCC, subject, Body – as shown.m.From = new MailAddress(from, fromName);m.To.Add(new MailAddress(to, toName));m.CC.Add(new MailAddress(cc, ccName));//similarly BCCm.Subject = subject;//IsBodyHtml muss hier auf true gesetzt werden, um HMTL-Mail zuunterstützen.m.IsBodyHtml = true;m.Body = body;
SMTP-SERVER und SMTP-Port festlegenfestlegensc.Host = smtPServer;sc.Port = serverPort;//Login und Passwort für GMX-Account für die Anmeldung// auf GMX-Mail-Server werden überprüft und SMTP-Portsc.Credentials = newSystem.Net.NetworkCredential("tafaba@gmx.de", "tafa2674");sc.EnableSsl = true;//Nach erfolgeicher Überprüfung der Credentials, wird die Emailverschicktsc.Send(m);}Business LayerProjekt „WCFEntityData.BusinessLayer“Im Business Layer findet der Zugriff auf den Data Access Layer (DAL) statt,sprich hier werden die Daten vom DAL geladen und verändert. Im BusinessLayer befindet sich eine Klasse DocumentRepository, welche die Business-Operationen implementiert, die für die Implementation des Service- Interfacebenötigt werden.Das Handling der OptimisticConcurrencyException – eine Exception welchevom Framework beim Auftreten einer Optimistic Concurrency-Verletzunggeworfen wird – soll bei den Update-Methoden gehandhabt werden. Im Falledes Auftretens einer solchen Exception wird eineLocalOptimisticConcurrencyException geworfen, welche die neuen in derDatenbank vorhandenen Werte beinhaltet.3
Falls den Update-Methoden das modifizierte und das Original-Objekt mitgebenwird, können diese nach dem konvertieren wieder dem verwendeten OR-Mapperangehängt werden.Service LayerProjekt „DocumentService“Der Service Layer ist die eigentliche WCF-Serviceschnittstelle undimplementiert das Interface IDocumentService.Im Normalfall müsste es hier genügen, eine Instanz der DocumentRepository-Klasse zu halten und die eingehenden Calls mehr oder weniger direkt an dieseweiterzureichen. Der Service-Layer ist in dieser einfachen Applikation alsonicht viel mehr als ein „Durchlauferhitzer“.Windows Phone 7 ClientProjekt „WP7TestClient“Die Wichtigsten Schritte zur Entwicklung eines Windows Mobile-Anwendungsind wie folgt: Erstellen eine Windows Mobile Application Erstellen eine Datenbank Erstellen eines WCF-Dienst Konsumieren des WCF-Dienst von Windows Mobile 7 ApplicationErstellen eine Windows Mobile 7 Application wird im nächsten Kapitelbeschrieben. Datenbank und WCF-Dienst sind schon vorhanden. Nunwollen wir den WCF-Service im Windows Phone 7 Client konsumieren.Verbrauchen WCFdienst von Windows Mobile 7 Applicationo Dienstverweis hinzufügen zu WP7TestClient (Add ServiceReference)
Nach diesem Schritt werden alle Metadaten des WCF-Dienstes imWP7Client kopiert. Im WP7Client kann nun über einen Proxy den WCF –Service konsumiert werden.Da wir im WP7Client Dokumente dynamisch erstellen wollen, muss dieAnwendung mit Listen arbeiten, um die Daten anzeigen zu können. DieWP7 –Anwendung besteht aus vier wesentlichen Views (Seiten): MainPage ParameterViewPage EditorPage EmailConfigPageMainPage.xaml
Die XAML-Datei der MainPage definiert die Oberfläche der Hauptseite. Seibeinhaltet ein ListBox-Control-Element (LongListSelector).Sie zeigt alle Documenttyps aus der Datenbank (WMD2CDatabase) an.Die neue Version von Silverlight for Windows Phone Toolkit beinhaltet neuenControls, welche auf der Projektseite von Silverlight Toolkit auf CodeplexReleased worden sind.Neue Komponenten sind folgende:AutoCompleteBoxListPickerLongListSelectorPage TransitionsÄnderungen gab es bei folgenden Komponenten:Gesture Service/ListenerContextMenuDatePickerTimePickerToogleSwitchWrapPanel//Hier wird die Liste definiert.
MainPage.csHier wird einen WCF –Proxy erzeugt um, die Daten aus der Daten zu laden.//Create Client Proxy//Statt Localhost im Uri muss die IP –Address von der Maschine, auf welche derWebservice läuft, mitgegeben werden.DocumentServiceClient proxy = new DocumentServiceClient();proxy.Endpoint.Address = newSystem.ServiceModel.EndpointAddress(newUri("http://localhost:81/Service1.svc", UriKind.RelativeOrAbsolute));//Load all Documenttyp from Database using WCF Service.proxy.DocumenttypGetAllCompleted += newEventHandler(proxy_DocumenttypCompleted);proxy.DocumenttypGetAllAsync (); Die Daten (hier die Documenttyps aus der Datenbank) werden dem Viewübergegen.void proxy_DocumenttypCompleted (object sender,DocumenttypGetAllCompletedEventArgs e)if (e.Result!= null)//Populate Documenttyp ListBox with data from Database.//LongListSelector mit Documenttyps füllendocumentypListFlatComposite.ItemsSource = e.Result;
Sobald ein Documenttyp ausgewählt wird, müssen die zugehörigenParameter angezeigt werden. Dafür muss eine Page-Navigationstattfinden, da die Parameter auf der ParameterViewPage angezeigtwerden. Für die Auswahl von Objekten einer Liste wird ein Event Handlerdefiniert, welcher gefeuert wird, wenn ein Objekt in der Liste ausgewähltwird.//Event Handler für die Liste „documentListFlatComposite“this.documentypListFlatComposite.SelectionChanged += newSelectionChangedEventHandler(documentypListFlatComposite_SelectionChanged);Zu ParameterViewPage navigierenWählt der Nutzer einen Eintrag in der List aus, soll die App zur DetailsPage(ParameterViewPage) wechseln. Dies wird durch das SelectionChanged-Eventder ListBox (documentypListFlatComposite).Die Page-Navigation in Windows Phone 7 funktioniert über eine definiert„NavigationService“-Klasse. Die NavigationService-Klasse hat eine„Navigate“-Methode, welche die Page-Navigation über Uri delegiert.Da eine Entität anhand des Primärschlüssels gelesen wird, muss die Id desgewählten Documenttyps als QueryString mitgegeben werden.//d.DocumentIDNavigationService.Navigate(newUri(string.Format("/ParameterViewPage.xaml?DocId={0}", d.DocumentID),UriKind.Relative));ParameterViewPage.XamlDie XAML-Datei der ParameterViewPage definiert die Oberfläche für dieDetailPage der MainPage. Die ParameterViewPage enthält weitereInformationen zum ausgewählten documentypListFlatComposite-Eintrag. Dawir zwei Typen von Parameter haben, beinhaltet die ParameterViewPage zweiListbox-Controls. Für CheckboxParameter wird eine Checked-Liste definiertund für die DropDownParameter eine ComboBox-liste.
CheckBoxParameterin „parameterItemTemplate” anzeigen. //DropDownParameter in “parameterItemCombo” anzeigenDataTemplate x:Key="parameterItemCombo">
ParameterViewPage.csDiese Datei beinhaltet die ganze Logik für die ParameterViewPage. FolgendeSchritte werden hier durchgeführt:o Parameter eines ausgewählten Documenttyps aus der Datenbankladeno Parameter nach ParameterType filterno ParameterValues für DropDownParameter aus der Datenbankladen.Parameter eines ausgewählten Documenttyps aus derDatenbank laden
Um die Parameter zu laden, wird die DocumentID des ausgewähltenDocumenttyps benötigt. Diese ID wurde mit dem QueryString im Uri für diePage-Navigation zu der ParameterViewPage geschickt.(NavigationService.Navigate(newUri(string.Format("/ParameterViewPage.xaml?DocId={0}", d.DocumentID),UriKind.Relative));)Die ParameterViewPage muss die OnNavigateTo-Methode überschreiben, umdie DocumentID aus dem QuerySting zu lesen.protected override voidOnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e){base.OnNavigatedTo(e);DocumentServiceClient proxy1 = new DocumentServiceClient();proxy1.Endpoint.Address = newSystem.ServiceModel.EndpointAddress(newUri("http://localhost:81/Service1.svc", UriKind.RelativeOrAbsolute));proxy1.GetDocParamAllCompleted += newEventHandler(proxy1_GetDocParamAllCompleted);string doctyp = "";//Hier wird die DocumentId gelesenif (NavigationContext.QueryString.TryGetValue("DocId", out doctyp))
{//this.DataContext = doctyp;ShardeId = doctyp;proxy1.GetDocParamAllAsync(doctyp);}}Parameter nach ParameterType filternIn der Method: void proxy1_GetDocParamAllCompleted(object sender,GetDocParamAllCompletedEventArgs e)private void proxy1_GetDocParamAllCompleted(object sender,GetDocParamAllCompletedEventArgs e){ObservableCollection values = e.Result;o ParameterType = 10 => CheckBoxParmeterforeach (Parameter para in values)
{if (para.ParameterType == 10){//CheckBoxParameterTyp have no values//ParamerTyp = 10._checkbox.Add(para);//Populate the Checked Listbox with CheckBoxParameterTypparameterListFlatComposite.ItemsSource = _checkbox;Elseo ParameterType = 20 => DropDownParameter{if (para.ParameterType == 20){_Combox.Add (para);// Asynchrone-Aufrufe der Methode werden hier berücksichtigte, damit dieDaten korrekt geladen werden könnenlock (paramLock)
{_names1.Add(new Hoi() { ParamId = para.ParameterID, Name= para.ParameterName, Values = new List() });}//ParameterValue für DropDownParameter laden.client.GetParamValuesAsync(para.ParameterID);//Here bind the data to the combo box as DataContextparameterListFlatCombo.ItemsSource = _names1; //_Combox;parameterListFlatCombo.Tag = result;Die ParameterViewPage beinhaltet noch ein Button-Control-Element(CreateDocument). Beim Anklicken des Buttons wird die Applikation zurEditorPage wechseln. Auf der EditorPage wird das geladene Document aus derDatenbank angezeigt. Die Entität Document wird anhand zwei Parameter ausder Datenbank gelesen: DocumentID (ID des ausgewählten Documenttyps),Sprache (die ausgewählte Sprache). Die ParameterViewPage muss dann beideParameter der EditorPage übergeben.Diese Logik wird im Event-Handler des CreateDocument-Buttons realisiert.private void button1_Click(object sender, RoutedEventArgs e){
foreach (Hoi ho in parameterListFlatCombo.ItemsSource){//Dropdown Parameter : Sprache// Aus dem ComboBox wird die gewünschte Sprache ausgewählt.if (((Hoi)parameterListFlatCombo.SelectedItem) == ho){List res = ho.Values;foreach(Strings str in res)//DocumentId wurde schon aus dem QueryString gelesen, und wird hierweitergeleitet.NavigationService.Navigate(new Uri("EditorPage.xaml?DocId=" +ShardeId + "&Sprache=" + str.Value, UriKind.Relative));}}EditorPage.xamlDie XAML-Datei der EditorPage beinhaltet nur ein RichtextBox-Control. Hierwird ein C1RichtextBox von ComponentOne Studio® for Windows Phone(http://www.componentone.com/SuperProducts/StudioWindowsPhone/)verwendet. Es gibt Controls z.B. für WindowsForms, WPF, Silverlight und vieleandere. Nun hat ComponentOne auch die CTP für Phone 7 Tools veröffentlicht.Diese beinhalten eine ganze Menge nützlicher Komponenten für die Phone 7Entwickler.Unter anderem gibt es:
CHARTCOVER FLOWDOCK PANELHYPER PANELLAYOUT TRANSFORMERMAPSMASKED TEXTBOXNUMERIC TEXTBOXPDF VIEWERREFLECTORRICHTEXTBOXUNIFORMGRIDWRAPPANELWie man anhand der Komponenten erkennen kann, handelt es sich wirklich umtolle Dinge, die jedem Entwickler das Leben erleichtern!Um an diese CTP zu gelangen, muss man sich bei ComponenteOne kostenlosregistrieren. Anschließend wird einem der kostenlose <strong>Download</strong> angeboten.EditorIm Editor sind drei Button-Controls für die Text-Formatierung definiert:o B (Bold) :o I(Italic)o U (Underline)
EditorPage.csDie Logik für das Laden und Anzeigen von HTML-Dokumenten aus derDatenbank wird hier implementiert. Folgende Schritte werden durchgeführt: Document anhand DocumentId und Sprache aus der Datenbank laden(Inhalt des Dokuments) Inhalt des Document im Editor anzeigen lassenDocument anhand DocumentID(des ausgewählten Documenttyps)und Sprache aus der Datenbank laden (Inhalt des Dokuments)- OnNavigatesTo-Mehode wieder überschreiben, um die Parameter ausdem QueryString zu lesen.//protected override void OnNavigatedTo(NavigationEventArgs e)//WCF proxy erzeugenDocumentServiceClient proxy1 = new DocumentServiceClient();proxy1.Endpoint.Address = newSystem.ServiceModel.EndpointAddress(newUri("http://localhost:81/Service1.svc", UriKind.RelativeOrAbsolute));proxy1.GetDocBySprCompleted += newEventHandler(proxy1_GetDocBySprCompleted);//DocumentId und Sprache aus dem QueryString holenstring doctyp = this.NavigationContext.QueryString["DocId"];string sprach = this.NavigationContext.QueryString["Sprache"];//Document aus der Datenbank laden.proxy1.GetDocBySprAsync (doctyp, sprach);
private void proxy1_GetDocBySprCompleted(object sender,GetDocBySprCompletedEventArgs e)if (e.Result != null)Doc = e.Result;//Inhalt des Dokuments im Editor anzeigen lassenthis._rtb.Html = Doc;Inhalts des Documents wird per Email verschickt. Dafür müssen die Daten andie EmailConfigPage weitergeleitet werden. Wenn der Nutzer im Editor dasButton-Control „ComposeMail“ anklickt, so wird zu der EmailConfigPagenavigiert.EmailConfigPage.xaml (Konfigurationsseite für Email)Die XAML-Datei der EmailConfigPage definiert die Oberfläche für dieEmailConfigPage.EmailConfigPage
EmailConfig.xamlDiese Datei beinhaltet die Logik für das versenden von Emails viaSmtpMailClient.Wenn der Nutzer das Button-Control „Send Mail“ anklickt,wird die Service-Methode(SendMailClient) aufgerufen und das Document perEmail verschickt.//private void button1_Click(object sender, RoutedEventArgs e)//Email Input Informationstring _userName ="tafaba@gmx.de";////Userstring _passWort = "tafa2674";// passwordBox1.Password;//Passwort
string _from = "tafaba@gmx.de";// fromtxt.Text; //fromstring _to = "mba@hsr.ch";// totxt.Text; //tostring _CC = "kurtysde@yahoo.fr";// CCtxt.Text; // CC.string _smtpServer = "mail.gmx.net";// servertxt.Text; //hoststring _smtpPort = "25";// porttxt.Text; //portstring _subject = "Test WP7 Mail";// subjtxt.Text;//subjectstring body = this.MessageBody; // Body//Use SmtpClient from WCF Service to send Mail in WP7 Client.DocumentServiceClient client = new DocumentServiceClient();client.Endpoint.Address = newSystem.ServiceModel.EndpointAddress(newUri("http://localhost:81/Service1.svc", UriKind.RelativeOrAbsolute));client.SendMailClientCompleted += newEventHandler(client_SendMailClientCompleted);//WCF-Service Methodeclient.SendMailClientAsync(_userName, _passWort, _from, _to,_CC,_smtpServer, _smtpPort,_subject, body);
Einführung in die Entwicklung fürWindows Phone 7Kurze FaktenübersichtEntwicklungsumgebung ist Visual Studio 2010 Entwicklungsframework ist ein Silverlight-Derivat genannt „Silverlightfor Windows Phone“ Phone-Emulator ist vorhanden Echte Phone-Geräte müssen für die Entwicklung registriert werden Probleme bei der Registrierung von Entwickler-Phones bei Studenten-Accounts App-Verteilung über Windows Phone Marketplace ist kostenpflichtig Keine private oder firmeninterne Verteilung von Apps möglichEntwicklungsumgebungUm mit der Entwicklung für Windows Phone 7 zu starten, genügt bereits dieInstallation der Windows PhoneDeveloper Tools, welche von Microsoft als kostenloser <strong>Download</strong> angebotenwerden (create.msdn.com). ImInstallationspaket befinden sich unter anderem die folgenden Programme undTools: Visual Studio 2010 Express Windows Phone Emulator XNA Game Studio 4.0 Microsoft Expression Blend for Windows PhoneFalls bereits eine oder mehrere der enthaltenen Komponenten installiert sind,werden nur die zusätzlichbenötigtes Programm installiert. Die Windows Phone Developer Toolsintegrieren sich auch automatisch in einebereits vorhandene Installation von Visual Studio 2010.
Abbildung 27: Windows Phone Template-AuswahlNach der Installation der Entwicklertools stehen dieWindows Phone Projektvorlagen in Visual Studio2010 zur Auswahl (sieh Abbildung links).Das Framework für die Entwicklung für WindowsPhone 7 nennt sich Silverlight for Windows Phone.Dieses basiert auf einer abgespeckten Version von Silverlight 3.0 mitspezifischen Erweiterungen für die Windows Phone Hardware. DieLaufzeitumgebung (CLR) ist aber nicht eine Silverlight-Portierung, sondernspezifisch für die Smartphone-Hardware optimiert, da diese ja ohneleistungsfähige PCProzessoren und Grafikkarten auskommen muss.
Windows PhoneEmulatorIm Visual Studio gibt es zwei auswählbare Ziele („Targets“) für die Ausführungbzw. das Debuggen von Applikationen. Davon ist eines der Windows PhoneEmulator und das andere ein per USB angeschlossenes Windows Phone Gerät.Wenn der Emulator als Ziel ausgewählt ist, wird er automatisch gestartet, sobaldman ein Windows Phone Projekt aus dem Visual Studio heraus ausführt (gilt fürRelease- und Debug-Version). Der Emulator ist Microsoft wirklich sehr gutgelungen. Es ist eigentlich alles so umgesetzt, wie es sich auf einem richtigenGerät verhält. Die Bedienung der Apps auf dem Emulator erfolgt mit Maus undTastatur. Der Emulator unterstützt aber auch echtes Multi-Touch, wozu abernatürlich ein entsprechender Touch-Monitor vorhanden sein sollte. Es gibt zwarspezielle Tools, mit denen sogar Multi-Touch mitzwei angeschlossenen PC-Mäusen simuliert werden kann, aber dieMöglichkeiten sind sehr beschränkt und auch etwas realitätsfern. Der Emulatorerlaubt auch den Zugriffauf das Netzwerk und somit auch auf das Internet.Somit können Client-Server-Applikationen uneingeschränkt getestet werden.Hardwarespezifische Funktionen wie den Beschleunigungssensor oder dieKamera sowie Kommunikationsmöglichkeiten über Telefon, Email und SMSsind dagegen nur eingeschränkt oder gar nicht verfügbar. Um eine App auf
einem echten Smartphone zu testen, braucht es noch einige zusätzliche Schritte.Diese sind zusammen mit den Voraussetzungen im nächstenApp auf echtem Gerät testen (App Hub Account)Um eine App auf einem echten Smartphone zu testen, muss das Phone zuerst alsEntwicklergerät bei Microsoft registriert werden. Dies ist u.a.eine Massnahme, um das Abspielen von „Raubkopien“ zu verhindern. DerRegistrierungsprozess ist grundsätzlich sehr einfach gehalten. Dazumuss ein kleines Registrierungstool gestartet werden, das bei der Installation derWindows Phone Developer Tools mitinstalliert wurde. Indiesem Registrierungstool muss nur das Login für den App Hub Accounteingegeben werden. Danach wird das über USB angeschlossene Phone auf denangegebenen Account registriert und für die Entwicklung freigeschaltet. AppHub ist Microsofts neue Web-Plattform für die Entwicklung mit WindowsPhone 7 und XBOX 360, und ist unter create.msdn.com erreichbar. Um den fürdie Registrierung des Phones benötigten App Hub Entwickler-Account zuerstellen, ist leider etwas Geduld gefragt. Für diesen Account muss nämlich einejährliche Gebühr von $99 USD bezahlt werden. Zusätzlich wird von Microsofteine Identitätsprüfung verlangt, die von der von Microsoft beauftragten FirmaGeoTrust durchgeführt wird. Für die Validierung muss normalerweise einFormular zusammen mit einem Identitätsausweis oderFührerschein an GeoTrust geschickt werden. Der Validierungsprozess kanneinige Tage in Anspruch nehmen, währenddessen keine Phones für dieEntwicklung freigeschaltet werden können. Der App Hub Account wird erstfreigeschaltet, wenn die Identitätsprüfung erfolgreich und die Gebühr von $99USD bezahlt worden ist.
Entwickler-Phone RegistrierungApp Hub Account für StudentenStudenten profitieren vom Microsoft DreamSpark Programm(www.dreamspark.com), wodurch keine Kosten fürden App Hub Account anfallen. Dafür gibt es bei den Studenten-Accounts einProblem bei der Registrierung vonEntwickler-Phones. Die Ursache liegt darin, dass die Validierung vonStudenten-Accounts anders abläuft, als beiden bezahlten Accounts. So wird der Identitätsprüfungsvorgang normalerweisegleich bei Erstellung des Accountsinitiiert. Bei Studenten erfolgt dies aber erst mit dem Einsenden der ersten Appfür den Marketplace. Da bei der Erstellung des Accounts seitens Microsoft abernicht genügend auf diesen Ablauf hingewiesen wird, verbleibt man in derAnnahme, der Account würde automatisch freigeschaltet. Sobald man aberversucht, ein Phone als Entwicklergerät zu registrieren, scheitert dieser Vorgangmit einer kryptischen Fehlermeldung. Erst durch eine Anfrage beim Microsoft
Support, konnte der Missstand aufgeklärt werden. Der Microsoft Support kanndenIdentitätsprüfungsvorgang aber nicht anstossen. Er rät dazu, eine Dummy-Appzur Veröffentlichung auf dem Marketplace einzusenden, welche dannautomatisch den Identitätsprüfungsvorgang initiiert. Dieses Vorgehenfunktioniert tatsächlich. Die Dummy-App wird bei der Validierung auchumgehend zurückgewiesen und somit nicht im Marketplace veröffentlicht. Dasszuerst eine App eingesendet werden muss, bevor auf einem Phone getestetwerden kann, ist als Fehler im Prozess anzusehen. Hier sollte Microsoftunbedingt nachbessern und zumindest die Benutzer besser informieren.Verteilung der Apps über Windows Phone MarketplaceApps können nur auf für die Entwicklung registrierten Geräten direkt aufgespieltwerden. Ansonsten wird die Verteilung der Apps ausschliesslich über denWindows Phone Marketplace abgewickelt. Das während dieser Studienarbeitentwickelte Windows Mobile Dynamic Document Creation System wurde nichtim Marketplace veröffentlicht. Die Gründe dafür sind, dass es einerseits nur einPrototyp ist und andererseits eine firmeninterne Anwendung, welche derÖffentlichkeit nicht zugänglich sein sollte. In diesem Punkt gibt es noch einengewissen Aufholbedarf seitens Microsoft, da zurzeit keine Möglichkeit besteht,Apps nur firmenintern zu verteilen. Bei der Konkurrenz von Apple wird diefirmeninterne Verteilung, als Teil eines grösseren Leistungspakets, gegen eineGebühr von $299 USD im Jahr angeboten. Apps, welche für dieVeröffentlichung auf dem Marketplace eingesendet werden, durchlaufen einenValidierung und Zertifizierungsprozess. Microsoft hat dazu auf dem App Hubeine Anleitung veröffentlicht, welche den Prozess erklärt und alleAnforderungen an die einzusendenden Apps beschreiben. Die Apps werden erstnach erfolgreichem Bestehen aller unterzogenen Prüfungen im Marketplaceveröffentlicht.Zusätzliche Tools und LibrariesDa Silverlight for Windows Phone auf Silverlight 3.0 basiert, sind vielehilfreiche und dringend benötigteFunktionen, welche in Silverlight 4.0 zur Verfügung stehen, noch nichtvorhanden. Das bedeutet, dass der Einsatz von zusätzlichen Libraries undFrameworks fast unumgänglich ist. Im Folgenden werden zwei wichtige Zusatz-Libraries kurz vorgestellt, die auch in dieser Bachelorarbeit verwendet wurden.
Silverlight for Windows Phone ToolkitDas Silverlight for Windows Phone Toolkit ist von Microsoft selbst entwickeltworden. Es beinhaltet vor allemzusätzliche Controls sowie Komponenten für eine vereinfachte Handhabung vonGestures. Es wird regelmässigaktualisierte Versionen auf silverlight.codeplex.com veröffentlicht.Prism - Windows Phone 7 Developer GuidePrism für Windows Phone 7 ist als Teil des Windows Phone 7 Developer Guideverfügbar, welcher unter demMicrosoft patterns & practices Label veröffentlicht wurde. Prism besteht auseiner Library sowie Beispielprojektenund Hilfestellungen für die Entwicklung unter Windows Phone 7. Der WindowsPhone 7 Developer Guide kann vonwp7guide.codeplex.com heruntergeladen werden.Mit der folgenden Zeile wird eine neue Instanz der ViewModelLocator-Klasseerstellt und alsapplikationsweite Ressource verfügbar gemacht:Asynchrone Service-ArchitekturBei den meisten Client-Server-Architekturen sind Client und Server einfach zukontrollieren, aber bei dem was dazwischen liegt, der Datenverbindung, gibt esnur wenig Einflussmöglichkeiten. So kann die Verbindung jederzeit gestört,kurzzeitig unterbrochen oder auch für immer unterbrochen werden. Um mitdiesen Situationen möglichst vernünftig umzugehen, ohne dem Benutzer dasLeben schwer zu machen, wird eine asynchrone Kommunikation verwendet.Damit das aus der Perspektive des Softwaredesigns auch handhabbar ist, wird
eine asynchrone, serviceorientierte Architektur verwendet. Mit dieser werdendie REST- bzw. HTTP-spezifischen Kommunikationseigenheiten vor denService-Konsumenten vollständig versteckt. Die Benutzer eines Servicesentsprechen in der WP7TestClient-App den ViewModel-Klassen. In diesen wirddie Benutzerinteraktion in Service-Anfragen umgewandelt, welche fast immer ineiner Kommunikation mit dem Server enden. Damit die Benutzung der Servicesfür die ViewModel-Klassen so einfach wie möglich ist, wird das bekannteKonzept eines Service-Locators eingesetzt. Um eine Instanz eines bestimmtenServices zu erhalten, wird nur eine einzige Zeile Code benötigt:IGatewayAuthentication authenticationService =Context.ServiceLocator.FindService();Der Aufruf einer Servicemethode sieht dann z.B. folgendermassen aus:authenticationService.Authenticate(UserName, Password,AuthenticateCallback);Das Methodenargument “AuthenticateCallback“ ist ein Delegate auf eineMethode, welche bei der Rückgabe desResultates aufgerufen wird:private void AuthenticateCallback(AuthenticateEventArgs e){if (e.ResultState.State == OperationState.Successful){// Successfully logged in, do work...}else{// Error occurred:MessageBox.Show(e.ResultState.Error.ToString());}}
Diese drei Schritte bleiben bei der Benutzung aller Services die gleichen:1. Instanz des entsprechenden Services über den ServiceLocator holen2. Servicemethode aufrufen und eine Callback-Methode angeben3. Rückgabe des Resultates in der Callback-Methode verarbeitenDabei ist nie klar, wie viel Zeit zwischen Serviceaufruf und Rückgabe desResultates vergeht. Dies muss bei derGestaltung sowie dem Verhalten der Benutzeroberfläche berücksichtigt werden.Der Vorteil an diesem Vorgehen ist, dass die Benutzeroberfläche nie„einfrieren“ kann, wenn eine Serviceanfrageetwas länger dauert oder im Fehlerfall ein extrem langes Timeout auftritt. Auchkönnen Fehler so viel schönerbehandelt werden und müssen nicht überall mit Try-Catch-Blöcken abgefangenwerden.Internationalisierung (I18N)Statische Texte in der Benutzeroberfläche sind direkt im XAML-Codegeschrieben. Da die WP7TestClient-App als Prototypentwickelt wurde, war der Fokus nicht auf einer sauberen Unterstützung einerMehrsprachigenBenutzeroberfläche. Diese Texte in eine Ressourcen-Datei (*.resx) auszulagern,wäre aber gut umsetzbar.Im Gegensatz dazu sind Texte, welche als dynamisch generierter Inhalt auf derBenutzeroberfläche dargestelltwerden, bereits in einer Ressourcen-Datei abgelegt. Bei diesen Texten handelt essich mehrheitlich umÜbersetzungen für Enum-Werte der Datenpunkte. Bei diesen Enumerationenhandelt es sich zum Beispiel um
Einheiten wie C°, km/h, m², etc. oder auch um Signal- oder Fehlerzustände usw.Die Texte für dieseEnumerationen werden ebenfalls in der Benutzeroberfläche desKontrollersimulators benötigt. Daher ist dieRessourcen-Datei Teil der Common-Bibliothek.Leistungsfähigkeit (Performance)Microsoft stellt mit Windows Phone 7 relativ hohe Leistungsanforderungen andie Smartphone-Hersteller, umeine möglichst schnelle und verzögerungsfreie Bedienung zu garantieren. Manmerkt tatsächlich schon bei dererstmaligen Verwendung eines Windows Phone 7-Gerätes, dass dasBetriebssystem speziell auf Performanceoptimiert wurde. Alle Systemfunktionen sowie die von Microsoft erstelltenApps reagieren extrem schnell und esgibt weder Ruckeln noch Ladebildschirme oder Sanduhren. Bei Apps vonDrittherstellern sieht dies hingegen ganzanders aus. Oft kommen Ladebildschirme mit beträchtlichen Wartezeiten voroder beim Scrollen von längerenListen stockt der Bildaufbau. Schon hier zeigt sich also, dass es nicht ganzeinfach ist, eine App zu entwickeln, dieüber eine ansprechende Optik verfügt und zugleich eine störungsfreieBenutzung erlaubt.Windows Phone Ausführungsmodell (Execution Model)Das Ausführungsmodell von Windows Phone 7 erlaubt generell keinMultitasking. Das bedeutet, dass nur eineApplikation gleichzeitig im Arbeitsspeicher geladen sein darf. Nur gewisseSystemprogramme und Microsoft Apps,wie z.B. die Musikwiedergabe, dürfen beim Starten einer anderen Applikationim Hintergrund weiterlaufen. DasAusführungsmodell zusammen mit einem ausgeklügelten Bedienkonzept lassenden Benutzer aber im Glauben,dass trotzdem mehrere Applikationen gleichzeitig laufen.
So wird jeweils beim Navigieren durch die einzelnen Seiten einer App, jedeSeite auf einen Stapel abgelegt. DurchDrücken der Starttaste kann eine weitere Applikation gestartet werden, wobeidie erste App deaktiviert und ausdem Speicher entfernt wird. Wenn der Benutzer nun in der aktiven App weiternavigiert, werden wiederum allebesuchten Seiten auf den Stapel abgelegt. Das geht so weiter, bis der Stapelgefüllt ist und die zuerst geöffnetenSeiten zuunterst wieder aus dem Stapel herausfallen. Durch Drücken derZurücktaste wird nun die letzte Seitevom Stapel genommen und wiederhergestellt. Sobald der Benutzer durchwiederholtes Drücken der Zurücktastezur letzten Seite der ersten App zurückkommt, wird die zweite App endgültigbeendet und die erste App wieder inden Speicher geladen und aktiviert.Der Vorgang, bei dem eine App deaktiviert und aus dem Speicher entfernt wird,wird als Tombstoning bezeichnet.Das „Back-Button“-Konzept, bei dem der Navigationspfad über mehrere Appshinweg auf einem Stapel abgelegtwird und beim Drücken der Zurücktaste wiederhergestellt wird, lässt denBenutzer im Glauben, dass dievorhergehend aufgerufenen Apps die ganze Zeit im Hintergrund weitergelaufensind. Dabei überlässt es Microsoftdem Anwendungsentwickler, bei der Deaktivierung der App, denApplikationszustand zu speichern und bei dererneute Aktivierung, den vorhergehenden Zustand wiederherzustellen. Dasgesamte Konzept für die Speicherung und Wiederherstellung desApplikationszustandes ist relativ umfangreich und es sind einige Spezialfälle zubeachten. Microsoft stellt ein paar rudimentäre Hilfsmittel zurVerfügung, welche die Handhabung etwas erleichtern. Grundsätzlich musszwischen der Speicherung des Applikations- und des Seitenzustandesunterschieden werden. Mit ersterem ist der globale Applikationskontext gemeintund mit letzterem der Zustand der einzelnen Controls auf derBenutzeroberfläche. Die Zustände der Controls sind z.B. der Inhalt einerTextBox, die Position einer Scrollbar oder das aktuell fokussierte Control. Bei
der SCT-App wird zurzeit nur der Applikationszustand gespeichert. Da dergesamte applikationsweite Zustandin der ApplicationContext-Klasse enthalten ist, gestaltet sich dessenSpeicherung und Wiederherstellung sehr einfach. Das Speichern und Laden derSeitenzustände wurde aus Zeitgründen nicht implementiert. Dies ist auch nichtweiter kritisch, sondern eher als ein „Schönheits-Fehler“ anzusehen.Applikationszustand sowie Seitenzustand sind als flüchtige Daten zubezeichnen, die nur wieder geladen werden,falls die Applikation reaktiviert wird. Diese Daten überleben eine endgültigeBeendigung der Applikation nicht und werden gelöscht. Daten, welche dieBeendigung einer Applikation überleben und bei einer frisch gestartetenApplikation wieder vorhanden sein sollten, müssen im IsolatedStoragegespeichert werden. Dies wird beim WP7TestClient z.B. mit den Login-Datenso gemacht.Benutzeroberfläche (UI)Kurze Erklärung der benutzten Gesten bei der Touch-Bedienung: Antippen (Tap)Die Geste „Antippen“ ist eine kurze Berührung des Bildschirms mit einemFinger in einem definiertenBereich. Flick-Bewegung (Flick)Die Flick-Bewegung ist eine Berührung mit einem Finger und eine schnelleBewegung nach links oderrechts. Halten (Hold)Die Geste „Halten“ ist eine lange Berührung ohne Bewegung in einemdefinierten Bereich.Application BarDie Windows Phone Application Bar ist sozusagen das Pendant zur Menüleisteoder Toolbar einerDesktopanwendung. Die Application Bar wird zuunterst auf dem Bildschirmangezeigt und wird vollständig vonder aktiven App kontrolliert. Es finden bis zu vier Icons auf der Application BarPlatz. Zusätzlich existiert noch ein
erweitertes, rein textuelles Menü, das von der Application Bar aus aufgerufenwerden kann und bis zu 50 weitereMenüpunkte aufnehmen. Es besteht jederzeit die Möglichkeit, die ApplicationBar sowie einzelne Icons bzw.Menüpunkte ein- oder auszublenden. Die folgenden Screenshots stammen vonder Windows Phone InternetExplorer App.Es empfiehlt sich, die Application Bar als möglichst statisches Element zuverwenden, da häufiges Ändern derIcons den Benutzer leicht verwirren könnte.Da die Application Bar einSystemobjekt und nicht direkt Teil des XAML-Visual-Trees ist, gilt es ein paarBesonderheiten zu beachten. Obwohl die Application Bar im XAML-Codedefiniert werden kann, funktioniert weder Databinding noch Command-Binding. Anstatt dessen ist ein Workaround vorhanden, bei dem dieApplicationBarButtonCommand-Klasse der Prism-Library verwendet wird. Sokönnen die Application Bar Buttons an Commands gebunden werden.KontextmenüObwohl in den Microsoft-eigenen Apps ein Kontextmenü verwendet wird, ist esin den Standardbibliotheken von
Silverlight for Windows Phone nicht enthalten. Dafür wird dieses wichtigeBedienelement im Silverlight forWindows Phone Toolkit nachgeliefert, welches Aussehen und Verhalten desKontextmenüs aus den MicrosofteigenenApps imitiert. Bei der Benutzung des Kontextmenüs tritt ein Problem auf:Sobald ein Menüpunkt per Tippen angewählt wird,wird der Tipp-Befehl auch an das dahinterliegende Bedienelement gesendet.DieAnsichten reagieren also ganznormal auf Tipp-Befehle, wie wenn gar kein Kontextmenü geöffnet wäre. Diesscheint ein Fehler in derImplementation des Kontextmenüs oder des verwendeten Toolkit-Gesture-Listeners zu sein, welche auf dieselbenBewegungsmuster reagieren. Aber möglicherweise ist dies auchAuslegungssache, weil diese Bedienelementevielleicht gar nicht für eine gemeinsame Benutzung ausgelegt sindSobald das Kontextmenü geschlossen wird, was z.B. bei der Auswahl einesMenüpunktes geschieht, wird das Flag nach einem Timeout von 150ms wiedergelöscht:private void ControllerContextMenu_Opened(object sender, RoutedEventArgse){IsContextMenuOpened = true;}private void ControllerContextMenu_Closed(object sender, RoutedEventArgs e){// Use a timeout of 150ms before resetting the flag to prevent other// action listeners from being executed after clicking a context menu item.new Thread(() =>{Thread.Sleep(150);
IsContextMenuOpened = false;}).Start();}Windows Phone ThemesAuf dem Windows Phone 7 gibt es Einstellungen, um die Farben für dieDarstellung den eigenen Vorlieben anzupassen. Grundsätzlich sind zwei Themesvorhanden. Ein dunkles, bei dem die Grundfarbe Schwarz ist und ein helles,welches Weiss als Grundfarbe hat. Zusätzlich zur Grundfarbe kann eineAkzentfarbe definiert werden. Die Akzentfarbe wird für Bereiche/Texte benutzt,welche selektiert sind oder grafisch hervorgehoben werden sollen.List PickerDas Combobox-Bedienelement wird auf dem Windows Phone nicht angeboten,da es aus der Welt der Desktopanwendungen stammt und nicht für die Touch-Bedienung ausgelegt ist. Trotzdem bleibt natürlich die eigentlicheProblemstellung auf dem Smartphone dieselbe: Wie kann der Benutzer aus einergegebenen Liste von Elementen eines auswählen, ohne dass das Bedienelementviel Platz benötigt. Als Lösung bietet das Silverlight for Windows Phone Toolkitein List Picker-Bedienelement an. Der List Picker zeigt normalerweise nur dasausgewählte Element an. Mit Antippen wir der List Picker zu einer vollwertigenListe vergrössert, woraus ein anderes Element durch ein weiteres Antippen„herausgepickt“ werden kann. Danach wird die Liste wieder verkleinert und eswird nur noch das neu ausgewählte Element angezeigt. Der List Picker zeigtdieses Verhalten jedoch nur bei weniger als sechs Elementen. Bei mehrElementen wird das Bedienelement nicht einfach vergrössert, sondern eserscheint ein bildschirmfüllendes Popup, das eine scrollbare Liste der Elementezeigt. Sobald ein Element ausgewählt wurde, schliesst sich das Popup wieder.Der List Picker wurde erst in der November-Aktualisierung des Silverlight forWindows Phone Toolkits veröffentlicht und scheint noch ein paar Bugs zuhaben. So führt z.B. das Databinding in gewissen Situationen zu Fehlern, abernur wenn der Visual Studio Debugger nicht angeheftet ist.
SchlussfolgerungZusammenfassungDiese Studienarbeit hat zum Ziel die Entwicklung eine Windows Phone 7 App,welche Emails in HTML-Format versenden kann. Nach der Analyse derAnforderungen und der bestehenden Technologien ist mir klar geworden, dasses nur um einen Prototype handeln soll. Ein realistisches Konzept der Lösungwurde erstellt. Windows Phone 7 Built-In Email-Client kann keine HTML-Emails versenden, aber es ist doch möglich irgendwie HTML-Email im WP7 zuversenden.Beurteilung der ResultateAlle funktionalen Anforderungen wurden erfüllt. Die WMD2C-Anwendungmacht folgende Funktionalitäten verfügbar: Verfügbare Dokumentyps aus der Datenbank laden und anzeigen Dazugehörige Parameter eines ausgewählten Documenttyps ausDatenbank laden und anzeigen. Parameter nach ParameterType filtern : CheckboxParameter,DropdownParameter Dokument anhand Sprache und Documenttyp-ID aus der Datenbank ladenund anzeigen. HTML-Dokument per Email versenden wie z.B :Hallo BOLD roter text „ eAusblickDie WMD2C-App eröffnet neue Wege für Entwicklung von Windows Phone 7App. Dynamic Document Creation System in Windows Phone 7 kann mitWMD2C weitere Innovationen in die WP7-Entwicklung bringen. WMD2C kannnoch weiterentwickelt werden ,um ein besseres Produkt auf dem Markt bringenzu können.
ProjektplanEMAIL CLIENT DYNAMIC DOCUMENTCREATIONStudienarbeit :Autor :Verantwortlicher :Betreuer:Industriepartner:Integration eines Dynamic Document Creation System in einenWindows Phone 7 Mail ClientBa Mohamedou MoustaphaProf. Hansjörg HuserProf. Hansjörg HuserHerr Simon BaerSevitec AG, Eschlikon TG
DokumentinformationenÄnderungsgeschichteDatum Version Änderung Autor28.02.2011 0.1 Meilensteine, Iterationen (Tabellen) mba01.03.2011 0.2 Riskomangement,ManagementmbaAbläufe,Infrastruktur,Qualitätsmanagement, ArbeitspaketeDokument-Layout23.03.2011 0.3 Meilensteine ergänzen, Dokument bearbeiten09.06.2011 1.0 Änderungen in der Planung anpassen mba
InhaltDokumentinformationen............................................................................................................... 850.1. Änderungsgeschichte.................................................................................................... 850.2. Inhalt ............................................................................................................................. 861. Einführung ............................................................................................................................ 871.1. Zweck ........................................................................................................................... 871.2. Gültigkeitsbereich......................................................................................................... 871.3. Definitionen und Abkürzungen .................................................................................... 871.4. Referenzen .................................................................................................................... 871.5. Übersicht....................................................................................................................... 872. Projekt Übersicht .................................................................................................................. 872.1. Definitionen und Abkürzungen .................................................................................... 882.2. Zweck und Ziel ............................................................................................................. 882.3. Annahmen und Einschränkungen ................................................................................. 883. Projektorganisation ............................................................................................................... 893.1. Organisationsstruktur ................................................................................................... 893.2. Externe Schnittstellen ................................................................................................... 894. Management Abläufe ........................................................................................................... 904.1. Projekt Kostenvoranschlag ........................................................................................... 904.2. Projektplan.................................................................................................................... 904.2.1. Zeitplan................................................................................................................ 904.2.2. Meilensteine......................................................................................................... 904.2.3. Besprechungen (Meetings)................................................................................. 914.2.4. Iterationen ........................................................................................................... 924.2.5. Software Releases ............................................................................................... 945. Risiko Management .............................................................................................................. 946. Arbeitspakete ........................................................................................................................ 967. Infrastruktur ........................................................................................................................ 1008. Qualitätsmassnahmen ......................................................................................................... 1018.1 .Team und Kommunikation ............................................................................................ 1018.2 . Dokumentation und Planung ........................................................................................ 1018.3 . Reviews ....................................................................................................................... 1028.4 Backup/Datensicherung.................................................................................................. 1028.5 Tests................................................................................................................................ 1028.6 Kodierungsrichtlinien ..................................................................................................... 102
EinführungZweckDieses Dokument beschreibt die Projektplanung für das Projekt WMD2CGültigkeitsbereichDieses Dokument gilt als Grundlage für das ganze Projekt WMD2C und hat deshalb Gültigkeit überdie gesamte Projektdauer.Definitionen und AbkürzungenBeschrieben in XX_Glossar/Glossar.docReferenzen01_Projektantrag/Projektantrag.doc02_Projaktplan/Projektplan.xls02_Projektplan/Risikomanagement.xlsSE2 Projekt DokumentvorlagenRudin, H. (02. Februar 2011). MS1ReviewProjektplanungCheckliste1-0.<strong>Rapperswil</strong>, St.Gallen: <strong>HSR</strong>.Rudin, H. (02. Februar 2011). SE2Projekt-FS11-Anleitung. <strong>Rapperswil</strong>,St.Gallen: <strong>HSR</strong>.ÜbersichtDas nachfolgende Kapitel gibt eine kurze Beschreibung des Projekt WMD2C,beschreibt auch Sinn und Zweck sowie die Zielsetzung des Projekt WMD2C.Anschliessend werden in weiteren Kapiteln die Projektorganisation,Management Abläufe, Risikomanagement, Arbeitspakete, Infrastruktur sowiedie Qualitätsmassnahmen beschrieben.Projekt ÜbersichtDas Projekt WMD2C beschäftigt sich mit der Integration eines dynamischenDokument Erstellungssystem in einen Windows Mobile 7 Mail Client. Es solleinen HTML-Mail Client als WP7 App entwickelt werden.
Definitionen und AbkürzungenAbkürzung BeschreibungWP7 Windows Phone 7 : Neuansatz einer mobilenPlattform von Microsoft für den Consumer- undBusiness-BereichSWO Semesterwoche ( Beginn mit Frühjahrsemester am22.02.2011)WMD2C Windows Mobile Dynamic Document Creation: :Name der WP7 Email app<strong>HSR</strong> <strong>Hochschule</strong> für <strong>Technik</strong> <strong>Rapperswil</strong>App Kurzform für Application : ist im Allgemeinenjede Form von AnwendungsprogrammenZweck und ZielDer Industriepartner Sevitec AG stellt Zusatzsoftware-Produkte zu MicrosoftOffice(www.idfix.ch) her, womit Kunden in allen Branchen als Alternative zuselbstprogrammierten Office-Templates auf effiziente Art Geschäftsdokumenteund Emails in perfektem Corporate Identity erzeugen können. Dazu gehört auchdas Erstellen von formatierten HTML-Emails in Microsoft Outlook, mit Profil-,Sprach- und Zielgruppen-abhängigen Signatur.Ziel diese vorliegende Arbeit ist die Integration dieser Funktionalität inSmartphones unter Windows Mobile 7.Annahmen und EinschränkungenDas Projekt WMD2C wird im Rahmen einer Studienarbeit im Frühjahrsemester2011 durchgeführt und darf eine Dauer von 14 Wochen nicht überschreiten. DerProjektplan muss über die Dauer des Frühjahrsemester (14 Wochen)entsprechend erstellt werden.
Pro Woche wird eine Soll Arbeitszeit von Sechzehn Stunden erwartet. Tretenunerwartete Aufwände oder Probleme auf, kann die Arbeitszeit auf maximal 10Stunden erhöht werden.ProjektorganisationDiese vorliegende Arbeit wird als Einzelarbeit durchgeführt. Das Projektteambesteht aus nur einer Person, die für alle Aufgabe im Projekt WMD2C zuständigist. Herr Huser ist verantwortlich für das Projekt WMD2C und ist für dieBetreuung der Arbeit zuständig.OrganisationsstrukturM.M. Ba.Person Kürzel ZuständigkeitBa Mustafa mba Realisierung des ProjektesExterne SchnittstellenPerson Kürzel ZuständigkeitBa Mustafa mba Realisierung des Projektes
Hansjörg Huser HH Dozent an der <strong>HSR</strong> und Leiter vomInstitut INS, Beratung, Betreuung,Kontrolle(Reviews),BewertungPatrik Dietschweiler PD Software-Entwickler im Institut INSan der <strong>HSR</strong>, Technische Probleme imBereich Windows Phone 7EntwicklungSimon Baer SB Software-Entwickler bei der FirmaSevitec AG, Betreuung des Projektesin EschlikonManagement AbläufeProjekt KostenvoranschlagFür die Realisierung des Projektes stehen pro Woche 16 Stunden zur Verfügung.Der Projektstart ist am 21 Februar 2011 d.h Beginn des Frühjahrsemesters ander <strong>Hochschule</strong> für <strong>Technik</strong> <strong>Rapperswil</strong> (<strong>HSR</strong>) und das Projektende am 3 Juni2011. Falls unerwartete Probleme auftreten sollen, kann der Arbeitsaufwand proWoche um 10 Stunden erhöht werden.ProjektplanZeitplanSiehe separates Dokument im Ordner: 02_Projektplan/Zeitplan.xlsMeilensteineMeilenstein Geplant Erreicht Artefakte
MS1:Projektplan 07.03.2011 07.03.2011 Projektplan ZeitplanMS2:Anforderungenund Analyse18.03.2011 30.03.2011 Anforderungspezifikation (nichtfunktionaleAnforderungen, UseCases) Domain ModellMS3: Prototyp 04.04.2011 06.04.2011 Architekturprototyp(Smatphoneseitig,Serverseitig)“proof of concept” Client/Server ArchitekturEntwurfMS4: Konzept Analyse 18.04.2011 19.04.2011 Alpha Release Konzept Analyse Webservice Interfaces Design EntwurfMS5: Design 02.05.2011 02.05.2011 Beta Release Software Architektur undDesign Spezifikation UI Design StudieMS6: Final 16.05.2011 20.05.2011 Finale Release Technischer BerichtEntwurfMS7: Demo 26.05.2011 23.05.2011 Email –Demo mit demProdukt WMD2CMS8: Abgabe 03.06.2011 10.06.2011 Technischer Bericht Abgabe vonProjektDokumente (CD undPapierform)Besprechungen (Meetings)Pro Woche finden zwei Meetings statt. Vorgesehen sind ein kurzes Meeting amDienstag sowie ein umfangreiches jeweils am Freitag. Die Meetings dienen
dazu, die anstehenden Arbeiten sowie anfallende Probleme zu besprechen.Während den Besprechungen wird Protokoll geführt.Besprechung Teilnehmer Datum/Zeit OrtMit Betreuer mba,PD,HH Mittwochs, 9.30 -10.30 <strong>HSR</strong>Mit Industriepartner SB,mba Donnerstags,9.30 –10.30Sivitec AGEschlikon TGIterationenDie nachfolgende Tabelle zeigt eine Übersicht über die verschiedenenIterationsphasen und deren Inhalt. Genauere Informationen bezüglich derzeitlichen Abläufe können dem Zeitplan entnommen werden.Iteration Beschreibung Ende DauerinWocheInception Projektantrag, Einarbeitung in der Windows Phone 7TechnologieSWO1 1
Elaboration 1Elaboration 2Construction 1Construction 2 Analyse vom Kontext Dokumentvorlagen, Projektplan(Zeitplan, Risiko,Konfigurationsverwaltung Domain Model, Entwurf des externenDesigns Konzeptioneller Design, Analyse derAnforderungen und der zurVerfügung stehenden Technologien, Schnittstellenspezifikation der Lösung Design Model, Logische Architektur der Packages, 100% Use Cases im Fully dressedFormat(zumindest der nichtoptionalenFeatures, Korrektur des Externen Design, Client/Server Analyse incl. Funktions-Prototyps aus verschiedenenTeilsystemen, internes Design des UI incl. Prototypeiner graphischen Oberfläche. Prototyp (Serverseitig, Smartphoneseitigund evtl. Webservices), Ausbau Server /Windows Mobile 7Mail Client –Kommunikation, Projekt Automation, Prototyp des UI weiter ausbauen. Einfaches Dokument dynamisch imWindows Mobile 7 Mail Clienterzeugen. Funktionale Anforderungen desSystems implementieren (wieErstellen von formatierten HTML-Mails in Microsoft Outlook, mitProfil-, Sprach- und ZielgruppenabhängigenSignaturen.SWO3 2SWO5 2SWO7 2SWO10 3Construction 3 Erstellen eines dynamischenDokument mit WMD2C, Implementierung zusätzlicherFeatures, BugfixingSWO12 2
Transition 1 Integration von WMD2C in einemWindows Phone 7, Vorbereitung Schlusspräsentationund AbgabeSWO14 2Software ReleasesDatum Beschreibung Release04.04.2011 Architekturprototyp über alle PrototypLayer18.04.2011 Grundfunktionalität:HTML- AlphaEmail mit Logo16.05.2011 Voller Funktionsumfang(alle BetaPflicht Anforderungen),Systemtest erfolgreichdurchgeführt26.05.2011 Email-Demo FinalRisiko ManagementID Risiko Auswirkung Massnahmen S W GR01 Ausfall eines36 1% 3.Teammitglieds0 6Die Arbeit wirdbei einerEinzelarbeitbeendet.R02 Datenverlust Teil der Arbeitgeht verlorenEine Ersatzpersonfür die Arbeiteinplanen.SVN bzw. TeamFoundation Servereinsetzen mithäufigem Commit10 10% 1
R03R04R05R06WP7 hatunbekannteRestriktionen(gegenüber normalemSilverlight)Fehler in derZeitplanungWP7 Mail Client– Architektur nichtklar definiert –Emulator erlaubtnicht das Sendenvon EmailAusfallEntwicklungsrechnerR07 Windows Phone 7Gerät nichtverfügbarR08R09R10Keine Erfahrungmit Entwicklungfür SmartphoneAufgabenstellungunklarAuftretenunerwartetProbleme bei derImplementationdes WP7 MailClientFunktionennicht umsetzbar,keine SchöneLösungMeilensteinekönnen nichteingehaltenwerden.Lösungskonzeptnicht klar fürdieSpezifikationArbeitsstationauf dementwickelt wird, fällt ausKeine Test undDemos mitechter HardwaremöglichSchwierigkeitenbei GestaltungKomplexerGUI‟s fürSmartphoneVerzögerungen,FehlleistungskostenTermine für dieMeilensteinewerden nichteingehalten.Technologiestudium bzw. Prototypmöglichst frühZeitreserveeinplanen,FunktionenstreichenFrühzeitig mitWP7 Mail Clientexperimentieren.WP7 DevicefrühzeitigRegistrieren.- Ausweichenauf Firmen,oderNotebook- Ersatzrechner beantragen.Tests und Demomit EmulatorZeitreserven fürDesignMöglich früheAbklärungen mitentsprechendenPersonenMöglich früh dieMachbarkeit-Studie anfangenGesamtrisiko der Studienarbeit in Stunden 361S: Max. Schaden in Stunden[h]20 30% 680 40% 3280 40% 3215 5% 0.80 100%030 40% 1280 20% 1610 30% 3
W: Wahrscheinlichkeit[%]G: Gewichteter Schaden in Stunden(G=W*S)ArbeitspaketeProjektmanagementID Name Beschreibung VerantwortlichA101A102A103Projektplanung(Initial)InfrastrukturAufbauProjektplan(laufend)Projektplanungs-Dokument verfassen undübergebenSVN-Zugangorganisieren undAblagestruktur definierenArbeitspakete undZeitplanung weiterführen/ verfeinernmba 35mba 17Aufwand[h]Abhängigkeit/Risikenmba 16 A101RequirementsID Name Beschreibung VerantwortlichA201A202A203A204Anforderungen,nichtfunktionalDokument-Erstellung undUse Case, BriefUse CaseDiagrammUse Cases, „fullydressed“Definition allernichtfunktionalenAnforderungenDokumenterstellung undDefinitionen allerfunktionalenAnforderungen im „BriefFormat“UseCase DiagrammerstellenFür die wichtigstenfunktionalenmba 4Aufwand[h]Abhängigkeit/Risikenmba 10 A201mba 3 A202mba 20 A202,A203
A205AbklärungenAnforderungen, dieUseCase im ,fullydressed Format erstellen.Abklärungen zuAnforderungen inklusiveUser Interfacemba 18AnalyseID Name Beschreibung VerantwortlichA30 Domain Domain Modell1A302A303Analyse(OOA)SicherheitskonzeptSOA Web-TechnologieerarbeitenVarianten Analyse für einSicherheitskonzeptVarianten Analyse fürSOA Web Technologiein Bezug auf MobileDevices(REST,SOAP,WCF)DesignID Name Beschreibung VerantwortlichA40 Software Beschreibung der1 Architektur Software-ArchitekturA402A403A404Design(OOD)Web-ServiceInterfaceUI DesignStudie fürMobile DeviceBeschreibung desSoftware-Designs(Package –Klassen – undSequenzdiagramme)Definition eines Web-Service Interface für dieInbetriebnahmeüber ein Mobile-DeviceStudie für ein auf dieAnforderungen vonMobile-Devicesoptimiertes UserAufwand[h]Abhängigkeit/Risikenmba 16 A202mba 8(optional)mba 20(optional)Aufwand[h]Abhängigkeit/Risikenmba 40 A2*,A3*mba 30 A2*,A3*mba 16 A2*mba 25
InterfaceImplementationID Name Beschreibung VerantwortlichA501A502ArchitekturprototypImplementationRefactoringArchitekturprototypZugriff aufWebservicesvon WP7 ClientImplementation desArchitekturprototypen fürein „proof of concept“Umfasst die KompletteImplementation. Wird amEnde derElaborationsphase 2genauer aufgeteilt.Refactoring desArchitekturprototypenClient /ServerKommunikation startenAufwand[h]Abhängigkeit/Risikenmba 60 A2*,A301,A401,A402mba 163 A2*,A3*,A4*mba 5 A501mba 4TestID Name Beschreibung VerantwortlichA601A602SystemtestTestdokumentationBeinhaltet denmanuellen, auf dieAuslieferungausgerichteten Test dergesamten Applikationvor jedem Release.Erstellen derTestdokumentation.Aufwand[h]Abhängigkeit/Risikenmba 6 A2*,A5*,A602FallsFehlervorhandenMehraufwand beiA503mba 14 A2*,A5*
DokumentationID Name Beschreibung VerantwortlichA70 Kurzbericht Verfassen und online1Abgabe des Kurzberichts.A70 Technischer Verfassen des2 Bericht Technischen BerichtsA70 Management Management Summary3A704A706SummaryDokumentAbschlussSchlussberichterstellenAbschluss undBereinigung allerDokumenteSchreiben despersönlichenSchlussberichtesmba 10mba 40mba 12mba 16mba 6Aufwand[h]Abhängigkeit/RisikenTechnologie StudienID Name Beschreibung VerantwortlichA011A012Einarbeiten inWP7Einarbeiten inMobile UIDesignWissen zur Entwicklungfür das Windows Phone 7beherrschenWissen über UI-Designfür Mobile-Devicesbeherrschenmba 20mba 10Aufwand[h]Abhängigkeit/RisikenSitzungenID Name Beschreibung VerantwortlichA02 Reviews Reviews mit dem mba/ 37Aufwand[h]Abhängigkeit/Risiken
1 Betreuer zurÜberprüfung derMeilensteine.A022SitzungenSitzung mit demBetreuer über denaktuellen ProjektstandHusermba/Huser26QualitätssicherungID Name Beschreibung VerantwortlichA031Code ReviewCode-Review mit demBetreuer,Debuggingmba/HuserReserve Reserve 100h mba 100Aufwand[h]8Abhängigkeit/RisikenInfrastrukturHardware <strong>HSR</strong>-Rechner am Arbeitsplatz an der <strong>HSR</strong> SVN-Server der <strong>HSR</strong>(svn.hsr.ch)Software Microsoft Visual Studio 2010(Entwicklungsumgebung) Microsoft Expression Blend 4 (GUI Design) Notepad2(XML-Dateien) FxCop (Überprüfen auf Microsoft Coding-Guidelines) GhostDoc(Unterstützung für Kommentare in .Net) MsBuild (Build –Automatiom) Adobe Photoshop CS4 (Icon/Grafiken)Dokumentation
Microsoft Word 2010 (Dokumentation) Microsoft Excel 2010 (Planung, Dokumentation) Adobe Acrobat 9 Professional(PDF-Dokument Generieren) Enterprise Architekt 7.0 (UML-Modeling) Doc-O-Matic (Quellcode-Dokumentation)Versionsverwaltung Subversion (SVN-Server der <strong>HSR</strong>) TortoiseSVN als ClientQualitätsmassnahmen8.1 .Team und KommunikationDas Projektteam besteht nur aus einer Person, deswegen muss die Koordination mit dem Betreuer gutabgewickelt sein. Für eine erfolgreiche Lösungsorientierte Kommunikation dienen die verschiedeneSitzungen und Reviews über die gesamte Projektdauer. ( 14 Wochen).8.2 . Dokumentation und PlanungEine Gute Dokumentation ist in erste Linie massgeblich für den Erfolg eines Projektes. DieProjektdokumentation wird daher laufend aktualisiert und angepasst. Eine gute Zeitplanungermöglicht ein besseres Zeitmanagement im Projekt. Dadurch können Verzögerungen frühzeitigerkannt werden. Eine Zeiterfassung wird laufend vom Teammitglied geführt und alle aufgewendetenStunden werden in der Deteilplanung eingetragen.
8.3 . ReviewsEin wichtiger Faktor für die Qualitätssicherung stellen die Reviews im Projektverlauf dar. Deswegenwerden regelmässig Dokumentsreviews und auch Code-Reviews mit dem Betreuer durchgeführt. Fürdiese Sitzungen werden Sitzungsprotokolle als Grundlage für weitere Vorgehensweise festgehalten.8.4 Backup/DatensicherungDaten bzw. Dokumente sowie Sourcecodes werden regelmässig im SVN-Verwaltunsgtooleingecheckt. Dies garantiert jederzeit eine Datensicherung auf dem SVN-Server.8.5 TestsAlle Funktionalen Anforderungen, welche auch anhand Use Cases spezifiziert wurden, werdengetestet. Die Testresultate werden in einem Testplan ausgeführt.8.6 KodierungsrichtlinienWir werden Microsofts Coding Standard und Best Practices folgen um eine zuverlässige undwartungsfreundliche Email-Anwendung zu realisieren.AnforderungsspezifikationEMAIL CLIENT DYNAMIC DOCUMENTCREATION
Studienarbeit :Autor :Verantwortlicher : Prof. Hansjörg HuserBetreuer:Prof. Hansjörg HuserIndustriepartner:Integration eines Dynamic Document Creation System in einenWindows Phone 7 Mail ClientBa Mohamedou MoustaphaHerr Simon BaerSevitec AG, Eschlikon TGDokumentenverwaltungDokumenthistorieVersion Status Datum Verantwortlicher Änderungsgrund0.1 InBearbeitung05.03.2011mbaDokumentvorlage erstellt0.1 InBearbeitung0.1 InBearbeitung0.1 InBearbeitung0.1 InBearbeitung0.1 InBearbeitung06.03.201107.03.201114.03.201121.03.201122.03.2011mbambambambambaKapitel 1, Kapiel2, bis kapitel4Use Case Diagram, use CasesBriefDokument überarbeitenAnforderungen ergänzen, UseCases anpassen.UI Storyboard
ReviewFolgende Personen haben das Dokument gelesen und geprüft:Herr Simon Baer : Donnerstag,10.März 2011Herr Simon Baer: Mittwoch,23.März 2011
Inhaltsverzeichnis1 Einführung ............................................................................................................................................1061.1 Zweck .............................................................................................................................................1061.2 Gültigkeitsbereich ..........................................................................................................................1061.3 Definitionen und Abkürzungen ......................................................................................................1061.4 Referenzen......................................................................................................................................106Projektantrag/Aufgabenstellung.pdf ....................................................................................................1062 . Allgemeine Beschreibung ..................................................................................................................1072.1 Produkt Perspektive........................................................................................................................1072.2 Produkt Funktion............................................................................................................................1072.3 Benutzer Charakteristik ..................................................................................................................1082.4 Einschränkungen ............................................................................................................................1082.5 Annahmen ......................................................................................................................................1082.6 Abhängigkeiten ..............................................................................................................................1083 . Spezifische Anforderungen ................................................................................................................1093.1 Zugriff auf Datenbank ...................................................................................................................1093.2 Benutzbarkeit .................................................................................................................................1093.3 Schnittstellen ..................................................................................................................................1103.4 Lizenzanforderungen......................................................................................................................1104 . Use Cases............................................................................................................................................1104.1 Use Case Diagramm .......................................................................................................................1104.2 Aktoren & Stakeholders .................................................................................................................1165 . Use Cases Brief ..................................................................................................................................1175.1 UC1: Dokumenttyp auswählen ....................................................................................................1175.2 UC2: Parameter auswählen ............................................................................................................1175.3 UC3: Benutzerprofil auswählen ...................................................................................................1175.4 UC4: Dokument erstellen...............................................................................................................1175.5 Dokument steuern ..........................................................................................................................1176 . Use Cases Brief ..................................................................................................................................1176.1 UC1: Dokumenttyp auswählen .....................................................................................................1176.2 UC2: Parameter auswählen ............................................................................................................1186.3 UC3: Benutzerprofil auswählen .....................................................................................................1186.4 UC4: Dokument erstellen...............................................................................................................1196.5 UC5: Dokument steuern.................................................................................................................120
EinführungZweckDas Anforderungsdokument beschreibt die Anforderungen an das zu beschaffendesSoftware-System. Die Nicht-Funktionale Anforderungen sowie die FunktionaleAnforderungen in Form von Use Cases werden in diesem Dokument spezifiziert.GültigkeitsbereichDie Gültigkeit dieses Anforderungsdokuments erstreckt sich über die gesamte Projektdauer(14 Wochen).Die Änderungen werdenDefinitionen und AbkürzungenAbkürzungWP7WCFWMD2CRESTSilverlightXNABeschreibungWindows Phone 7 : Neuansatz einer mobilen Plattform von Microsoftfür den Consumer- und Business-BereichWindows Communication Foundation : Service-orientierteKommunikationsplattform von Microsoft für verteilte Anwendungen .Windows Mobile Dynamic Document Creation : Name der WP7Email appRepresentational State Transfer : Software-Architekturstil für verteilteHypermedia-Systeme wie z.B World Wide WebSilverlight ist Microsofts Technologie für sog. Rich InternetApplications (RIA)XNA ist Microsofts .NET-basiertes Spieleframework fürhochperformante 2D- und 3D-SpieleReferenzenProjektantrag/Aufgabenstellung.pdf
. Allgemeine BeschreibungIn folgenden Kapiteln dieses Dokuments wird das Produkt WMD2C zuerst kurzbeschrieben. Danach folgt eine Beschreibung von funktionalen und nicht-funktionalenAnforderungen. Das letzte Kapitel beschreibt ausführlich die Use Cases.Produkt PerspektiveDie Coorporate Identity (CD) spielt eine sehr wichtige Rolle für die Abwicklung derGeschäfte bei Unternehmen aller Branche, da sie die Persönlichkeit eines Unternehmensdarstellt. . Da Dokumente und Email ein unverzichtbares Kommunikationsmittel für dieGeschäftswelt darstellen, müssen Geschäftsdokumente sowie Email mit perfetem CoorporateIdentity erstellt werden.Die Firma Sevitec AG hat mit dem Software –Produkt ONEOFFIXeine Lösung für Microsoft-Word Dokumente geliefert. Die Integration dieser Software inMicrosoft-Word ermöglicht eine dynamische Dokument-Erstellung mit Coorporate Identity,Sprach und Profil sowie Benutzer-Abhängige Signaturen. Für Geschäftleute , die unterwegsGeschäfte abwickeln , wäre eine portierung solche Software-Produkte auf Mobile-Telefonevon sehr grossen Bedeutung. Dazu soll einen WP7 Mail Client als WP7 App entwickeltwerden.Produkt FunktionWMD2C soll folgende Funktionalitäten zur Verfügung stellen: Email in HTML-Format in Microsoft Outlook erstellen. Geschäftsdokumente in perfektem Corporate Identity erzeugen. Dokumenttyp laden Dokument-Parameter auswählen Benutzer- Signatur im Dokument einfügen Dokument erstellen Dokument steuern :o Element (Parameter) Einblendeno Element(Parameter) Ausblendeno Elemente (Parameter) nachträglich ändernDokumenttypen und Parameter sind in der Datenbank abgelegt und sollen daher nicht statischprogrammiert. Der ganze Prozess soll dynamisch ablaufen. Es sollte jederzeit möglich seinin der Datenbank einen neun Dokumenttyp oder Parameter eingefügt werden können. Beimnächsten Erstellen eines Dokuments soll der neue Dokumenttyp bzw. Parameter angezeigtwerden.
Benutzer CharakteristikDie Zielgruppe für WMD2C beschränkt sich auf Geschäftsleute aller Branchen, welcheGeschäftsdokumente mit Corporate Identity (CI) per Email mit einem Windows Phone 7Gerät verschicken wollen.EinschränkungenWP7 basiert auf Microsoft Embedded-Betriebssystem CE. Die Betriebssystemebene (APIs)ist für Softwareentwickler allerdings nicht zugänglich, dies ist allein den Geräteherstellernvorbehalten. Für die Entwicklung von Anwendungen (Apps) steht eine .Net-basierteAnwendungsplattform (Silverlight) zur Verfügung.Als WP7 Email App konzipiert kann WMD2C nur auf WP7-Geräte lauffähig sein.AnnahmenIn der Einarbeitungsphase konnte ein Konzept für das WMD2C System definiert werden.Dieses Grundkonzept besteht aus einem WebService, einer Datenbank (SQL-Server 2008)und WP7- Gerät. Der WebService stellt Daten wie (Dokumentvorlagen, Parameter) aus derDatenbank für das WP7-Gerät zu Verfügung. Im Rahmen dieser Studienarbeit wirdangenommen, dass der Zugriff auf Webservices von WP7 –Geräte möglich wäre.Abhängigkeiten
. Spezifische AnforderungenDie Spezifischen Anforderungen werden im Kapitel 4 Anhand Use Case beschrieben. Dieanderen Anforderungen, welche nicht aus Benutzer-Perspektive beschrieben werden könnenwerden in folgendem Kapitel beschrieben.Zugriff auf DatenbankDie Dokumentvorlagen sollen auf einem SQL-Server 2008 liegen. WMD2C soll auf dieseDaten via Internet zugreifen können. Für die Bereitstellung der Daten aus der Datenbank solleinen WCF-Service realisiert werden.LoginDer Zugriff auf dem Websevice soll über Username /Passwort aus via Smartphone möglichsein.Sicherheit , Performance, StabilitätAnwendungen für WP7 werden grundsätzlich in einem Framework entwickelt, welches auf.NET basiert und Stabilität, Performance und Sicherheit garantiert. In diesem Frameworkstehen zwei UI-Technologien zur Verfügung: Silverlight und XNA.Unter Windows Phone 7 stellt Silverlight ein vollwertiges Anwendungsframework füreigenständige Programme dar, läuft also nicht im Browser. Es basiert auf Silverlight 3 mitErweiterungen und Anpassungen, bspw.o Durchgehende Hardwarebeschleunigung für höchste Performanceo Integration des Software-Keyboards für Eingabeelementeo Multitouch-Unterstützungo Zugriff auf die Gerätehardware (Kamera, GPS, Sensoren) über spezielle APIso Anpassung an das Anwendungsmodell von WP7 (voneinander isolierte Anwendungeno Weniger enge Sandbox( für Cross-Domain-Zugriff)BenutzbarkeitGeräte mit WP7 verfügen grundsätzlich über kapazitive Touchscreens, welche fürFingerbedienung optimiert sind und Multitouch-Funktionalität (4 oder mehr Touchpoints)unterstützen. Die einheitliche Bildschirmauflösung ist WVGA(800x480), so dass aufwändigesTesten mit verschiedenen Geräten entfällt. Unterstützung von Portrait- und Landscape-Modusgewährleistet. Zwecks Navigation sind drei Buttons auf der Vorderseite (Back, Home,Suche). Hardware-Tastatur oder andere Buttons und Sensoren sind optional.VerständlichkeitDas GUI soll intuitiv zu bedienen sein. Es wird erwartet, dass die eingesetzten Icons eineinterne sowie externe Konsistenz aufweisen. Die Grundelemente werden daher stark an dasOriginal-WP7Mail Client angel
WiederherstellbarkeitBei einem Systemabsturz sollen alle relevanten Daten und letzte Benutzeränderungen, sicherabgespeichert sein.VerbrauchsverhaltenSpeicher-Verbrauch vom Original-WP7 Mail Client gilt auch für das System WMD2C.ModifizierbarkeitAllfällige Änderungen am WP7 Mail Client -Funktionalitäten müssen innerhalb von 2Manntagen implementiert werden können.InstallierbarkeitWMD2C kann als WP7 App einfach auf jedes WP7-Gerät installiert werden.SchnittstellenEin Webservice definiert die Schnittstelle für die Kommunikation mit dem WP7 EmailClient.DatenbankschnittstelleEs wird eine Datenbankschnittstelle benötigt, da Dokument-Vorlage auf eine Datenbankgespeichert sein muss. SQL-Server 2008 wird als Datenbank im Einsatz kommen.LizenzanforderungenEs werden keine Lizenzen benötigt.. Use CasesUse Case Diagramm
UI Prototype & Storyboard
Aktoren & StakeholdersDer primäre Aktor ist Geschäftsmann Nutzer eines WP7-Geräts.
. Use Cases BriefUC1: Dokumenttyp auswählenDer Benutzer kann aus einer Drop-Down Liste den gewünschten Dokumenttyp auswählen.Dokumenttypen sollen im allgemein in Gruppen zusammengefasst werden. Es werden zweiGruppen definiert: Eine Gruppe „Email“ und eine Gruppe „Newsletter“. Die Gruppe„Newsletter“ besteht aus zwei Dokumenttypen: „ONEOFFIXX“ und „SEVITEC“.UC2: Parameter auswählenIm allgemein sollen die möglichen Parameter, die der Benutzer auswählen kann, vomDokumenttyp abhängig sein.Dokumenttyp „Email „ hat die Parameter: Logo, Rolle, Dokumenttyp „Newsletter“ hat alsParameter : Sprache.UC3: Benutzerprofil auswählenDer Benutzer kann das gewünschte Benutzerprofil festlegen .Der Benutzerprofil wird alsSignatur für das Dokument verwendet. Das Benutzerprofil soll einmal definiert undgespeichert werden.UC4: Dokument erstellenDer Benutzer kann aus den gewählten Dokumenttyp und Parametern ein dynamischesDokument erstellen bzw. eine formatierte HTML-Email erstellen. Bevor das Mail gesendetwird, muss der Benutzer es bearbeiten können.Dokument steuernDer Benutze kann nachträgliche Änderungen im Dokument vornehmen. Ein Dokument-Bereich lässt sich dadurchEin -/ und Ausblenden.. Use Cases BriefUC1: Dokumenttyp auswählenÜberblickVorbedingungenNachbedingungenDer Benutzer will ein dynamisches Dokument mit dem WP7-Geräterstellen. Für die Erstellung eines Dokuments muss denDokumenttyp definiert werden. Email-Anwendung (WMD2C) ist auf WP7-Gerät installiert undlauffähig. Email-Account von Benutzer auf dem WP7-Gerät vorhanden. Dokumenttyp wurde erfolgreich ausgewählt.
Standardablauf1. Benutzer startet den WP7 Email Client2. System zeigt Email-Operationen an.3. Benutzer wählt die Option Dokument –Erstellen aus.4. System zeigt Dokumenttypen an : Email oder Newsletter5. Benutzer wählt den gewünschten Dokumenttypen aus.ErweiterungenSpezielleAnforderungen4a. Falls Benutzer den Dokumenttyp Newsletter auswählt4b. System zeigt zwei Newsletter-Typen an : ONEOFFIX oderSEVITEC4.c Benutzer wählt Newsletter-Typ aus.Häufigkeit desAuftretensOffene Fragen:UC2: Parameter auswählenÜberblickVorbedingungenNachbedingungenStandardablaufDer Benutzer muss zum gewählten Dokumenttyp die Parameterdefinieren. UC1 Parameter wurden erfolgreich festgelegt.1. System zeigt die definierten Parameter für dieDokumente an : Sprache,Layout, Rolle.2. Benutzer wählt die gewünschten Parameter aus der Listeaus.Erweiterungen2a. Bei der Wahl von Dokumenttyp Email2a. Benutzer wählt nur Parameter Rolle aus.SpezielleAnforderungenHäufigkeit desAuftretensOffene Fragen:UC3: Benutzerprofil auswählenÜberblickDer Benutzer muss das passende Benutzerprofil im Dokument
einfügen.Vorbedingungen UC1 UC2NachbedingungenStandardablauf Die Signatur wurde erfolgreich im Dokument eingefügt.1. Benutzer wählt über die Funktion „Einstellungen“im Dokument das Benutzerprofil.2. System zeigt Eingabefelder für die Identifikationdes Benutzers3. Benutzer gibt folgende Informationen ein :(Name, Vorname, Firma, Rolle)4. System speichert das Benutzerprofil und fügt esautomatisch in jedes erstellte Dokument ein.ErweiterungenSpezielleAnforderungenHäufigkeit desAuftretensOffene Fragen:UC4: Dokument erstellenÜberblickVorbedingungenNachbedingungenStandardablaufDer Benutzer erstellt nun ein dynamisches Dokument mit demWP7-Gerät. UC1 UC2 UC3 Dokument wurde erfolgreich erstellt1. Das gewählte Dokument wird automatisch vom Systemaus der Datenbank geladen.2. Das Dokument wird automatisch in den Dokument-Editorgeladen.3. Benutzer kann nun Dokument schicken oder speichern.Erweiterungen
SpezielleAnforderungenHäufigkeit desAuftretensOffene Fragen:UC5: Dokument steuernÜberblickVorbedingungenNachbedingungenStandardablaufErweiterungenSpezielleAnforderungenDer Benutzer will ein erstelltes Dokument ändern. UC4 Änderungen im Dokument wurden erfolgreich durchgeführt.1. Benutzer öffnet das Dokument im WP7 EmailClient.2. Benutzer klickt auf dem zu ändernden Bereich imDokument an3. System zeigt die Optionen für die Steuerung einesDokuments : Dokument-Sektion ein/oder –ausblenden4. Benutzer klickt auf die gewünschte Option an umdie Änderung am Dokument durchzuführen5. System übernimmt die Änderung im Dokument.Häufigkeit desAuftretensOffene Fragen:Software-Architecture & Design
EMAIL CLIENT DYNAMIC DOCUMENT CREATIONStudienarbeit : Integration eines Dynamic Document Creation System in einenWindows Phone 7 Mail ClientAutor :Ba Mohamedou MoustaphaVerantwortlicher : Prof. Hansjörg HuserBetreuer: Prof. Hansjörg HuserHerr Simon BaerIndustriepartner: Sevitec AG, Eschlikon TG
DokumentinformationenÄnderungsgeschichteDatum Version Änderung Autor30.03.2011 0.1 Dokument erstellt mba10.06.2011 1.0 End Version des Dokuments mba
Inhalt0 Dokumentinformationen .......................................................................................................122Änderungsgeschichte ...............................................................................................................122Inhalt.........................................................................................................................................1231 Einführung ............................................................................................................................1242 Zweck ...................................................................................................................................1243 Gültigkeitsbereich .................................................................................................................124Definitionen und Abkürzungen ................................................................................................1244 Referenzen ............................................................................................................................1245 Übersicht ...............................................................................................................................1246 Physikalische Architektur .....................................................................................................1247 logische Architektur..............................................................................................................125Datenbank ...........................................................................................................................1258 Prozesse und Threads ...........................................................................................................1269 Data Access Layer ................................................................................................................126WCFEntityData ........................................................................................................................127Entities......................................................................................................................................128DocumentRepository ..........................................................................................................12910 Service Layer .....................................................................................................................129DocumentService ................................................................................................................12911 Client Layer .......................................................................................................................130WP7TestClient ....................................................................................................................130MainPage .............................................................................................................................130ParameterViewPage ...........................................................................................................130EmailConfigPage ................................................................................................................130
EinführungZweckDieses Dokument beschreibt die Software Architektur des Grundsystems. Design Alternativen undEntscheide sind in diesem Dokument beschriebenGültigkeitsbereichDas Dokument ist für die komplette Dauer des Projektes gültig(14 Wochen).Definitionen und AbkürzungenReferenzenAufgabenstellung.pdfDomainanalyse.pdfÜbersichtDie folgenden Kapitel beschreiben die gesamte Architektur der Applikation WMD2C.Physikalische ArchitekturDas WMD2C System läuft als WP7 app auf einem Smartphone und kann übers Internet mit einemWebService interagieren. Der WebService kann direkt die nötigen Daten für die Erstellung einesDokuments aus der Datenbank laden und diese dem WP7 Email Client zur Verfügung stellen. Dasfolgende Bild zeigt die drei wichtigen Komponenten der physikalischen Architektur des Systems:WP7 Client, WebService und Datenbank.
logische ArchitekturDatenbankDie Daten werden auf einer Datenbank abgelegt. Die Parameter, die ausgewählt werden können, sinddann von Dokumenttyp abhängig. In der Datenbank kann jederzeit einen neuen Dokumenttyp oderParameter eingefügt werden. Beim nächsten Erstellen eines Dokuments werden die neuen Einträge inder Datenbank angezeigt.Die SQL-Server Datenbank ist einfach gehalten mit folgender Struktur:
Die SQL Server Datenbank ist einfach gehalten mit folgender Struktur.Prozesse und ThreadsJede Windows Phone 7 App wird aus Sicherheitsgründen in einer isolierten Sandbox ausgeführt.Dadurch können Applikationen nicht direkt auf Ressourcen des Geräts zugreifen. Für den Zugriff aufdie Ressourcen, wie etwa die Bildbibliotheke, werden daher sogenannte Launcher und Choosersbereitgestellt. Launcher und Choosers sind eigenständige Applikationen. Ein Launcher startet eineintegrierte Applikation, welche keine Daten an die aufrufende Applikation zurückliefert. Als Beispielsei der EmailComposeTask genannt. Dieser öffnet die eingebaute E-Mail-App.Ein Chooser hingegenliefert Daten an die aufrufende Applikation zurück. Beispielsweise öffnet der CameraCaptureTask dieKameraapplikation und liefert als Ergebnis ein neu aufgenommenes Foto an die aufrufende App. Dieaktuell vorhandene Windows-Phone-Version verhindert, dass mehrere Apps parallel ausgeführtwerden. Verwendet eine App einen Launcher oder Chooser, wird somit die rufende App beendet, inden sogenannten Tombstone-Modus versetzt und faktisch beendet. Dies ist ein essenzielles Konzeptder Windows-Phone-Entwicklung.Data Access LayerDer Data Access Layer wird mit dem ADO.NET Entity Framework CodeFirst Modellimplementiert. Dieser Layer beinhaltet eigentlich nur das *.edmx Datenmodell (z.B.WP7MailClientModel.edmx), welches den Datenzugriff auf die darunterliegende SQL ServerDatenbank ermöglicht.Das Modell sieht folgendermaßen aus:
WCFEntityDataDas WCFEntityData Projekt implementiert das Data Access Layer der Applikation. DiesesProjekt besteht aus drei Komponenten: Entities, Model, Repositories, Interfaces, SmtpMail.
KlassendiagrammEntitiesFür jede Entität im Entity Datenmodell wird eine Klasse definiert. Diese Klassen sind imOrdner „Entities“ abgelegt.DocumentsDiese Klasse definiert ein Daten Transfer Object (DTO), welches ein Mapping mit derentsprechenden Datenbank Tabelle (Documents) realisiert.DocumenttypsDiese Klasse definiert ein Daten Transfer Object (DTO), welches ein Mapping mit derentsprechenden Datenbank Tabe13.06.201113.06.2011lle (Documenttyps) realisiert.ParameterDiese Klasse definiert ein Daten Transfer Object (DTO), welches ein Mapping mit derentsprechenden Datenbank Tabelle (Parameters) realisiert.ParameterValue
Diese Klasse definiert ein Daten Transfer Object (DTO), welches ein Mapping mit derentsprechenden Datenbank Tabelle (ParameterValues) realisiert.WCFEntityContext (DTO Converter)Diese Klasse implementiert die ObjectContext- Klasse im Namespace System.Data.Objects.Die WCFEntityContext-Klasse teilt dem Entity Framework mit, wie es das Mappingzwischen den Entitäten im Datenmodell und den DTO‟s machen soll.DocumentRepositoryDiese Klasse implementiert die Funktionalität für den Service-Layer. Für jede Entität –Documenttyp, Document, Parameter, ParameterValue- sollen folgende CRUD-Operationenunterstützt werden. Definiert der Business-Layer.des Primärschlüssels lesenService LayerDocumentServiceWebService-Projekt mit Windows Communication Foundation (WCF) amtiert alsService Layer für die ganze Applikation.IDocumentServiceDiese Klasse ist die eigentliche WCF-Serviceschnittstelle. Definiert alle Service-Operationenfür den Windows Phone 7 ClientProxyDataContractResolverDiese Klasse implementiert die DataContractResolver-Klasse. Die KlasseDataContractResolver erweitert beim WCF-Service die Serialisierungs-undDeserialisierungsprozsse.
Client LayerWP7TestClientDiese Windows Phone 7 Client Applikation verwendet den WCF-Service um einendynamischen Dokument zu erstellen.MainPageDiese Klasse definiert die HauptSeite der Applikation. Alle Documenttypen in der Datenbankwerden automatisch beim Starten der Applikation angezeigt.ParameterViewPageDiese Klasse definiert die Parameter-Seite. Wenn ein Documenttyp aus der HauptSeiteausgewählt wird, navigiert die Applikation von der HauptSeite zur Parameter-Seite. AlleParameter eines Documenttyps aus der Datenbank werden automatisch angezeigt.EmailConfigPageDiese Klasse definiert einen Html-Editor um erzeugte Dokumente darzustellen.Erfahrungsbericht
EMAIL CLIENT DYNAMIC DOCUMENTCREATIONAutor :Verantwortlicher :Betreuer:Industriepartner:Ba Mohamedou MoustaphaProf. Hansjörg HuserProf. Hansjörg HuserHerr Simon BaerSevitec AG, Eschlikon TGIch wollte schon immer etwas mit der .Net Technologie anfangen und vor allemetwas im Mobile Bereich entwickeln. Alles hat bei mir angefangen als ich dasModul „Microsoft Technologie“ bei Herr Huser an der <strong>Hochschule</strong> für <strong>Technik</strong><strong>Rapperswil</strong>(<strong>HSR</strong>)besuchte. Ich war immer sehr begeistert und wusste gleich,Aha das ist wirklich etwas für mich. Ich habe also mir gedacht, die besteMöglichkeit sich intensiv mit .Net Technologien zu befassen wäre, eine Arbeitin der Welt von Microsoft zu schreiben. Ich habe vergeblich einen Team-Partnergesucht und ich musste unbedingt meine letzte Studienarbeit absolvieren. ZumGlück habe ich ein sehr kompetenter Professor und vor allem mit Herzgefunden, der mir die Chance gab endlich meine Studienarbeit zu schreiben. DasThema der Studienarbeit war sehr interessant und ich war sehr froh darüber,dass ich die Arbeit bei meinem Favorit an der <strong>HSR</strong> schreiben dürfte. Ich habesehr viel gelernt und immer Grosse Freude von Anfang zum Ende des Projektesempfunden. Die Zusammenarbeit mit dem Industriepartner (Sevitec AG)inEschlikon war sehr angenehm. Ich war froh, dass die Firma Sevitec für michFahrspesen bezahlt. Ich finde das sehr großzügig. Herr Simon Baer ist ein sehrkompetenter Ingenieur und die Zusammenarbeit mit ihm war sehr positiv fürmich. Ich habe leider diese Studienarbeit in schwierige Zeiten für michdurchgeführt. Ich hatte die ganze Zeit keinen Kopf frei gehabt. Ich habe viel Zeitinvestiert um zumindest das Grundkonzept der Lösung zu implementieren.Hauptsache alles ist gut gelaufen und ich bin zufrieden mit mir selbst. Ich binsehr froh, dass ich die Arbeit selbstständig durchgeführt habe. Natürlich HerrHuser hat mir sehr viel geholfen. Jetzt habe ich die Übung gemacht. Ich möchte
nun Kraft tanken um mein Studium erfolgreich abzuschließen. Ich bedanke michbei allen für die wertvolle Unterstützung.
Change language