iMasters

De qualquer forma, em 2011 pretendo dar um pouco mais de atenção ao SilverLight e um bom começo é ter o ambiente corretamente ajustado para poder usar a tecnologia.

Lembrando que o SilverLight foi lançado em meados de 2007 e desde então tem evoluído muito. Enquanto o ASP .NET é uma plataforma para desenvolvimento do lado do servidor, com a chegada do SilverLight o foco muda para o lado do cliente, visto que uma aplicação SilverLight roda no navegador do cliente em uma versão específica da CLR (Common Language Runtime).

Se o SilverLight é algo totalmente novo mas você conhece o WPF, fique sabendo que o SilverLight pode ser considerado como uma versão reduzida do WPF, sendo possível inclusive reutilizar código escrito no SilverLight 4 no WPF 4 e vice-versa.

Preparando o terreno

Para iniciar o desenvolvimento de aplicações SilverLight precisamos ter instalados as ferramentas e os SDKs necessários.

1. Instalar o Visual Studio 2010 ou o Visual Web Developer Express 2010;
2. Instalar o SilverLight 4 Tools for Visual Studio 2010;
3. Instalar o Expression Blend 4;

Após baixar e instalar as ferramentas acima, não ocorrendo nenhum erro, tudo estará pronto para você dar início a saga de desenvolver aplicações para o SilverLight.

Invocando um serviço que expõe dados

Ao trabalhar em um projeto Silverlight que envolve serviços, o WCF (Windows Comunication Foundation) é a escolha preferida para a construção de um serviço se temos que criar este e o aplicativo cliente do Silverlight que irá utilizá-lo. Dessa forma, usando o WCF temos um controle completo sobre quais tipos serão enviados para o cliente.

Quando queremos construir uma aplicação Silverlight que trabalha com os dados disponíveis sobre o serviço (talvez proveniente de um banco de dados ou outro serviço externo), precisamos ter em mente as seguintes questões:

• Como devemos projetar o serviço que expõe os dados de modo que possa ser acessível a partir do Silverlight?
• Como devemos proceder para projetar o aplicativo do Silverlight, para que ele se comunica com o serviço?

Para mostrar como podemos nos conectar a partir do Silverlight com um serviço WCF que expõe os dados, vamos começar com a concepção do próprio serviço.

Observação: O artigo foi baseado em alguns exemplos prontos que foram adaptados e ajustados.

Vamos supor que estamos construindo uma aplicação que contém uma janela de visualização onde o usuário poderá obter informações sobre os funcionários de uma empresa.

Os dados do funcionário serão expostos pelo serviço e o aplicativo Silverlight irá se conectar ao serviço e trabalhar com os dados no lado do cliente. A seguir estão os passos que precisa executar para começar este trabalho.

Dica importante: para tornar mais simples o exemplo não vamos trabalhar com um banco de dados mas iremos preencher os dados via código.

Dando a partida: criando a aplicação SilverLight 4

Abra o Visual Web Developer 2010 Express Edition no menu File selecione New Project. A seguir selecione Visual C# e o template SilverLight > SilverLight Application, informe o nome SilverLightFuncionarios e clique em OK.

Será apresentada a janela abaixo, onde vemos o projeto do tipo ASP .NET Web Application Project selecionado como o tipo de projeto web que será usado para hospedar a aplicação SilverLight. Note que a versão do SilverLight escolhida é a versão 4.

Após fazer estas verificações clique em OK. Será criada uma solução com dois projetos:

• O projeto SilverLight: SilverLightFuncionarios;
• O projeto Web: SilverLightFuncionarios.web - responsável por hospedar o conteúdo SilverLight;

Vamos nos concentrar primeiro na aplicação web. Os dados que desejamos expor consistem em informações sobre os funcionários. Vamos então definir as classes que representam o domínio do nosso problema.

A seguir vemos o diagrama de classes que mostra as classes do nosso domínio:

O diagrama de classes acima mostra o relacionamento entre as classes e a enumeração CarroTipo. Note que a classe Funcionario é uma classe abstrata e que as demais classes herdam da classe Funcionario.

Dica Importante: Utilizando classes abstratas você pode declarar classes que definam apenas parte de uma implementação, deixando que as classes estendidas forneçam a implementação específica de alguns ou de todos os métodos. Uma classe abstrata em geral será  destinada apenas a servir como base para a criação de outras classes.

O próximo passo é criar as classes no projeto SilverLightFuncionarios.web. Vamos começar criando a classe Funcionario. Selecione o projeto SilverLightFuncionarios.web e no menu Project clique em Add Class. A seguir informe o nome Funcionario.cs e clique no botão Add.

Repita o procedimento acima e crie as seguintes classes:

• Gerente.cs
• Consultor.cs
• Administrativo.cs
• CarroTipo.cs

