Olá pessoal, tudo certo?
Continuando nosso estudo sobre Composite Application Guidance for WPF, vamos olhar um pouco mais sobre sua estrutura e principais recursos da CAL - Composite Application Library. Existe um conjunto básico de componentes que estão envolvidos na construção de uma aplicação de composição com essa biblioteca. Esses componentes são baseados nos conceitos:
Cada conceito envolve uma etapa do processo de construção de uma interface de composição. Vejamos:
Vejamos um exemplo. Um projeto básico de aplicação com o Composite Application Guidance for WPF contém os seguinte componentes:
Exemplo "HelloWorld Solution".
A solução acima é composta por 5 projetos: 3 projetos da Composite Application Library (Composite, Composite.WPF e Composite.UnityExtensions), 1 projeto de módulo de funcionalidades (HelloWorld) e 1 projeto principal da interface Shell da aplicação (HelloWorldSample).
Portanto, podemos iniciar a construção da aplicação em 2 frentes: o projeto principal da Shell e o projeto de cada módulo independente.
Para o projeto principal da Shell, notamos o arquivo Shell.xaml, que contém a chamada para a classe BootStrapper, responsável pela inicialização dos demais serviços da biblioteca CAL. Uma classe bootstrapper para nosso exemplo seria:
1: using System.Windows;
2: using Microsoft.Practices.Composite.Modularity;
3: using Microsoft.Practices.Composite.UnityExtensions;
4:
5: // Módulo de funcionalidades para a interface de composição.
6: using HelloWorld;
7:
8: namespace HelloWorldSample
9: {
10: internal class Bootstrapper : UnityBootstrapper
11: {
12: protected override IModuleEnumerator GetModuleEnumerator()
13: {
14: // Adicionando o módulo a interface.
15: return new StaticModuleEnumerator()
16: .AddModule(typeof(HelloWorldModule));
17: }
18:
19: protected override DependencyObject CreateShell()
20: {
21: Shell shell = new Shell();
22: shell.Show();
23:
24: return shell;
25: }
26: }
27: }
No método GetModuleEnumerator() acima, vemos a adição do módulo "HelloWorldModule" como funcionalidade cadastrada na Shell. Isso é feito através da chamada .AddModule. Para aplicações com vários módulos de funcionalidades, podemos adicionar várias chamadas AddModule, determinando ainda uma hierarquia entre os módulos, para sua apresentação e navegação do usuário.
No projeto do módulo, adicionamos um UserControl que conterá o controle ViewBox para renderização de funcionalidades implementadas pelo módulo. Veja o exemplo de User Control e View "HelloWorldView" a seguir (arquivo "HelloWorldView.xaml":
1: <UserControl x:Class="HelloWorld.Views.HelloWorldView"
2: xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3: xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
4: <Grid>
5: <TextBlock Text="Hello World" Foreground="Green" HorizontalAlignment="Center" VerticalAlignment="Center" FontFamily="Calibri" FontSize="24" FontWeight="Bold"></TextBlock>
6: </Grid>
7: </UserControl>
Na sequência, definimos um controle RegionManager no arquivo "Shell.xaml" do projeto da Shell. O controle RegionManager será responsável pela coleção de regiões que poderemos ter em nossa interface.
1: <Window x:Class="HelloWorldSample.Shell"
3: xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4: xmlns:cal="http://www.codeplex.com/CompositeWPF"
5: Title="Composite Application Library Sample" Width="400" Height="300">
6: <ItemsControl cal:RegionManager.RegionName="MainRegion"/>
7: </Window>
A seguir, vemos a classe principal de módulo "HelloWorldModule", relacionando a região alvo para renderização de sua funcionalidade, em nosso exemplo, a região "MainRegion":
1: using HelloWorld.Views;
3: using Microsoft.Practices.Composite.Regions;
5: namespace HelloWorld
6: {
7: public class HelloWorldModule : IModule
8: {
9: private readonly IRegionManager regionManager;
10:
11: public HelloWorldModule(IRegionManager regionManager)
12: {
13: this.regionManager = regionManager;
14: }
15:
16: public void Initialize()
17: {
18: IRegion mainRegion = this.regionManager.Regions["MainRegion"];
19: mainRegion.Add(new HelloWorldView());
20: }
21: }
22: }
Assim, cercamos alguns dos principais conceitos envolvidos na CAL. Esses componentes são representados de forma organizada na figura a seguir:
Então é isso: quando usamos a CAL para construir uma aplicação composta, pensamos na interface principal chamada Shell e nos vários módulos componentes. Assim, precisamos definir quais são as regiões existentes na interface principal Shell. Cada módulo contém funcionalidades que serão apresentadas em regiões da interface Shell. Essa apresentação é feita através do componente View, que adicionamos em cada módulo. Todo o módulo é contido num container, que encapsula e oferece recursos para a cola com a interface Shell. Essa cola é feita através do injection do módulo junto a aplicação Shell. Por fim, podemos realizar o desenvolvimento de módulos e Shell de forma desacoplada e em paralelo, uma necessidade que é características de interfaces compostas.
Esse post fez apenas uma introdução sobre os principais aspectos da CAL, estudando uma aplicação composta muito básica. Claro que o objetivo do pacote é construir interfaces mais complexas, com um grande número de módulos, funcionalidades e eventos associados. Outro assunto importante no estudo da CAL é o pattern de subscrição de eventos. Cada módulo também pode assinar os eventos desejados para o disparo de funcionalidades específicas.
Em posts futuros, vamos continuar discutindo alguns exemplos, enquanto aumentamos a complexidade de nossas composições sobra a Composite Application Library.
Por enquanto é só! Até o próximo post :)
Waldemir.
PingBack from http://blog.a-foton.ru/index.php/2008/10/23/composite-application-guidance-for-wpf-parte-2/