Arquivos | Delphi RSS for this section

Trabalhando em modo desconectado com UniDAC

Modo desconectado é uma forma de se tralhar com banco de dados sem manter a conexão  FULL TIME aberta ou seja, a conexão é aberta somente no momento em quem uma transação é requerida e fechada imediatamente apos a transação ser concluída.

Em sistemas onde a aplicação é divida em 3 ou mais camadas, esse tipo de transação é muito utilizado, como em php, onde a conexão é aberta somente no momento da execução do script logo apos é encerrada e o servidor web é desconectado do banco de dados.

Quando trabalhamos com Delphi não temos esse conceito, pois a aplicação se mantem conectada durante toda o tempo em que o sistema persiste em memória, mantendo um conexão aberta para cada instancia da aplicação,

Quando se tem o numero necessário de licenças de banco de dados, isso não é problema, mas quando esse numero de licenças é limitado, e teremos mais clientes conectadas ao bando do que licenças adquiridas, trabalhar em modo desconectado se torna uma boa opção.

para usarmos esse processo com unidac devemos setar:

TCustomDAConnection.Close ou TCustomDAConnection.Disconnect
TCustomDAConnection.Options.DisconnectedMode para True.

pronto, agora as conexões são abertas e fechadas automaticamente, o que permite que o próximo usuário concorrente posa usar a mesma licença de banco de dados.

mas lembre-se que caso o sistema abra a conexão explicitamente com TCustomDAConnection.Open ou TCustomDAConnection.Connect

a conexão ficara aberta;
Mais informações podem ser lidas em:  http://www.devart.com/sdac/docs/index.html?work_disconnectmode.htm

Exportar um TcxDBPivotGrid para Excel

esse é curtinho:

add a Uses cxExportPivotGridLink, Winapi.ShellAPI;

crie a procedure:

procedure ExportarParaExcel()
begin
try
if dlgSalvar.Execute() then
begin

cxExportPivotGridToExcel(dlgSalvar.FileName, pivFluxo);

if Application(‘Deseja visualizar o arquivo’, ‘Exportação’, mbYesNo) = mryes then
begin
ShellExecute(Handle, ‘open’, pchar(dlgSalvar.FileName), nil, nil, SW_SHOW);
end;
end;
except
on E: Exception do
ShowMessage(‘Ocorreram erros na exportação: ‘ + sLineBreak + E.Message);
end;

End;

Exportar um TcxDBTreeList para Excel

Olá

Nesse post vou demonstrar como exportar registro de um grid para um arquivo do tipo .XLS

add a uses

cxTLExportLink, Winapi.ShellAPI;

crie a procedure:

procedure ExportarParaExcel()
begin
cxExportTLToExcel(‘grid.xls’, dbeBalancete, True, True, True);
ShellExecute(Handle, ‘open’, pchar(‘grid.xls’), nil, nil, SW_SHOW);
End;

dica rápida: Exportar tcxGrid para excel

Olá

Nesse post vou demonstrar como exportar registro de um grid para um arquivo do tipo .XLS

add a uses

cxGridExportLink, Winapi.ShellAPI;

crie a procedure:

procedure ExportarParaExcel()
begin
ExportGridToXLS(‘grid.xls’,Grade, False);
ShellExecute(Handle, ‘open’, pchar(‘grid.xls’), nil, nil, SW_SHOW);
End;

tente também:

  ExportGridToHTML();
      ExportGridToFile();
      ExportGridToXML();
      ExportGridToText();
      ExportGridToXLSX();

Como chamar o arquivo de ajuda no Delphi XE2

Olá, mais uma dica para ajudar ao meus queridos alunos.

No Delphi XE2 temos uma classe para chamar arquivos de ajuda tipo chm

para isso addicione Vcl.HtmlHelpViewer a Uses do programa.
e no evento keypress do form chame o helpcontext da applicação

veja o exemplo

——————————————————————————

unit UntHelp;

interface

uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls,
Vcl.HtmlHelpViewer;

type
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
procedure FormKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
private
{ Private declarations }
public
{ Public declarations }
end;

var
Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
   Application.HelpFile := ‘help.chm'; // o arquivo de ajuda deve estar no mesmo diretório do executável
   KeyPreview:= True;
end;

procedure TForm1.FormKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
if key = VK_F1 then
  begin
    Application.HelpContext(50);
  end;
end;

end.

Chamar um HTMLHelp (.chm)

Tem coisas que a Borland, Codegear ou  Embarcadeiro abandonam, e as funções de integração de novos help são uma telas
para ajudar a chamar o help vou postar um exemplo tirado do arquivo de dicas de help de como chamar um help com extensão chm.