Após criar os arquivos para as classes vamos definir o código da classe Funcionario.cs conforme abaixo:

using System;
using System.Runtime.Serialization;

namespace SilverlightFuncionarios.Web
{
[DataContract]
    [KnownType(typeof(Gerente))]
    [KnownType(typeof(Consultor))]
    [KnownType(typeof(Administrativo))]
    public abstract class Funcionario
    {
[DataMember]
        public int funcionarioid { get; set; }

[DataMember]
        public string nome { get; set; }

[DataMember]
        public string email { get; set; }

[DataMember]
        public DateTime nascimento { get; set; }
    }
}

Vamos entender a classe Funcionario:

• A classe é uma classe abstrata e isso indica que a classe não pode ser instanciada e deve ser herdada por outra classe.
• O atributo DataContract usado na classe indica que o tipo pode ser enviado via rede.
• DataContract especifica que o tipo define ou implementa um contrato de dados e é serializável por um serializador, como o DataContractSerializer. Para fazer o seu tipo serializável, os autores do tipo devem definir um contrato de dados para o seu tipo.
• O atributo DataMember usado nos campos da classe será incluído no tipo e poderá ser enviado via rede para o lado do cliente.
• O DataMember quando aplicado ao membro de um tipo, especifica que o membro faz parte de um contrato de dados e é serializável pelo DataContractSerializer.
• O atributo KnowType marca os tipos a serem incluídos no processo de serialização.
• O atributo de classe KnownType permite que você especifique, antecipadamente, os tipos que devem ser incluídos para apreciação durante a desserialização.

Agora vamos definir o código da classe Gerente conforme o código a seguir:

using System.Runtime.Serialization;

namespace SilverlightFuncionarios.Web
{
    public class Gerente : Funcionario
    {
[DataMember]
        public double Gratificacao { get; set; }

[DataMember]
        public CarroTipo Carro { get; set; }
    }
}

A classe Gerente herda da classe Funcionario e define os campos:

• Gratificacao
• Carro

Observação: Para poder usar os atributos DataContrat e DataMember, talvez você terá que incluir uma referência a System.RunTime.Serialization no projeto web.

Abaixo temos a definição da classe Consultor:

using System.Runtime.Serialization;

namespace SilverlightFuncionarios.Web
{
    public class Consultor : Funcionario
    {
[DataMember]
        public CarroTipo Carro { get; set; }
    }
}

A classe Consultor herda da classe Funcionario e define o campo:

• Carro

Observação: Para poder usar os atributos DataContrat e DataMember talvez você terá que incluir uma referência a System.RunTime.Serialization no projeto web.

A seguir temos o código da classe Administrativo:

namespace SilverlightFuncionarios.Web
{
    public class Administrativo : Funcionario
    {
    }
}

A classe Administrativo herda da classe Funcionario. Finalmente o código da enumeração CarroTipo: 

namespace SilverlightFuncionarios.Web
{
    public enum CarroTipo
    {
            Esportivo,
            Passeio,
            Utilitario
    }
}

Nosso próximo objetivo será criar uma classe chamada FuncionarioRepositorio que será usada para carregar os dados de exemplo. Em uma aplicação real geralmente carregaríamos os dados de um banco de dados. Para criar a classe repita o procedimento usado para criar a classe Funcionario.

O código desta classe é definido como:

using System;
using System.Collections.Generic;

namespace SilverlightFuncionarios.Web
{
    public class FuncionarioRepositorio
    {
        private static List<Funcionario> todosFuncionarios;

        public FuncionarioRepositorio()
        {
            carregaFuncionarios();
        }

