novembro

2013
novembro
2013
 04 05
Criando aplicações com
o Ribbon
Editorial Autor: Luciano Pimenta

08
TFileHV:
Gerenciamento Básico de Arquivos – Parte 2

Autor: Hamden Vogel

13
Desenvolva uma Aplicação
Desktop em C# e MySQL –
Parte 4

Índice Autor: João Marcos Sakalauska

20 27
Criando fomulário de SoapUI
layout padrão - Delphi 7 Ferramenta para Open
Source para consumir
Web Services

Autor: Lucas Vieira de Oliveira Autor: Thiago C.

Montebugnoli

03
novembro
2013
Editorial
Olá amigos do The Club, é sempre com muita satisfação e alegria que
preparamos mais uma revista recheada de assuntos interessantes aos
Av. Profº Celso Ferreira da Silva, 190
Jd. Europa - Avaré - SP - CEP 18.707-150
Informações e Suporte: (14) 3732-1529

Internet
http://www.theclub.com.br
Cadastro: cadastro@theclub.com.br
Suporte: suporte@theclub.com.br
senhores. Começando com nosso consultor técnico Lucas de Oliveira, que Informações: info@theclub.com.br
Skype Cadastro: theclub_cadastro
aborda um assunto de grande utilidade no desenvolvimento de aplicações Skype Suporte: theclub_linha1
theclub_linha2
Desktop, como devemos criar um Formulário de Layout Base utilizando o theclub_linha3

Delphi 7, podendo ser englobada em todas as versões do Delphi. Hamden

Vogel finaliza o artigo “TFileHV – Gerenciamento Básico de Arquivos”. Um
dos tópicos desta segunda parte ele nos ensina a realizar uma Conexão com www.twitter.com/theclubbr
o servidor FTP via “TFileHV”, muito útil para quem necessita deste recurso
em seus programas. Nosso colaborador Luciano Pimenta utiliza o Ribbon, um
estilo incorporado pela Microsoft na suíte Office desde versões anteriores
do Delphi. Este recurso nos permite incorporar estilos elegantes e diferentes
em suas aplicações. João Marcos Sakalauska finaliza sua série de artigos de
desenvolvimento de uma aplicação Desktop em C# junto com o Banco de Copyright The Club 2013

Dados Mysql. Nesta quarta parte ele disponibiliza a aplicação completa para Diretor Técnico
download para quem deseja aprender um pouco mais sobre esta tecnologia. Marcos César Silva

Para Finalizar nossa série de artigos, apresento uma ferramenta Freeware Diagramação
Vitor M. Rodrigues
chamada “SoapUI”, muito indicada para Consumir e testar diversos tipos
Design
de Web Services. Vitor M. Rodrigues

Revisão
Fiquem a vontade para nos dar sugestões de artigos e dicas para artigos Drielly Cristini Patrinhani

futuros. Colunistas
Hamden Vogel
Jeferson Silva de Lima
Luciano Pimenta
Thiago Cavalheiro Montebugnoli
Vou Ficando por aqui, um forte abraço e até o mês que vem!
Juninho
Jeferson Silva de Lima

Impressão e acabamento:
GRIL - Gráfica e Editora
Taquarituba-SP - Tel. (14) 3762-1345

Reprodução
A utilização, reprodução, apropriação, armazenamento em banco
de dados, sob qualquer forma ou meio, de textos, fotos e outras
criações intelectuais em cada publicação da revista “The Club
Megazine” são terminantemente proibidos sem autorização
escrita dos titulares dos direitos autorais.

Thiago Montebugnoli - Editor Chefe

thiago@theclub.com.br Delphi é marca registrada da Borland International,
as demais marcas citadas são registradas
pelos seus respectivos proprietários.

04
novembro
2013
Criando aplicações com
o Ribbon
R
ibbon é um estilo incorporado pela Microsoft na suíte Office
a partir da versão 2007. A ideia era agrupar várias funciona-
lidades em uma mesma barra de ferramenta para facilitar a
vida do usuário. Além disso, possui um menu para concentrar
as funcionalidades mais acessadas da aplicação.

O Delphi possui suporte ao Ribbon a partir da versão 2009. Vou mostrar

neste artigo como usar das facilidades do Ribbon no Delphi. Veja na Figura 1
os controles que compõem a paleta Ribbon Controls da Tool Palete.

Figura 2. Ribbon adicionado no formulário

Para criar um grupo (RibbonPage), basta clicar com o botão direito e esco-
lher Add Tab. Na aba, temos as propriedades para sua configuração (Caption,
Hint etc), semelhante ao TabSheet do PageControl. Dentro da aba, podemos
adicionar os grupos (RibbonGroup), para isso, clique com o botão direito e
escolha Add Group.

Dentro desses grupos, teremos os itens (botões) que vamos usar. Agora,
precisamos configurar as actions do ActionManager. Dê um duplo clique no
ActionManager e acesse a aba Actions (Figura 3).

Figura 1. Ribbon Controls

Crie um novo projeto VCL. O trabalho principal esta concentrado no

ActionManager, que irá disponibilizar as ações (itens), para adicionarmos no
Ribbon. Adicione o controle em tela, assim como um ImageList. Escolha as
imagens de sua preferencia.

Configure o ImageList com a propriedade Images do ActionManager.

Adicione um Ribbon ao formulário (Figura 2).
Figura 3. Editor de actions no ActionManager

05
novembro
2013
 Para quem já trabalhou com ActionList, a tela é bastante familiar. Após,
vamos configurar essas actions para o Ribbon. Acesse a propriedade ActionBars
do ActionManager e adicione um ActionBarItem. No ActionBarItem, vamos
vincular com cada grupo que criamos anteriormente, ou seja, cada grupo terá
um ActionBarItem vinculado.
Acesse a propriedade Items do ActionBarItem e para cada item que deseja
adicionar, você pode vincular para com uma ação (propriedade Action). Pronto,
cada item (action) deve ser colocado em um grupo (ActioBarItem) e um ou
mais grupos podem estar dentro de um aba (RibbonPage). Veja na Figura 4.
Configurando controles
Para criar um CheckBox ou RadioButton, basta escolher a opção no Com-
mandStyle. Caso deseje criar um Combobox, arraste um RibbonComboBox da
Tool Palette para dentro de um grupo. Preenche o combo, usando a proprie-
dades Items do controle recém adicionado.
Veja na Figura 5 um Ribbon contendo botões, CheckBox, RadioButton,
menus e ComboBox.

Figura 5. Várias possibilidades do Ribbon

Figura 4. Ribbon configurado Usamos a mesma facilidade para usarmos o SpinEdit. Basta adicionar um
RibbonSpinEdit diretamente no grupo.
Podemos adicionar Action pré-definidas, basta clicar na propriedade
Action e escolher New Standar Action, onde temos uma lista das actions que
podemos configurar para o item. Menu de acesso rápido

Como comentei anteriormente, o Ribbon trouxe a funcionalidade de

Nota: Caso a imagem não fique proporcional no botão (isso depen-
de do tamanho da imagem usada), altere para bsLarge a propriedade
CommandProperties>ButtonSize.
um menu com acesso rápido a documentos adicionados, funcionalidades de
impressão, salvar etc. Clique com o botão direito no Ribbon e escolha Add Ap-
plication Menu. Será adicionado um botão na parte superior esquerda das abas.
Ao clicar nele (mesmo em tempo de design) um menu é mostrado. Podemos
adicionar funcionalidades nesse menu, acessando a propriedade OptionsItems.

Cada item representa uma Action e cada item adicionado será mostrado
na parte inferior do menu do Application Menu (Figura 6). Ideal para comandos
de fechar a aplicação, configurações etc.
Controles no Ribbon

A propriedade CommandProperties do ActionClientItem (o botão adicio-

nado com o Action), possui muitas sub-propriedades interessantes para sua
configuração. ButtonSize indica o tamanho do botão. Em ButtonType temos
as seguintes opções:

• btNone: botão normal;

• btDropDow: uma seta indica que temos um menu ao clicar no botão
(para configurar os itens do menu, acesse a propriedade Items e adicione os
menus que deseja);
• btGallery: exibe uma galeria suspensa; Figura 6. Adicionando botões no menu
• btSplit: Uma seta indica um menu, mas o botão também possui a
funcionalidade em seu clique. Para adicionar itens no menu, clique no botão e acesse a propriedade
Items. Para cada funcionalidade adicione um item, atribuindo uma Action
Outra propriedade interessante é o CommandStyle onde podemos mudar (semelhante ao que fizemos com os itens dos grupos do Ribbon). Veja na
o botão para um CheckBox, RadioButton, ComboBox por exemplo. Figura 7, o itens adicionados ao menu.

06
novembro
2013
 Para adicionar itens, acesse a propriedade ActionBars do ActionManager.
No editor, selecione o ActionBar do Quick Access Tolbar. Na propriedade Items,
adicionamos os itens que queremos. Veja o resultado na Figura 9.

Figura 7. Itens no Application Menu do Ribbon

Para alterar o ícone, clique no Ribbon e acesse a propriedade

ApplicationMenu>Icon. Agora, vamos adicionar um menu de acesso rápido.
Clique com o botão direito no Ribbon e escolha Add Quick Access Toolbar.
Será adicionado um controle ao lado do botão. Se rodar a aplicação, teremos
algumas configurações do próprio Ribbon (Figura 8). Figura 9. Ribbon configurado com a Quick Access Toolbar

Conclusões

Vimos nessa dica rápida, como usar o Ribbon para criar aplicações com
visual moderno, com o Delphi. Já tive a experiência de usar o controle em uma
aplicação e o resultado foi muito bom, sendo que o usuário da aplicação achou
o visual mais limpo e organizado.

Um grande abraço a todos e até a próxima!

