Převod Windows Forms do Windows Presentation

Transkript

BAKALÁŘSKÁ PRÁCE
Převod Windows Forms do
Windows Presentation
Foundation
Converting Windows Forms
into Windows Presentation
Foundation
Straka Jiří
Unicorn College © 2010
Unicorn College, V kapslovně 2767/2, Praha 3, 130 00
Název práce v ČJ:
Název práce v AJ:
Převod WF do WPF
Converting WF into WPF
Autor:
Straka Jiří
Akademický rok:
2011
Kontakt:
E-mail: [email protected]
Tel.: (+420) 774 439 398
Bakalářská práce
Převod Windows Forms do Windows Presentation Foundation
Converting Windows Forms into Windows Presentation Foundation
1. ZADÁNÍ
-4-
2. ABSTRAKT
V následující práci se podíváme na historický vývoj technologií pomocí, kterých lze vyvíjet
okenní aplikace pro operační systém Windows. Detailněji se podíváme na dvě nejnovější
technologie společnosti Microsoft, které jsou součástí .NET Frameworku a jedná se o
technologie Windows Forms a Windows Presentation Foundation (WPF). Technologie
Windows Forms může být také využita např. pro vývoj aplikací pro operační systém Linux
pomocí projektu Mono od společnosti Novell. Celá práce je zaměřena hlavně na technologii
WPF, a proto také nahlédneme do jejího využití ve vývoji bohatých internetových aplikací
pomocí Silverlight a Windows Phone 7, které nám umožňuje vyvíjet pro mobilní zařízení.
Nejobsáhlejší část práce je věnována popisu aplikace pro převod Windows Forms do WPF.
V popisu aplikace nalezneme např. požadavky kladené na aplikaci, třídní diagram celé
aplikace, popis jednotlivých tříd, použité návrhové vzory, atd.
Aplikace umožňuje načíst
vstupní soubor, který definuje uživatelské rozhraní ve Windows Forms a převést tento
soubor do, co možná nejvěrohodnější reprezentace ve WPF pomocí značkovacího jazyka
XAML (Extensible Application Markup Language), který je typický pro WPF. Aplikace pro
svůj vlastní převod nepodporuje všechny komponenty, které Windows Forms nabízí, ale
pouze omezenou množinu vybraných komponent. U této množiny komponent je opět
vybráno jen několik stěžejních vlastností, které aplikace pro převod podporuje. Rozšiřitelnost
je jeden z hlavní požadavků, který musí aplikace splňovat. Proto je všechna aplikační logika
pro převod mezi technologiemi soustředěna v zásuvných modulech. Zásuvné moduly
umožňují snadné rozšíření portfolia podporovaných komponent a jejich vlastností pro
převod.
V závěru práce jsou shrnuty všechny poznatky, které byly nasbírány během vývoje aplikace.
Je zde uveden výčet možných směrů, jakými by se mohlo rozšiřování aplikace ubírat, ale
také faktory, které převod z Windows Forms do WPF ztěžují a v některých případech i
znemožňují.
Klíčová slova: .NET Framework, Windows Forms, Windows Presentation Foundation, XAML,
Silverlight, Windows Phone 7, XNA, C#, návrhový vzor, zásuvný modul.
-5-
3. ABSTRACT
Inside following Bachelor's Thesis we take a look at historical development of technologies
which allow us to develop form applications for operation system called Windows. We take
look at the two latest Microsoft technologies which are a part of .NET Framework in detail.
These technologies are Windows Forms and Windows Presentation Foundation (WPF).
Technologies Windows Forms can be also used for developing applications for Linux
operation system through Mono project by Novell Company. The whole Bachelor's Thesis is
mainly focused on WPF. Therefore, we look into its usage in developing rich internet
application via Silverlight and Windows Phone 7 which allows us to develop for mobile
devices.
The most extensive part of whole Bachelor’s Thesis is dedicated to description of application
for converting Windows Forms into Windows Presentation Foundation. Inside the description
of application we can find for example requirements for application, class diagram of whole
application, description of each class, used design patterns, etc. Application allows us to
load input file which defines user interface in Windows Forms technology and convert this file
into as credible representation as possible in WPF using markup language XAML. This
markup language is typical for WPF. The application doesn't support all the components
which Windows Forms offers. But there is just limited set of selected components. Every
component has selected set of supported attributes for conversion. Extensibility is one of the
most important requests for application. That's why all the application logic for converting is
concentrated inside plugins. Plugins allow to application be easily extensible and
upgradable.
The conclusion of Bachelor's Thesis summarizes all pieces of knowledge that have been
collected during developing application. There is also enumeration of all possible ways how
could be the application extended. But there are also facts which make converting Windows
Forms into WPF more difficult.
Keywords: .NET Framework, Windows Forms, Windows Presentation Foundation, XAML,
Silverlight, Windows Phone 7, XNA, C#, design pattern, plugin
-6-
4. PROHLÁŠENÍ
Prohlašuji, že svou bakalářskou práci na téma Převod Windows Forms do Windows
Presentation Foundation jsem vypracoval samostatně pod vedením vedoucího bakalářské
práce a s použitím odborné literatury a dalších informačních zdrojů, které jsou v práci
citovány a jsou též uvedeny v seznamu literatury a použitých zdrojů.
Jako autor uvedené bakalářské práce dále prohlašuji, že v souvislosti s vytvořením této
bakalářské práce jsem neporušil autorská práva třetích osob, zejména jsem nezasáhl
nedovoleným způsobem do cizích autorských práv osobnostních a jsem si plně vědom
následků porušení ustanovení § 11 a následujících autorského zákona č. 121/2000 Sb.
…….……………….
V Praze dne
Straka Jiří
-7-
5. PODĚKOVÁNÍ (DOBROVOLNÉ)
Děkuji vedoucímu bakalářské práce Ing. David Hartman Ph.D. za účinnou metodickou,
pedagogickou a odbornou pomoc a další cenné rady při zpracování mé bakalářské práce.
-8-
6. OBSAH
1. Zadání ............................................................................................................................... - 4 2. Abstrakt ............................................................................................................................ - 5 3. Abstract ............................................................................................................................ - 6 4. Prohlášení ........................................................................................................................ - 7 5. Poděkování (dobrovolné) ................................................................................................. - 8 6. Obsah ............................................................................................................................... - 9 7. Úvod ............................................................................................................................... - 12 7.1 Popis jednotlivých kapitol práce .............................................................................. - 12 7.2 Konvence používané v této práci ............................................................................. - 13 7.3 Konvence .................................................................................................................. - 13 8. Vývoj aplikací pro systém Windows ............................................................................... - 14 8.1 Základy architektury .NET ........................................................................................ - 15 8.2 Možnosti vývoje na platformě .NET ......................................................................... - 16 8.3 Windows Forms ....................................................................................................... - 17 8.3.1 Některé novinky Windows Forms 2 .................................................................. - 18 8.3.2 Realizace Windows Forms ................................................................................ - 19 8.4 Projekt Mono ........................................................................................................... - 20 8.4.1 Součásti projektu Mono .................................................................................... - 20 8.5 Windows Presentation Foundation ......................................................................... - 21 8.5.1 XAML ................................................................................................................. - 22 8.5.2 Ukázka XAML jazyka .......................................................................................... - 22 8.5.3 Výhody WPF oproti WinForms .......................................................................... - 23 8.5.4 Vývoj WPF ......................................................................................................... - 24 8.5.5 Vylepšení ve WPF 3.5 ........................................................................................ - 24 8.5.6 Vylepšení ve WPF 3.5 SP1 ................................................................................. - 25 8.5.7 Vylepšení ve WPF 4 ........................................................................................... - 25 8.6 Silverlight.................................................................................................................. - 27 8.6.1 Souhrn zajímavých možností technologie Silverlight ........................................ - 28 8.6.2 Jak Silverlight aplikace funguje? ....................................................................... - 29 8.6.3 Začlenění aplikace do internetové stránky ....................................................... - 29 8.7 Windows Phone 7 .................................................................................................... - 31 -9-
9. Návrh a analýza aplikace ................................................................................................ - 32 9.1 Požadavky na aplikaci .............................................................................................. - 32 9.1.1 Funkční požadavky ............................................................................................ - 32 9.1.2 Nefunkční požadavky ........................................................................................ - 32 9.2 Diagram tříd ............................................................................................................. - 33 10. Implementace .............................................................................................................. - 34 10.1 Zvolené technologie ............................................................................................... - 34 10.2 Popis aplikace......................................................................................................... - 34 10.3 Podporovaní komponenty a vlastnosti pro převod ............................................... - 34 10.4 Rozhraní aplikace ................................................................................................... - 35 10.4.1 IControlCreator ............................................................................................... - 35 10.4.1.1 Decorator ..................................................................................................... - 36 10.4.1.2 Využití vzoru Decorator v aplikaci ................................................................ - 37 10.5 Popis tříd prezentační vrstvy.................................................................................. - 37 10.5.1 MainWindow................................................................................................... - 37 10.5.2 PluginWindow ................................................................................................. - 38 10.6 Popis jednotlivých tříd aplikační logiky .................................................................. - 39 10.6.1 Constants ........................................................................................................ - 39 10.6.2 ControlCreatorFactory .................................................................................... - 39 10.6.3 Attribute .......................................................................................................... - 40 10.6.4 ElementAttribute ............................................................................................ - 40 10.6.5 FormConverter ................................................................................................ - 41 10.6.5.1 Facade .......................................................................................................... - 41 10.6.5.2 Využití vzoru Facade v aplikaci..................................................................... - 42 10.6.6 FormElement................................................................................................... - 42 10.6.7 FormElementReader ....................................................................................... - 43 10.6.7.1 GetNamespace ............................................................................................. - 44 10.6.7.2 GetFormName ............................................................................................. - 44 10.6.7.3 GetElementType .......................................................................................... - 44 10.6.7.4 GetChildElements ........................................................................................ - 45 10.6.8 Logger.............................................................................................................. - 45 10.6.8.1 Singleton ...................................................................................................... - 46 10.6.8.2 Využití vzoru Singleton v aplikaci ................................................................. - 47 - 10 -
10.6.9 LogWatcher ..................................................................................................... - 47 10.6.10 PluginManager .............................................................................................. - 48 10.6.11 TreeNodeCreator .......................................................................................... - 49 10.6.11.1 Rekurze ...................................................................................................... - 49 10.6.12 TreeViewManagment ................................................................................... - 49 10.6.13 XamlBuilder ................................................................................................... - 50 10.6.14 XamlWriter .................................................................................................... - 50 11. Dokumentace ............................................................................................................... - 52 11.1 Uživatelská dokumentace ...................................................................................... - 52 11.1.1 Načtení vstupního souboru............................................................................. - 52 11.1.2 Zobrazení náhledu .......................................................................................... - 54 11.1.3 Převedení formuláře ....................................................................................... - 54 11.2 Programátorská dokumentace .............................................................................. - 55 11.2.1 Vytvoření ukázkového pluginu pro TextBox ................................................... - 55 11.2.1.1 Implementace vlastnosti Name ................................................................... - 56 11.2.1.2 Implementace vlastnosti Version ................................................................ - 56 11.2.1.3 Implementace vlastnosti Description .......................................................... - 56 11.2.1.4 Implementace metody Create ..................................................................... - 57 12. Závěr............................................................................................................................. - 59 13. Conclusion .................................................................................................................... - 61 14. Seznam použité literatury ............................................................................................ - 63 15. Seznam použitých symbolů a zkratek .......................................................................... - 64 16. Seznam obrázků ........................................................................................................... - 65 17. Seznam tabulek ............................................................................................................ - 66 18. Seznam příloh............................................................................................................... - 67 18.1 Příloha 1 – Ukázka formuláře SampleForm1 ve WF .............................................. - 68 18.2 Příloha 2 - Ukázka převedeného SampleForm1 do WPF ....................................... - 69 18.3 Příloha 3 – Ukázka formuláře SampleForm2 ve WF .............................................. - 70 18.4 Příloha 4 - Ukázka převedeného SampleForm2 do WPF ....................................... - 71 18.5 Příloha 5 – CD ......................................................................................................... - 72 -
- 11 -
7. ÚVOD
Windows Forms jsou stále jednou z nejpoužívanějších technologií pro vývoj aplikací pro
operační systémy Windows, přestože je zde tato technologie od roku 2001, kdy vyšel .NET
Framework 1. O pět let později to je roku 2006 vychází v pořadí třetí verze .NET
Frameworku a jeho součástí je nová technologie pro vývoj desktopových aplikací systému
Windows s názvem Windows Presentation Foundation (WPF). WPF nabízí nové možnosti
vývoje aplikací pro systém Windows v podobě nových komponent uživatelského rozhraní,
hardwarovou akceleraci, vektorovou grafiku, animace, deklarativní programování, podporu
médií atd. O rok později se WPF rozšíří i do webových aplikací pomocí produktu z dílny
Microsoft s názvem Silverlight. Další uplatnění se nachází v mobilních zařízeních, které
podporují operační systém Windows Phone 7 a vyšší. Aplikace pro tyto zařízení mohou být
psány pomocí technologie WPF a nebo XNA Frameworku (XNA je mimo rozsah této práce).
Cílem této práce je, vytvořil aplikaci, která je schopná převádět jednotlivé formuláře
vytvořené v technologii Windows Forms do novější technologie WPF. V současné době není
autorovi známá žádná aplikace, která by umožňovala převádět formuláře z technologie
Windows Forms do WPF. Aplikace nepodporuje veškeré komponenty Windows Forms a
kompletní výčet jejich vlastností, ale pouze omezenou množinu předem vybraných relativně
jednoduchých komponent. U každé komponenty aplikace podporuje jen určité vlastnosti.
Jedním z nejvýznamnějších požadavků na aplikaci, je její snadná rozšiřitelnost a schopnost
aktualizace, aniž by se musely překompilovat všechny zdrojové kódy stávající aplikace.
Těchto požadavků bude docíleno pomocí tzv. zásuvných modulů, které aplikace podporuje a
veškerá aplikační logika pro konkrétní reprezentaci WPF na základě vstupních souborů
z Windows Forms je soustředěna v těchto zásuvných modulech.
7.1 Popis jednotlivých kapitol práce