        private void carregaFuncionarios()
        {
            if (todosFuncionarios == null)
            {
                todosFuncionarios = new List<Funcionario>()
{
    new Gerente()
{
funcionarioid=1,
nome="Macoratti",
email="macoratti@yahoo.com",
carro=CarroTipo.Esportivo,
gratificacao=10000.00,
nascimento=new DateTime(1960, 1, 1)
},
new Consultor()
{
funcionarioid=2,
nome="Mario",
email="mario@bol.com.br",
carro=CarroTipo.Passeio,
nascimento=new DateTime(1976, 11, 9)
},
new Consultor()
{
funcionarioid=3,
nome="Janice",
email="janice@uol.com.br",
carro=CarroTipo.Utilitario,
nascimento=new DateTime(1983, 3, 12)
},
new Consultor()
{
funcionarioid=4,
nome="Jefferson",
email="jeff@net.com",
carro=CarroTipo.Passeio,
nascimento=new DateTime(1984, 6, 7)
},
new Administrativo()
{
funcionarioid=5,
nome="Miriam",
email="miriam@uol.com.br",
nascimento=new DateTime(1970, 9, 22)
},

new Administrativo()
{
funcionarioid=6,
nome="Jose",
email="jose@bol.com.br",
nascimento=new DateTime(1973, 2, 19)
},
};
   }

         public List<Funcionario> TodosFuncionarios
         {
            get
            {
                return todosFuncionarios;
            }
        }

        }
    }

A classe FuncionarioRepositorio usa uma lista estática de funcionários: private static List<Funcionario> todosFuncionarios.

Agora que definimos as classes do nosso domínio e a classe que irá popular os objetos da nossa classe vamos incluir um serviço WCF no projeto web. Selecione o projeto SilverLightFuncionarios.web e no menu Project clique em Add New Item.

Na caixa de diálogo Add New Item veremos duas opções para adicionar um serviço WCF:

• SilverLight-enabled WCF Service;

• WCF Service;

Vamos selecionar o item SilverLight-enabled WCF Service e informe o nome FuncionarioService e clique no botão Add. Será criado um arquivo FuncionarioService.csv conforme a figura abaixo:

Vamos fazer alguns ajustes no arquivo FuncionarioService gerado para habilitar os serviços WCF. O serviço deverá apresentar dois métodos:

• O primeiro deverá recuperar todos os funcionários;
• O outro deverá recuperar um funcionário pela identificação do funcionário;

Cada método deverá estar disponível no lado do cliente e deverá ter o atributo OperacionContract que indica que o método define uma operação que é parte de um contrato de serviço em uma aplicação.

Dessa forma o código implementado no serviço deverá chamar o método TodosFuncionarios da classe FuncionarioRepositorio conforme abaixo:

using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.Collections.Generic;

namespace SilverlightFuncionarios.Web
{
    [ServiceContract(Namespace = "")]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class FuncionarioService
    {
        [OperationContract]
        public List<Funcionario> GetTodosFuncionarios()
        {
            return new FuncionarioRepositorio().TodosFuncionarios;
        }

        [OperationContract]
        public Funcionario GetFuncionarioPorId(int funciid)
        {
            return new FuncionarioRepositorio().TodosFuncionarios.Where
            (e => e.funcionarioid == funciid).FirstOrDefault();
        }
    }
}

Com isso encerramos os ajustes do lado do cliente e podemos partir para o lado do servidor. Antes de continuar compile a aplicação (Build). Selecione o projeto SilverLight SilverLightFuncionarios e no menu Project clique em Add Service Reference.

A seguir clique no botão Discover e selecione: Services in Solution. Se o serviço estiver disponível ele deverá aparecer na caixa Services.

Se o serviço puder ser conectado sem erros, ele irá aparecer na lista de serviços e em Operations serão exibidos os nomes dos métodos criados. A seguir selecione o serviço e informe o nome FuncionarioService e clique no botão OK.

Depois de clicar no botão OK, Visual Web Developer 2010 Express tentará construir um proxy que é mais ou menos uma cópia do lado do cliente da classe de serviço. Na janela Solution Explorer o serviço poderá ser visto conforme mostra a figura a seguir:

Vamos agora cuidar da interface onde iremos usar o serviço criado. Selecione o projeto SilverLightFuncionarios e no menu Project clique em Add Reference e inclua referência a System.Windows.Controls.Data. Em seguida clique com o botão direito do mouse sobre o projeto e selecione Add > New Folder e informe o nome Converters para a pasta criada.

Depois vamos incluir dois arquivos que serão usados como conversores de data para o campo Nascimento e moeda para o campo Gratificação:

• CurrencyConverter.cs

• ShortDateConverter.cs

Observação: Não vou entrar em detalhes sobre os conversores, irei apenas usá-los no projeto. Se você quiser saber mais sobre eles consulte este link. 

Selecione o arquivo MainPage.xaml e a partir da ToolBox inclua os seguintes controles conforme o leiaute da figura abaixo;

• TextBlock
• TextBox
• Button
• DataGrid

A seguir temos a exibição do código XAML correspondente:

<UserControl xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"

x:Class="SilverlightFuncionarios.MainPage"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

mc:Ignorable="d"

xmlns:local="clr-namespace:SilverlightFuncionarios.Converters" Loaded="UserControl_Loaded"

d:DesignHeight="450" d:DesignWidth="550" DataContext="{Binding}">

<UserControl.Resources>

<local:ShortDateConverter x:Key="localShortDateConverter"></local:ShortDateConverter>

<local:CurrencyConverter x:Key="localCurrencyConverter"></local:CurrencyConverter>

</UserControl.Resources>

<Grid x:Name="LayoutRoot" Background="White" Height="450" Width="550">

<Grid.RowDefinitions>

<RowDefinition Height="60"></RowDefinition>

<RowDefinition Height="*"></RowDefinition>

</Grid.RowDefinitions>

<Grid.ColumnDefinitions>

<ColumnDefinition Width="*"></ColumnDefinition>

</Grid.ColumnDefinitions>

<TextBlock x:Name="TitleTextBlock" Grid.Row="0" Grid.ColumnSpan="2" Text="Macoratti.net - SilverLight" FontSize="24" FontWeight="Bold" HorizontalAlignment="Center"></TextBlock>

<StackPanel Grid.Row="1" Background="Bisque" >

<Grid Margin="3" HorizontalAlignment="Center" >

<Grid.RowDefinitions>

<RowDefinition Height="50"></RowDefinition>

<RowDefinition Height="300"></RowDefinition>

</Grid.RowDefinitions>

<Grid.ColumnDefinitions>

<ColumnDefinition Width="3*"></ColumnDefinition>

<ColumnDefinition Width="2*"></ColumnDefinition>

</Grid.ColumnDefinitions>

<StackPanel Grid.Row="0" Orientation="Horizontal" Grid.ColumnSpan="2">

<TextBlock x:Name="FunciIDTextBlock" VerticalAlignment="Center" Margin="2">Cod. Funci.::</TextBlock>

<TextBox x:Name="FunciIDTextBox" HorizontalAlignment="Left" Width="200" VerticalAlignment="Center" Margin="2"></TextBox>

<Button x:Name="ProcuraFunciButton" Click="ProcuraFunciButton_Click" Margin="2" Content="Procurar Funci" Width="120" Height="30" HorizontalAlignment="Center"></Button>

<TextBlock x:Name="ErrorTextBlock" Foreground="Red"></TextBlock>

</StackPanel>

<data:DataGrid x:Name="FunciDataGrid" Grid.Row="1" SelectionChanged="FunciDataGrid_SelectionChanged" CanUserReorderColumns="False"

IsReadOnly="True" AutoGenerateColumns="False" Width="316" Margin="0,0,3,0">

<data:DataGrid.Columns>

<data:DataGridTextColumn Binding="{Binding funcionarioid}" Header="Cod.Funci"></data:DataGridTextColumn>

<data:DataGridTextColumn Binding="{Binding nome}" Header="Nome"></data:DataGridTextColumn>

<data:DataGridTextColumn Binding="{Binding email}" Header="Email"></data:DataGridTextColumn>

</data:DataGrid.Columns>

</data:DataGrid>

<Grid x:Name="DetailGrid" Grid.Row="1" Grid.Column="1" Width="219" Margin="3,3,-10,3">

<Grid.RowDefinitions>

<RowDefinition Height="20"></RowDefinition>

<RowDefinition Height="20"></RowDefinition>

<RowDefinition Height="20"></RowDefinition>

<RowDefinition Height="20"></RowDefinition>

<RowDefinition Height="20"></RowDefinition>

<RowDefinition Height="20"></RowDefinition>

</Grid.RowDefinitions>

<Grid.ColumnDefinitions>

<ColumnDefinition Width="100"></ColumnDefinition>

<ColumnDefinition Width="100"></ColumnDefinition>

</Grid.ColumnDefinitions>

<TextBlock x:Name="FunciIdTextBlock" Grid.Row="0" Grid.Column="0" Text="Cod. Funci:" FontWeight="Bold"></TextBlock>

<TextBlock x:Name="FunciIdValueTextBlock" Grid.Row="0" Grid.Column="1" Text="{Binding funcionarioid}"></TextBlock>

<TextBlock x:Name="NomeTextBlock" Grid.Row="1" Grid.Column="0" Text="Nome:" FontWeight="Bold"></TextBlock>

<TextBlock x:Name="NomeTextBlockValue" Grid.Row="1" Grid.Column="1" Text="{Binding nome}" ></TextBlock>

<TextBlock x:Name="EmailTextBlock" Grid.Row="2" Grid.Column="0" Text="Email:" FontWeight="Bold"></TextBlock>

<TextBlock x:Name="EmailTextBlockValue" Grid.Row="2" Grid.Column="1" Text="{Binding email}" ></TextBlock>

<TextBlock x:Name="NascimentoTextBlock" Grid.Row="3" Grid.Column="0" Text="Nascimento:" FontWeight="Bold"></TextBlock>

<TextBlock x:Name="NascimentoTextBlockValue" Grid.Row="3" Grid.Column="1" Text="{Binding nascimento, Converter={StaticResource localShortDateConverter}}" ></TextBlock>

<TextBlock x:Name="GratificacaoTextBlock" Grid.Row="4" Grid.Column="0" Text="Gratificação:" FontWeight="Bold"></TextBlock>

<TextBlock x:Name="GratificacaoTextBlockValue" Grid.Row="4" Grid.Column="1" Text="{Binding gratificacao, Converter={StaticResource localCurrencyConverter}}" ></TextBlock>

<TextBlock x:Name="CarroTextBlock" Grid.Row="5" Grid.Column="0" Text="Carro:" FontWeight="Bold"></TextBlock>

<TextBlock x:Name="CarroTextBlockValue" Grid.Row="5" Grid.Column="1" Text="{Binding carro}" ></TextBlock>

</Grid>

</Grid>

</StackPanel>

</Grid>

</UserControl>

Na interface teremos as informações dos funcionários exibidas no controle DataGrid e os seus detalhes nos controles TextBlock conforme o funcionário selecionado. Observe o uso dos conversores localShortDateConverter e localCurencyConverter para os campos nascimento e gratificação.

Observe que estamos utilizando os recursos do DataBinding, vinculando cada controle ao nome do membro e definido na classe de domínio. A classe Binding está no namespace System.Windows.Data e é responsável por manter a comunicação entre a origem e o destino, expondo uma série de propriedades que nos permite customizar o comportamento dessa comunicação.

Entre as principais propriedades, temos:

• ElementName: define o nome do elemento que servirá como fonte. Utilize esta propriedade quando desejar preencher uma outra propriedade com o valor de um controle do WPF.
• Mode: determina a direção das informações.
• NotifyOnSourceUpdated: valor boleano indicando se o evento SourceUpdated é disparado quando alguma atualização na fonte das informações ocorrer.
• NotifyOnTargetUpdated: valor boleano indicando se o evento SourceUpdated é disparado quando alguma atualização no destino das informações ocorrer.
• Path: espefica o nome da propriedade que será exibida.
• RelativeSource: especifica uma fonte de forma relativa à posição do objeto atual.
• Source: define o nome do objeto que servirá como fonte. Utilize esta propriedade quando desejar preencher com uma instância de um objeto.
• XPath: a mesma finalidade da propriedade Path, mas define uma expressão XPath quando a fonte de informações for um arquivo Xml.

Dessa forma temos a interface pronto para ser usada, receber e exibir as informações de funcionários.

Acompanhe a segunda parte do artigo onde vamos implementar o código no arquivo MainPage.xaml.cs referente ao evento Click do botão Procurar Funci, que irá chamar a rotina carrega TodosFuncionarios - responsável por usar o serviço criado para obter as informações dos funcionários.

Eu sei é apenas SilverLight 4, mas eu gosto...

artigo publicado originalmente no iMasters, por José Carlos Macoratti

Neste artigo, veremos como criar novas sections customizadas. Até o momento, a solução foi testada no Visual Studio .NET 2010 e 2005 e funcionou perfeitamente. Acredito que funcione nas outras versões sem qualquer problema.

Usado para desenvolvimento:

• Visual Studio .NET 2010
• Linguagem C#.NET
• Web.config

O primeiro passo foi gerar a o website ou o projeto do tipo web. Dependendo da forma que gerar, será necessário inserir alguns dados a mais no web.config da aplicação. Com base neste artigo, você pode criar várias outras formas de desenvolvimento e customização de sectionConfigurations.

O segundo passo foi gerar uma classe .cs para configuração do arquivo. Criei a classe CustomConfiguration.cs.

Importes necessários:

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

É necessário estender a classe ConfigurationSection.

public class CustomConfiguration : ConfigurationSection
{}

O passo seguinte foi gerar duas propriedades dentro do arquivo de configuração. Os dois artigos são do tipo Int32.