procure no seu computador a OCX hhctrl.ocx, caso não a encontre baixeo arquivo aqui e salve no diretório c:\windows\System32 ou na pasta do seu executável.

No formulário principal, logo após o primeiro uses da seção Interface, defina :

function HtmlHelp(hwndCaller: THandle; pszFile: PChar; uCommand:  cardinal;
                  dwData: longint): THandle; stdcall; external 'hhctrl.ocx' name 'HtmlHelpA' ;

No OnCreate do formulário principal faça o seguinte :

Application.OnMessage := ChamaHelp ;

Agora é só usar essa procedure

procedure TfrmPrincipal.ChamaHelp(var Msg: TMsg; var Handled: Boolean);
begin
   if  (Screen.ActiveForm.ClassName = 'TMessageForm') = false then
      if  Msg.message = WM_KEYDOWN then
         if  Msg.wParam = VK_F1 then
             HtmlHelp(Screen.ActiveForm.Handle,  PChar(Arquivo_de_Help.chm), 
                      $F, Screen.ActiveForm.HelpContext ) ;
end;

Pronto. Ao apertar a tecla F1 em qualquer parte do projeto o help será chamado, desde que o no formulário ativo, onde for pressionada o F1 a propriedade HelpContext esteja preenchida.

Importante:

Não coloque o nome do arquivo de help no Project>Options>HelpFile, nem no Application.HelpFile, pois ao pressionar F1 a aplicação tentará carregar o Htmlhelp (.CHM) que estiver lá , gerando uma exception pois o formato CHM não é suportado pelo Delphi .

Backup no Mysql com Delphi – Segunda Parte

O Mysql é uma ótima ferramenta para gerenciamento de banco de dados e funciona muito bem com Delphi, mas sinto falta de um componente simples para execução do backup.

Seria muito fácil fazer um backup apenas copiando os  arquivos da pasta “Data” do banco mysql, como se faz com programas e pastas do computador, porem nos temos um problema quando tentamos copiar a pasta de dados, pois os arquivos estão em uso pelo servido do banco, para copiar os arquivos, poderíamos usar os comandos net use, parar o serviço, copiar o banco e iniciar  o serviço novamente.

Esse tipo de backup tem que ser feito em horários em que o sistema não esteja em funcionamento, pois o banco fica  indisponível.

Mas nossos sistema também devem ter rotinas que permitam que o backup seja feito a qualquer momento. para isso recomendo a leitura de um post anterior de como usar o utilitário MyDump.exe  antes de prosseguir.

http://soprogramando.wordpress.com/2008/08/01/backup-no-mysql/

lembrando que o MyDump.exe está nos binários da instalação do Mysql e deve ser copiado onde o executável está instalado, e deve ser executado por parâmetros via comando.

veja um exemplo de uma função do backup.

private 
 { Private declarations }
 procedure ExecutaBackupBD();
  function ExecutarProcesso(cmd: string): Boolean;
implementation
procedure TFrmManBackup.ExecutaBackupBD;
var
   strBanco, strHost, strUsuario, strSenha, strComando, strCaminho, strArquivo: string;
begin
   try 
      strCaminho := ExtractFilePath(Application.ExeName) + 'backup\';
      if not DirectoryExists(strCaminho) then
      begin
         CreateDir(strCaminho);
      end;
      if FileExists(ExtractFilePath(Application.ExeName) + 'mysqldump.exe') then
      begin
          strArquivo := strCaminho + 'BD_' + FormatDateTime('YYYY-mm-dd_hhnnss', Now) + '.sql';
         strHost := 'Servidor';
         strUsuario :='Usuario';
         strSenha := 'Senha';
         strBanco := 'Banco';
        strComando := 'cmd.exe /c ""' + 
                       ExtractFilePath(Application.ExeName) +
                       '\mysqldump.exe" ' + strBanco +
                       ' -h' + strHost +
                       ' -u' + strUsuario +
                       ' -p' + strSenha + 
                       ' --databases --opt -c -e ' + 
                       '>' + '"' +
                       strArquivo + '""';
        ExecutarProcesso(strComando);
      end
      else
      begin
         ShowMessage('Atenção o aplicativo auxiliar mysqldump não se encontra no diretório, ' +
                     'solicite o mesmo ao suporte do sistema ');
      end;
   finally
      FreeAndNil(Ini);
   end;
end;
function TFrmManBackup.ExecutarProcesso(cmd: string): Boolean;
var
 SUInfo : TStartupInfo;
 ProcInfo: TProcessInformation;