Kapitola 8: Vývoj aplikací pro systém Windows – V této části se podíváme na
historický vývoj psaní aplikací pro operační systémy Windows v závislosti na čase a
používané technologii.

Kapitola 9: Návrh a analýza aplikace – Před pohledem na konkrétní implementaci
se podíváme na high-level schémata aplikace.

Kapitola 10: Implementace – V této kapitole se seznámíme s detailní implementací
aplikace na převod Windows Forms do WPF.

Kapitola 11 – Obsahuje uživatelskou dokumentaci, jak obsluhovat aplikace a také
programátorskou dokumentaci, jak naimplementovat další zásuvný modul.
- 12 -

Kapitola 12 – Shrnutí poznatků celé práce, možnosti budoucího vývoje a diskuze o
možném využití aplikace.
7.2 Konvence pouţívané v této práci
Informace v této práci jsou uspořádány tak, aby byly snadno srozumitelné. Před čtením
vlastního textu práce doporučují přečíst si pár typografických konvencí, které jsou v práci
použity.
7.3 Konvence

Neproporcionální písmo – je použito, jak je k tomu v každém vývojovém prostředí
pro odlišení výrazových prostředků programovacího jazyka v textu, jako jsou např.
příkazy, proměnné, atributy, jmenné prostory, vlastnosti, metody, hodnoty, události,
objekty atd.

Tučné písmo – použito pro zvýraznění důležitých nebo klíčových pojmů v textu.

VELKE_NEPROPORCIONÁLNÍ_PÍSMO
– velké neproporcionální písmo oddělené
podtržítky místo mezer je použito pro zvýraznění konstant v ukázkách kódu.
- 13 -
8. VÝVOJ APLIKACÍ PRO SYSTÉM WINDOWS
Na podzim roku 1985 společnost Microsoft vydala svojí první verzi operačního systému
Windows pod názvem Windows 1.0. Jednalo se pouze o nástavbu nad operačním
systémem DOS. Významná změna přišla s příchodem Windows 95, kdy operační systém
pracuje na 32bitové architektuře. Další významný milník nastal v roce 2001, když Microsoft
vydal svojí pátou verzi systému Windows s označením Windows XP. Tato nová verze
přinesla 64bitovou architekturu, která se používá i v dnes poslední verzi Windows 7.
První verze Windows podporovali pouze vývoj aplikací pomocí programovacího jazyka C a
rozhraní s názvem Windows API, které obsahuje základní funkce i funkce pro vytváření
uživatelského rozhraní. Postupem času se pro vývoj aplikací pro systém Windows
přizpůsobily již existující programovací jazyky, jako jsou Microsoft Visual Basic nebo C++
anebo vznikl nový programovací jazyk C#, který je založen na jazyce C. Následující diagram
uvádí vývoj programovacích jazyků založeným na programovacím jazyku C a rozhraních
používaných pro vývoj aplikací. (Petzold, 2008)
1985
C
Rozhraní Windows API
1992
C++
Knihovna Microsoft Foundation Class
2001
C# nebo C++
Windows Forms
2006
C# nebo C++
Windows Presentation Foundation
Obrázek 1 - Vývoj programování aplikací pro systém Windows
Zdroj: Mistrovství ve Windows Presentation Foundation, vlastní tvorba
V digramu je vidět, že v roce 2001 nastal zlom ve vývoji aplikací pro systém Windows. Byl
představen první nativní objektově orientovaný programovací jazyk C# pro vývoj aplikací pro
Windows společně s frameworkem Windows Forms, který jsou součástí .NET Frameworku
1.
- 14 -
8.1 Základy architektury .NET
Architektura .NET byla vyvinuta formou Microsoft a vypuštěna do světa v roce 2002. Cílem
této nové platformy bylo zjednodušit a sjednotit vývoj aplikací. Technologie .NET se tak stala
hlavním konkurentem platformě Java od firmy Sun Microsystems. Platforma .NET nám
přináší:

Nové programovací jazyky

Common Intermediate Language (CIL)

Modul CLR

Just-in-Time kompilátor

Kooperaci různých jazyků

Obrovské množství knihoven

Vývojové prostředí Visual Studio
Více informací o jednotlivých tématech viz. (Nash, 2010)
S příchodem platformy se objevili o nové programovací jazyky, jako jsou například J#, F#,
C# atd. Snad nejrozšířenější a nejpoužívanější je jazyk C#. Jedná se o vysokoúrovňový
objektově orientovaný programovací jazyk. Svojí inspiraci syntaxe čerpal v programovacích
jazycích C++ a Java. Jazyk C# je mnohoúčelový a můžeme se s ním tedy setkat u vývoje
formulářových aplikací, webových aplikací, služeb systému Windows, webových služeb atd.
Časový vývoj platformy .NET zachycuje následující obrázek:
- 15 -
.NET
Framework
2.0
.NET
Framework
3.0
WinForms
WPF
.NET
Framework
3.5
.NET
Framework
4.0
LINQ
Parallel LINQ
ADO.NET Entity
Framework
Task Parallel
Library
ASP.NET
WCF
ADO.NET
WinForms
Base Class Library
CLR
Card Space
Obrázek 2 - Vývoj .NET Frameworku
Zdroj: http://en.wikipedia.org/wiki/.NET_Framework, vlastní tvorba
8.2 Moţnosti vývoje na platformě .NET
Jednou z velkých výhod platformy .NET je nepřeberné množství druhů projektů, které lze
vyvíjet. Ať je jedná o aplikace běžící přímo v operačním systému Windows, webové
aplikace, zásuvné moduly pro Microsoft Office atd. Začneme přiblížením první skupinou typy
aplikací. Jedna z možností je vývoj klasické konzolové aplikace. Dále mnohem více
uživatelsky přívětivější tzv. formulářové aplikace za pomocí technologie Windows Forms,
která využívá volání Win32 API nebo pomocí novější technologie Windows Presentation
Foundation. O obou technologiích pro vývoj formulářových aplikací budou detailněji
pojednávat následující stránky. Další typ projektu, který můžeme najít pod .NET platformou
jsou Windows Služby. Služba je aplikace, která běží na pozadí sytému a není v přímém
kontaktu s uživatelem.
Druhou skupinou jsou webové aplikace, které poslední dobou získávají stále více na oblibě.
Zde nám platforma .NET nabízí možnost vývoje webových aplikací pomocí technologií např.
ASP.NET WebForms, tato technologie nám nabízí vývoj stavových aplikací nad nestavovým
- 16 -
protokolem HTTP. Další možností je ASP.NET MVC, jak název napovídá umožnuje vývoj
aplikací založený na architektuře Model-View-Controller.
Jednou z nejnovějších možností je psaní aplikací pro Cloud Computing, kde aplikace jsou
hostovány na serverech třetích stran, a výkon je možné škálovat dle potřeb. Přístup do
aplikace je možný, jak pomocí tenkého klienta, tak tlustého klienta.
Mezi ostatní typy projektů bych zmínil vývoj tzv. knihoven. Knihovny implementují určitou
funkcionalitu, kterou lze využít ve všech typech předešlých projektů.
8.3 Windows Forms
Technologie Windows Forms byla představena společně s .NET 1 v roce 2002, jedná se o
grafické programovací rozhraní pro aplikace (API). Nahrazovala dosavadní technologie, jako
jsou MFC nebo Win32. Volání toho rozhraní odkazuje na nativní rozhraní Microsoft
Windows. Zabaluje již existující Windows API do řízeného kódu (managed code). Tento
řízený kód je spouštěn pod virtuálním strojem Common Language Runtime. Pomocí
Windows Forms můžeme vytvářet aplikace s bohatým uživatelským rozhraním, které se
snadno vyvíjí a udržují aktualizované. Základním stavebním kamenem technologie Windows
Forms je formulář. Aplikace musí obsahovat alespoň jeden takovýto formulář. Formulář zde
slouží k zobrazování informací uživateli, jedná se o kontejner pro komponenty. Komponenta
je prvek uživatelského rozhraní (GUI), který buď zobrazuje informace uživateli anebo čeká
na uživatelský vstup. Windows Forms jsou založeny na událostně řízeném modelu. To
znamená, že například po stisknutí tlačítka uživatelem je vyvolána událost, v tomto případě
událost tlačítka OnClick a je spuštěn obslužný kód této události tzv. EventHandler. Formulář
vytvořený pomocí technologie Windows Forms viz. Obrázek 3.
Oproti klasickému vývoji formulářových aplikací pomocí C++ a volání funkcí Win32 nám
Windows Forms přináší tyto výhody:

Nezávislost na platformě – existují implementace pro Linux, FreeBSD, Mac OS X,
atd., viz. projekt Mono níže.

Skutečné objektově orientované paradigma pro vývoj

Jednodušší, rychlejší a pohodlnější vývoj aplikací

Výběr z mnoha programovacích jazyků platformy .NET např. Visual Basic, C# atd.
Windows Forms ve své první verzi přišly s celou řadou již předdefinovaných komponent,
jako jsou například:

Button – Představuje tlačítko s popiskem na formuláři.

CheckBox – Slouží pro výběr hodnot z uzavřené množiny možností.
- 17 -

GroupBox – Slučuje komponenty do logických celků.

Label – Přidává popisek k jednotlivým komponentám na formuláři.

TextBox – Slouží převážně k přijímání uživatelského vstupu.

Atd.
8.3.1 Některé novinky Windows Forms 2
V roce 2005 byl představena nová verze .NET Frameworku společně s novou verzí
Windows Forms 2.0 Celý model Windows Forms zůstal nezměněn, ale přibyly např.
následující nové změny:

Přidání komponenty SplitContainer – Jedná se o kontejnerový prvek tzn. může
obsahovat jiné prvky uživatelského rozhraní. Umožnuje rozdělit formulář na dvě
části, kterým zle po spuštění aplikace měnit velikost pomocí myši.

Přidání komponenty WebBrowser – Umožnuje zobrazit internetovou stránku na
formuláři aplikace, jak z lokálního zdroje, tak ze vzdáleného.

Přidání komponenty DataGridView – Nahrazuje komponentu DataGrid z .NET
Frameworku 1. Přináší nové možnosti do zobrazování dat na formuláři.

Přidání komponenty BackgroundWorker – Slouží pro zpracování úloh v dalším
vlákně, tak aby uživatelské rozhraní nezamrzlo a reagovalo na uživatelské vstupy.

ClickOnce – Je technologie, která umožňuje uživateli nainstalovat a spustit aplikaci
pomocí kliknutí na odkaz uvnitř internetoví stránky.

Vizuální styly – S nástupem Windows XP přišla i možnost pomocí nový tříd vytvořit
komponenty s vlastním vizuálním vzhledem.