    // First Number Property
    [ConfigurationProperty("firstNumber", DefaultValue=1, IsRequired=true)] 
    [IntegerValidator(MinValue=-100, MaxValue=100)]
    public Int32 FirstNumber
    {
        get
        { return (Int32)this["firstNumber"]; }
        set
        { this["firstNumber"] = value; }
    }

    // Second Number Property
    [ConfigurationProperty("secondNumber", DefaultValue=1, IsRequired=true)] 
    [IntegerValidator(MinValue=-100, MaxValue=100)]
    public Int32 SecondNumber
    {
        get
        { return (Int32)this["secondNumber"]; }
        set
        { this["secondNumber"] = value; }
    }

Gerei o construtor recebendo dois parâmetros de entrada. Um construtor vazio e outro recebendo parâmetro.

// Construtor vazio
    public CustomConfiguration()
    {
    }


   // Construtor recebendo parâmetros
    public CustomConfiguration (Int32 firstValue, Int32 secondValue)
    {
        FirstNumber = firstValue;
        SecondNumber = secondValue;
    }

O próximo passo é gerar dentro do arquivo web.config as configurações customizadas. Dentro da tag <configuration> existe <configSections> responsável para configuração da sectionGroup.

<sectionGroup name="customSection">
   <section name="settings" type="CustomConfiguration" allowLocation="true" allowDefinition="Everywhere" />
</sectionGroup>

Note que o tipo (type) é o mesmo nome da classe de configuração. O nome (name) settings é o nome que escolhi para gerar a segunda tag customizada. Se a sua aplicação estiver usando namespace, basta colocar no tipo todo o namespace até a classe.

<sectionGroup name="customSection">
   <section 
name="settings" type="MinhaAplicacao.Classe.Util,CustomConfiguration" 
allowLocation="true" allowDefinition="Everywhere" />
</sectionGroup>

Depois de fechar a tag </configSections>, é necessário inserir a outra customizada com os valores e as duas propriedades.

<customSection>
 <settings firstNumber="20"secondNumber="43" />
</customSection>

Note que a sessão customizada possui os mesmos nomes colocados na primeira tag. O nome customSection foi gerado na segunda tag XML e assim por diante. As duas propriedades firstNumber e secondNumber possuem valores do tipo inteiro na segunda tag XML adicionada.

<configSections>
  <sectionGroup name="customSection">
   