Figura 8. Menu de acesso rápido

Nota: o ActionManager possui quatro propriedades para imagens

(DisabledImages, Images, LargeDisabledImages e LargeImages). Para
que possamos trabalhar com imagens pequenas e grandes, temos que
configurar as quatro propriedades (usando o mesmo índice para a ima-
gem nos quatro ImageLists). Para mostrar a imagem grande, usamos a
propriedade CommandProperties>ButtonSize.

Sobre o autor
Luciano Pimenta
Luciano Pimenta (NOVO DOMINIO: www.lucianopimenta.com) é desenvolvedor Delphi/C#
para aplicações Web com ASP.NET, Windows com Win32 e Windows Forms com .NET. Palestrante
da 4ª edição da Borland Conference (BorCon) e da 1ª Delphi Conference.
É MVP Embarcadero, grupo de profissionais que ajudam a divulgar o Delphi no mundo.
Atualmente é desenvolvedor da SoftDesign fábrica de softwares em Porto Alegre-RS.
Autor de mais de 90 artigos e de mais de 600 vídeos aulas publicadas em revistas e sites
especializados, além de treinamentos presenciais e multimídias. É consultor da FP2 Tecnologia
(www.fp2.com.br) onde ministra cursos de programação e banco de dados.

www.lucianopimenta.net

07
novembro
2013
TFileHV - Gerenciamento
Básico de Arquivos Parte 2

N
o capítulo anterior, vimos a primeira utilização prática do
componente, que é a procura automática de arquivos e Text;
procura por strings de dentro deles; vimos também que FTPPort :=
ele retorna as linhas das ocorrências encontradas e quando StrToIntDef(edtPort.Text, 21);
clicado em um TListView associado a ele, é mostrada uma
Result := LoadFTP;
tela dinâmica com o arquivo-texto carregado mais a linha selecionada contendo
end;
a string procurada.

Além disso, foi explicado sobre o processo de anexação de arquivos (basi-

camente a utilização de um arquivo de recursos para ser associado juntamente
Olhando para dentro da função LoadFTP, ele vai chamar internamente uma
com a aplicação) podendo ser também extraído para os arquivos originais. Todo
instância privada de TIdFTP (pacote Indy da Borland) , em que é primeiramente
processo é dinâmico e embutido dentro do componente, até a compilação pelo
criado; se já criado ele é desconectado para ser conectado novamente.
Delphi em linha de comando sem precisar de instalá-lo.

Agora, vem a segunda parte, que é sobre o tema FTP e versionamento

automático de arquivos. Código Fonte da função LoadFTP

function TFileHV.LoadFTP:
Começando pelo começo: Conectando o Servidor FTP pelo Boolean;
TFileHV begin
if (fHost = ‘’) or (fUserName
Conectar um Servidor FTP pelo componente é tão fácil quanto conectar = ‘’) or (fPassWord = ‘’) then
manualmente (sem o componente), mas o componente oferece outros recursos begin
de conexão embutidos através da função booleana LoadFTP. Basicamente a Result := False;
maneira mais prática é passando diretamente os parâmetros para o compo- Exit;
nente. Um exemplo segue abaixo (também disponível ele e os outros demais end;
do escopo deste artigo para download):
Result := True;
if not Assigned(tempFTP) then
Exemplo de Conexão com o servidor FTP via TFileHV.
tempFTP := TIdFTP.
with FileHV1 do Create(Self)
begin else
FTPHost := edtHost.Text; tempFTP.Disconnect;
FTPUserName := edtUserName.
Text; tempFTP.Host := fHost;
FTPPassWord := edtPassword. tempFTP.Username :=

08
novembro
2013
 Portanto, o Versionamento vai consistir para o histórico apenas um mesmo
fUserName; nome de arquivo e suas versões correspondentes. E todo arquivo será zipado
tempFTP.Password := no servidor (utilizando-se a biblioteca ZLB para compactação/descompactação
fPassWord; de arquivos) - esse processo de compactação será feito somente para armaze-
tempFTP.Port := fPort; namento de um arquivo novo, enquanto o de descompactação será feito toda
try vez em que for visualizar um arquivo (deve-se fazer download, descompactar e
finalmente visualizar) e comparar versões quando no momento de armazená-lo
tempFTP.Connect;
(conforme já explicado acima).
except
Result := False; Após subido o arquivo, ele será compactado e consequentemente terá sua
tempFTP.Disconnect; extensão renomeada para “zip”, e a novidade é que terá um prefixo com um
FreeAndNil(tempFTP); hífen, para indicar a ordem do versionamento (e é assim que o componente
end; identifica a ordem cronológica do versionamento), por exemplo:
end;

Exemplo de padronização de nomes de arquivos

Código-Fonte da função LoadFTP, utilizada em todas as conexões com o Arquivo: “teste.txt”

Servidor FTP feitas pelo nosso componente. Histórico: “1-teste.zip”;
“2-teste.zip”,
“3-teste.zip”,
Conectei-me. E agora, o que podemos usufruir de bom do etc.
Componente?

O melhor está por vir: o componente e seu tema central deste artigo Arquivo: “Faturamento.pdf”
explorará o processo de versionamento de arquivos, histórico de versões, Histórico: “1-Faturamento.zip”;
upload, download (que equivale a visualização do mesmo), exclusão, exclu- “2-Faturamento.zip”;
são/visualização automática da última versão, renomear arquivos, etc, tudo “3-Faturamento.zip”,
isso providenciado pelo próprio componente - não será necessário escrever etc.
código-fonte para todas essas operações, bastando-se apenas suas chamadas
de funções que são em grande maioria de uma a duas linhas de código no
máximo. Isso não chega a ser prático? Exemplo de padronização de nomes de arquivos utilizados no processo
de versionamento de arquivos do TFileHV.

Versionamento A função para retornar sempre a última versão de um arquivo é comple-

O processo de Versionamento do componente é um tanto complexo;
existem muitas operações embutidas; primeiramente o arquivo é subido para
o Servidor. Quando o próximo for subido, o componente verifica se já existe
uma primeira versão deste arquivo - e se existir, ele vai comparar se a versão do
arquivo que está sendo subido é superior à última versão que está no Servidor
(através da data de modificação de ambos os arquivos) - e no caso do Servidor
possuir a última versão desta comparação, vai confirmar ao usuário se deseja
realmente subir assim mesmo - se sim, sobe e o processo é concluído com
sucesso - se não, o caso de uso deste processo é encerrado.
xa: envolvendo um TClientDataSet para guardar temporariamente todos os
arquivos que satisfaçam à procura pelo parâmetro do arquivo a ser pesqui-
sado (sempre o nome do arquivo, retirando o prefixo numérico mais o hífen
e a extensão “zip”). O papel fundamental do TClientDataSet é obter a última
versão do arquivo, guardando todas as ocorrências de DirectoryListing.Items[i].
ModifiedDate (da classe TIdFTPListItem, descendente de um TCollectionItem
que implementa métodos e propriedades utilizadas em arquivos no FTP) - em
um campo agregado criado dinamicamente (assim como todo o TClientDa-
taSet) chamado MODIFIEDDATE do tipo Data/Hora; um pequeno trecho do
fonte segue abaixo:

O outro aspecto deste processo é como ele armazena os arquivos. O

componente consegue reconhecer sozinho todo um histórico de um mesmo Código Fonte
arquivo, sem a necessidade de se recorrer à uma tabela de algum banco de
dados para obter essa informação: temos muito mais vantagens que desvanta- with tempClientDataSet.
gens neste processo; as vantagens são a eficiência e rapidez (pelo motivo citado Aggregates.Add do
anteriormente de não se recorrer a banco de dados), praticidade, possibilidade begin
de extensão do algoritmo, fácil recuperação de arquivos e fácil customização Expression :=
dos diretórios-raízes do processo. As desvantagens: o nome do arquivo precisa ‘MAX(MODIFIEDDATE)’;
ser único (pelo fato do mesmo ser utilizado neste processo como identificador
AggregateName := ‘MaxData’;
exclusivo - semelhante a uma chave primária de uma tabela); a outra desvanta-
Active := True;
gem é que não há logs ou registros de transações - pelo menos nesta primeira
versão esse requisito não está implementado. end;

09
novembro
2013
 Trecho da criação do campo agregado MODIFIEDDATE, que tem o papel
de retornar o último registro (mais recente) de Data/Hora em que o arquivo
foi subido no Servidor FTP.

Figura 11 - Programa Demo mostrando o TFileHV interagindo com o ListView e

exibindo em um combobox os arquivos versionados armazenados no Servidor.

Uma última consideração sobre o versionamento é a criação de diretórios

no Servidor - o componente criará todos os diretórios embaixo de um diretório-
-base (pai), sendo que todos os demais serão seus subdiretórios. A propriedade
FTPDefaultFolder (default “Sources”) contém o nome do diretório pai, em que
no nosso caso nada mais é que um “agrupador” de todos os diretórios criados
pelo TFileHV. E quando e como esses diretórios são criados? Toda vez que um
arquivo for armazenado, o componente pegará o primeiro diretório do caminho
em que ele se encontrava no momento de sua solicitação de armazenagem
para o componente. Exemplificando, se o arquivo “teste.txt” está no caminho
“c:\Daniel\Documentos\teste.txt” o diretório a ser criado será “Daniel”, que
será o subdiretório debaixo do diretório-pai definido na propriedade FTPDe-
faultFolder, conforme explicado anteriormente.

Figura 12 - Continuação do Demo, exibindo o histórico de um arquivo em um Lis-

Figura 10 - Fluxograma do processo de Versionamento de Arquivos pelo compo-
tView associado ao TFileHV. Note que a maioria dos dados retornados também podem
nente TFileHV.
ser obtidos por qualquer método que dê suporte a TStrings (um memo, listbox, etc).