begin
 FillChar(SUInfo, SizeOf(SUInfo), #0);
 SUInfo.cb := SizeOf(SUInfo);
 SUInfo.dwFlags := STARTF_USESHOWWINDOW;
 SUInfo.wShowWindow := SW_HIDE;
 Result := CreateProcess(nil, PChar(cmd), nil, nil, False, CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS, nil, nil, SUInfo, ProcInfo);
if (Result) then
 begin
 WaitForSingleObject(ProcInfo.hProcess, INFINITE);
 CloseHandle(ProcInfo.hProcess);
 CloseHandle(ProcInfo.hThread);
 end;
end;
Colaboração Andre Langner

Gerando um Instalador para aplicativos Delphi com INNO SETUP

Gerando Instalador delphi com Inno Setup

Muitos alunos nesse fim de ano estão fazendo seus projetos de conclusão de curso e necessitam fazer instaladores para seus aplicativos.

Hoje vou mostrar como fazer um instalar usando o utilitário INNO SETUP, que é Free!

Primeiro baixe o INNO SETUP no site http://www.jrsoftware.org/, procure sempre baixar a Release mais atual.

Instalando o programa

Após fazer o download instale o programa com a instalação NNF(Next, Next e Finnish)






Criando a Instalação

Feito a instalação abra o INNO SETUP

Au abrir deve ser exibido uma tela para criação do script, se não aparecer, crie um novo como mostrado abaixo e gere o  script utilizando o WIZARD

O com o Wizard é  muito fácil criar o instalador.

Clique em Next

O sistema irá pedir as informações do sistema e  da empresa que desenvolve o produto.

Nessa tela será exibido a pasta de destino de instalação do aplicativo, se desmarcar  “Allow user to change the application folder” o sistema não permitira que o usuário altere a pasta padrão de instalação. Caso seja necessário o desenvolvedor poderá escolher uma pasta Customizada, escolhendo o nome Custon.

Nessa tela o usuário ira colocar o aplicativo que deseja distribuir e se o usuário quiser que o aplicativo seja executado logo em seguida, deverá marcas “Allow user to start the applicaton after Setup hás finished”.
A Lista “Other application files” será a lista de todos os arquivos que são necessários serem instalados juntamente com o aplicativo, são por exemplo: DLL, OCX, Arquivos Auxiliares ou qualquer outra opção que deseja-se levar junto com o instalador.

Na Tela seguinte o usuário ira configurar as opções de criação de atalhos para acesso ao sistema

Nesta tela é possível definir os arquivos de licença , informações iniciar e de e pós instalação

A linguagem da instalação também pode ser personalizada.

Aqui será informado o diretório onde o instalador será compilado, o nome do instalador ícone do instalador e se senha de instalação.

Pronto script de instalação foi concluído, finalize o Wizard.

Lembrando que todo esse processo foi para a construção do script, e o processo deve ser compliado para que o instalador seja criado

Após finalizar o sistema perguntará se você já quer gerar o executável.

Se você estiver gerando um novo script ele ira pedir para salvar o projeto do instalador,  se para compilar o instalador.

Após o processo será exibido o log da compilação e o instalador iniciará e você já poderá testar seu novo setup.

Até a Próxima

UML, documentação, auditorias e métrica com Delphi e Together

UML, documentação, auditorias e métrica com Delphi 2006 e Together

By: Renato Quedas

Abstract: Conhecendo como a dupla Delphi 2006 e Together pode lhe ajudar através da UML, documentação de código e análise.

In This Article

Eu me lembro do dia em que soube que a Borland havia comprado a Togethersoft, passei a noite pensando nas possibilidades de ter recursos do Together agregados as nossas ferramentas de desenvolvimento. Acho que não preciso dizer que a primeira visão que tive foi de como o Delphi massacraria a concorrência se tivesse tais capacidades disponíveis para os seus desenvolvedores.

Bom, logo de cara sabíamos que teríamos que esperar um tempo até que a equipe do Together trabalhase em uma integração com o Delphi. Primeiro, veio a superfície de design para modelos de classe para o ECO I no Delphi 8 for .Net, depois a visualização e navegação de código Win32 ou .Net através de diagramas de classe no Delphi 2005.

Em todos os eventos que fazíamos, os desenvolvedores seguiam fazendo a mesma pergunta; Quando teremos o Together for Delphi?

É com grande prazer que digo o tempo de espera acabou. O Together não só foi integrado ao Delphi como se tornou um feature presente em TODAS as edições do Delphi 2006. É isso mesmo, os desenvolvedores que utilizam desde o Delphi 2006 Professional até o Delphi 2006 Architect terão as capacidades de utilizar todos os diagramas UML 1.5 e o famoso LiveSource para as linguagens Delphi (Win32 e .Net) e C# (.Net).

Neste artigo irei apresentar como todos os recursos do Together disponíveis no Delphi 2006 podem suportar o desenvolvimento de aplicações Win32 ou .Net.

Projetos de análise

Uma das novas capacidades do Delphi 2006 é a criação de projetos modelagem UML utilizando UML 1.5 ou UML 2.0 também conhecidos como projetos de design. Podemos considerar estes projetos como se fossem projetos de análise e como tal, não possuem nenhuma interação com código. A vantagem destes projetos é permitir que você utilize o Delphi 2006 já na fase de refinamento do escopo, mesmo que ainda não tenha decidido se o projeto vai ser implementado na plataforma Win32 ou na plataforma .Net. Uma vez que tenha definido qual plataforma, o Delphi 2006 pode transformar seu projeto de análise em um projeto de implementação em Delphi Win32 ou em Delphi .Net ou C# (.Net).

Para criar um novo projeto de design, selecione File | New | Other para acessar a caixa de diálogo New Items e na lista de opções Itens Categories selecione Design Projects e em seguida escolha UML 1.5 Design Projects para criar projetos utilizando a versão 1.5 da UML ou UML 2.0 Design Projects para utilizar a versão mais atual da mesma.

Usando UML dentro de seus projetos Delphi.

Vamos criar um novo projeto para demonstrarmos o uso de UML dentro de projetos Delphi já existentes. Isto pode ser feito em qualquer tipo de projeto Delphi Win32, Delphi .Net ou C#, pois são as personalidades que possuem suporte aos recursos do Together.

O Delphi 2006 permite que o desenvolvedor possa eleger em que projetos vai utilizar ou não as capacidades do Together. Isto pode ser feito de diversas maneiras, mas a mais prática é selecionar o painel Model View logo após ter aberto um projeto. Se o seu projeto ainda não está fazendo uso dos recursos do Together o Delphi 2006 abrirá a caixa de diálogo Add Model Support perguntando se você gostaria de adicionar as capacidades de modelagem ao seu projeto, dê um clique no botão Yes para habilitar os recursos do Together em seu projeto.

O acesso ao designer de diagramas UML no Delphi 2006 é feito através do painel Model View, em sua configuração original, o painel Model View está disponível como uma aba ao lado do Database Explorer.

O painel Model View apresenta uma estrutura hierarquica de seu projeto representando os seus namespaces. Todo projeto terá um namespace raiz conhecido como default que será o namespace raiz , note também que seram criados um namespace para cada unit do projeto e um namespace para o próprio projeto, este por sua vez representando o arquivo dpr. Para poder ter acesso ao designer de qualquer elemento UML do Delphi 2006, dê um duplo clique sobre o ícone do elemento no painel Model View.

Dê um duplo clique sobre o ícone do namespace default no painel Model View, para abrir o seu designer UML.

O painel Model View com a superfície de design UML do namespace default.

Note que todo namespace possui uma classe com o esteriótipo UnitClass, esta classe na verdade representa a sessão implementation de toda unit de um projeto, isso permite que você tenha acesso a variáveis e rotinas definidas nesta sessão da unit que está trabalhando.

O desenho dos diagramas UML funciona basicamente como o desenho de um Form no Delphi 2006, ou seja, uma vez que você tenha um diagrama aberto, todos os elementos disponíveis para aquele diagrama estarão disponívels no Component Palette, para incluir um elemento, basta selecionar-lo no Component Palette e em seguida, dar um clique sobre o diagrama.

Incluiremos no namespace defaul, dois packages, um chamado casosdeuso e outro minhasclasses. Agora daremos um duplo clique no namespace casosdeuso e criaremos um novo diagrama, para isso, dê um clique com o botão direito sobre o diagrama e selecione Add | Other Diagram… no menu de contexto apresentado para poder acessar a caixa de diálogo Add New Diagram.

Criaremos um diagrama de caso de uso, então, selecione Use case diagram na lista Diagrams e digite Cadastro de Clientes no campo name.

Criando um novo diagrama de Casos de Uso

Neste caso de uso incluiremos um ator chamado Usuario e dois casos de uso, Incluir ClienteApagar Cliente. Para isso vamos dar um duplo clique sobre o diagrama Cadastro de Clientes no painel Model View, note que automaticamente a Tool Palette apresenta somente elementos para o diagrama de casos de uso. Selecione um ator (Actor) e clique sobre o designer do diagrama. Repita o processo para os dois casos de uso (Use Case).

Agora vamos representar a interação entre o ator (Usuario) e o seus casos de uso (Incluir Cliente e Apagar Cliente), para isso selecione o elemento Communicate na Tool Palette, agora dê um clique sobre o ator, e em seguida dê um clique sobre o caso de uso Incluir Cliente, repita o processo para o outro caso de uso.

Um diagrama de Casos de Uso com o Component Palette correspondente

Vamos agora criar um diagrama de classes para representar o domínio de nossos casos de uso. A idéia aqui é criar um diagrama que possa oferecer uma visão mais concreta das entidades que estarão envolvidas na realização dos casos de uso.

Dê um duplo clique sobre o package implementação no painel Model View, note que os packages são na verdade diagramas de classes e por isso, você pode construir seus modelos diretamente neles.

Vamos incluir duas classes no diagrama Implementação, uma chamada CatalogoClientes que será responsável por representar as regras de negócio de nosso cadastro e uma chamada Cliente que representará os atributos e comportamentos de nossa entidade Cliente. Para isso dê um clique sobre o elemento Class na Tool Palette e em seguida dê um clique sobre o diagrama Implementacao, mude o nome da classe de Class1 para CatalogoClientes, repita a operação para criar a classe Cliente.

Agora que temos nossas classes, podemos começar a incluir seus respectivos atributos, propriedades e métodos. Vamos começar criando as propriedades da classe Cliente, para isso, dê um clique com o botão direito sobre a classe Cliente e selecione Add | Property no menu de contexto apresentado. Note que a propriedade aparecerá criada dentro da classe e pronta para ter seu nome alterado, note também que já foram criadas as respectivas rotinas Get/Set para ajudar no encapsulamento do atributo responsável por manter o dado da propriedade. Por default a representação da propriedade é feita da seguinte forma “-nome:tipo”, logo se você já conhece os tipos disponíveis pode automaticamente renomear a propriedade e definir o seu tipo de uma só vez, em nosso caso, vamos escrever “codigo:Integer” para criarmos uma propriedade chamada codigo do tipo Integer. Vamos repetir o processo e criar outra propriedade chamada nome do tipo String.

Agora que temos nossa entidade Cliente criada, vamos criar na classe CatalogoClientes, as operações responsáveis por concretizar um de nossos casos de uso Inserir Cliente. Para isso dê um clique com o botão direito sobre a classe CatalogoClientes e selecione Add | Procedure no menu de contexto apresentado. A procedure (ou método se você preferir) aparecerá criada dentro da classe e pronto para ser alterada, por default a sua representação é feita da seguinte forma “+nome”,da mesma forma que nos atributos, você pode descrever o método em uma só operação, então, vamos escrever “+incluirCliente()” para criarmos um metodo chamado incluirCliente. Este método terá dois parâmetros; um chamado codigo do tipo int e outro chamado nome do tipo string, para poder incluir os parametros no método, precisaremos alterar a propriedade Params de nossa classe, como já era de se esperar, as propriedades de um elemento UML (nesse caso atributos e métodos de uma classe) estão disponíveis no Object Inspector. Selecione o método incluirCliente e em seguida digite codigo:integer;nome:string como valor da propriedade Params.

O modelo de classes com o Object Inspector apresentando as propriedades para o método incluirCliente.

A qualquer momento, se você quiser acessar o código que representa um determinado elemento (classes, atributos, propriedades, métodos e etc…), basta selecionar o elemento, dar um clique com o botão direito do mouse e selecionar Go to Definition no menu de contexto.

Agora que já sabemos criar diagramas e incluir elementos UML podemos compreender alguns recursos úteis disponíveis no designer UML do Delphi 2006.

Recursos do designer UML

Você pode ampliar ou reduzir a visão que tem de um diagrama através do recurso de zoom, para controlar o campo de visão de um diagrama, tecle “ – “ (zoom out) ou “ + “ (zoom in) no teclado numérico de seu computador repetidas vezes até alcançar a visão desejada (se estiver usando um notebook, utilize a tecla Fn em conjunto com a tecla que representa o símbolo de “ – “ ou o símbolo de “ + “) existe a opção de dar um clique com o botão direito e selecionar Zoom | Zoom out mas sinceramente, o teclado é muito mais rápido.

Quem já trabalhou com qualquer ferramenta de modelagem sabe a dificuldade de navegação nos diagramas quando eles se tornam muito grandes (alguém ai ja viu um diagrama de classes com algumas dezenas delas?). Para facilitar sua navegação nesses diagramas, utilize a janela Overview que fica no canto direito inferior de todo diagrama. Ela apresenta um overview do diagrama inteiro com uma guia (um pequeno retangulo) que pode ser arrastado até a área do diagrama que se deseja trabalhar.

Outro encomodo comum em diagramas com grande quantidade de entidades é a complexidade na compreensão dos relacionamentos existentes entre elas. O designer UML do Delphi 2006 pode ajustar a disposição dos elementos de um diagrama de forma a facilitar sua compreensão, para isso, dê um clique com o botão direito do mouse sobre o diagrama e selecione Layout | Do Full Layout.

Utilizando Design Patterns

A idéia da utilização de Design Patterns é permitir o reuso de melhores práticas existentes no mercado ou até mesmo dentro de sua equipe. O Delphi 2006 vem com os famosos patterns do GOF (Gang of Four, lembram do livro com os patinhos voando na capa?) já disponíveis em seu catálogo.

Para poder criar uma classe de acordo com um pattern, basta dar um clique com o botão direito sobre a superfície de um diagrama e selecionar Create by Pattern no menu de contexto para poder ter acesso ao Pattern Wizard.

No Pattern Wizard os patterns ficam organizados por pastas, para cada pattern disponível existe uma breve descrição que explica os benefícios de utilização do mesmo.

Uma vez selecionado o pattern desejado, basta preencher as suas respectivas propriedades exibidas na lista Pattern Properties e em seguida dar um clique no botão OK, pronto, sua classe foi criada de acordo com o pattern selecionado.

O Pattern Wizard com o pattern de Singleton selecionado.

Você também pode gerar seus próprios patterns, é importante notar que um pattern pode ser composto por um ou diversos elementos UML, ou seja, em um diagrama de classe, podemos gravar uma classe ou um conjunto de classes e suas associações como sendo um pattern.

Para poder gerar seu pattern, basta selecionar todos os elementos que farão parte dele, dar um clique com o botão direito sobre um dos elementos e selecionar Save as Pattern no menu de contexto para poder acessar o Create Pattern Wizard.

No primeiro passo do Create Pattern Wizard você informará basicamente o nome de seu pattern no campo Name:, note que o wizard automaticamente utiliza o valor do campo Name como base para definir o nome arquivo xml (campo File:)que manterá as configurações de seu pattern. Você também pode definir uma descrição para seu pattern, para isso, preencha o campo Description.

Após preencher o nome e a descrição de seu pattern, dê um clique sobre o botão Next>> para poder acessar a página de parâmetros de seu pattern. Você poderá atribuir um conjunto básico de parâmetros para cada elemento participante de seu pattern, ou seja, se você estiver criando um pattern composto por duas classes e uma interface, sua lista de parâmetros conterá três entradas. Estes parâmetros serão apresentados dentro Pattern Wizard no momento da criação de um elemento baseado neste pattern.

Os parâmetros disponíveis para cada participante são:

Name – Nome do parâmetro

Display Name – Nome que será exibido ao lado do valor do campo que receberá o valor do parâmetro

Defaul Value – Valor que será apresentado como default para o parâmetro

Description – Descrição do parâmetro

Use Existent – Se marcada, esta opção permite que ao invés de criar um novo elemento baseado em seu pattern, a estrutura do pattern seja aplicado a um elemento existente.

Uma vez definidos os parâmetros, dê um clique sobre o botão Next>>. O último passo do Create Pattern Wizard permite que você defina em que folder do catálogo de patterns você gostaria que seu pattern fosse apresentado. Selecione o folder desejado e dê um clique sobre o botão Finish.

O Create Pattern Wizard com a lista de folders disponíveis para armazenar seu novo pattern

Melhorando a programação orientada a objetos através de Métricas

Quem é que não ouviu falar da velha ladainha “Alta Coesão, Baixo Acoplamento”? Acho que qualquer desenvolvedor que teve aulas ou conversou com algum outro desenvolvedor mais experiente em desenvolvimento orientado a objetos, já ouviu a famosa frase.

A maioria das pessoas, ao começar com desenvolvimento orientado a objetos se pergunta, como é que vou saber se minha implementação de código tem ou não, por exemplo, baixo acoplamento?

Para poder realizar tal tarefa, o desenvolvedor precisa terá que definir:

Qual indicador tem interesse em avaliar em um determinado projeto, por exemplo, complexidade

As faixas de um indicador, entendesse por faixa o menor valor e o maior valor aceitável para um indicador.

A técnica que será utilizada para obter o tal indicador, por exemplo, complexidade ciclomática.

Depois de determinar o indicador, sua faixa e sua técnica, o desenvolvedor terá que executar um trabalho de revisão de código, buscando calcular o valor do indicador o que pode tomar algumas horas de seu dia, por este motivo, quase nenhuma equipe executa tal operação.

Na verdade um dos maiores desafios no desenvolvimento de software sempre foi e será, aumentar a qualidade sem afetar a produtividade da equipe.

Graças ao se recurso de Métricas, o Delphi 2006 permite que o desenvolvedor melhore a qualidade de suas aplicações com uma produtividade não encontrada em nenhuma outra ferramenta. Através da Métricas, você poderá selecionar que indicadores quer obter (coesão, complexidade, acoplamento e etc…) definir suas faixas de aceitação e o Delphi 2006 faz o resto.

Para poder eleger seus indicadores e definir suas faixas, selecione o painel Model View, dê um clique com o botão direito sobre o ícone com o nome do projeto e selecione QA Metrics, a caixa de diálogo QA Metrics será exibida:

A caixa de diálogo QA Metrics.

Agora você poderá selecionar que indicadores gostaria de avaliar em seu código e quais as faixas aceitáveis como resultado de cada indicador, em seguida, dar um clique sobre o botão Start.

Basicamente o Delphi 2006 faz uma revisão de todo o seu projeto confrontando os valores encontrados dos indicadores selecionados com as faixa definidas pelo desenvolvedor e gerando um relatório apresentando os resultados encontrados para cada indicador, por namespace e por classes.

A tabela de resultados de métricas.

Garantindo a utilização de melhores práticas através de Auditorias.

Quantas vezes você já definiu um guia de melhores práticas de codificação que evitasse que sua equipe de programadores cometessem aquelas gafes de codificação que podem tornar o código tão ineficiente quanto incompreensível?

Suponhamos que sua equipe tenha um guia de melhores práticas, a segunda pergunta fatalmente é; Como podemos garantir que o guia está sendo seguido?

A resposta novamente será, revisão de código (code review), e se encaixarmos tal prática no contexto de um projeto com milhares de linhas de código, sabemos que o resultado pode ser catastrófico no que diz respeito a tempo.

Através do recurso de auditoria de código (QA Audits) do Delphi 2006 você poderá finalmente definir um conjunto de boas práticas de codificação e garantir que estas práticas estão sendo seguidas em seus projetos.

Basta dar um clique com o botão direito sobre o ícone de seu projeto no painel Model View e selecionar QA Audits no menu de contexto apresentado.

A caixa de diálogo QA Audits com uma auditoria selecionada.

Na caixa de diálogo QA Audits, selecione um conjunto de práticas de implementação que você gostaria de garantir, defina os parâmetros de análise para cada prática (severidade por exemplo) e dê um clique sobre o botão Start.

Semelhante ao trabalho realizado com o recurso de QA Metrics, o Delphi 2006 fará uma revisão de todo o seu projeto validando se as práticas foram respeitadas ou não e gerando um relatório apresentando todas as práticas que não foram respeitadas e com seus arquivos e linhas de código respectivos.

A tabela de resultado da Auditoria de código

Gerando a Documentação de seu Projeto

Quantos projetos você tem feitos em Delphi que não possuam nenhum tipo de documentação? Com o Delphi 2006 você poderá fazer uma engenharia reversa de todas as units de um projeto, gerar os diagramas de classe e os diagramas de sequencia para seus métodos e em seguida, gerar um web site contendo estes diagramas de uma forma bastante estruturada.

Para gerar um web site contendo a documentação de um projeto, selecione Tools | Generate Documentation. Na caixa de diálogo Generate Documentation, você encontrará as seguintes opções para gerar a documentação:

Current namespace (o namespace atualmente selecionado)

Current namespace with descendant namespaces (o namespace atualmente selecionado e todos os outros namespaces que estejam dentro dele)

Current diagram (o diagrama atualmente selecionado)

All (todo o projeto)

Dê um clique sobre o botão OK e o Delphi 2006 irá gerar toda a documentação de seu projeto em formato HTML e pronta para ser publicada em um web site.

A documentação de um projeto sendo apresentada no Browser.

Conclusões

O casamento Together e Delphi 2006 levou um tempo para acontecer, mas sem dúvida, tornou o Delphi um ambiente completo para toda a fase de análise e construção de uma aplicação Win32 ou .Net. O resultado deste casamento é o aumento da qualidade de suas aplicações sem impactar diretamente na sua produtividade, se somarmos então as capacidades do ECO III, teremos não só maior qualidade como um aumento de produtividade animal no desenvolvimento para .Net seja em WinForms ou ASP.Net.

Published on: 10/17/2006 10:53:23 PM

Server Response from: ETNASC01

Retirado de: http://edn.embarcadero.com/article/33730

Manipulando um arquivo XML através de um ClientDataSet

esse é sensasional!

By: Rodrigo Leonhardt

Introdução

O uso de arquivos XML se torna cada dia mais comum, por oferecer um padrão capaz de trafegar entre ambientes heterogêneos, tornando a integração uma realidade em ambientes de soluções tecnologicamente diferentes entre si.

Transformando o arquivo XML

Uma vez de posse de um arquivo XML, é preciso manipulá-lo em meio à aplicação. Existem várias formas de realizar esse processo de manipulação, e entre elas está o uso do componente XMLTransformProvider.

Para exemplificar o uso do componente, será utilizado um arquivo XML de nome arquivo1.xml com o seguinte conteúdo:

<clientes>
  <cliente>
    <codigo>1</codigo>
    <nome>Cliente 1</nome>
    <telefone>1234-5678</telefone>
  </cliente>
  <cliente>
    <codigo>2</codigo>
    <nome>Cliente 2</nome>
    <telefone>9876-5432</telefone>
  </cliente>
</clientes>

Primeiramente um novo projeto deve ser criado, através do menu File>New>VCL Forms Application – Delphi for Win32.

Em seguida o arquivo XML deve ser mapeado através da ferramenta XML Mapper, que pode ser encontrada no menu Tools>XML Mapper.

Hide image
Click to see full-sized image

Imagem 1 – Interface do XML Mapper

Através do menu File>Open selecionando o arquivo1.xml será exibido do lado esquerdo da interface, a estrutura do arquivo XML com seus respectivos nós e atributos.

Ao clicar com o botão direito do mouse sobre as informações exibidas, selecione a opção Select All, para que todos os nós sejam considerados na transformação e exibidos na área central da interface, como exibido na Imagem 2 abaixo.

Hide image
img2

Imagem 2 – Menu exibido ao clique direito do mouse

Em seguida, através do menu Create>Datapacket from XML serão exibidas informações do lado direito da interface, referentes ao pacote de transformação XML criado com base no documento original.

Após isso, clique com o botão direito do mouse sobre a área central da interface, e selecione a opção Create Transformation do menu.

Por fim, clique no menu File>Save>Transformation para salvar o arquivo de transformação com o nome ToDp.xtr. O arquivo de transformação é um arquivo de conteúdo XML, que contém informações necessárias para que o arquivo original seja transformado em um DataPacket, que é um formato utilizado pelo Provider do Delphi para envio e recepção de dados.

Criando a interface

Visualizando o Form Designer, devem ser inclusos alguns componentes para manipulação e visualização dos dados originados do arquivo XML.

Inicialmente inclua o componente XMLTransformProvider da palheta Data Access. Altere a propriedade XMLDataFile para o caminho onde está o arquivo XML arquivo1.xml. Altere também a propriedade TransformRead>TransformationFile indicando o caminho onde está o arquivo de transformação ToDp.xtr.

Em seguida inclua o componente ClientDataSet da palheta Data Access. Altere a propriedade ProviderName indicando o componente XMLTransformProvider criado anteriormente. Altere também a propriedade Active para True.

Depois inclua o componente DataSource da palheta Data Access. Altere a propriedade DataSet indicando o ClientDataSet criado anteriormente.

Finalmente inclua o componente DBGrid da palheta Data Controls. Altere a propriedade DataSource indicando o componente DataSource criado anteriormente.

Ao final desses passos, o resultado visual será o exibido na Figura 3 abaixo.

Hide image
Click to see full-sized image

Imagem 3 – Resultado visual final

Conclusão

Com a utilização do componente XMLTransformProvider, o arquivo XML pode ser transformado para uma outra estrutura desejada, e convertida para o formato DataPacket, que pode ser utilizado em conjunto com o ClientDataSet para manipular os dados como se estivessem em uma tabela de um banco de dados.

Além do apresentado, também é possível gerenciar os dados na ferramenta XML Mapper, como mudar o nome dos atributos, definir a dimensão dos dados, omitir atributos, e outras funcionalidades.

retirado: http://edn.embarcadero.com/article/37321

Seguir

Obtenha todo post novo entregue na sua caixa de entrada.

Junte-se a 552 outros seguidores