 <section name="settings" type=" 
MinhaAplicacao.Classe.Util.CustomConfiguration, MinhaAplicacao" 
allowLocation="true" allowDefinition="Everywhere" />
  </sectionGroup>
</configSections>

Dessa maneira, a classe de leitura foi feita e o arquivo config gerado, basta agora mostrar como é feita a leitura desses valores. Para ler o arquivo, basta colocar o código abaixo:

CustomConfiguration config = (CustomConfiguration)System.Configuration.ConfigurationManager.GetSection("customSection/settings");

Essa linha de código pode ser colocada no seu Page_Load sem qualquer problema.

O GetSection("customSection/settings"); busca diretamente as tags com esse nome. Fica simples, depois basta pegar as propriedades.

Colocando a instância e ponto aparece o nome da propriedade.

Int32 primeiro = config.FirstNumber 
Int32 segundo = config.SecondNumber

Somando os valores, veja o resultado:

Até a próxima!

Você pode criar aplicações WPF usando as seguintes ferramentas:

• Visual Studio 2010 (pode baixar uma versão trial)
• Visual C# 2010 Express Edition (grátis)
• Visual Basic 2010 Express Edition (grátis)
• SharpDevelop 4.0 (grátis)

Pela sua simplicidade o projeto poderá ser aberto em qualquer uma das versões citadas. A linguagem escolhida poderia ser C# ou VB .NET, pois o código também é bem simples, mas usaremos o SharpDevelop justamente para mostrar que podemos usar o recurso de converter o código para C# ou VB .NET.

Agora abra o SharpDevelop 4.0 e no menu File selecione New -> Solution:

Na janela New Project , observe as opções oferecidas. Vamos selecionar a linguagem C# e o item WPF e em Templates selecionar WPF Application. Em seguida, vamos informar o nome WPF_Menu_c e clicar no botão Create.

Será criada a solução, e em uma das suas visões, selecionando a aba Projects veremos a estrutura da solução. Selecionando a guia Source, veremos a janela Window1.xam.

Agora clique sobre o arquivo Window1.xaml.cs para ver o código:

Vamos incluir a rotina criarMenu(), depois definir o seu código para criar um menu Arquivo com duas opções: Abrir e Sair.

private void criarMenu()
        {
            // cria o menu principal.
            Menu mainMenu = new Menu();
            contentGrid.Children.Add(mainMenu);
            mainMenu.HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch;
            mainMenu.VerticalAlignment = System.Windows.VerticalAlignment.Top;

            // Cria o menu de Arquivo
            MenuItem fileMenuItem = new MenuItem();
            fileMenuItem.Header = "_Arquivo";
            mainMenu.Items.Add(fileMenuItem);

            // Cria os itens do menu Arquivo: Abrir
            MenuItem openMenuItem = new MenuItem();
            fileMenuItem.Items.Add(openMenuItem);
            openMenuItem.Header = "_Abrir";
            openMenuItem.Click += openMenuItem_Click;
            ToolTip openToolTip = new ToolTip();
            openMenuItem.ToolTip = openToolTip;
            openToolTip.Content ="Abrir um novo Arquivo";

            //cria o item Sair
            MenuItem exitMenuItem = new MenuItem();
            fileMenuItem.Items.Add(exitMenuItem);
            exitMenuItem.Header = "S_air";
            exitMenuItem.Click += exitMenuItem_Click;
            ToolTip exitToolTip = new ToolTip();
            exitMenuItem.ToolTip = exitToolTip;
            exitToolTip.Content = "Encerrar";
        }
        private void openMenuItem_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Abrir um novo arquivo");
        }
        private void exitMenuItem_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Até logo!");
            this.Close();
        }