10
novembro
2013
 Obtendo a Última Versão do Arquivo Código Fonte

Ao solicitar ao componente para obter a última versão de um arquivo, ou If not FileHV1.GetInfoFile(‘c:\

mesmo para simplesmente visualizar qualquer versão do mesmo, será exibida fontes\TIdFTP-Teste\teste.txt’)
uma tela para que seja informado o caminho de onde será “baixado” o arquivo then Exit;
do Servidor, de acordo com a seguinte figura abaixo:

Com isso o caminho do documento é passado e tratado pelas variáveis

internas do componente, para obter a primeira pasta deste caminho, verificar
se o caminho informado é inválido, etc.

Última consideração sobre os métodos RenameFTPFile e DeleteFTPFile:

Através das funções RenameFTPFile e DeleteFTPFile, o componente pode
renomear e deletar um arquivo versionado, respectivamente. Para isso basta
chamar os métodos correspondentes, em apenas uma linha de código. Segue
exemplos abaixo:

Código Fonte

//renomear arquivos:
//modo 1:
//FileHV1.
RenameFTPFile(‘Fontes\100-
teste.zip’, ‘12-teste.zip’);
//modo 2:
Figura 13 - Tela de Informação do Caminho onde será efetuado o download do // FileHV1.RenameFTPFile(‘3-
arquivo para a sua visualização. teste.zip’, ‘333-teste.zip’);
//deletar arquivos:
Ambos os métodos DownloadLastVersion e DeleteLastVersion chamam a //modo 1:
função GetLastFileVersion para retornar a última versão de um arquivo. Graças //FileHV1.
ao método ModifiedDate de DirectoryListing.Items[i] (da classe TIdFTPListItem) DeleteFTPFile(‘Fontes\1-teste.
explicado anteriormente é possível descobrir o último arquivo daquela versão zip’);
que foi inserido no servidor: é só buscar a sua data/hora de inclusão e com //modo 2:
a ajuda de um campo agregado do tipo data/hora de um ClientDataSet fazer // FileHV1.
um “max” em seus registros para obter a última data/hora de um registro. DeleteFTPFile(CbFiles.Items.
Basicamente é isso: filtra-se o arquivo e sua última data/hora de inclusão Strings[CbFiles.itemIndex]);
no servidor, por exemplo: tempClientDataSet.Filter := ‘MODIFIEDDATE = ‘
+ QuotedStr(tempClientDataSet.Aggregates.Find(‘MaxData’).Value); onde
MaxData é o nome do nosso campo agregado criado em run-time para esta
finalidade. Explicação: o modo 1 acima citado realizará a operação diretamente
no diretório especificado. Se o diretório não existir, a operação falha. Do outro
lado, se o diretório não é fornecido, então o componente percorrerá a nossa
Como obter dados a pesquisar de um arquivo: Método Ge- estrutura de diretórios criados (abaixo do diretório-pai) para localizar o arquivo
tInfoFile em ação: citado, e se encontrado, efetuará a operação solicitada. Vale ressaltar que o
componente não percorrerá todo o FTP, e sim apenas nos diretórios criados
GetInfoFile é uma função booleana com dois parâmetros (assinatura: pelo componente explicados anteriormente.
function TFileHV.GetInfoFile(const myFullPathFile: string = ‘’): Boolean) - se
a constante myFullPathFile não for preenchida, então presume-se que você
deverá informá-la seu caminho completo, e para isso será criado um TOpen- Conclusão
Dialog para que o usuário especifique o caminho do documento; do outro lado
o programa pode fornecer diretamente o caminho via parâmetro, como em Primeiramente discorremos sobre a eficiência e a praticidade de procurar
arquivos, strings dentro de arquivos, exibir a linha selecionada de um arquivo,

11
novembro
2013
manipulação de arquivos, etc, de uma forma mais automatizada pelo compo-
nente, economizando várias (dezenas) de linhas de código-fonte necessárias
para obtenção do mesmo resultado se feito fora do componente; além de mos-
trar uma forma personalizada de anexação e extração de arquivos, acionando
externamente o compilador do Delphi sem a necessidade de instalá-lo; técnicas
avançadas com o ListView (evento duplo-clique avançado, criação e manipu-
lação dinâmica, etc) e com o ClientDataSet (operações utilizando TFileStream,
TBlobField para armazenamento de arquivos, criação de campos agregados
e índices dinamicamente, criação e destruição de colunas automática, etc).
a grande maioria das funções podem ser acessadas a partir de um TStrings,
disponíveis para um Memo, Listbox, etc;
Portanto, foram explicadas todas as funcionalidades desta corrente versão
do TFileHV; na minha página pessoal está disponível sempre a nova versão do
mesmo. Dicas, críticas e sugestões também são bem-vindos. O código-fonte do
componente e os programas Demo também estão disponíveis para download.

Também vimos uma forma alternativa, prática e eficiente de versionamen-

to de arquivos feito inteiramente pelo componente, podendo ser parametrizada
muitas opções de diretórios, arquivos, etc. Podem ser versionados quantos Sobre o autor
arquivos forem necessários, de qualquer extensão, de qualquer tamanho e
de qualquer diretório, sendo todos compactados para ganhar mais espaço. Hamden Vogel
O bom é que tudo está embutido de dentro do componente, guardando por
Analista de Sistemas pós-graduado em Engenharia de Software pela
sua conta a relação de histórico para cada arquivo versionado, oferecendo UPIS e Programador Delphi com larga experiência desde 2000, tem de-
praticidade em vários processos padronizados e facilmente customizados, senvolvido e vendido softwares em Delphi para a África e Estados Unidos,
além do mercado nacional. Colaborou com dicas e componentes para sites
podendo ser estendidos para aperfeiçoá-los através do código-fonte disponí- especializados em Delphi. Também desenvolve em outras linguagens como
C/C++, ASP, PHP e .NET.
vel. O retorno das informações também está eficiente e intuitivo, através da
utilização personalizada e prática de um TListView, componente escolhido por
ser muito intuitivo e prático, podendo ser personalizado de várias formas de
apresentação (modos de visualização diversos - lista, detalhe, etc) - sendo que
suporte@theclub.com.br

12 novembro
2013
Desenvolva uma
Aplicação Desktop em
C# e MySQL – Parte 4
N
os artigos anteriores, iniciamos o desenvolvimento da
aplicação verificando aspectos pertinentes ao desenvolvi-
mento, mas devido a quantidade de informações, tivemos
que dividir o artigo.

Nessa última etapa, fecharemos todos os tópicos propostos na primeira

parte do artigo, explanando apenas um dos módulos da aplicação, mas não
se preocupem, a aplicação completa estará a disposição para os assinantes.

Imagem 11 – inclusão do Entity Data Model

Nota: As referências de imagens estão diretamente relacionadas a
terceira parte desse artigo, sendo assim, é necessário estar ter iniciado
o desenvolvimento da aplicação pela terceira parte.
Na janela que se abrirá você estará na etapa “ChooseModelContents”,
clique em “GeneratefromDatabase” (pois, nesse caso, já temos o modelo e
as entidades do banco serão reconhecidas automaticamente) e em seguida
clique em Next conforme imagem 12:

Continuando...

LINQ + Entity Framework na Mini Aplicação

Voltando a nossa aplicação, faremos uso desses poderosos recursos a fim

de que nossa aplicação fique enxuta e robusta, além de funcional.

Então, para começar, vá até a janela Solution Explorer, clique com o botão
direito no projeto MiniAplicacao e escolha Add -> New Item.

Na janela que se abrirá “Add New Item – MiniAplicacao” selecione a op-

ção “Data” em “InstalledTemplates” e a primeira opção “ADO.NET Entity Data
Model” e coloque o nome de MAplic.edmx conforme imagem 11. Imagem 12 – opção “GeneratefromDatabase” selecionada.

13
novembro
2013
 Na etapa “Chooseyour data Connection” clique em “New Connection”
e selecione “MySQLDatabase” e depois clique em “Continue” conforme
imagens 13 e 14:

Imagem 15 – Versão do MySQLConnector

Voltando a configuração...

Em “Connection Properties” informe os dados para acesso conforme

imagem 16.
Imagem 13 – Seleção de nova conexão clicando em “New Connection”
Server Name: LDC
User Name: root
Password: <Vazio>

Imagem 14 – Seleção do nosso Data SourceMySQLDatabase

Observação: Descobri recentemente que a versão mais atualizada

do MySQLConnector não funciona com a versão que estamos trabalhando
para esse artigo. Então, fique atento as seguinte informações para não
ter problema nessa etapa:

IDE: Visual Studio 2010

MySQL:<Indiferente>
.NET FW: 4.0
MySQLConnector: 6.6.5
Imagem 16 – Connection Properties.

Clique em “Test Connection” até mesmo para confirmar se você subiu

o serviço do MySQL corretamente e caso esteja tudo certo clique em “OK”.
Consulte a referência no seu projeto para verificar a versão, conforme
Repare que ao retornar para “Chooseyour Data Connection” o campo
imagem 15.
“Entity Connection String” estará preenchido. Aproveitando, renomeieopção

14
novembro
2013
“Save entity connection string in App.Config as:”para “MAEntities” confor-
meimagem 17. Observação: Repare que o campo “usuario” não pode ter o mesmo
nome da entidade, por isso o mesmo foi renomeado automaticamente
para “usuario1”. Isso não é impeditivo para o projeto (mesmo nesse
artigo), porém, por questões de Arquitetura e Projeto, tomem cuidado
para não cair nesse tipo de situação, pois, dependendo da complexidade
do projeto isso pode se tornar um problema sim. Imagine que você esteja
desenvolvendo um projeto complexo e seu cliente é uma SoftwareHouse.
O Responsável pode muito bem receber o código fonte e questiona-lo a
ponto de pedir que isso seja alterado e é aí que vem o pior, pois, depen-
dendo da etapa do seu projeto, o impacto poderá ser grande e custoso.