Přidání komponenty MaskedEdit – Poskytuje vstup pro uživatelské vstupy, které
musí odpovídat předem definovanému formátu.
- 18 -
Obrázek 3 - Ukázka formuláře z technologie Windows Forms
Zdroj: http://www.alitopaloglu.com/c-windows-form-olusturma/, převzato
8.3.2 Realizace Windows Forms
Při vytváření každého formuláře ve vývojovém prostředí Microsoft Visual Studio (MSVS) se
vždy generují dva soubory (třídy) s příponou .cs (pokud programujeme v jazyce C#) pro
jeden formulář. Ve skutečnosti se jedná o jednu třídu, která je označená klíčovým slovem
partial, toto klíčové slovo umožňuje rozdělit definici třídy do několika samostatných
souborů, která jsou spojeny, když je aplikace zkompilována. Představme si, že přidáváme do
projektu formulář s názvem OdeslaniObjednavky. V tomto případě MSVS vygeneruje tyto
soubory:
OdeslaniObjednavky.Designer.cs
a
OdeslaniObjednavky.cs.
Soubor
OdeslaniObjednavky.Designer.cs obsahuje definici uživatelského rozhraní formuláře. Celá
tato definice se ukrývá v metodě InitializeComponents, která se volá v konstruktoru každého
formuláře. Obsah metody je automaticky generován designérem v MSVS a její obsah se
nedoporučuje ručně upravovat. (Sharp, 2006) Následující ukázka zdrojového kódu zobrazuje
krátkou metodu InitializeComponent:
private void InitializeComponent()
{
this.button1 = new System.Windows.Forms.Button();
this.SuspendLayout();
//
// button1
//
this.button1.Location = new System.Drawing.Point(112, 52);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(75, 23);
this.button1.TabIndex = 0;
this.button1.Text = "tlačítko";
- 19 -
this.button1.UseVisualStyleBackColor = true;
this.button1.Click += new System.EventHandler(this.button1_Click);
//
// Form1
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(284, 262);
this.Controls.Add(this.button1);
this.Name = "Form1";
this.Text = "Form1";
this.ResumeLayout(false);
}
Na začátku metody je vidět, že se inicializují všechny privátní členy třídy (formuláře) ve
formě komponent na formuláři. V této ukázce se jedná pouze o komponentu tlačítka. Dále
jsou jim přes tečkovou notaci nastavovány všechny potřebné vlastnosti jako jsou: Name,
Text, Size, atd. Také zde mohou být nastaveny odkazy na metody pomocí delegátů, které se
mají spustit po vyvolání nějaké události. V ukázce se například nastavuje, která metoda se
spustí po klepnutí (Click) na tlačítko.
Druhou polovinu třídy tvoří soubor OdeslaniObjednavky.cs, někdy se tomuto souboru také
říká tzv. code-behind (kód, která se skrývá za formulářem). V tomto souboru jsou popsány
všechny reakce na události komponent formuláře.
8.4 Projekt Mono
Mono je softwarová platforma navržená tak, aby umožnila vývojářům co nejjednodušší vývoj
aplikací napříč platformami. Jedná se o open-source projekt, jehož hlavním cílem je vytvořit
sadu nástrojů kompatibilní s Microsoft .NET založeného na ECMA standardech pro
programovací jazyk C# a Common Language Runtime. V době, kdy je tato práce psaná
projekt Mono podporuje celý .NET 4.0 kromě WPF, EntityFramework, System.Managment a
System.EnterpriseServices.
8.4.1 Součásti projektu Mono
Projekt Mono tvoří několik následujících částí:

C# kompilátor – Mono kompilátor pro programovací jazyk C# podporuje tyto verze
jazyka: 1.0, 2.0, 3.0 a 4.0 (ECMA).

Mono runtime – stejně jako Microsoft .NET i v Mono projektu můžeme najít
Common Language Infrastructure, Just-In-Time kompilátor, Garbage Collector,
podporu vláken, atd.
- 20 -

Základní bázové knihovny - poskytuje obrovské množství knihoven, na kterých
můžeme stavět vlastní aplikace. Tyto knihovny jsou kompatibilní s Microsoft .NET
třídami.

Mono knihovny – Mono navazuje na Microsoft .NET základní bázové knihovny a
poskytuje nadstavbu nad těmito knihovnami, které jsou převážně využívaní při
tvorbě aplikací pro Linux. Mezi tyto knihovny patří: Gtk+, Zip files, LDAP, OpenGL,
POSIX, atd.
8.5 Windows Presentation Foundation
WPF byla poprvé představena v listopadu roku 2007 jako součást .NET Frameworku 3.0.
WPF, dříve známo jako projekt Avalon je technologie používaná pro vykreslování bohatého
1
grafického uživatelského rozhraní založeném na DirectX .
Dalo by se říci, že WPF je
následníkem Windows Forms, který nabízí nové možnosti ve vývoji aplikací, jenž nebyly ve
WinForms vůbec realizovatelné za využití 2D a 3D grafiky, vektorovou a bitmapovou
grafikou, anebo dokonce audiem a videem. Jedním z největších přínosů WPF je oddělení
vzhledu aplikace od samotného kódu, jako je tomu např. u třívrstvé architektury. Aby toto
oddělení bylo možné je potřeba nějakého jazyku pro definování uživatelského rozhraní, a tím
je XAML. Náhled aplikace s bohatým uživatelským rozhraním demonstruje následující
obrázek:
Obrázek 4 - Ukázka okna s bohatým uživatelským rozhraní vytvořeného ve WPF
Zdroj: http://www.infragistics.com/innovations/vs2010/wpf.aspx#WPF, převzato
1
DirectX – je množina knihoven poskytující přímé ovládání moderního hardwaru. Součástí DirectX je i
knihovna s názvem Direct3D, kterou používá WPF pro vykreslování grafiky.
- 21 -
8.5.1 XAML
XAML (čteno „zamel“) je zkratka z anglického XML for Application Markup Language –
značkovací XML jazyk pro aplikace. Jedná se o rozšíření jazyka XML. Jazyk XAML nám
umožňuje
deklarativním
způsobem
definovat
bohaté uživatelské rozhraní
a jeho
hierarchickou strukturu. Kde používáme XAML elementy pro vytváření samotných prvků
uživatelského rozhraní a pro definování jejich vlastností využíváme buď jiných XAML
elementů (ve WPF muže např. tlačítko obsahovat video) nebo atributy XAML elementů.
Každý XAML element je reprezentován stejnojmennou třídou ve jmenném prostoru
System.Windows.Controls pro vytváření a přístupu k uživatelskému rozhraní např. ve
vlastních třídách. (Stephens, 2010)
Klíčovou myšlenkou značkovacího jazyka XAML je oddělení definice uživatelského rozhraní
od programové části. Toto oddělení nám umožnuje paralelní práci vývojářů a návrhářů
uživatelského rozhraní, kteří sami o sobě programovat neumí. Tato myšlenka dala vzniknout
grafickému nástroji pro návrh uživatelského rozhraní Microsoft Expression Blend. Jedná
se o nástroj, kde je možné vyvíjet aplikace pro desktopové, webové (Silverlight – o který
bude popsán na následujících stranách) a mobilní aplikace (Windows Phone 7 – také bude
popsáno později).
8.5.2 Ukázka XAML jazyka
<Window x:Class="WpfApplication1.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MainWindow" Height="350" Width="525">
<Grid>
<Button Content="Button" Height="23" Margin="12" Name="btn"
Width="75">
<Button.Background>
<LinearGradientBrush EndPoint="1,0.5" StartPoint="0,0.5">
<GradientStop Color="Black" Offset="0" />
<GradientStop Color="White" Offset="1" />
</LinearGradientBrush>
</Button.Background>
</Button>
</Grid>
</Window>
V následující ukázce je možno vidět defaultní kód, který vygeneruje Visual Studio po
vytvoření WPF aplikace a následné přidání jednoho tlačítka. Povšimneme si elementu
Button, tento element obsahuje atributy Content, Height, Margin atd, jenž tvoří vlastnosti
objektu “btn”. Ale také obsahuje vlastnost, která je opět element. Kde hodnota je definována
tzv. podřízeným elementem v našem případě <LinearGradientBrush />.
- 22 -
8.5.3 Výhody WPF oproti WinForms

Deklarativní programovaní – Stejně jako během tvorby internetových
stránek používáme HTML tagy pro definování struktury stránky, tak ve WPF
aplikacích používáme značkovací jazyk XAML.

Hardwarová akcelerace – WPF je založena na Direct3D tzv., že všechen
obsah ve WPF aplikaci (2D i 3D grafika) je převedena na trojúhelníky a ty
jsou potom vykreslovány pomocí hardware. Přesunutí výpočetní kapacity na
grafickou kartu. Neznamená to ovšem, že potřebujeme výkonné grafické
karty, protože vykreslovaní uživatelského rozhraní může probíhat i na
procesoru.

Bohaté přizpůsobení komponent - Pomocí XAML jazyka můžeme např.
definovat tlačítko, které bude obsahovat video nebo animovat prvky
uživatelského rozhraní na základě událostí. WPF aplikace podporují
vytváření tzv. skinů – jedná se o naprosto odlišné vzhledy uživatelského
rozhraní (velikosti jednotlivých prvků, jejich uspořádání, barevné rozložení
jednotlivých prvků na formuláři atd.).

Nezávislost na rozlišení obrazovky – Jednotka používaná ve WPF pro
specifikování velikosti komponent se jmenuje Device Independent Pixel
(DIP). Jedná se o logický pixel nezávislý na rozlišení obrazovky. Standardně
se používají obrazovky s DPI (Dots per Inche – Počet bodů na palec) 96 x
96. Jestliže např. ve WPF řekneme, že tlačítko má šíři 96, to se rovná 1
palec, a tuto aplikaci spustíme na monitoru s hodnotou DPI 120, šířka
tlačítka se přepočítá a velikost každého pixelu vyjde 1.25 pixelů. A
výsledkem bude skutečnost, že šíře tlačítka i na monitoru s DPI 120 bude 1
palec.

Vektorová grafika – WPF podporuje tzv. vektorovou grafiku, ta pro
uchovávání svého vlastního obsahu používá body, úsečky a jiné
geometrické prvky. Zatímco bitmapová grafika shromažďuje informace o
jednotlivých pixelech obrázku. Výhodami vektorové grafiky je nižší
paměťová náročnost a libovolné zvětšení a zmenšení obrázku bez ztráty
kvality.

Animace – ve Windows Forms jsme mohli použít časovač pomocí něj
složitě animovat prvky na formuláři. WPF nám nabízí výkonné prostředí pro
animování libovolné vlastnosti prvku a vytvoření tak naprosto interaktivní
vzhledu aplikace.

Podpora audio a video formátů – technologie WPF podporuje nejrůznější
formáty obrázků, audio souborů a dokonce i video formáty, aby poskytlo, co
možná nejpřitažlivější uživatelské rozhraní.
- 23 -

Nové prvky uţivatelského rozhraní – WPF přichází s novou sadou prvků
uživatelského rozhraní pro rozmístění jejich potomků. Mezi příklady bych
uvedl: Grid, který umisťuje prvky v řádcích a sloupcích, StackPanel slouží
k umístění prvku v jednom sloupci či řádku a DockPanel, který zachytává
svoje potomky k vlastním hranám. (MacDonald, 2008)
8.5.4 Vývoj WPF
První verze WPF nese název WPF 3.0, protože byla vypuštěna společně s .NET
Frameworkem v roce 2006. Další verze téměř o rok později v roce 2007 pod označením
WPF 3.5. Třetí verze byla uvolněna jako opravný balíček pro .NET Framework 3.5, avšak
nejedná se o klasický opravný balíček, protože přináší spousty nových možností a vylepšení.
Poslední verze WPF vyšla v roce 2010 s pořadovým číslem 4. Časový vývoj verzí WPF
zachycuje následující obrázek:
2006
WPF
3.0
WPF
3.5
2007
WPF
2008 3.5 SP1
2010 WPF 4
Obrázek 5 - Vývoj technologie WPF v závislosti na čase
Zdroj: vlastní tvorba
8.5.5 Vylepšení ve WPF 3.5
Některé z novinek, které nám přineslo WPF 3.5 oproti verzi WPF 3.0:

Interaktivní 2D na 3D – Nová funkčnost, která umožňuje zobrazit interaktivní 2D
grafiku na 3D objektu.

Firefox podpora pro XBAPs – WPF nyní umožnuje spustit aplikaci WPF
hostovanou v internetovém prohlížeči (známé jako XBAPs) Firefox stejně jako
v Internet Explorer.

Podpora LINQ pro data binding – LINQ je nová technologie pro dotazovaní nad
daty přímo v programovacím jazyce. Jedná se o rozšiřující metody, které se nalézají
v namespace System.Linq. Obrovskou předností jazyka LINQ je, že se všemi
datovými zdroji pracuje stejným způsobem. Mezi tyto datové zdroje patří: objekty
v paměti, XML soubory a databáze. (MacDonald, 2008)
- 24 -
8.5.6 Vylepšení ve WPF 3.5 SP1
Následující výčet jsou některé ze zajímavých novinek, které přináší WPF 3.5 SP1:

Vylepšený data binding (vázání dat) – WPF přichází s podporou XLINQ, lepší
validací a debuggováním.

Vylepšené speciální efekty – Efekty, které byly součástí první verze WPF
s oficiálním doporučením je nepoužívat, kvůli jejich nízkému výkonu byly
přepracovány za pomocí hardwarové akcelerace a došlo k zvýšení jejich výkonu.

Direct3D – Byla přidána interoperabilita pro podporu Direct3D. Nyní je možné vložit
přímo 3D scénu vykreslenou pomocí Direct3D do obrázků nebo textur WPF
aplikace.

Vylepšení z oblasti Textu – WPF přináší vylepšený výkon pro vykreslování textu a
mezinárodní podporu znaků.

Vylepšené nasazení aplikace a .NET Framework – proces instalace .NET
Frameworku je nyní na straně klienta rychlejší. Obsahuje novou Bootstrapper
komponentu, která se stará o .NET Framework instalace a upgrady místo uživatele.
A nové možnosti ClickOnce.

Vylepšený výkon – celá technologie WPF dosáhla mnohem lepších výkonnostních
výsledků, jako jsou např. rychlejší spuštění aplikace (hlavně první spuštění),
animace jsou nyní mnohem plynulejší, rychlejší data binding atd.

Splashscreen (spouštěcí obrazovka) – Některé obsáhlé aplikace napsané ve
WPF se mohou načítat poměrně dlouho dobu, a proto přibyla možnost vybrat
statický obrázek, který se zobrazí během načítání aplikace uživateli. (Nathan, 2010)
8.5.7 Vylepšení ve WPF 4
Seznam nejzajímavějších novinek ve WPF 4:

Podpora Multi-touch – Přichází společně Windows 7, které sami o sobě multitouch podporují. Dotyky pomocí několika prstů zároveň jsou reprezentovány novými
událostmi u jednotlivých prvků uživatelského rozhraní. Kromě Windows multi-touch
2
také plně využívá Microsoft Surface .
2
Microsoft Surface – jedná se o počítač ve formě konferenčního stolku, který obsahuje velkou multi
dotykovou obrazovku. Tato obrazovka nahrazuje klasickou klávesnici a myš. Ovládání probíhá
pomocí gest uživatele.
- 25 -

Integrace s Windows 7 Shell – WPF 4 přichází s novinkami ve formě integrace
s novými možnostmi v operačním systému Windows 7. Hlavní s těchto novinek je
možnost integrace s Hlavním panelem. Mezi možnosti práce s Hlavním panelem
patří: Aero náhledy oken aplikací, tzv. jump lists, které usnadňují spouštění např.
naposledy otevřených souborů, podsvícení ikony barvou, ve kterém stavu se
aplikace nachází (Normal, Error, atd.), přidávání tlačítek do náhledu okna, atd.

Nové komponenty – WPF nyní obsahuje komponenty, jako jsou DataGrid,
Calendar a DatePicker.

Easing funkce pro animaci – Easing funkce nám dovolují přidat matematické
formule do animací. Za pomocí těchto matematických formulí animace vypadá
přirozeně a plynule. WPF 4 přichází s 11 již předdefinovaných matematických
formulí, jako jsou např. BounceEase, ElasticEase a SineEase.

Vylepšené nasazení aplikace – Klient .NET Frameworku může být nainstalován
společně s plnou verzí .NET Frameworku.

Vylepšený výkon – Aby byl výkon vektorové grafiky možná co nejlepší WPF nyní
umí vykreslené výsledky kešovat jako bitmapy a znovu je použít. V pokročilých
případech je zde možnost ovlivnit toto chování pomocí vlastnosti CacheMode.
(Nathan, 2010)
- 26 -
8.6 Silverlight
Jedná se o konkurenta produktu Flash nebo Flex od společnosti Adobe. Stejně jako
v případě Flash technologie jedná se o lightweight (asi 4MB) zásuvný modul, který se
instaluje do internetového prohlížeče. V současné době jsou podporovány tyto prohlížeče:
Internet Explorer, Mozilla Firefox, Safari a Google Chrome. Pomocí technologie Silverlight
může vytvářet tzv. internetové aplikace s bohatým uživatelským rozhraním (RIA). Silverlight
aplikace mohou pracovat v režimu mimo okno prohlížeče, a dokonce i v tzv. off-line režimu,
kdy internetový prohlížeč není připojen k internetu.
Porovnání Silverlight aplikace s bohatým uživatelským rozhraním s běžnou HTML stránkou:
Obrázek 6 - Silverlight RIA aplikace
Zdroj: http://community.citrix.com/, převzato
- 27 -
Obrázek 7 - Běžná HTML stránka
Zdroj: www.zive.cz, printscreen
Uživatelské rozhraní Silverlight aplikací je deklarováno pomocí XAML jazyka stejně jako u
WPF. Aplikace typu Silverlight tvoří svými možnostmi podmnožinu WPF aplikací, která se
s každou další verzí Silverlight přibližuje WPF aplikacím. Při vytváření aplikací můžeme
využívat vývojové nástroje, jako jsou Microsoft Visual Studio 2010 a Microsoft Expression
Blend, které jsou založeny na Commom Language Runtime, to znamená, že při vývoji si
můžeme vybrat z velkého množství programovacích jazyků, jako jsou např. C#, Visual Basic
anebo dokonce z některých dynamických jazyků: Ruby nebo Python. Protože je celý
Silverlight postaven na .NET Frameworku můžeme ve svým aplikacích používat Base Class
Libraries, výsledkem je, že můžeme pracovat s obrovským množstvím již naprogramovaných
tříd, jako jsou např. různé kolekce, práce s vlákny, práce s řetězci atd.
8.6.1 Souhrn zajímavých moţností technologie Silverlight

Silverlight je rozšířený napříč platformami a napříč nejrůznějšími internetovými
prohlížeči.
- 28 -

Silverlight aplikace mohou být naprogramovány v těchto vývojových prostředích:
Visual Studio, Expression Blend a dokonce Eclipse.

Přináší podporu nejrůznějších vysoce kvalitních video a audio formátů. Mezi video
formáty, které Silverlight nativně podporuje, patří: Windows Media VC-1/WMA,
MPEG-4 s H.264 kódováním a to až do velikosti videa 720p+. Z podporovaných
audio formátů bych uvedl AAC.

Standardně Microsoft přináší přes 60 komponent, avšak existuje další obrovské
množství komponent, které byly vyvinuty třetími stranami.

Práce s vlákny je další z jeho klíčových předností. V aplikacích Silverlight můžeme
využít tento prvek moderních aplikací dnešní doby. Složitější výpočty nebo
komunikace s webovými službami může probíhat na pozadí aplikace.

Silverlight nabízí animaci, která je založená na čase, na rozdíl od největšího
konkurenta Flash, kde je animace založena na snímcích.

Silverlight nabízí možnost nahrávat a streamovat audio a video zdroje přímo
z koncových zařízení, které se nacházení u koncového uživatele.

Ve svých Silverlight aplikacích můžeme využít různé možnosti, jako jsou např. tisk,
navigace, drag-and-drop podpora, kontextové nabídky, kopírování do schránky atd.
(Lair, 2010)
8.6.2 Jak Silverlight aplikace funguje?
Celá aplikace typu Silverlight je uložena v souboru XAP, pokud uživatel navštíví stránku,
která je vytvořena pomocí Silverlight a má nainstalovaný potřebný zásuvný modul pro
internetový prohlížeč, tak se dotáže pomocí klasického požadavku GET na tento soubor
XAP. Soubor XAP je pouze výsledný archív celé aplikace se soubory DLL. DLL obsahují
samotný funkční kód, obrázky, zvuky, soubory grafiky a jiné možné zdroje aplikace.
8.6.3 Začlenění aplikace do internetové stránky
Když v Microsoft Visual Studio zakládáme nový projekt, tak se nás Visual Studio zeptá, do
jakého typu webové aplikace chceme, aby byla Silverlight aplikace vložena. Na výběr je
z možností ASP.NET Web Application, ASP.NET Web Site a ASP.NET MVC. Při zvolení
typu projektu ASP.NET Web Application vypadá internetová stránka se Silverlight
následovně:
- 29 -
<body>
<form id="form1" runat="server" style="height:100%">
<div id="silverlightControlHost">
<object data="data:application/x-silverlight-2," type="application/xsilverlight-2" width="100%" height="100%">
<param name="source" value="ClientBin/SilverlightApplication2.xap"/>
<param name="onError" value="onSilverlightError" />
<param name="background" value="white" />
<param name="minRuntimeVersion" value="4.0.50826.0" />
<param name="autoUpgrade" value="true" />
<a href="http://go.microsoft.com/fwlink/?
LinkID=149156&v=4.0.50826.0" style="text-decoration:none">
<img src="http://go.microsoft.com/fwlink/?LinkId=161376" alt="Get
Microsoft Silverlight" style="border-style:none"/>
</a>
</object><iframe id="_sl_historyFrame"
style="visibility:hidden;height:0px;width:0px;
border:0px"></iframe></div>
</form>
</body>
V ukázce je vidět, že k samotnému vložení Silverlight aplikace do HTML stránky dochází
v tagu object. V atributech tohoto tagu se nastavuje velikost Silverlight aplikace, v tomto
případě je šířka i výška aplikace 100%. V prvním parametru s názvem source se nastavuje
samotný odkaz na Silverlight aplikaci. Další ze zajímavých parametrů jsou barva pozadí a
minimální verze Silverlight zásuvného modulu do internetového prohlížeče pro spuštění
aplikace. Za pozornost stojí také odkaz je formě tagu <a href=”…”></a>, protože tento
odkaz se zobrazí, pokud není v internetovém prohlížeči nainstalovaný zásuvný modul pro
podporu Silverlight aplikace.
- 30 -
8.7 Windows Phone 7
Je operační systém pro mobilní zařízení, jedná se o přímého následníka Windows Mobile.
Windows Phone představuje konkurenci pro iOS od společnosti Apple a Android od
společnosti Google.
Pro vývojáře je Windows Phone 7 zajímavá technologie, protože nabízí dva naprosto odlišné
způsoby psaní aplikací:
Silverlight – je technologie, která se převážně používá pro vývoj aplikací. Jak již bylo
zmíněno v předešlé kapitole, celý Silverlight je založen na WPF, a proto je vhodný pro
vytváření sofistikovaných bohatých uživatelských rozhraní s využitím tradičních ovládacích
prvků, vysoce kvalitního textu, vektorové grafiky, animací, médií, vázáním dat, atd.
XNA – jak by se na první pohled mohlo zdát, že se jedná o zkratku tří anglických slov, tak
tomu tak není. XNA je označení herní platformy společnosti Microsoft, která podporuje, jak
2D grafiku, tak 3D grafika s běžnou herní smyčkou. XNA se spíše používá pro vývoj her na
Xbox 360 a PC, ale dá se použít i pro vývoj her na Windows Phone 7. (Henry Lee, 2010)
- 31 -
9. NÁVRH A ANALÝZA APLIKACE
Na začátku kapitoly se budeme věnovat definování funkčních a nefunkčních požadavků na
aplikaci, co uživatelé mohou od aplikace očekávat. V druhé polovině kapitoly se podíváme
na třídní diagramy a rozdělení aplikace do tří vrstev, kterými jsou: GUI, aplikační logika a
vstupně/výstupní operace.
9.1 Poţadavky na aplikaci
Následující dvě tabulky představují všechny funkční a nefunkční požadavky kladené na
aplikaci.
9.1.1 Funkční poţadavky
Označení
poţadavku
Popis
REQ01
Aplikace umožní vybrat vstupní soubor s příponou .Designer.cs pro
převod do WPF
REQ02
Aplikace umožní vybrat výstupní cestu, kam se zapíše výsledný
soubor
REQ03
Aplikace umožní převést formulář (ne kompletní výčet komponent a
jejich vlastností) z WF do WPF
REQ04
Aplikace bude obsahovat okno pro zobrazení struktury vstupního
souboru
REQ05
Aplikace bude umožnovat otevřít všechny uzly v náhledu
REQ06
Aplikace bude umožnovat zavřít všechny uzly v náhledu
REQ07
Aplikace bude umožnovat zobrazit jednotlivé vlastnosti komponent
v náhledovém okně
REQ08
Aplikace umožní zobrazit náhled okna před samotných převedením
vstupního souboru
REQ09
Aplikace bude obsahovat okno s výpisem všech dostupných
zásuvných modulech
Tabulka 1 - Funkční požadavky aplikace
9.1.2 Nefunkční poţadavky
Označení
poţadavku
Popis
REQ01
Zdrojové kódy aplikace budou napsány v anglickém jazyce
REQ02
Uživatelské rozhraní bude v českém jazyce
REQ03
Aplikace bude lehce ovladatelná
REQ04
Aplikace bude snadno rozšiřitelná pomocí zásuvných modulů
REQ05
Aplikace bude podporovat operační systém Windows XP SP3 a vyšší
- 32 -
Tabulka 2 - Nefunkční požadavky aplikace
9.2 Diagram tříd
Obrázek 8 - Třídní diagram aplikace
- 33 -
10. IMPLEMENTACE
10.1 Zvolené technologie
Aplikace je implementován za využití .NET Frameworku 4. Z této platformy je zvolen jako
programovací jazyk C# a pro vytvoření okenní aplikace technologie Windows Presentation
Foundation (WPF). Hlavním důvodem pro upřednostnění WPF před Windows Forms je fakt,
že aplikace slouží pro převod Windows Forms do WPF. Další motivací byla funkčnost, která
má za úkol zobrazit náhled převáděného okna. Tato funkčnost by obtížně implementovala ve
Windows Forms.
10.2 Popis aplikace
Celá aplikace je rozdělena do tří vrstev. Nejvyšší vrstva je prezentační, která tvoří
uživatelské rozhraní. Součástí této vrstvy je hlavní okno aplikace MainWindow a
PluginWindow. Další z vrstev je vrstva aplikační logiky, která se skládá z několika tříd a
pluginů tzv. zásuvných modulů, pomocí kterých může být aplikace snadno rozšířena.
Poslední a nejnižší vrstva je I/O vrstva, která zpracovává vstupy a výstupy celé aplikace.
Při načtení vstupního souboru se pomocí třídy FormElementReader analyzuje vstupní
soubor a na jeho základě se vytvoří objekt typu FormElement. Tento objekt nese všechny
důležité informace o vstupním formuláři, jako jsou komponenty, které se na formuláři
nachází, jejich hierarchická struktura a jejich vlastnosti. Objekt je dále vstupem pro dvě třídy,
které s ním nadále pracují. První z těchto dvou tříd je TreeNodeCreator, která na jeho
základě sestaví objekt typu TreeNode pro komponentu TreeView, která znázorňuje
hierarchickou strukturu vstupního souboru. Druhou třídou, která využívá objekt FormElement
je XamlBuilder. Jejím hlavním úkolem je na základě objektu sestavit XAML reprezentaci
komponent. Tato reprezentace je nyní tvořena objektem typu XmlNode. Na závěr celého
konverzního procesu se takto vytvořený XmlNode zapíše pomocí třídy XamlWriter na
požadovanou cestu, kterou uživatel zadal. Zdrojové kódy celé aplikace viz. “Příloha 5 – CD“.
10.3 Podporovaní komponenty a vlastnosti pro
převod
Jak již, bylo zmíněno ve funkčních požadavcích na aplikaci, aplikace nebude podporovat
kompletní seznam všech komponent pro převod, které Windows Forms nabízejí ale pouze
jejich podmnožinu. A u těchto vybraných nejpoužívanější komponent nebudou podporovány
všechny jejich vlastnosti, protože to by bylo nad rámec této práce, ale zase pouze jen
- 34 -
podmnožina těch nejvýznamnějších vlastností. Následující tabulka ukazuje podporované
komponenty a jejich vlastnosti:
Komponenta
Vlastnosti
Button
Name, Location, Size a Text
GroupBox
CheckBox
Name, Location, Size, Text a Checked
Label
RadioButton
Name, Location, Size, Text a Checked
TabControl
Name, Location a Size
TabPage
TextBox
Name, Location, Size, Text a ReadOnly
Tabulka 3 - Podporované komponenty pro převod do WPF a jejich vlastnosti
Nyní známe popis vrstev aplikace, hlavního procesu aplikace, ale také požadavky na
aplikaci kladené. A proto si teď přiblížíme detailní popis jednotlivých tříd aplikace.
10.4 Rozhraní aplikace
10.4.1 IControlCreator
Je jediné, ale za to velmi důležité rozhraní celé aplikace. Protože je aplikace založená na
zásuvných modulech (plugin) je důležité, aby všechny pluginy implementovali toto
jednoduché rozhraní. Tato technika je známá jako State Pattern ze standartu GOF.
IControlCreator definuje následující členy:

string Name { get; } – Název zásuvného modulu. Název musí být shodný
s typem komponenty ve Windows Forms. Jako příklad může být komponenta, která
slouží pro zadávaní nebo zobrazování textu ve Windows Forms, a ta se nazývá
TextBox. Z předešlých vět tedy plyne, že vlastnost Name bude v tomto případě mít
hodnotu “TextBox”. Dodržovaní této jmenné konvence je jedním z důležitých
pravidel pro správné fungování celé aplikace, protože když aplikace chce převést
právě komponentu typu TextBox projde všechny zásuvné moduly a zkontroluje jejich
vlastnost Name. Pokud existuje takový modul s touto hodnou s hodnou “TextBox”
použije aplikace právě tento modul pro převod komponenty.

string Version { get; } – Verze zásuvného modulu.

string Description { get; } – Krátký popis zásuvného modulu.
- 35 -

XmlNode Create(FormElement element, IControlCreator creator) – Jediná
metoda celého rozhraní, která z objektu typu FormElement vygeneruje jeho XML
(XAML) reprezentaci.
Protože se v jednotlivých zásuvných modulech vyskytuje návrhový vzor Decorator, tak si
tento vzor v krátkosti představíme.
10.4.1.1 Decorator
Účel
Umožňuje již existující objektům přidávat nové dynamické chování a vlastnosti bez nutnosti
vytváření odvozené třídy.
Návrh
Rozhraní IComponent představuje společného předka, pro všechny objekty, které budou
dekorovány. Třída Decorator zahrnuje ve svých privátních členech vlastnost typu
IComponent, její jednota může být např. objekt typu Component. Ve třídě Decorator dále
zavoláme metodu Operation nad objektem IComponent a dále metodu Operation objektu
Decorator a tímto postupem změníme např. objektu typu Component chování nebo stav,
aniž by sám o sobě o tom věděl. (Bishopová, 2010)
Obrázek 9 - UML diagram vzoru Decorator
- 36 -
10.4.1.2 Vyuţití vzoru Decorator v aplikaci
Návrhový vzor Decorator můžeme najít u jednotlivých zásuvných modulů aplikace. Všechny
pluginy implementují rozhraní IControlCreator, které odpovídá rozhraní IComponent
z předešlé
ukázky.
V případě
zásuvných
modulů
jsou
„dekoruje“
objekt
typu
CommonAttributes všechny ostatní, kterými jsou např. ButtonCreator, LabelCreator,
TextBoxCreator, atd. Vše si detailně popíšeme na příkladu s ButtonCreator. ButtonCreator
vytvoří základní XML (XAML) tag, který je charakteristický pro tlačítko ve WPF a
CommonAttribues tomuto tlačítku přidá všechny vlastnosti, které jsou společné pro všechny
WPF komponenty. ButtonCreator neví, že se něco takového děje a CommonAttributes
upravuje jeho vnitřní stav.
Obrázek 10 - UML diagram využití vzoru Decorator
10.5 Popis tříd prezentační vrstvy
10.5.1 MainWindow
Jedná se o hlavní okno celé aplikace. Představuje rozhraní mezi vrstvou aplikační logiky a
uživatelem. V horní části okna se nachází hlavní panel s kontextovými nabídkami. Dále
Hlavní okno obsahuje dvě textová pole, která zobrazují vstupní cestu k souboru pro převod a
výstupní cestu, kde bude převedený soubor uložen. Po načtení vstupního souboru se
zobrazí hierarchická struktura komponent vstupního souboru v části “Detaily vstupního
souboru“ na kartě “Rozložení souboru”. Druhá karta s názvem Log slouží pro výpis
logovacího souboru. Poslední s důležitých prvků na Hlavním okně je tlačítko v dolní pravé
- 37 -
části okna, které slouží pro samotný převod vstupního souboru. Celé Hlavní okno
s načteným vstupním soubor je zobrazeno na obrázku 11:
Obrázek 11 - Hlavní okno aplikace
Zdroj: printscreen aplikace, vlastní tvorba
10.5.2 PluginWindow
Druhé okno prezentační vrstvy je dialogové okno pro podporované doplňky. Dialogové okno
se otevře z hlavního panelu záložka Nápověda a dále klepnutím na Podporované doplňky.
V okně jsou vypsány všechny zásuvné moduly, kterými aplikace disponuje. U každého
zásuvného modulu je uveden jeho název, verze a jeho popis. Dialogové okna
s podporovanými doplňky je zachyceno na obrázku 12:
- 38 -
Obrázek 12 - Okno s podporovanými doplňky
10.6 Popis jednotlivých tříd aplikační logiky
10.6.1 Constants
Třída Constants je velice jednoduchá svojí implementací. Jedná se o statickou třídu.
Obsahuje pouze velké množství vlastností, převážně typu string, které jak již název třídy
napovídá, slouží jako centralizované uložiště všech konstant. Centralizované uložiště je
zvoleno, aby bylo v budoucnu možné jednotlivé konstanty jednoduše změnit na jednom
místě aplikace bez nutnosti přepisování všech hodnot v různých třídách aplikace.
10.6.2 ControlCreatorFactory
Jedná se o jednu z klíčových tříd aplikace. Úkolem třídy je rozhodnou, který zásuvný modul
se použije pro vytvoření XAML tagu z objektu FormElement. V konstruktoru třídy se načtou
všechny zásuvné moduly do proměnné plugins pomocí třídy PluginManager. Třída
ControlCreatorFactory je obsahuje pouze jedinou metodu a tou je FactoryMethod.
public XmlNode FactoryMethod(FormElement element)
{
try
{
XmlNode result = null;
- 39 -
// Vytvoření XAML elementu podle typu elementu
if (plugins.ContainsKey(element.Type) &&
plugins.ContainsKey("CommonAttributes"))
{
if (plugins[element.Type] is IControlCreator)
{
result = ((IControlCreator)plugins["CommonAttributes"])
.Create(element, (IControlCreator)plugins[element.Type]);
}
}
return result;
}
catch (Exception ex)
{
// kód byl z důvodů přehlednosti odstraněn
}
}
Metoda vrací objekt typu XmlNode, který představuje XAML reprezentaci prvku na formuláři.
FactoryMethod pracuje způsobem, že se podívá do proměnné plugins, jestli obsahuje
potřebný zásuvný modul pro převedení prvku formuláře a plugin s obecnými vlastnostmi pro
převod. Pokud proměnná plugins tyto zásuvný moduly neobsahuje, bude prvek ignorován a
ve výsledném převedeném formuláři nebude zobrazen. Když je zásuvný modul nalezen a
implementuje rozhraní IControlCreator zavolá se nad tímto zásuvným modulem metoda
Create, která se postará o sestavení objektu typu XmlNode. A tento XmlNode je vrácen
metodou.
10.6.3 Attribute
Jedná se o abstraktní třídu, která slouží pro odvozování konkrétních typů, jako jsou
ElementAttribute a FormAttribute. Tato třída je velice jednoduchá a obsahuje pouze
dvě veřejné vlastnosti a těmi jsou: Name a Content. Vlastnost Name představuje název
vlastnosti, jedno prvku formuláře. Touto vlastností může např. být: Text, Size, Location, atd.
Zatímco vlastnost Content uchovává samotný obsah vlastnosti, která byla načtena ze
vstupního souboru pro převod k názvu vlastnosti konkrétního prvku.
10.6.4 ElementAttribute
Třída ElementAttribute je odvozená od abstraktní třídy Attribute. Typ ElementAttribute
slouží pro uchovávání vlastností jednotlivých prvku formuláře.
Příkladem může být tlačítko ve vstupním souboru s popiskem „Odešli objednávku“. Potom
bude stav objektu ElementAttribute vypadat následovně: Vlastnost Name bude mít
hodnotu Text a vlastnost Content bude obsahovat hodnotu typu string „Odešli objednávku“.
- 40 -
10.6.5 FormConverter
FormConverter představuje vysokoúrovňové rozhraní pro převod vstupního formuláře
z Windows Forms do WPF, které je založené na návrhovém vzoru Facade (vzor je popsán
dále v textu). Tato třída v sobě zapouzdřuje následující typy: FormElementReader,
TreeNodeCreator
a
XamlWriter.
Umožňuje,
přistup
k těmto
typům
pomocí
tří
jednoduchých metod a těmi jsou: RenderTreeView, ShowPreview a WriteXaml. Motivace
k vytvoření této třídy bylo odlehčení tzv. code behind v hlavním formuláři aplikace
MainWindow, kde se nyní reaguje na události prvků pouze pomocí voláním některé z tří výše
uvedených metod.
10.6.5.1 Facade
Účel
Poskytnou uživateli vysokoúrovňové rozhraní např. na třídy, komponenty, subsystémy,
systémy atd. Jejich detaily jsou buď uživateli záměrně skryty anebo slouží pouze
k zjednodušení. Jednotlivé operace mohou byt sestaveny z různých prvků.
Návrh
Uživatel aplikace komunikuje pomocí Facade. Facade získává požadavky od uživatele. Tyto
požadavky dále zasílá příslušným objektům, které tvoří její datové složky. Vzor Facade je
rozhraní, ale je implementováno jako třída.
Obrázek 13 - UML diagram vzoru Facade
- 41 -
10.6.5.2 Vyuţití vzoru Facade v aplikaci
V aplikaci můžeme nalézt návrhový vzor Facade implementovaný ve třídě FormConverter,
kde vytváří rozhraní pro třídy: FormElementReader, TreeNodeCreator a XamlWriter.
Využívá některých jejich metody a transformuje tyto metody do vysokoúrovňového rozhraní.
Obrázek 14 - UML diagram využití vzoru Facade
10.6.6 FormElement
FormElement je klíčovou entitou celé aplikace. Představuje každý prvek (komponenta), který
je umístěn na vstupním formuláři. Každý prvek se skládá s unikátních vlastností, které ho
charakterizují a jinak tomu není ani u entity FormElement. Tato entity slouží pro zapouzdření
všech podporovaných vlastností (atributů) u jednotlivých prvků formuláře. Vlastnosti entity
FormElement jsou:

IsOnFormElement – Je booleovská hodnota, která říká, jestli je prvek umístěn
přímo na formuláři nebo je součástí nějakého kontejnerového prvku např. GroupBox,
protože v případě, kdy je prvek uvnitř kontejnerového prvku je počátek jeho
souřadnic v technologii WPF odlišný, než když je umístěn přímo na formuláři. Prvky
gbDetails a tpCustomer budou mít tuto hodnotu nastavenou na true viz obrázek 15.

LevelOfNesting
–
Představuje
číselnou
hodnotu
zanoření
prvku
v jiných
kontejnerových prvcích. Tato vlastnost je nutná z důvodu korekce pozice prvku,
- 42 -
protože pozice je odlišná, pokud je prvek v jednou nebo třech GroupBoxech. Pro
tlačítko btnUpdate bude tato hodnota 2 viz obrázek 15.

ChildElement – Každý FormElement může obsahovat další FormElement entity
(potomky), tímto způsobem je vytvořena odpovídající hierarchie prvků na formuláři.
Pro prvek gbAddress budou jeho potomci lblFirstName, tbFirstName a btnUpdate viz
obrázek 15.

Attributes – Hešovací tabulka, která uchovává všechny podporované vlastnosti pro
převod prvku do WPF jako jsou jeho pozice, velikost atd.

Type – Reprezentuje typ prvku (komponenty) např. TextBox, GroupBox, Label atd.

Name – Název prvku na vstupním formuláři pro převod do WPF např. txtFirstName.
Obrázek 15 - Ukázka hierarchie komponent na formuláři
10.6.7 FormElementReader
Třída FormElementReader je nejdůležitější třída celé aplikace, protože se tato třída stará o
načtení vstupního souboru a sestavení objektu typu FormElement, který se používá v celé
aplikaci. FormElement vzniká parsování vstupního souboru výrazů, který definuje
uživatelské rozhraní Windows Forms. Parsuje se převážně pomocí regulárních výrazů a
metod třídy String. Ukázka toho souboru se nachází v kapitole “8.3.2 Realizace Windows
Forms”. Tento objekt je použit pro zobrazení náhledu výsledného okna, sestavení stromové
struktury po načtení vstupního souboru a samozřejmě také pro sestavení výsledného XAML
souboru.
- 43 -
FormElementReader je svojí implementací nejrozsáhlejší třída. Třída se skládá s jedné
veřejné metody a tou je metoda GetFormHierarchy. Úkolem této metody je samotné
vytvoření hierarchické struktury, jak je ukázáno na obrázku 13 - Ukázka hierarchie
komponent na formuláři. Metodě při parsování pomáhá několik soukromých metod:

GetNamespace – Metoda získá ze vstupního souboru jmenný prostor, v jakém se
převáděný formulář nachází.

GetFormName – Metoda získá název vstupního formuláře.

GetChildElements – Metoda nalezne všechny potomky kontejnerové komponenty.

GetElementType – Metoda vyhledá jakého je typu převáděná komponenta.

GetElementAttributes – Metoda získá všechny atributy jednoho konkrétního
elementu.
Nyní si přiblížíme implementace jednotlivých metod třídy FormElementReader.
10.6.7.1 GetNamespace
Metoda je svojí implementací velice jednoduchá, jak již bylo napsáno, nalezne pouze jmenný
prostor převáděného formuláře. Jmenný prostor je nalezen na základě jednoduchého
regulárního výrazu, který vypadá následovně:
"namespace ([A-Za-z0-9]+(\.)?)+ "
Takto nalezený jmenný prostor je následně metodou vrácen jako řetězec.
10.6.7.2 GetFormName
Její implementaci je analogicky velice podobná metodě GetNamespace.
10.6.7.3 GetElementType
Metoda přijímá jediný parametr a tím je objekt typu FormElement, pro který chceme zjistit
typ. Pro nalezení typu metoda využívá následující regulární výraz:
"this\.{0} = new System\.Windows\.Forms\.[A-Za-z]+"
Složené
závorky s nulou
uprostřed
v regulárním
výrazu
jsou
nahrazeny
názvem
komponenty. Ukázkový řádek, které regulární výraz hledá:
this.txtLabel = new System.Windows.Forms.TextBox();
S výše uvedeného řádku dále metoda odstraní všechny znaky až po poslední tečku a vrátí
typ objektu jako řetězcovou hodnotu.
- 44 -
10.6.7.4 GetChildElements
Úkolem metody je nalézt všechny vnořené komponenty v kontejnerovém prvku na základě
názvu komponenty, který se předává jako parametr metodě. Ve vstupním souboru jsou
komponenty přidávány do kontejnerového prvku následovně:
this.grbDocumentOutline.Controls.Add(this.trvDocumentOutline);
V uvedené ukázce se do komponenty typu GroupBox s názvem grbDocumentOutline
přidává komponenta TreeView s názvem trvDocumentOutline. Tento způsob vkládání se
pro všechny prvky stejný proto platí, že následující regulární výraz vyhledá všechny řádky,
kde se do kontejnerové komponenty vkládají komponenty vnořené:
"this\.{0}\.Controls\.Add\(this\.[A-Za-z0-9]+\)"
Složené závorky s nulou jsou vždy nahrazený názvem komponenty, který se předává jako
parametr metodě. Nalezené řádky se dále uříznou o nežádoucí znaky a nechá se pouze
název komponenty. Vytvoří se objekt typu FormElement a jeho vlastnosti Name se nastaví
na právě nalezený název komponenty. Pomocí metody GetElementType se zjistí typ
komponenty a uloží se do vlastnosti Type objektu FormElement. Pokud se právě nalezeny
prvek nachází přímo na formuláři, tak se vlastnost IsOnFormElement objektu typu
FormElement nastaví na true, jinak false. Tato vlastnost je následně využívaná při korekci
umísťování
ve
výsledné
WPF
reprezentaci
formuláře.
Dále
se
pomocí
metody
GetElementAttributes naleznou všechny atributy komponenty. Předposledním krokem je
rekurzivní zavolání metody GetChildElements pro všechny nalezené komponenty.
Posledním krokem je přidání sestaveného objektu typu FormElement do rodičovského
seznamu potomků.
10.6.8 Logger
Tato třída je navržena podle strukturálního návrhového vzoru Singleton, který bude obecně
popsán i s detailním využitím ve třídě Logger později. Třída Logger slouží pro zapisování
jednotlivých
klíčových
událostí do
výstupního
souboru,
který je
možno
nastavit
v konfiguračním souboru aplikace pod názvem logFile. Třída disponuje pouze dvěma
statickými metodami pro zápis a čtení logovacího souboru.
Ukázka kódu pro zápis do logovacího souboru aplikace.
public static void Write(string logMessage)
{
using (FileStream fs = new FileStream(logPath, FileMode.Append))
{
using (StreamWriter sw = new StreamWriter(fs))
{
lock (padlock)
- 45 -
{
sw.WriteLine(String.Format("{0} - {1}", DateTime.Now,
logMessage));
}
}
}
}
Ukázková metoda Write pro zápis do logovacího souboru přijímá jedený parametr a tím je
text logovací zprávy, který se propíše do souboru. Zajímavostí na metodě je použití
klíčového slova using jazyka C#, které deklaruje proměnou, jež je přístupná pouze ve
složených závorkách. Takto inicializovaná proměnná musí implementovat rozhraní
IDisposable, protože po ukončení příkazu using dojde k zavolání metody Dispose, která
se uvolní veškeré prostředky pro Garbage Collector a není nutno uzavírat používané proudy.
Uvnitř prvního příkazu using je deklarován proud pro připsání textové zprávy za veškerý
text v již existujícím souboru. Samotný zápis do souboru je uzamčen zámkem, aby nemohlo
dojít k situaci, kdy jedno vlákno aplikace bude např. zapisovat do souboru a druhé vlákno
aplikace
bude
číst
soubor.
V tomto
případě
by
došlo
k vyvolání
výjimky typu:
System.IO.IOException.
10.6.8.1 Singleton
Účel
Účelem vzoru Singleton je zajistit, aby byla v aplikace pouze jediná instance daného typu a
k této instanci existuje pouze jediný přístupový bod.
Návrh
Návrhový vzor Singleton je implementovaný pouze pomocí jediné třídy a tím je třída
Singleton. Třída obsahuje jeden soukromý statický člen s názvem singleton, jedná se o
instanci samotné třídy Singleton, která není vnějšímu okolí viditelná. Soukromý člen je dále
statický, aby byl sdílený mezi všemi instancemi třídy a ne pouze v rámci jediné jeho
instance. K členu se přistupuje pomocí veřejné metody GetInstace. Dále je konstruktor
třídy privátní, aby nebylo možné k němu přistupovat z vnější.
- 46 -
Obrázek 16 - UML diagram vzoru Singleton
10.6.8.2 Vyuţití vzoru Singleton v aplikaci
Vytvářecí návrhový vzor Singleton je v aplikaci použit pro implementaci třídy Logger, která
se stará o zápis, čtená a smazaní logovacího souboru aplikace. Postup implementace vzoru
Singleton je u této třídy trošku odlišný. Na rozdíl od obecné ukázky výše třída Logger
obsahuje veřejný konstruktor, ve kterém se volá soukromá metoda GetInstance, aby se
každé čtení nebo zápis do souboru omezil pouze na jediný řádek kódu a byla zachována
struktura jedináčka.
Zde je ukázka, jak probíhá zápis do logovacího souboru:
Logger.Write("Zobrazení náhledu formuláře.");
Obrázek 17 - UML diagram využití vzoru Singleton
10.6.9 LogWatcher
Pokaždé, když jakákoliv z tříd v programu zapíše do logovacího souboru, změní se tím i
velikost souboru na harddisku. A právě sledování změny velikosti logovacího souboru je
hlavní úkol třídy LogWatcher, respektive její metoda Watch. Třída obsahuje privátní metodu
- 47 -
PrivateWatch, aby bylo možné jednoduše v metodě Watch spustit metodu PrivateWatch
ve svém vlastním vlákně. Když dojde ke změně velikosti “hlídaného” souboru dojde ke
spuštění události LogChanged.
10.6.10 PluginManager
Jedním z požadavků na aplikaci je její snadná rozšiřitelnost a nahrazení stávajících knihoven
(pluginů - *.dll souborů) za novější verzi bez rekompilace zdrojových kódů aplikace. Aby byl
tento požadavek splněn, musela vzniknout třída PluginManager, jejíž starostí je při spuštění
aplikace načíst všechny pluginy, které se nacházejí v potřebné složce. Umístění této složky
je možno nastavit přes konfigurační soubor aplikace, jedná se o vlastnost s názvem
sourceFolder. PluginManager implementuje pouze jedinou metodu pro načtení všech
pluginů a vracení výsledku ve formě datové struktury Slovníku (Dictionary). Jako klíč je
použit název pluginu a hodnota je vytvořená instance typy IControlCreator.
Ukázka metody Load pro načtení pluginů:
public Dictionary<string, IControlCreator> Load(string folder)
{
try
{
string[] dllFiles = Directory.GetFiles(folder, DLL_EXTENSION);
foreach (string dllFile in dllFiles)
{
Assembly assembly = Assembly.LoadFrom(dllFile);
foreach (Type type in assembly.GetTypes())
{
if (type.GetInterface(INTERFACE_NAME)
== typeof(IControlCreator))
{
IControlCreator plugin =
Activator.CreateInstance(type) as
IControlCreator;
plugins.Add(plugin.Name, plugin);
}
}
}
return plugins;
}
}
Celá výše uvedená metoda je naimplementována pomocí tzv. reflexe. Pomocí reflexe
můžeme za běhu programu dynamicky zjišťovat informace o existujících typech nebo např.
vytvářet jejich instance jako je to i v následující metodě. Metoda pro načtení všech pluginů
přijímá jediný parametr a tím je složka, ve které se nacházení pluginy pro načtení. Pomocí
statické metody Directory.GetFiles z jmenného prostoru System.IO vyhledáme všechny
soubory s příponou *.dll ve zvolené složce a cesty k těmto souborům si uložíme do
- 48 -
proměnné dllFiles. Ve smyčce procházíme všechny nalezené soubory, které splnily výše
uvedené podmínky a načítáme každý soubor do sestavení. Pro každé sestavení si načteme
všechny typy, které se v daném sestavení nachází a otestujeme je, zda implementují
rozhraní IControlCreator. Jestli toto rozhraní implementuje právě procházený typ, potom
vytvoříme instanci tohoto typu a uložíme instanci do výsledné datové struktury slovníku pod
klíč, kterým je název pluginu. (Watson, 2010)
10.6.11 TreeNodeCreator
Třída TreeNodeCreator slouží pro vytváření objektu TreeViewItem, který reprezentuje
náhled stromové struktury v komponentě TreeView. Metoda obsahuje celkem tři metody
z toho pouze jedna je veřejná a zbylé dvě jsou soukromé. Veřejná metoda MakeTree vytváří
samotný strom hierarchie elementů na formuláři za pomocí dvou soukromých metod
ConvertElementToTreeNode a MakeTreeViewItem. Tato metoda přijímá pouze jedený
parametr a tím je logická pravda či nepravda, jestli se u každého z prvků formuláře mají
zobrazit jeho vlastnosti jako potomci tohoto uzlu. První ze dvou soukromých metod je
ConvertElementToTreeNode, která slouží pro rekurzivní (pojem rekurze viz. Rekurze níže)
vytvoření hierarchie formuláře. Druhá je privátní metoda s názvem MakeTreeViewItem, která
je volána z první soukromé metody ConvertElementToTreeNode, metoda má za úkol vytvořit
jeden konkrétní uzel pro komponentu TreeView. Tento uzel se skládá z ikony a názvu prvku,
název v sobě skrývá typ prvku a za pomlčkou následuje jeho původní název.
10.6.11.1 Rekurze
V imperativním programování můžeme za pomocí rekurze v metodě volat tuto samotnou
metodu opakovaně, aniž by došlo k ukončení přechozího volání. Důležitou součástí rekurze
je ukončovací podmínka, aby nedošlo k vytvoření nekonečného cyklu.
10.6.12 TreeViewManagment
TreeViewManagment patří mezi jednodušší třídy aplikace. Obsahuje pouze dvě metody a to
ExpandAllItems a CollapseAllItems. V klasických WinForms aplikací, k
de je
komponenta TreeView s vlastností Expand, která nám umožnuje po nastavení hodnoty na
true rekurzivně otevřít všechny elementy uzlu. Obdoba této vlastnosti ve WPF chybí, a
proto je zde třída TreeViewManagment, která nám toto otevření a zavření uzlů zajistí.
Ukázka kódu pro otevření všech uzlů elementu:
public static void ExpandAllItems(this ItemCollection items)
{
foreach (TreeViewItem item in items)
{
item.IsExpanded = true;
- 49 -
if (item.HasItems)
ExpandAllItems(item.Items);
}
}
Metoda je napsána jako tzv. rozšiřující, to nám umožní zavolat metodu přímo na kolekci typu
ItemCollection. Metoda ve smyčce prochází všechny jednotlivé prvky kolekce a nastavuje
jejich vlastnost IsExpanded na true, která se stará o otevření uzlu. Jestli prvek obsahuje
další uzly jako svoje potomky, potom se rekurzivně volá metoda nad těmito potomky.
Opačná metoda CollapseAllItems, která všechny položky zavře, pracuje obdobným
způsobem, ale analogicky opačným.
10.6.13 XamlBuilder
Třída XamlBuilder je svojí implementací jedna z jednodušších tříd aplikace. Obsahuje
pouze jedinou metodu Build. Tato metoda se stará o vytvoření celé hierarchické struktury
XAML souboru. Metoda Build využívá rekurzivní algoritmus k poskládání celé struktury. Více
o rekurzi v kapitole “10.6.11 TreeNodeCreator”. V prvním volání metody Build dojde
k nastavení proměnné parentNode na XmlNode jehož vnitřní tag nese název Window. Dále
se v metodě projdou všechny potomci elementu Window a dojde k jejich převedení na XAML
reprezentaci pomocí metody FactoryMethod. Zkontroluje se, jest-li výsledný navrácený
objekt se nerovná hodnotě null. Táto hodnota je metodou FactoryMethod vrácena v případě,
že komponenta není podporována převodem (neexistuje zásuvný modul pro převod této
komponenty z Windows Forms) nebo došlo k chybě během převodu. Pokud je výsledný
objekt typu XmlNode odlišný od null hodnoty, importuje se pomocí objektu doc. Pokud by
nedošlo k tomuto importu, byla by vyvolána výjimka, která říká, že XmlNode je jiného původu
a následně by nemohl být vložen do rodičovského XmlNodu. Další z podmínek zjišťuje, jestli je rodičovský uzel kontejnerový tag. Musí platit podmínka, že obsahuje potomka a tento
potomek musí mít zároveň název “Grid”. Pokud je tato podmínka splněna přidáme
převedený XmlNode do elementu Grid rodičovského uzlu. Jinak se vloží za poslední uzel
v rodičovském uzlu. Celá metoda Build je dále rekurzivně volána s parametry potomka. Na
závěr je rodičovský objekt typu XmlNode vrácen pomocí klíčového slova return.
10.6.14 XamlWriter
Jedná se o nepříliš rozsáhlou a jednoúčelovou třídu pro zápis výsledného XAML do souboru.
Třída obsahuje pouze jednu privátní a jednu veřejnou metodu. Privátní metoda s názvem
GetDefaultTemplateData nedělá nic jiného, než že načte text ze souboru, který slouží jako
šablona pro vygenerované okno. Obsah šablony je následující:
<Window
- 50 -
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="{2}" Height="{3}" Width="{4}">
<Grid>
</Grid>
</Window>
V šabloně je vidět rodičovský element Windows, který obsahuje výchozí direktivy při
vytvoření okenní aplikace ve WPF. V tagu Windows se dále nacházení vlastnosti: Title,
Height a Width, jejíž hodnoty budou později nastaveny na konkrétní hodnoty. Poslední je tag
Grid, jehož obsah bude tvořit vygenerovaný XML (XAML) aplikací.
Veřejná metoda Write se v aplikaci používá pro dva případy:
1. Vytvoření dočasného souboru s příponou .dat pro funkčnost Zobrazení
náhledu, která soubor načte a zobrazí okno.
2. Pro zapsání výsledného XAML do souboru.
Metoda Write přijímá dva parametry path typu string – cesta, kde se výsledný
soubor zapíše a objekt typu FormElement – nese všechny důležité informace o
vstupním formuláři pro převod. Pokud je parametr path nastaven na hodnotu null,
tak je metoda Write využita k vytvoření dočasného souboru s příponou .dat, který
se vytvoří ve složce s aplikací. Uvnitř těla metody se otevře proud pro zápis do
souboru na zvolené cestě. Pomocí soukromé metody se načte výše uvedená
šablona pro zápis do lokální proměnné typu XmlDocument s názvem doc. Po načtení
šablony se nastaví konkrétní hodnoty vlastností tagu W indow podle vstupního
parametru metody form
v proměnné doc. Další důležitý krok je sestavení
samotného XML (XAML) kódu pro zápis pomocí třídy XamlBuilder. Když je XAML
kód vygenerován je zapsán do tagu Grid unitř proměnné doc. Na závěr se vše
pomocí metody Save objektu doc zapíše do souboru.
- 51 -
11. DOKUMENTACE
11.1 Uţivatelská dokumentace
V rámci uživatelské dokumentace se seznámíme se všemi funkčnostmi, které aplikace
nabízí.
11.1.1 Načtení vstupního souboru
Pro vybrání vstupního souboru vybereme s hlavní lišty ze záložky “Soubor” položku
“Otevřít…”. Ukázky možných vstupních souborů viz. “Příloha 1“ a “Příloha 3” Vše
demonstruje obrázek.
Obrázek 18 - Výběr vstupního souboru
Po klepnutí na položku “Otevřít…” se zobrazí dialogové okno pro vybrání souboru
s příponou *.Designer.cs. Vše demonstruje následující obrázek.
- 52 -
Obrázek 19 - Dialogové okno pro výběr vstupního souboru
Po načtení vstupního souboru se aktualizuje textové pole s cestou ke vstupnímu souboru (1)
a v části formuláře s názvem “Detaily vstupního souboru” se zobrazí stromová struktura
načteného formuláře (2).
Obrázek 20 - Aktualizované hlavní okno po načtení vstupního souboru
- 53 -
11.1.2 Zobrazení náhledu
Pro zobrazení náhledu výsledného převedeného okna do WPF se zobrazí po klepnutí na
položku “Zobrazit náhled…” (1) ze záložky “Náhled” hlavní lišty aplikace, poté se zobrazí
samotný náhled okna (2). Vše demonstruje následující obrázek.
Obrázek 21 - Zobrazení náhledu převáděného formuláře
11.1.3 Převedení formuláře
Pro úspěšné převedení vstupního formuláře je potřeba provést výběr vstupního souboru
podle kapitoly “11.1.1 Načtení vstupního souboru”. Dále je potřeba vybrat výstupní cestu,
kde bude převedený soubor uložen. Výběr se provede vybráním položky “Výstupní cesta…”
ze záložky “Soubor” (1), následně se zobrazí dialogové okno pro vybrání výstupní cesty (2).
- 54 -
Obrázek 22 - Výběr výstupní cesty
Posledním krokem po vybrání vstupního souboru a výstupní cesty je klepnutí na tlačítko
“Convert Now”. Pokud dojde k úspěšnému převedení formuláře, zobrazí se dialogové okno
se zprávou o úspěšném převedení. Ukázky již převedených formulářů viz. “Příloha 2” a
“Příloha 4”.
11.2 Programátorská dokumentace
V následující si představíme ukázkové vytvoření pluginu pro převod textového pole.
11.2.1 Vytvoření ukázkového pluginu pro TextBox
V následující části si ukážeme, jak naimplementovat zásuvný modul pro aplikaci, pomocí
kterého přidáme aplikaci funkčnost převádět textová pole. Každý plugin pro aplikaci
ConvertingWFIntoWPF představuje samostatný projekt v Microsoft Visual Studio typu Class
Library. Uvnitř toho projektu se nachází pouze jedna třída, která bude sloužit pro převod
komponenty v našem případě pojmenovaná TextBoxCreator, protože se bude převádět
komponenty
typu
TextBox.
Třída
TextBoxCreator
musí
implementovat
rozhraní
IControlCreator, které zaručí, že třída bude obsahovat všechny potřebné členy pro převod.
Detailní popis tohoto rozhraní viz. kapitola 10.3.1 IControlCreator. Následující obrázek
ilustruje pouze všechny členy rozhraní IControlCreator.
- 55 -
Obrázek 23 - Rozhraní IControlCreator
11.2.1.1 Implementace vlastnosti Name
Vlastnost Name tedy v zásuvném modulu pro převod komponent typu TextBox má hodnotu
“TextBox”. Její implementace potom vypadá následovně:
public string Name
{
get { return "TextBox"; }
}
11.2.1.2 Implementace vlastnosti Version
Další vlastnost s názvem Version je pouhé číselné označení verze zásuvného modulu, které
volí sám vývojář podle stádia vývoje, v jakém se zásuvný modul nachází. Číselné verzování
se opírá o standard společnosti Microsoft. Celé číslo verze se skládá ze čtyř čísel, které jsou
odděleny tečkami. Příklad takového číslování může být verze 7.3.4206.1500. První číslice je
označení primární verze, druhá číslice udává sekundární verzi, třetí číslice označuje číslo
sestavení (build) a poslední čtvrtá číslice opravný baličky a hotfixy. V našem případě lze říct,
že verze obsahuje opravný balíček číslo 1 a 500 hotfixů. (XXX.XXX.XXX.1500).
Implementace vlastnosti Version vypadá následovně:
public string Version
{
get { return "2.95.125.1200"; }
}
11.2.1.3 Implementace vlastnosti Description
Poslední vlastnost rozhraní je Description. Tato vlastnost slouží pouze ke krátkému popisu
zásuvného modulu.
Všechny tři výše uvedené vlastnosti se zobrazují v dialogovém okně “O Doplňcích…”, viz.
kapitola 10.5.2.
- 56 -
11.2.1.4 Implementace metody Create
Metoda Create slouží pro vytvoření XAML (XML) tagů Windows Forms komponent. Na
začátku implementace každé metody Create se vytváří objekt typu XmlDocument, který
představuje XAML tag pro WPF.
XmlDocument doc = new XmlDocument();
XmlNode node = doc.CreateElement(Constants.CTRL_TEXTBOX);
Metoda doc.CreateElement(Constants.CTRL_TEXTBOX)
vytvoří v objektu doc XML
element, který vypadá následovně:
<TextBox></TextBox>
Pro každou komponent jsou typické naprosto odlišné vlastnosti, pro textové pole jsou to
např. vlastnosti Text – jedná se o text, který je v textovém poli již předvyplněný a ReadOnly
– hodnota v textovém poli slouží pouze pro čtení a nelze zadávat vlastní text. Zásuvný
modul pro převod komponenty TextBox bude tedy podporovat tyto dvě vlastnosti, které jsou
pro něj klíčové.
Přidání podpory pro předvyplnění textového pole textem stačí pouze XAML elementu přidat
atribut s názvem “TEXT”. Celé přidání vypadá následovně:
if (element.Attributes.ContainsKey(Constants.ATTR_TEXT))
{
XmlAttribute ctrlText = doc.CreateAttribute(Constants.ATTR_TEXT);
ElementAttribute text =
ElementAttribute)element.Attributes[Constants.ATTR_TEXT];
ctrlText.Value = text.Content.ToString();
node.Attributes.Append(ctrlText);
}
V podmínce se zjistí, jest-li objekt typy FormElement obsahuje vlastnost s názvem “Text”,
pokud takovou vlastnosti obsahuje, dojde k vytvoření XML atributu s názvem Text. Atributu
se nastaví hodnota, která odpovídá hodnotě vlastnosti Text objektu FormElement. A celý
atribut se přidá do objektu doc. Výsledný objekt doc po přidání atributu potom vypadá
následovně:
<TextBox Text=”Tady je text objektu FormElement”></TextBox>
Druhá vlastnosti, kterou bude zásuvný modul pro převod textového pole podporovat je
vlastnost ReadOnly. Aby bylo textové pole ve WPF pouze ke čtení stačí XAML elementu
přidat pouze vlastnost ReadOnly s hodnou true. Ukázka zdrojového kódu pro přidání odpory
vlastnosti ReadOnly:
if (element.Attributes.ContainsKey(Constants.ATTR_READ_ONLY))
- 57 -
{
XmlAttribute ctrlReadOnly =
doc.CreateAttribute(Constants.ATTR_IS_READ_ONLY);
ElementAttribute readOnly =
(ElementAttribute)element.Attributes[Constants.ATTR_READ_ONLY
];
ctrlReadOnly.Value = readOnly.Content.ToString();
node.Attributes.Append(ctrlReadOnly);
}
Přidání vlastnosti ReadOnly textovému poli je analogické jako v případě vlastnosti Text.
Výsledný objekt doc po přidání vlastnosti ReadOnly vypadá následovně:
<TextBox Text=”Tady je text objektu FormElement” ReadOnly=”True”>
</TextBox>
Takto vytvořený zásuvný modul stačí překompilovat a vložit do příslušné složky v aplikaci, ve
které se nachází zásuvné moduly. Ve výchozím nastavení aplikace se zásuvné moduly
nachází ve složce s názvem source. Avšak název složky, která slouží pro zásuvné moduly,
se může lehce změnit v konfiguračním souboru aplikace.
- 58 -
12. ZÁVĚR
V rámci práce byla naimplementována aplikace pro převod formuláře s Windows Forms do
novější technologie Windows Presentation Foundation (WPF), které jsou součástí Microsoft
.NET Frameworku. Aplikace je naimplementovaná pomocí objektově orientovaného
programovacího jazyka C# za využití právě WPF, která umožňuje lehce zobrazit náhled
výsledného okna oproti Windows Forms. Aplikace demonstruje snadné přizpůsobení všech
formulářových prvků ve WPF.
Aplikace umožňuje vybrat vstupní soubor (s příponou .Designer.cs), který deklaruje
uživatelské rozhraní a převést tento soubor na jeho, co možná nejvěrohodnější reprezentaci
ve WPF pomocí značkovacího jazyka XAML. WPF využívá XAML jako značková jazyk pro
deklarování uživatelského rozhraní. Pomocí jazyka XAML umožňuje oddělit definici
uživatelského rozhraní od aplikační logiky aplikace. Aplikace dále umožňuje např. zobrazení
hierarchické struktury vstupního souboru, zobrazení náhledu okna, vybrání cesty, kde bude
výsledný převedený soubor uložen atd. Aplikace nepodporuje všechny komponenty
Windows Forms, ale pouze vybranou množiny těch nejpoužívanějších a nejrozšířenějších,
jako jsou např. textové pole, popisek, tlačítko, přepínatko atd. U každé z těchto komponent
aplikace
opět
podporuje
pouze
vybranou
množinu
jejich
vlastností.
Jeden
z
hlavních požadavků na implementaci byla snadná rozšiřitelnost. A proto je veškerá aplikační
logika soustředěna do zásuvných modulů. Moduly jsou prezentovány knihovnami typu .dll.
Ke každé komponentě, kterou má aplikace podporovat musí existovat zásuvný modul.
Pomocí těch zásuvných modulů může být aplikace snadno rozšířena bez rekompilace
zdrojových kódu celé aplikace. Stačí pouze vytvořit nový zásuvný modul pro novou
komponentu, kterou má aplikace podporovat a nahrát tento modul do složky určené pro tyto
zásuvné modulu a aplikace bude při dalším spuštění podporovat i tuto komponentu.
Během vývoj aplikace se zjistilo, že jedním z největších problému, se kterými se na začátku
vůbec nepočítalo je umisťování prvků ve WPF. Celý problém začíná už ve velikosti
formuláře. Formulářová aplikace o velikosti 500x500 pixelu ve Windows Forms vůbec
neodpovídá formulářové aplikace o stejné velikosti ve WPF. To samé platí i o samotných
komponentách ve WPF. Každá komponenta ve WPF nese naprosto jiný souřadnicový
počátek, než jak je tomu u obdobné komponenty ve Windows Forms. Další z možných
problémů, který může nastat nejen u umísťování komponent na jejich pozice, ale u
všeobecné analýzy jejich vlastností pro převod je dynamická úprava těchto vlastností z kódu
na pozadí aplikace. Např. v implementaci konstruktoru formuláře může být umístěný kód,
který dynamicky nastavuje vlastnosti formuláře na základě nějakého parametru předaného
v konstruktoru. Další z faktorů, které znemožňují přímou konverzi Windows Forms do WPF
je, že ne všechny komponenty z Windows Forms jsou ve WPF zastoupeny.
- 59 -
Cest, kterými by se mohl budoucí vývoj aplikace ubírat, je mnoho. Prvním z možných
vylepšení aplikace je samotné vylepšení umísťování prvků na formulář ve výsledném XAML
souboru. Dále by se mohli vyvíjet zásuvné moduly pro podporu dalších komponent
z Windows Forms. Aplikace by se mohla rozšířit na převádění celých projektů a nejen pouze
jednotlivých formulářů. V dalších verzích by aplikace mohla přinést i podporu pro převádění
kódu na pozadí formulářů. A nakonec také podporu databindingu (vázání dat na komponenty
z různých datových zdrojů např. databáze nebo XML).
Aplikace by mohla najít své uplatnění v malých a středních firmách, které vlastní informační
systémy, které jim byla navrženy na míru a chtějí je modernizovat. Aplikace by ušetřila
značné náklady na vývoj informačního systému, protože by nemusel být vyvíjen od začátku.
- 60 -
13. CONCLUSION
During this Bachelor’s Thesis has been developed application for converting form from
Windows Forms technology into newer technology called Windows Presentation Foundation.
Both technologies are part of .NET Framework. Application has been developed using
object-oriented C# programming language together with WPF. WPF is used because it is
easier to implement preview of converted form in WPF then in Windows Forms. Application
also demonstrates customization of all form controls.
Application allows user to select input file (with extension .Designer.cs) which defines user
interface in Windows Forms technology and convert this file into its WPF representation as
credible as possible. WPF uses XAML as declarative language for defining user interface.
XAML allows to application easily separate definition of user interface from application logic.
This application offers user following: display hierarchical structure of input file, display
windows preview, select path, where the output file would be saved and so on. Application
doesn’t support all Windows Forms controls for converting but there is just select set of the
most used controls. Among these controls are textbox, label, button, checkbox and so on. At
every control application supports selected set of its attributes. One of the most important
requirements for application was extensibility. That’s why all application logic for converting
controls is centered in plugins. Plugins are represented like *.dll libraries. For each control
that application supports must be plugin. Using these plugins can be application easily
extended without recompiling all the source code. Simply another plugin can be implemented
which should support application for converting and put this plugin into folder which contains
these plugins and when the application starts again it will use this new plugin for converting.
During application development, it was found that one of the biggest problems faced at the
beginning of no account is placing control in WPF. The whole problem starts at the size of
the form. Windows Forms application with dimensions 500 x 500 pixel doesn’t correspond to
the application of the same size in WPF. And the same is true for WPF controls. Every WPF
control has different zero coordinates then its same control in Windows Form technology.
Another big problem not only for positing the controls is dynamic assigning of their attributes.
Controls’ attributes can be set from code behind. For example inside the constructor of form
can be placed some parameter which is used to set some control attribute. Another one of
facts that complicates straight conversion of Windows Forms into WPF is that there are not
all available controls in WPF to represent Windows Forms controls.
There are many paths which could be the future development of application. The first of the
possible enhancements to the application is better control placing in output XAML file. Next
plugins could be also developed to support more Windows Forms control for conversion.
Conversion could be spread to support whole projects and not only file which defines user
- 61 -
interface. Later stages of development could bring support of converting code behind files.
And finally application could be able to convert controls with data binding values.
Application could find its place in small and medium companies which own information
systems designed to order and they want to modernize them. Application would save a lot of
costs because the information system won’t be developed from begin.
- 62 -
14. SEZNAM POUŢITÉ LITERATURY
1. SHARP, John. Microsoft Visual C# 2005 Krok za krokem. Brno: Computer Press,
2006. 528 s. ISBN 80-251-1156-3.
2. BISHOPOVÁ, Judith. C# návrhové vzory. Brno: Zoner Press, 2010. 328 s. ISBN
978-80-7413-076-2.
3. NAGEL, C., EVJEN, B., GLYNN, J., SKINNER, M., WATSON, K. C# 2008
Programujeme profesionálně. Brno: Computer Press, 2009. 1898 s. ISBN 978-80251-2401-7.
4. ARLOW, J., NEUSTADT, I. UML2 a unifikovaný proces vývoje aplikací. Brno:
Computer Press, 2007. 563 s. ISBN 978-80-251-1503-9.
5. WATSON, Ben. C# 4.0 HOW-TO. Indianapolis: SAMS, 2010. 653 s. ISBN 978-0672-33063-6.
6. NATHAN, Adam. WPF 4 Unleashed. Indianapolis: SAMS, 2010. 825 s. ISBN 978-0672-33119-0.
7. MACDONALD, Matthew. Pro WPF in C# 2008. New York: Apress, 2008. 1040 s.
ISBN 978-1-4302-0576-0.
8. LAIR, Robert. Beginning Silverlight 4 in C#. New York: Apress, 2010. 395 s. ISBN
978-1-4302-2989-6.
9. LEE, H., CHUVYROV, E. Beginning Windows Phone 7 Development. New York:
Apress, 2010. 458 s. ISBN 978-1-4302-3217-9.
10. NASH, Trey. Accelerated C# 2010. New York: Apress, 2010. 627 s. ISBN 978-14302-2538-6
11. What is Mono [online], http://www.mono-project.com/What_is_Mono
- 63 -
15. SEZNAM POUŢITÝCH SYMBOLŮ A ZKRATEK
Zkratka
Popisek
WF
Windows Forms
WPF
Windows Presentation Foundation
XAML
Extensible Application Markup Language
XML
Extensible Markup Language
REQ
Požadavek
GUI
Graphic User Interface
API
Application Programming Interface
CLR
Common Language Runtime
MSVS
Microsoft Visual Studio
DPI
Dots Per Inch
RIA
Rich Internet Application
- 64 -
16. SEZNAM OBRÁZKŮ
Obrázek 1 - Vývoj programování aplikací pro systém Windows ........................................ - 14 Obrázek 2 - Vývoj .NET Frameworku ................................................................................ - 16 Obrázek 3 - Ukázka formuláře z technologie Windows Forms .......................................... - 19 Obrázek 4 - Ukázka okna s bohatým uživatelským rozhraní vytvořeného ve WPF .......... - 21 Obrázek 5 - Vývoj technologie WPF v závislosti na čase .................................................. - 24 Obrázek 6 - Silverlight RIA aplikace .................................................................................. - 27 Obrázek 7 - Běžná HTML stránka ..................................................................................... - 28 Obrázek 8 - Třídní diagram aplikace .................................................................................. - 33 Obrázek 9 - UML diagram vzoru Decorator ....................................................................... - 36 Obrázek 10 - UML diagram využití vzoru Decorator .......................................................... - 37 Obrázek 11 - Hlavní okno aplikace .................................................................................... - 38 Obrázek 12 - Okno s podporovanými doplňky ................................................................... - 39 Obrázek 13 - UML diagram vzoru Facade ......................................................................... - 41 Obrázek 14 - UML diagram využití vzoru Facade.............................................................. - 42 Obrázek 15 - Ukázka hierarchie komponent na formuláři ................................................. - 43 Obrázek 16 - UML diagram vzoru Singleton ...................................................................... - 47 Obrázek 17 - UML diagram využití vzoru Singleton .......................................................... - 47 Obrázek 18 - Výběr vstupního souboru ............................................................................. - 52 Obrázek 19 - Dialogové okno pro výběr vstupního souboru .............................................. - 53 Obrázek 20 - Aktualizované hlavní okno po načtení vstupního souboru ........................... - 53 Obrázek 21 - Zobrazení náhledu převáděného formuláře ................................................. - 54 Obrázek 22 - Výběr výstupní cesty .................................................................................... - 55 Obrázek 23 - Rozhraní IControlCreator ............................................................................. - 56 -
- 65 -
17. SEZNAM TABULEK
Tabulka 1 - Funkční požadavky aplikace ........................................................................... - 32 Tabulka 2 - Nefunkční požadavky aplikace ....................................................................... - 33 Tabulka 3 - Podporované komponenty pro převod do WPF a jejich vlastnosti ................. - 35 -
- 66 -
18. SEZNAM PŘÍLOH
1. Příloha 1 – Ukázka formuláře SampleForm1 ve WF
2. Příloha 2 - Ukázka převedeného SampleForm1 do WPF
3. Příloha 3 – Ukázka formuláře SampleForm2 ve WF
4. Příloha 4 - Ukázka převedeného SampleForm2 do WPF
5. Příloha 5 – CD
- 67 -
18.1 Příloha 1 – Ukázka formuláře SampleForm1 ve
WF
- 68 -
18.2 Příloha 2 - Ukázka převedeného SampleForm1
do WPF
- 69 -
18.3 Příloha 3 – Ukázka formuláře SampleForm2 ve
WF
- 70 -
18.4 Příloha 4 - Ukázka převedeného SampleForm2
do WPF
- 71 -
18.5 Příloha 5 – CD
CD je přiloženo u tištěné verze bakalářské práce.
Adresářová struktura CD:

Složka Aplikace
o

Složka Bakalářská práce
o

Obsahuje finální verzi aplikace pro převod Windows Forms do WPF
Obsahuje digitální verzi bakalářské práce ve formátu .docx a .pdf
Složka Zdrojové kódy
o
Obsahuje kompletní projekt aplikace pro Microsoft Visual Studio 2010
Ultimate
- 72 -

Převod Windows Forms do Windows Presentation

Transkript

Podobné dokumenty

bakalářská práce - Unicorn College

Výhody a nevýhody XML

Binding - vjj root page