Agora é só alegria! Executando o projeto iremos obter:

Simples né?

Agora vamos converter o código do projeto que foi feito na linguagem C# para a linguagem VB .NET. Selecione o arquivo Window1.xaml.cs e no menu Project selecione Convert -> From C# to VB .NET.

Será criado um novo projeto na solução, já convertido para a linguagem VB .NET conforme figura abaixo:

Simples assim!

O projeto completo disponível aqui: WPF_Menu_c.zip

No próximo artigo veremos como criar menus em tempo de projeto!  Eu sei, é apenas WPF, mas eu gosto!

Entretanto, construir bons softwares (e bons programadores sabem disso) requer uma série de características do desenvolvedores. E, a principal delas é o cuidado com a arquitetura.

Se você é o tipo de desenvolvedor que não se preocupa com a escrita de testes unitários, design pattern, inversão de controle, etc., aqui vai um conselho: ou começa a se preocupar com isso, ou seus sistemas tornar-se-ão legados prematuramente.

É bem verdade que seja possível escrever aplicações com a ausência de tais conceitos, entretanto, a reflexão que o desenvolvedor deve realizar aqui é "este software, está bem escrito? A manutenibilidade, é boa? É extensível? É testável?"

Se suas respostas às perguntas acima forem: não, não, não e não, será preciso repensar a maneira como você escreve suas aplicações.