Voltando...

Com nosso modelo estabelecido, temos uma série de coisas que poderiam
ser feitas nesse arquivo EDMX para deixar nossa aplicação melhor estruturada
e modelada possível.

Imagem 17 – Nomeando a entidade após escolha do “DataSource”. Mas vamos focar no básico para que o básico seja feito da melhor forma.

Após renomear a entidade para “MAEntities” clique em “Next”. Abra a classe Usuario.cs e inclua uma variável do tipo string que servirá
para indicação da ação que será realizada (linha em Negrito).
Na etapa “ChooseyourDatabaseObjects”, selecione a opção “Tables” e
renomeie o “ModelNamespace” para “MAModel” e clique em “Finish” con-
forme imagem 18. public partial class frmUsuario
: MAAcoes
{
public string strAcao = string.
Empty;
…

Dê um duplo clique no botão “Novo” e inclua o código a seguir:

private void btnNovo_

Click(object sender, EventArgs
e)
{
this.
Imagem 18 – Renomeando ModelNamespace. AjustaCamposFormulario(this.
Controls, true);
Após concluir as configurações o Visual Studio abrirá a janela MAplic.edmx this.
mostrando as entidades do nosso banco de dados LDC conforme imagem 19. AjustaBotoesFormulario(this.
Controls, true);
this.AjustaValorCamposFormulari
o(this.Controls);
this.strAcao = “NOVO”;
}

Imagem 19 – Maplic.edmx apresentando as entidades do BD LDC. Dê um duplo clique no botão “Alterar” e inclua o código a seguir:

15
novembro
2013
 private void btnAlterar_ Text)) && (!string.
Click(object sender, EventArgs IsNullOrEmpty(txtSenha.Text)))
e) {
{ switch (this.strAcao)
this. {
AjustaCamposFormulario(this.
case “NOVO”:
Controls, true);
using (MAEntities context = new
this.
AjustaBotoesFormulario(this. MAEntities())
Controls, true); {
this.strAcao = “ALTERAR”; usuario u = new usuario();
} u.nome = txtNome.Text;
u.usuario1
= txtUsuario.Text;
u.senha = txtSenha.Text;
Dê um duplo clique no botão “Cancelar” e inclua o código a seguir: context.usuario.AddObject(u);
context.SaveChanges();
MessageBox.Show(“Informações
inseridas com sucesso.”,
privatevoidbtnCancelar_
“Aviso”, MessageBoxButtons.OK,
Click(objectsender, EventArgs
e) MessageBoxIcon.Information);
{ }
if (MessageBox.Show(“Deseja break;
cancelar a operação atual?”,
this.Text, MessageBoxButtons. case “ALTERAR”:
YesNo, MessageBoxIcon. using (MAEntities context = new
Exclamation) == DialogResult. MAEntities())
Yes) {
{ intintID = Convert.
this. ToInt32(txtID.Text);
AjustaBotoesFormulario(this.
usuario u = context.usuario.
Controls, false);
First<usuario>(pu =>pu.
this.
AjustaCamposFormulario(this. idusuario == intID);
Controls, false); u.nome = txtNome.Text;
this.AjustaValorCamposFormulari u.usuario1
o(this.Controls); = txtUsuario.Text;
} u.senha = txtSenha.Text;
} context.SaveChanges();
MessageBox.Show(“Informações
alteradas com sucesso.”,
“Aviso”, MessageBoxButtons.OK,
Dê um duplo clique no botão “Salvar” e inclua o código a seguir: MessageBoxIcon.Information);
}
break;
}
privatevoidbtnSalvar_
Click(objectsender, EventArgs
this.
e)
AjustaCamposFormulario(this.
{
Controls, false);
if ((!string.
this.
IsNullOrEmpty(txtNome.
AjustaBotoesFormulario(this.
Text)) && (!string.
Controls, false);
IsNullOrEmpty(txtUsuario.
this.AjustaValorCamposFormulari

16
novembro
2013
 o(this.Controls); o(this.Controls);
} }
else }
{ }
MessageBox.Show(“Preencha o
campos antes de Salvar “,
“Aviso”, MessageBoxButtons.OK,
Espere um pouco... Estou falando de Alteração e Exclusão, mas, não temos
MessageBoxIcon.Warning); como buscar nossos dados na aplicação, temos?
}
} Temos, temos sim e eu separei um tempo para que nossa aplicação fique
cada vez melhor.

Primeiro, crie o form de consulta que deve possuir os controles Textbox,

Dê um duplo clique no botão “Excluir” e inclua o código a seguir: 2 Button e um DataGridView conforme imagem 20.