No artigo de hoje, veremos um destes conceitos fundamentais para a escrita de aplicações bem elaboradas: o conceito de injeção de dependência. E nesta primeira parte, implementaremos a DI (Dependency Injection) de forma manual, e logo depois utilizaremos uma ferramenta para sua implementação.

O que é injeção de dependência?

Trata-se de um design pattern que consiste na passagem de uma classe para outra, sendo que esta última irá utilizá-la (consumí-la), visando eliminar o forte acoplamento geralmente existente entre os módulos da aplicação. Para que essa ideia fique um pouco mais clara, considere a situação proposta logo abaixo:

A figura acima apresenta uma situação hipotética, onde um módulo para o gerenciamento de downloads existe. Para este exemplo, estamos propondo três camadas (classes com naturezas diferentes):

• clsDown (uma camada de nível mais alto), 
• clsDownBusiness (camada onde são implementadas as regras de negócios da aplicação),
• clsDownData (camada mais baixa de acesso a dados).

Note que para que uma instância da classe clsDown exista, é fundamental que a classe clsDownBusiness também exista. E para que esta última exista, clsDownData também precisa existir. Portanto, a dependência entre as camadas está apresentada. Mas a pergunta aqui é "qual o problema desta abordagem?"

A problemática implícita (motivação para implementação da ID)

A característica de "dependência" mencionada acima, onde uma classe concreta (de objetos reais) depende diretamente de outra é uma relação desinteressante do ponto de vista da arquitetura do software. Isso se deve há alguns motivos, dentro os quais podemos destacar os dois mais importantes:

• Testabilidade: escrever testes unitários para aplicações é uma prática extremamente recomendável, e, para que esta possa ser realizada com sucesso, as classes e métodos necessitam ser definidas de forma isolada. Testar classes com dependencia(s) direta(s) de outra(s) é uma prática praticamente impossível de ser realizada com sucesso.
• Extensibilidade: a correta aplicação da injeção de dependência resulta em módulos "plugáveis", extensíveis. Isto é, módulos podem ser utilizados por outras aplicações sem que estas sintam o impacto da "herança".

Injeção de dependência: alguns conceitos fundamentais

Basicamente, a injeção de dependência pode ser implementada de três formas:

• Construtor: as dependências do objeto são injetadas diretamente em seu construtor. Vale salientar que, esta abordagem deve ser adotada quando se pretende injetar todas as dependências externas.
• Propriedade: dependências do objeto são injetadas via setter em alguma(s) propriedade(s).
• Interface: o objeto a ser injetado oferece fornece uma abstração de seus serviços (na forma interface ou mesmo classe abstrata), sendo que a injeção é realizada via instância da abstração.

Não existe uma regra geral que defina qual a melhor abordagem dentre as três mencionadas. Como quase tudo em computação dependerá da situação problema, a injeção de dependência via construtor é mais comumente encontrada nas aplicações.

Obs.: Vinicius Quaiato escreveu um bom artigo em seu blog sobre a definição da melhor abordagem. E você pode efetuar a leitura deste artigo aqui.

Existem diversos frameworks para implementação de injeção de depencia em uma aplicação .NET, sendo que o mais famoso deles é o Unity. Por ora, implementaremos a injeção de dependência de forma manual, depois implementaremos ID utilizando o Unity. Dessa forma você poderá mensurar qual a melhor abordagem e qual se adequa mais a seu contexto.

Implementando injeção de dependência

Para que possamos entender de fato este conceito, utilizaremos a situação problema proposta pela figura citada logo acima. Temos um objeto "clsDown" que, para que possa existir, depende do objeto "clsDownBusiness" que, por dua vez depende do objeto "clsDownData".