privatevoidbtnExcluir_
Click(objectsender, EventArgs
e)
{
if (MessageBox.Show(“Deseja
excluir registro atual?”, this.
Text, MessageBoxButtons.YesNo,
MessageBoxIcon.Exclamation) ==
DialogResult.Yes)
{ Imagem 20 – Formulário de Pesquisa.
if (txtID.Text == string.Empty)
{ Com o formulário criado, insira o código em negrito:
MessageBox.Show(“Selecione um
registro no botão \”Pesquisar\”
antes de \”Excluir\”.”,
“Aviso”, MessageBoxButtons.OK, public partial class Consulta :
MessageBoxIcon.Information); MAAcoes
} {
else publicConsulta()
{ {
intintID = Convert. InitializeComponent();
ToInt32(txtID.Text); }

using (MAEntities context = new public string formName =

MAEntities()) string.Empty;
{
usuario u = context.usuario. publicConsulta(MAAcoes fc =
First<usuario>(pu =>pu. null)
idusuario == intID); {
context.DeleteObject(u); if (fc != null)
context.SaveChanges(); {
MessageBox.Show(“Informações formSender = fc;
excluidas com sucesso.”, this.Text += formSender.Text;
“Aviso”, MessageBoxButtons.OK, }
MessageBoxIcon.Information); InitializeComponent();
} }

this.AjustaValorCamposFormulari private void btnSair_

17
novembro
2013
 Click(object sender, EventArgs Width = 189;
e) dgvDados.Columns[“usuario1”].
{ HeaderText = “Usuário”;
this.Close(); dgvDados.Columns[“senha”].
this.Dispose(); Visible = false;
} dgvDados.Columns[“contato”].
Visible = false;
private void dgvDados_ break;
Click(object sender, EventArgs }
e) }
{
if (dgvDados.RowCount> 0)
{
Em seguida, temos que colocar o botão pesquisar no formulário de Usu-
this.setID(dgvDados. ários. Sendo assim, insira um botão e chame-o de “btnPesquisar” e coloque
SelectedCells[0].Value.
o texto “Pesquisar” como mostra a imagem 21.
ToString());
this.formSender.
chamarMetodo(“carregaDados”,
this.ID);
this.formSender.Show();
this.Close();
this.Dispose();
}
}

...
Imagem 21 – Botão Pesquisar

Com o novo botão, teremos que modificar algumas coisas na classe MA-
Depois, dê um duplo clique em btnPesquisar e insira o código em negrito Acoes e na Classe frmUsuario, então vamos começar pela classe MAAcoes
a seguir: inserindo o código em negrito:

private void btnPesquisar_ public class MAAcoes : Form

Click(object sender, EventArgs {
e) publicMAAcoesformSender;
{ public string senderFormName;
switch (this.formSender.Text) public string ID;
{
case “Usuário”: public virtual void
using (MAEntities context = new chamarMetodo(stringstrMetodo,
MAEntities()) string optionalParam = “”) { }
{
IEnumerable<usuario>usuario =
(from u in context.usuario
public virtual void
whereu.nome.
setFormName(string nome)
Contains(txtDescricao.Text)
{
select u).ToList();
senderFormName = nome;
dgvDados.DataSource = usuario;
}
}
public virtual void setID(string
dgvDados.Columns[“idusuario”].
strID)
Width = 189; {
dgvDados.Columns[“idusuario”]. this.ID = strID;
HeaderText = “ID”; }
dgvDados.Columns[“nome”].Width
= 400; ...
dgvDados.Columns[“nome”].
HeaderText = “Nome”;
dgvDados.Columns[“usuario1”].
Na classe frmUsuario, insira o código em negrito a seguir:

18
novembro
2013
 public partial class frmUsuario }
: MAAcoes }
{
publicMAAcoesformConsulta;
public string strAcao = string.
Empty; Ao testar nossa aplicação, devemos obter o resultado mostrado na
imagem 22.

Ainda na classe frmUsuario, dê um duplo clique no botão Pesquisar e

insira o código em negrito:

private void btnPesquisar_

Click(object sender, EventArgs
e)
{
this.formConsulta = new
Consulta(this);
this.formConsulta.
setFormName(this.Name);
this.formConsulta.Show();
}
Imagem 22 – Aplicação fazendo busca e trazendo o resultado na tela.
public override void
chamarMetodo(string strMetodo,
string optionalParam = “”) Conclusão
{
switch (strMetodo)
{ A aplicação completa poderá ser baixada através do site da revista.
case “carregaDados”: Vale a pena lembrar que foram deixados muitos links da MSDN no artigo
carregaDados(optionalParam); que detalham os assuntos abordados nesse artigo. Leiam, questionem-se,
break; pesquisem, analisem. Não tomem apenas esse artigo por verdade absoluta
} quando na verdade estou apresentando uma opção no meio de tantas.
}
Referente a projetos, avaliem a real necessidade do cliente, os impactos de
private void carregaDados(string manutenção e evolução do sistema. Não saiam aplicando a tecnologia apenas
strID) porque é rápida e prática, uma boa analise sobre as arquiteturas disponíveis
{ são sempre bem-vindas no inicio do projeto.
intintID = Convert.
ToInt32(strID);
Caso precise fazer alterações referentes a acesso a dados com base nesse
using (MAEntities context = new artigo, utilize o Appconfig para saber o que alterar num projeto já criado e
MAEntities()) configurado.
{
IEnumerable<usuario>usuario =
(from u in context.usuario
whereu.idusuario == intID
select u).ToList();
Sobre o autor
foreach (var u in usuario)
{
txtID.Text = u.idusuario.
João Marcos Sakalauska
ToString(); Colunista The Club.
txtNome.Text = u.nome.
ToString();
txtUsuario.Text = u.usuario1.
ToString();
txtSenha.Text = u.senha.
ToString();
} suporte@theclub.com.br

19
novembro
2013
Criando um formulário de
layout padrão - Delphi 7
O
lá pessoal, neste artigo vamos mostrar uma das variadas
formas de trabalhar com a padronização dos componentes
visuais no Delphi. A escolha da versão 7 do Delphi se deve a
sua popularidade na comunidade da ferramenta e também
porque as versões mais atuais do Delphi possuem muitos
recursos para a padronização de estilos dos componentes, contudo, a prática
utilizada neste artigo poderá ser utilizada em qualquer versão do Delphi, visto
que se trata de manipulação via programação e este é um recurso comum em
todas as versões.
Objetivo
O objetivo deste artigo é ensinar uma prática de padronização do layout dos
componentes visuais no Delphi. Essa prática possibilita o ajuste e a visualização
dos componentes em tempo de projeto, para isso utiliza-se um formulário,
onde serão dispostos os componentes visuais com as características que ser-
virão como padrão para a aplicação inteira, ou apenas para os formulários que
necessitarem utilizar esse padrão, pois podemos definir isso via programação.
Conceito de CSS
Quem já desenvolveu um website algum dia, conhece ou já ouviu falar do
uso do CSS para a configuração do layout de uma página HTML.
Existem três formas de se trabalhar com o CSS, são elas:
• Embutido – quando o estilo é aplicado diretamente à tag HTML;
• Interno – quando o código CSS fica disposto entre as tags STYLE no
próprio documento HTML;
• Externo – quando o código CSS fica disposto num arquivo separado
no documento HTML, esta é uma das formas mais dinâmicas de se trabalhar,
pois um único arquivo pode ser o responsável por configurar o estilo de inú-
meras páginas HTML. Com este método os elementos HTML podem ser criados
de forma padrão sem se preocupar com seus estilos, pois serão ajustados ao
serem carregados no webbrowser.
20 novembro
2013
É este último conceito, o de CSS externo, que iremos citar neste artigo,
pois essa prática de padronização de layout será tratada de forma parecida,
porém, ao invés de se ter um arquivo CSS externo, terá um formulário criado
apenas para disponibilizar os componentes que servirão de base para os demais
formulários do projeto. E da mesma forma que temos que fazer a chamada do
arquivo CSS na página HTML quando queremos utilizar seu estilo, teremos que
fazer a chamada do formulário padrão de layout nos formulários que iremos
utilizar essa padronização.
Para reforçar o entendimento do conceito de CSS nesta prática vamos
tomar como exemplo a utilização do CSS no HTML. É sabido que ao utilizar um
arquivo CSS externo para a estilização de um documento HTML, este último
pode ser criado com seus elementos padrão, ou seja, sem nenhuma formatação
ou alteração de características. Com essa prática de estilização dos componen-
tes no Delphi que iremos ensinar o conceito será o mesmo, para cada novo
formulário que for criar no projeto, bastará apenas chamar via programação o
formulário de estilo padrão, basta adicionar os componentes sem precisar se
preocupar com os ajustes visuais, pois serão ajustados em tempo de execução
pelo formulário base de layout.
Métodos e comportamentos
Com essa prática, além de podermos configurar o visual dos componentes
da aplicação, podemos também predefinir alguns métodos e comportamentos
para determinados componentes, como por exemplo, Edit que aceita apenas
números inteiros e Label que se destaca com o movimento do mouse ao
passar por cima dele entre outros métodos corriqueiros. Mas devemos fazer
uma ressalva, pois ao definir os métodos nos componentes do formulário base
de layout, devemos ter em mente que estes métodos serão vinculados aos
componentes dos demais formulários em tempo de execução.
Para explicar melhor o cuidado que se deve tomar ao utilizar métodos
nos componentes de layout padrão, iremos utilizar o exemplo do Edit que
aceita apenas números, essa programação será feita no evento OnKeyPress
do Edit e ao executar o projeto, ela é vinculada aos componentes Edit dos
demais formulários do projeto, isso indica que, se em algum Edit tiver alguma
outra programação no mesmo evento, OnKeyPress, esta será substituída pela
programação do Edit que aceita apenas números inteiros.
Por esse motivo indicamos que sejam criados apenas métodos genéricos e
específicos e se possível em eventos que comumente não se utilize, pois assim
evitará que ocorra esta substituição de eventos, pois esta prática funciona de
maneira diferente de quando utilizamos uma herança de formulários, nesta
última, o código no formulário base é adicionado ao código no formulário
que recebe a herança, ou seja, não ocorre perda de codificação, que é o que
acontecerá se um evento for substituído por outro como é feito nesta prática.
Contudo ainda não deixa de ser uma prática interessante, pois podemos
por exemplo, criar vários estilos de Edit, alguns com codificações e outros
comuns sem nenhuma codificação, diferenciando-os apenas pela sua pro-
priedade Tag.
Escolhendo o estilo pela propriedade Tag
Depois que fizermos toda a programação no formulário de base de layout,
bastará informar nos componentes dos demais formulários qual o estilo que
será aplicado em cada um. Isso será defino através da propriedade Tag de
cada componente.
A Tag padrão para qualquer componente criado pelo Delphi possui o valor
0 (zero), portanto todo estilo que for representado pela Tag 0 deve ser o mais
comum em sua aplicação, ou seja, o estilo que será tido como padrão, pois
facilitará muito na sua configuração posterior. Os demais podem ser apenas
uma variação do componente para casos mais específicos. Para casos em que
não se deva aplicar estilo algum, bastará informar no componente uma Tag
com valor negativo ou qualquer outro valor que não tenha sido definido como
um estilo, por exemplo, -1.
Quais propriedades podem ser padronizadas?
Essa é uma pergunta muito importante a ser feita, pois visto que iremos
fazer uma padronização de layout, devemos ter em mente o que tanto po-
deremos padronizar. Por exemplo, talvez não seja interessante alterarmos a
largura dos componentes, pois poderemos nos deparar com casos em que o
componente atravesse outro componente no escopo do formulário ou mesmo
saia do campo de visão do usuário. Isso iria causar uma grande dor de cabeça.
Outro caso que talvez não seja interessante padronizar é o tamanho e estilo
da fonte (negrito, itálico, etc...) , pois pode acontecer como o que foi citado
anteriormente, e na hora da execução o texto que estava dentro do escopo do
formulário em tempo de projeto com uma fonte sem estilo, pode desalinhar
com o estilo padrão assumido em tempo de execução, com uma fonte com
um tamanho maior e um estilo em negrito por exemplo.
Fizemos um apanhado das propriedades comuns entre os componentes
visuais do Delphi que podem ser úteis nesta padronização sem causar dores
de cabeça, veja abaixo a lista:
• Cursor – Define o cursor padrão do mouse quando está sobre o
componente;
• Font.Color – Define a cor da fonte do componente;
• Font.Name – Define qual o tipo de fonte que será aplicado ao
componente. Algumas fontes como Courier New, podem alongar o texto, por
isso tome cuidado ao escolher o estilo de fonte;
• ShowHint – Define se será exibido o texto de ajuda do componente.
Se estiver definido como True e a propriedade Hint estiver vazia, não será
mostrado nada ao usuário.
É claro que podemos padronizar outras propriedades, pois cada compo-
nente possui várias propriedades que podem ser manipuladas via programação,
por exemplo, no formulário podem ser alteradas as seguintes propriedades
além das que já foram citadas na lista anterior:
• Color – Define qual será a cor de preenchimento do formulário;
• Position – Define qual será a posição inicial do formulário ao ser
exibido;
• BorderIcons – Define quais serão os botões apresentados na borda
da janela (Minimizar, Maximizar e Fechar);
• BorderStyle – Define qual o estilo da borda do formulário;
Alguns componentes podem ter mais propriedades para configurar do
que outros. Isso irá variar para cada caso.
Criando o formulário base de layout
Criaremos um formulário para definir alguns estilos de Edit, SpeedButton,
Label, Panel e alguns outros componentes visuais. É importante reforçar que
pode-se trabalhar com vários componentes, isso dependerá da necessidade
e da criatividade do desenvolvedor.
Crie um nova aplicação no Delphi 7. O primeiro formulário será o nosso
formulário base para layout, defina em sua propriedade Name o nome “fr-
mFormBaseLayout”, salve a Unit com o nome unFormBaseLayout e o projeto
com o nome de sua preferência em um diretório em seu computador.
Adicionando estilos de Label
Adicione ao frmFormBaseLayout um componente TGroupBox, nomeie-o
como “gbLabel”, altere a propriedade Caption para “Label”. É dentro desse
grupo que ficarão os estilos diferentes de Label. Adicione 2 componentes
TLabel dentro do gbLabel, nomeie-os da seguinte forma: “Label0” e “Label1”.
Repare que a nomenclatura utilizada, é composta pelo nome do compo-
nente e um número que começa a partir do zero. Este número, na nomen-
clatura, irá representar qual a o valor que deve-se indicar na propriedade Tag
para utilizar este estilo.
Defina para o componente Label0 a propriedade Font.Name para “Taho-
ma” e na propriedade Font.Color a cor “clNavy”. Para a Label1 defina sua Font.
Name para “Cambria”, na propriedade Font.Color defina a cor “clRed” e por
fim altere a sua propriedade Cursor para “crHandPoint” e sua propriedade
ShowHint para “True”. A Label0 será nossa Label padrão e a Label1 será utili-
zada para casos em que a Label irá funcionar como um HiperLink disparando
algum evento ao ser clicada. Na Label1 vamos adicionar dois eventos, são eles:
OnMouseEnter e OnMouseLeave. Eles darão um destaque à Label quando o
mouse passar por cima dela. Veja na listagem 1 os códigos dos eventos citados.
21
novembro
2013
 Listagem 1 – Codificação dos eventos da Label1 if C.Tag = 1 then
procedure TfrmLayoutBase. begin
Label1MouseEnter(Sender: C.OnMouseEnter :=
TObject); X.OnMouseEnter;
begin C.OnMouseLeave :=
{ Altera a cor de fundo da X.OnMouseLeave;
Label } end;
TLabel(Sender).Color := end;
TLabel(Sender).Color + $1; end;
end;

procedure TfrmLayoutBase.
Label1MouseLeave(Sender: No primeiro trecho do código serão atribuídas à variável X as proprieda-
TObject); des de um dos componentes especificados como estilo. No segundo trecho,
begin verifica-se se a variável X recebeu alguma atribuição. Em caso de verdade,
{ Define a cor de fundo para a
cor do componente Parent } o parâmetro C receberá as propriedades da variável X. Por fim ainda temos
TLabel(Sender).ParentColor := mais uma verificação, se o parâmetro faz referência ao estilo de Tag 1, se for,
True; passam também os eventos da Lable1.
end;
A estrutura deste método será igual para o ajuste dos demais componen-
tes. O case utilizado no primeiro trecho é o que facilitará para a inclusão de
Vamos agora criar o método que irá incorporar o estilo nas demais Labels. um novo estilo, pois bastará incluir mais uma linha dentro do bloco do case
Consiste num procedimento com um parâmetro de entrada do tipo TLabel.
atribuindo o novo componente de estilo à variável X, assim não será preciso
Esse procedimento possui uma variável X também do tipo TLabel, que será
alterar o restante do método.
utilizada para incorporar as propriedades da Label0 ou da Label1. Será cha-
mado de AjustaLabel. Veja na listagem 2 a declaração na seção private e a
codificação do evento.
Adicionando estilos de Edit
Listagem 2 – Declaração e codificação do método AjustaLabel Adicione ao frmFormBaseLayout mais um GroupBox, altere seu Name
private para “gbEdit”. Adicione 5 componentes Edit dentro do gbEdit e nomeie-os da
{ Private declarations } seguinte forma: “Edit0”, “Edit1”, “Edit2”, “Edit3” e “Edit4”. As características
procedure AjustaLabel(C: destes são as seguintes:
TLabel);
{Tecle Ctrl + Shift + C • Edit0: Será o Edit padrão da aplicação;
para gerar o corpo do método} • Edit1: Será o Edit somente para leitura;
• Edit2: Será o Edit que aceita apenas números inteiros;
procedure TfrmFormBaseLayout. • Edit3: Será o Edit que aceita números com duas casas decimais;
AjustaLabel(C: TLabel);
• Edit4: Será o Edit que aceita números com N casas decimais.
var
X: Tlabel; Selecione os 5 Edits segurando a tecla Shift e clicando com o ponteiro do
Begin mouse em cada um deles, após todos estarem selecionados, acesse o painel
X := nil; Object Inspector do Delphi e altere as propriedades Font.Name para “Arial”,
case C.Tag of BorderStyle para “bsNone” e BevelKind para “bkFlat”, desta forma os edits
0: X := Label0; { Label assumirão um layout mais chapado, sem a aparência 3D.
comum }
1: X := Label1; { Label Selecione o Edit1 (somente leitura) e altere as seguintes propriedades:
link } Color para “clMoneyGreen”, Font.Color para “clBackground” e ReadOnly para
end; “True”.
if X <> nil then
Os Edits 2, 3 e 4 terão cada um deles uma programação no evento OnKey-
begin
C.Cursor := X.Cursor; Press, que será responsável por atribuir a eles suas características. Veja na
C.ShowHint := X.ShowHint; listagem 3 a codificação para cada um dos eventos.
C.Font.Name := X.Font.Name;
C.Font.Color := X.Font. Listagem 3 – Codificação do evento OnKeyPress dos Edits 2, 3 e 4
Color;
procedure TfrmFormBaseLayout.
Edit2KeyPress(Sender: TObject;
C.Transparent :=
var Key: Char);
X.Transparent;
begin

22
novembro
2013
 Como podemos ver, fizemos uma trava para cada um destes três Edits
{ Admite apenas números
seguindo a característica de cada um. Podemos executar o projeto agora
inteiros }
if not (Key in [‘0’..’9’, e testarmos se estes eventos estão funcionando corretamente. Este é um
#8]) then {#8 representa a exemplo de evento que pode ser útil para se padronizar, contudo ainda de-
tecla Backspace} vemos lembrar, que o Edit que for utilizar algum destes 3 estilos não deverá
Key := #0; ter nenhuma codificação no evento OnKeyPress, pois a esma será substituída
end; por esta codificação.

procedure TfrmFormBaseLayout. Vamos agora criar o método AjustaEdit que irá definir os estilos dos
Edit3KeyPress(Sender: TObject; edits em tempo de execução. Como foi dito, este método será semelhante
var Key: Char); ao AjustaLabel. Veja na listagem 4 os códigos do procedimento AjustaEdit. A
const declaração deste método é feita abaixo da declaração do método AjustaLabel
QDecimal = 2; { Defina aqui a
na sessão private da Unit.
Qtde de casas decimais }
var
S: string; Listagem 4 – Codificação do método AjustaEdit
P, Q: Integer;
begin procedure TfrmFormBaseLayout.
{ Admite número com um número AjustaEdit(C: TEdit);
definido de casas decimais na var
constante QDecimal } X: TEdit;
if not (Key in [‘0’..’9’, begin
‘,’, #8]) then { Caso seja ReadOnly mas não
Key := #0 esteja definida pela Tag, define
else a Tag 1 }
begin if (C.ReadOnly) and (C.Tag <>
S := TEdit(Sender).Text; 1) then
P := Pos(‘,’, S); C.Tag := 1;
if (P > 0) and (Key in
[‘0’..’9’, ‘,’]) then { Identifica o estilo pela Tag
begin }
S := Copy(S, P, Length(S) X := nil;
- P); case C.Tag of
Q := Length(S); 0: X := Edit0; { Edit comum
if (Q = QDecimal) or (Key }
= ‘,’) then 1: X := Edit1; { Edit
Key := #0; somente leitura }
end; 2: X := Edit2; { Edit só
end; inteiros }
end; 3: X := Edit3; { Edit só
decimais 2 casas }
procedure TfrmFormBaseLayout. 4: X := Edit4; { Edit só
Edit4KeyPress(Sender: TObject; decimais N casas }
var Key: Char); end;
var
S: string; { Transfere as propriedades
P: Integer; do componente base
begin para o componente passado
{ Admite números com N casas como parâmetro }
decimais } if X <> nil then
if not (Key in [‘0’..’9’, begin
‘,’, #8]) then C.Cursor := X.Cursor;
Key := #0 C.ShowHint := X.ShowHint;
else C.Font.Name := X.Font.Name;
begin C.Font.Color := X.Font.
S := TEdit(Sender).Text; Color;
P := Pos(‘,’, S);
if (P > 0) and (Key = ‘,’) C.Color := X.Color;
then C.BorderStyle :=
Key := #0; X.BorderStyle;
end; C.BevelKind := X.BevelKind;
end; C.ReadOnly := X.ReadOnly;

23
novembro
2013
 { Caso necessário transfere if X <> nil then
os eventos } begin
if C.Tag in [2, 3, 4] then C.Cursor := X.Cursor;
C.OnKeyPress := C.ShowHint := X.ShowHint;
X.OnKeyPress; C.Font.Name := X.Font.Name;
end; C.Font.Color := X.Font.
end; Color;

O que podemos destacar de diferente neste código é que a primeira
verificação se faz necessária para identificar se o componente passado como
parâmetro foi definido como somente leitura pela propriedade ReadOnly, mas
não foi definido o seu estilo na propriedade Tag, por isso alteramos a Tag para
1. Podemos ver que no caso dos Edits já foram transferidos mais propriedades
que na Label. A verificação para a transferência dos eventos é semelhante ao
método AjustaLabel, com a diferença que agora temos mais dois estilos que
têm eventos a serem passados.
Adicionando os estilos de SpeedButton
O componente TSpeedButton é muito interessante, pois com ele podemos
trabalhar com Flat (quando o botão apresenta apenas seu rótulo no formulário,
mas quando o mouse passa por cima dele ele assume a forma de um botão
comum) e imagens. Vamos criar dois estilos de SpeedButton um com Flat e
outro sem o recurso de flat, que seria um botão comum.
Adicione ao frmFormBaseLayout um GroupBox e nomeie-o como “gbS-
peedButton”, adicione dentro do gbSpeedButton, recém-criado, dois Speed-
Buttons, nomeie-os seguindo o padrão de nomenclatura citado, o nome do
componente mais um número sequencial a começar pelo zero. Selecione os
dois SpeedButtons e altere as propriedades Cursor para “crHandPoint”, Font.
Name para “Century” e Font.Color para “clHighlight”. Em seguida selecione
apenas o SpeedButton1 e altere sua propriedade Flat para “True”.
Nota: Estamos usando fontes de tipos diferentes nos componentes para
demonstrar de forma mais clara o objetivo deste artigo que é mostrar a va-
riedade de estilos que podemos criar com este formulário base para layout.
Não há necessidade de adicionarmos nenhum evento aos SpeedButtons,
neste caso apenas iremos criar o método AjustaSpeedButton. Veja na listagem
5 sua codificação. Lembrando que a declaração deste método é feita abaixo
da declaração do método AjustaEdit.
Listagem 5 – Codificação do método AjustaSpeedButton
procedure TfrmFormBaseLayout.
AjustaSpeedButton(C:
TSpeedButton);
var
X: TSpeedButton;
begin
X := nil;
case C.Tag of
0: X := SpeedButton0; {
SpeedButton comum }
1: X := SpeedButton1; {
SpeedButton Flat ativo }
end;
C.Flat := X.Flat;
C.Layout := X.Layout;
C.Transparent :=
X.Transparent;
end;
end;
Adicionando estilos de Panel
Este será o último exemplo de estilos de componentes. Iremos criar três
estilos diferentes de Panel, um mais simples, outro com uma borda transpa-
rente que não ficará visível para o usuário (bom para casos em que devemos
agrupar alguns componentes para facilitar o desenvolvimento do layout da
aplicação, mas não deve ficar visível ao usuário esse agrupamento) e por fim
outro Panel com uma borda diferenciada.
Adicione ao frmFormBaseLayout mais um GroupBox chamando-o de
“gbPanel” e adicione dentro dele três componentes Panel nomeando-os como
“Panel0”, “Panel1” e “Panel2”. Selecione os três Panels e altere as propriedades
Font.Name para “Trebuchet MS” e ParentColor para “True”.
Selecione o Panel0 e altere sua propriedade BevelWidth para “2”. Será o
Panel comum do projeto.
Selecione p Panel1 e altere a propriedade BevelOuter para “bvNone”. Será
o Panel que ficará invisível para o usuário.
Por fim selecione o Panel2 e altere suas propriedades BevelInner para
“bvLowered” e BevelWidth para “2”. Desta forma teremos um Panel com uma
borda diferenciada, semelhante a um quadro.
Vamos criar também o método AjustaPanel, que seguirá o mesmo padrão
dos demais métodos apenas adicionando algumas propriedades particulares
do Panel. Veja na listagem 6 a codificação deste último método de exemplo.
Lembre-se de declarar o procedimento abaixo do último método criado na
sessão private.
Listagem 6 – Codificação do método AjustaPanel
procedure TfrmFormBaseLayout.
AjustaPanel(C: TPanel);
var
X: TPanel;
begin
X := nil;
case C.Tag of
0: X := Panel0; { Painel
comum }

24
novembro
2013
 1: X := Panel1; { Painel { Ajusta apenas Form com tag
invisível } 0 }
2: X := Panel2; { Painel if Frm.Tag = 0 then
com bordas de quadro } begin
end; Frm.Cursor := Self.Cursor;
Frm.ShowHint := Self.
if X <> nil then ShowHint;
begin Frm.Font.Name := Self.Font.
C.Cursor := X.Cursor; Name;
C.ShowHint := X.ShowHint; Frm.Font.Color := Self.
C.Font.Name := X.Font.Name; Font.Color;
C.Font.Color := X.Font.
Color; Frm.Color := Self.Color;
Frm.Position := Self.
C.Alignment := X.Alignment; Position;
C.BevelInner := Frm.BorderIcons := Self.
X.BevelInner; BorderIcons;
C.BevelOuter := Frm.BorderStyle := Self.
X.BevelOuter; BorderStyle;
C.BevelWidth := end;
X.BevelWidth;
C.BorderStyle := { Ajusta os componentes
X.BorderStyle; visuais do Form }
C.BorderWidth := for I := 0 to Frm.
X.BorderWidth; ComponentCount - 1 do
C.ParentColor := begin
X.ParentColor; C := Frm.Components[I];
end; if C <> nil then
end; begin
if C is TLabel then
AjustaLabel(TLabel(C))
else if C is TEdit then
AjustaEdit(TEdit(C))
Criando o método AjustaForm else if C is TSpeedButton
then
AjustaSpeedButton(TSpee
Este método é o mais importante, pois ele será a ponte entre este formu- dButton(C))
lário base de layout e todos os outros que precisarem usufruir de seus estilos else if C is TPanel then
padrões. Portanto deverá ser um método público, para que os demais formu- AjustaPanel(TPanel(C));
lários possam acessá-lo. O mecanismo funcionará de forma parecida com os end;
demais métodos, será passado como parâmetro um formulário do tipo TForm, end;
que primeiro irá verificar se as propriedades do formulário serão alteradas, end;
logo após será feito uma varredura pelos componentes do formulário passado
como parâmetro, e para cada tipo de componente será feito a chamada para
o seu respectivo método. Veja na listagem 7 a declaração na sessão public e
a codificação deste método. Vamos explicar o que ocorre no segundo trecho deste código, já que o
primeiro trecho vimos em outros métodos, neste segundo trecho faremos
um laço de repetição para varrer todos os componentes do parâmetro Frm,
e dentro adicionamos o componente do Frm à variável C do tipo TCompo-
Listagem 7 – Declaração e codificação do método AjustaForm
nent. Servirá para verificarmos se é do tipo de algum componente que tenha
método de configuração de estilo, como Tlabel, TEdit e os demais. Depois de
public garantirmos que se trata de um componente com um método definido, basta
{ Public declarations } fazermos a chamada do método.
procedure AjustaForm(Frm:
TForm); O conceito da prática é bem simples e seguindo a linha de raciocínio po-
demos criar métodos para inúmeros componentes do Delphi e parametrizar
procedure TfrmFormBaseLayout. várias de suas propriedades, basta depois adicionar a chamada do método
AjustaForm(Frm: TForm); nesta sequência de Ifs do método AjustaForm.
var
C: TComponent;
I: Integer; Ou seja, o que você poderá fazer utilizando esta técnica vai depender
begin de sua criatividade. Veja na figura 1 como ficou o nosso formulário base de
layout em tempo de projeto.

25
novembro
2013
 Figura 1 – Ilustração do frmFormBaseLayout

Testando o ajuste de layout

Chegou a hora de vermos em prática o funcionamento desses métodos.
Crie mais um formulário em seu projeto no Delphi e chame de “frmTeste”
salve sua Unit com o nome “unTeste”. Adicione vários Edits, Labels, SpeedBut-
tons e Panels. Altere a propriedade Tag de cada um de forma aleatória para
ver os variados estilos que teremos.
Após adicionar os componentes iremos fazer a chamada do método
AjustaForm, veja na listagem 8 como é simples fazer essa chamada no evento
OnCreate do frmTeste.
Listagem 8 – Chamada do método AjustaForm no evento OnCreate do frmTeste
procedure TfrmTeste.
FormCreate(Sender: TObject);
begin
frmFormBaseLayout :=
TfrmFormBaseLayout.Create(Self);
frmFormBaseLayout.
AjustaForm(Self);
FreeAndNil(frmFormBaseLayout);
end;
Veja a transformação do frmTeste que fizemos para essa exemplificação
nas figuras 2 (em tempo de projeto) e 3 (em tempo de execução). Antes de
fazer este teste acesse o menu do Delphi (Project / Options) e mova o frmForm-
BaseLayout para a lista Available forms com um clique duplo sobre seu item.
Assim, o formulário principal passará a ser o frmTeste. Execute e verifique a
alteração nos estilos dos componentes do formulário.
Figura 3 – frmTeste em tempo de execução
Pode-se reparar que todos os componentes que foram configurados com
Tags válidas de estilo assumiram o padrão definido. Apenas o 4º edit, “Edit
com tag negativa -1”, que não assumiu nenhuma alteração, se manteve com a
aparência padrão do Delphi 7. Essa foi a maneira sugerida para não se aplicar
estilo base quando for necessário, basta informar uma Tag que não tenha sido
definida como estilo, neste caso -1.
Conclusão
Nesse artigo vimos uma técnica de padronização de layout de formulários
e componentes nos projetos em Delphi. Explicamos o conceito inicial da ideia
e demonstramos o dinamismo que a ideia possui, pois ela pode servir para
inúmeros componentes que podem ser inseridos nos formulários.
Demonstramos também um simples exemplo para mostrar a simplicidade
de se invocar a estilização nos demais formulários – se utilizar algum formulário
base para a criação dos seus forms de cadastros por exemplo, bastará fazer a
chamada no form base, que esses estilos se aplicarão a todos os formulários
de cadastro.
É importante lembrar que essa técnica pode ser utilizada nas demais
versões do Delphi sem nenhuma restrição, até mesmo porque se trata apenas
de uma codificação.
Bom pessoal, espero que tenham gostado do artigo e que o mesmo seja
de grande utilidade para vocês. Um abraço a todos e até uma próxima.

Sobre o autor
Lucas Vieira de Oliveira
Consultor Técnico The Club.

suporte@theclub.com.br
Figura 2 – frmTeste em tempo de projeto

26 novembro
2013
SoapUI - Ferramenta para
Open Source para consumir
Web Services
N
este artigo irei abordar o uso desta ferramenta Open-Source Download
para utilização junto com Web Services. SoapUI é uma so-
lução gratuita e com uma interface gráfica muito intuitiva Para realização do download entre no site:
permitindo rapidamente consumir e testar Web Services.
Para fins de curiosidade, ela foi escrita em Java e é baseada www.soapui.org
em XML e HTTP, cuja principal função é disponibilizar serviços interativos na
WEB podendo ser acessados por qualquer outra aplicação, independente de Na região superior localize no Menu o descritivo “Downloads” e escolha
plataforma ou linguagem. Por exemplo, podemos criar um Web Service em “Download SoapUI” (No caso estamos trabalhando com a versão Freeware).
Delphi, .Net, Java ou até mesmo utilizar um serviço pronto na internet que Seremos redirecionados para próxima página que é onde finalizamos o processo
esta ferramenta nos proporcionará os testes com os resultados necessários clicando no botão “Download”. A versão que está disponível para este artigo
facilitando todo o processo de criação e depuração por meio de uma inter- até o momento é a versão “4.6.1” em um tamanho total de aproximadamente
face gráfica agradável e de fácil manuseio. A seguir podemos citar umas das 150mb. Ver Figura 01.
principais características.

Principais Características

- Software de fácil manuseio;

- A Importação utilizando o protocolo WSDL é demonstrada como uma
árvore hierárquica para uma melhor visualização;
- Gerencia um número ilimitado de requisições SOAP;
- Geração automática de “Requests” do “Schema” associado;
- Permite realização de testes funcionais e de cargas;
- Formatação automática do ambiente;
- Suporta expressões XPATH, entre outras...

Requisitos do Sistema

É importante lembrar que esta ferramenta é multi-plataforma, ou seja,

podemos utilizá-la em qualquer Sistema Operacional. Como temos uma maioria
de usuários em nosso suporte técnico iremos informar apenas os requisitos
para utilização junto com o Windows.
- 1 GHz ou superior processador de 32-bit ou 64-bit;
- 512 MB de RAM;
- 200MB de espaço em disco para instalação;
- Windows XP ou mais recente.
Figura 01: Download do Software.
Instalação
A instalação é simples, o clássico “next, next, next and install”. A seguir
a tela indicando que a instalação foi completada com sucesso e em seguida
devemos executar o programa. Ver Imagem 02.

27
novembro
2013
 A opção “Create Request”, que significa para criarmos solicitações, deverá
estar checada, pois deveremos criar solicitações para todas as operações deste
Web Service. Em “Create TestSuite” iria criar uma suíte de testes para o WSDL
importado, já o “Relative Paths” armazenaria todos os caminhos dos arquivos
relacionados ao projeto. Portanto deixaremos apenas a primeira opção sele-
cionada. Clique em Ok para darmos início ao exemplo.

Teremos uma estrutura de árvore idêntica ao da Imagem 05, contendo

todos os serviços listados seguindo os métodos do Web Service em questão.

Figura 02: Concluindo a Instalação.

Observação: Geralmente no primeiro acesso poderá ocorrer o bloqueio

pelo Firewall, basta permitir o acesso para prosseguir.

A tela inicial poderá ser conferida conforme a Figura 03.

Figura 05: Navegador do Projeto.

Para efeitos didáticos e de entendimento, o exemplo deste Web Service

apresentado daqui por diante irá nos retornar o logradouro a partir do CEP
ou o CEP a partir do Logradouro. Possuirá alguns métodos como “ObterCEP”,
“ObterCEPAuth”, “ObterLogradouro”, “ObterLogradouroAuth” e “ObterVersao”.

Usaremos o método “ObterLogradouro”, para isto clique no mesmo

para expandir e com o botão direito sobre “Request” escolha “Show Request
Editor”. Ver Imagem 06.

Figura 03: Tela de Boas Vindas.

Criando o Exemplo
Para inicializar deveremos clicar em “File/New SOAP Project” como pode
ser visto na Imagem 04. Em “Project Name” defina como “ConsultaCep” (Será
o nome do projeto em questão) e em “Initial WSDL” usaremos um Web Service
de consulta de ceps, o mesmo abordado em artigos anteriores. Veja abaixo
o endereço completo.

http://www.byjg.com.br/site/webservice.php/ws/cep?WSDL

Figura 04: Criando um novo Projeto. Figura 06: Solicitando o Web Service.

28 novembro
2013
 Automaticamente a ferramenta irá gerar um XML, o mesmo sendo respon- Caso não ocorra nenhum erro, o resultado será outro XML idêntico ao
sável por invocar o método que desejamos, Veja a listagem 01. da listagem 02.

Listagem 01: Código XML para chamar o Método ObterLogradouro. Listagem 02: Código de retorno.

<soapenv:Envelope <SOAP-ENV:Envelope SOAP-

xmlns:xsi=”http://www. ENV:encodingStyle=”http://
w3.org/2001/XMLSchema- schemas.xmlsoap.org/soap/
instance” xmlns:xsd=”http:// encoding/”
www.w3.org/2001/XMLSchema” xmlns:SOAP-ENV=”http://schemas.
xmlns:soapenv=”http://schemas. xmlsoap.org/soap/envelope/”
xmlsoap.org/soap/envelope/” xmlns:ns1=”http://www.byjg.
xmlns:byjg=”urn:http://www. com.br” xmlns:xsd=”http://
byjg.com.br”> www.w3.org/2001/XMLSchema”
<soapenv:Header/> xmlns:xsi=”http://www.
<soapenv:Body> w3.org/2001/XMLSchema-instance”
<byjg:obterLogradouro xmlns:SOAP-ENC=”http://schemas.
soapenv:encodingStyle=”http:// xmlsoap.org/soap/encoding/”>
schemas.xmlsoap.org/soap/ <SOAP-ENV:Body>
encoding/”>
<cep <ns1:obterLogradouroResponse>
xsi:type=”xsd:string”>?</cep> <return
</byjg:obterLogradouro> xsi:type=”xsd:string”>VOCE
</soapenv:Body> PRECISA ESTAR AUTENTICADO.
</soapenv:Envelope> MAIORES INFO ACESSE O SITE,
Centro, Itaí, SP,</return>
</
Devemos-nos focar na tag: ns1:obterLogradouroResponse>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
<cep xsi:type=”xsd:string”>?</
cep>
Devemos-nos focar no código abaixo, onde serão retornados os dados.

Aqui é onde informamos o parâmetro do método do Web Service, no <return

nosso caso temos apenas um parâmetro do tipo string. xsi:type=”xsd:string”>VOCE
PRECISA ESTAR AUTENTICADO.
Exemplo: MAIORES INFO ACESSE O SITE,
Centro, Itaí, SP,</return>

<cep
xsi:type=”xsd:string”>18730000</
cep> A figura 08 é a interface básica para testar o acesso o Web Service.

Veja a figura 08.

Na região superior esquerda escolha a opção “Submit request to specified

endpoint URL” para termos um retorno. Ver Imagem 07. Outras Funcionalidades

Test Case

Significa “Caso de Teste”. Esta funcionalidade nos proporciona realizar tes-

tes com as requisições, para isto clique com o botão direito sobre a requisição
Padrão criada no tópico anterior e escolha “Add to TestCase”. Aparecerá uma
janela para definição de um nome da “Test Suite” e o nome do “Test Case”.
Figura 07: Executando. (recomendo deixar como “TestSuite1” e “TestCase1” )

29
novembro
2013

Figura 08: Interface de testes.
Uma “Test Suite” serve para agrupar um conjunto de “Test Cases” com
características em comum. Dentro de cada “Test Case” teremos um ou mais
“Test Steps”. Cada “Test Step” representa uma requisição que será enviada
ao Web Service.
Figura 09: “Test Case”.
Asserções
Basicamente, as asserções são validações que são feitas para confirmar
se a resposta de uma requisição contém as informações esperadas. Se as
asserções falharem, o “Test Step” e o “Test Case” indicarão um status de falha.
Podemos criar uma asserção por meio da janela “Test Step Editor”, poden-
do também definir asserções (ou verificações) que serão executadas contra a
resposta da requisição. Outra dica para adicionar uma asserção, seria clicando
com o botão direito do mouse na aba “Assertions” localizada na parte inferior
da janela “Test Step Editor”. Ver Figura 10.
Figura 10: Adicionado Asserções.
30
novembro
2013
O SoapUI oferece cinco tipos diferentes de asserções (ou verificações)
para validar a resposta de uma requisição, sendo:
Schema Compliance: Valida as respostas das requisições contra o xml-
-schema definido no WSDL.
Simple Contains: Verifica a existência de uma string nas respostas das
requisições.
Simple NotContains: Verifica a não existência de uma string nas respostas
das requisições.
SOAP Fault: Verifica se a resposta da requisição não contém um soap-fault.
XPath Match: Compara o conteúdo das respostas das requisições contra
uma expressão XPATH.
Referências
www.soapui.org
Conclusão
Muitas vezes nós programadores nos deparamos com situações que de-
vemos consumir um web Service que nunca vimos ou até mesmo em pouco
tempo hábil. Esta ferramenta se encaixa perfeitamente nestes casos, redu-
zindo e muito o tempo de testes para este serviço em questão. O propósito
deste artigo é de demonstrar um pouco das funcionalidades desta ferramenta
gratuita. Explorei suas principais características a fim de proporcionar futuras
adequações conforme achem necessário.
Um forte Abraço, até o mês que vem!
Sobre o autor
Thiago Cavalheiro Montebugnoli
adora aprender novas tecnologias. Formado pela Faculdade de Tecnologia de Botucatu
– SP (FATEC), já desenvolveu softwares utilizando a plataforma .NET, Delphi junto com Banco
de Dados SQL Server e Firebird. Atualmente trabalha no Centro de Processamento de Dados da
Prefeitura Municipal de Itaí-SP é colunista mensal da Revista The Club Megazine e é consultor
Técnico do The Club. Possui as seguintes certificações: MCP - Microsoft Certified Professional,
MCTS - Microsoft Certified Technology Specialist, MCAD - Microsoft Certified Application Developer
e MCSD - Microsoft Certified Solution Developer.
thiago@theclub.com.br
 05
novembro
2013
novembro
2013