Temos objeto "clsDown" que pode ser entendido neste caso como uma camada de visualização. Para que os dados sejam exibidos corretamente, a lógica foi implementada no objeto "clsDownBusiness". E para que a lógica  possa funcionar corretamente, o objeto "clsDownData" cuida do acesso a dados.

Assim, considere o trecho de código apresentado Listagem 1:

namespace InjecaoDependencia_1.Controllers
{
    public class clsDownController : Controller
    {
        public ActionResult NovoDownload(Download objDown)
        {
            var objDownBusiness = new clsDownBusiness();
            objDownBusiness.SalvarDownloadBD(objDown);
            return View();
        }
    }
}

public class clsDownBusiness
{
    public void SalvarDownloadBD(Download objDown)
    {
        var objDownData = new clsDownData();
        objDownData.ConexaoBanco();

        //Salva no BD
    }
}

public class clsDownData
{
    public void ConexaoBanco()
    {
        //Conecta no banco de dados
    }
}

public class Download
{
    //Definição de download
}

Em uma rápida observação do código apresentado pela listagem acima é possível ver as relações de dependência entre os objetos.

Note que a action "NovoDownload" precisa utilizar do objeto "objDownBusiness", que é do tipo "clsDownBusiness" e, esta última, precisa da informação de conexão com o banco de dados, que é provida pelo objeto "objDownData", que é do tipo "clsDownData".

Para que possamos implementar o mecanismo de injeção de dependência, vamos criar abstrações (interfaces) onde as dependências existem. No caso, a abstração ocorre para o objeto que será "injetado". Assim, a dependência entre "clsDown" e "clsDownBusiness" será realizada através de uma interface, chamada por nós de "IDownBusiness". Assim, temos nossa arquitetura um pouco modificada.

A Listagem 2 apresenta o código sugestivo para "IDownBusiness", a Listagem 3 apresenta o código sugestivo para "IDownData" e a Listagem 4 apresenta a estrutura da aplicação modificada.

public interface IDownBusiness
{
    public void SalvarDownloadBD(Download objDown);
}

Listagem 2: Código sugestivo para "IDownBusiness"

public interface IDownData
{
    public bool ConexaoBanco();
}

Listagem 3: Código sugestivo para "IDownData"

public class clsDownController : Controller
{
    private IDownBusiness iObjDownBusiness;

    public clsDownController(IDownBusiness _iObjDownBusiness)
    {
        this.iObjDownBusiness = _iObjDownBusiness;
    }

    public ActionResult NovoDownload(Download objDown)
    {
        iObjDownBusiness.SalvarDownloadBD(objDown);
        return View();
    }
}

public class clsDownBusiness : IDownBusiness
{
    private IDownData iObjDownData;

    public clsDownBusiness(IDownData _iObjDownData)
    {
        this.iObjDownData = _iObjDownData;
    }

    public void SalvarDownloadBD(Download objDown)
    {
        iObjDownData.ConexaoBanco();

        //Salva no BD
    }
}

public class clsDownData : IDownData
{
    public void ConexaoBanco()
    {
        //Conecta no banco de dados
    }
}

Listagem 4: "Injetando dependência" em nossos objetos de forma indireta "IDownData"

Nas Listagens 2, 3 e 4 tivemos a inserção de todos os conceitos importantes neste artigo:

• Listagem 2: criamos uma abstração (interface) do objeto a ser injetado em "clsDown" e, dentro dela, assinamos o método "SalvarDownloadBD".
• Listagem 3: criamos uma abstração (interface) do objeto a ser injetado em "clsDownBusiness" e dentro dela assinamos o método "ConexaoBanco".
• Listagem 4: em função da implementação das abstrações, temos agora que "injetar" a dependência destas nas classes que as consomem. O primeiro aspecto a ser notado é: as classes "clsDownBusiness" e "clsDownData" implementam as interfaces "IDownBusiness" e "IDownData" respectivamente. Isso pode ser observado nas linhas 17 e 34. Outra observação importante é que: a classe "clsDown" espera um objeto qualquer que implemente a interface "IDownBusiness", por inércia, temos a dependência direta com classe "clsDownBusiness" quebrada. O mesmo se repete em relação as classes "clsDownBusiness" e "clsDownData". Estas situações podem ser observadas nas linhas 3, 5, 6, 7, 19, 21, 22 e 23.

Nossa injeção de dependência foi realizada. Um próximo passo poderia ser a utilização de Abstract Factory, por exemplo, para centralizar todas as dependências. Como o foco deste texto consiste apenas na apresentação dos conceitos de injeção de dependência, ficamos por aqui.

Até a próxima! E não esqueça de deixar seu feedback através dos comentários.