abril 2009
abril 2009
Índice
Vitor Manuel
Rodrigues
Editorial
O Visual Studio 2010
e .NET Framework 4,0 em
breve estará em fase beta,
e Juntamente com este
lançamento, veremos o lançamento da versão 4.0 da
linguagem de programação
C #. Assim nesta edição
Fabiano Belmont no seu
artigo C3 4.0 irá olhar um
pouco a trás de
onde começou
a linguagem...
04
C# 4.0
Simulando Inumeric com o
dynamic do C# 4.0
O backup é mesmo importante?
DataSnap2009 - Parte II
A resposta é unânime entre os profissionais da área de informática.
“SIM! O backup é muito importante, e
bla bla bla...!”
Então faço outra pergunta.
- Porque “raios” esses mesmos profissionais que rezam a ladainha do backup não
fazem backup de seus preciosos
dados?
Será que eles pensam serem imunes a vírus, falhas ...
Delphi no Windows Vista
05
.NET
Delphi
Utilizando arquivo de
configuração UDF com ADO
Controle de versão de
software utilizando o JEDI
VCS
Dicas Delphi
22
Acertar a data e a hora através do sistema
26
Ocultar/exibir a barra de tarefas do windows
Evitar a proteção de tela durante seu programa
Verificar o estado de NumLock e CapsLock
Verificar se uma string contém um valor numérico válido
28
Limitar e região de movimento do mouse
Obter o espaço total e livre de um disco
Desafio
The CLub
Legenda
Iniciante
Intermediário
06
09
12
15
Teste seus conhecimentos.
Avançado
abril 2009
30
03
Bem-vindo
O Visual Studio 2010 e .NET Framework 4,0 em breve estará em fase
beta, e Juntamente com este lançamento, veremos o lançamento da versão 4.0 da linguagem de programação C #. Assim nesta edição Fabiano
Belmont no seu artigo C3 4.0 irá olhar um pouco a trás de onde começou
a linguagem de programação C # e olhar para onde Anders Hejlsberg do
C # e sua equipe querem chegar.
Neste mês dou continuidade para meu artigo de Datasnap 2009 Parte
II – Acesso a dados, onde mostro como é simples retornar dados através
de um objeto TDataset da uma aplicação Servidora para uma aplicação
cliente.
Temos também Victory Fernandes que após alguns meses sem escrever
para nossa revista esta de volta com o artigo Delphi no Windows Vista,
onde ele mostra dicas importantes e esclarece duvidas comuns de nossos
sócios para o bom funcionamento do Delphi neste sistema operacional tão
controverso.
O consultor do The Club Luiz Alexandre escreve sobre a ferramenta
de controle de versões JEDI Version Control System, sendo o controle de
versões um dos processos no desenvolvimento de software em equipe,
umas das grandes dificuldades encontradas em empresas e equipes desenvolvedoras de software.
Marco Antonio Armando vem com o artigo “Utilizando arquivo de configuração UDL com ADO”, embora o uso de arquivo de configuração de
conexão a dados UDL, seja relativamente simples, ainda é um recurso
pouco conhecido e utilizado pelos desenvolvedores que fazem uso dos
componentes de acesso a dados ADO.
Desejo mais uma vez uma boa leitura a todos e que tirem o maior proveito possível de nossa revista. Vale lembrar que estamos sempre abertos
a sugestões e criticas, caso tenham algo a nos dizer não percam tempo, me
envie um e-mail com suas reclamações e sugestões, isto irá com certeza
contribuir para a melhoria de nosso trabalho e conseqüentemente maior
satisfação de nossos sócios.
Av. Profº Celso Ferreira da Silva, 190
Jd. Europa - Avaré - SP - CEP 18.707-150
Informações: (14) 3732-1529
Suporte: (14) 3733-1588
Internet
http://www.theclub.com.br
Cadastro: [email protected]
Suporte: [email protected]
Informações: [email protected]
Skype Cadastro: theclub_cadastro
Skype Suporte: theclub_linha1
theclub_linha2
Copyright The Club Megazine 2008
Diretor Técnico
Marcos César Silva
Diagramação e Arte
Vitor M. Rodrigues
Revisão
Marcos César Silva
Colunistas
Antonio Spitaleri Neto
Fabiano Belmonte
Luís Alexandre de Oliveira
Marco Antonio Armando
Marcos César Silva
Victory Fernandes
Vitor M. Rodrigues
Impressão e acabamento:
GRIL - Gráfica e Editora
Rua São Paulo, nº 447
Cep: 18740-00 - 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.
Um grande abraço a todos.
Marcos César Silva - Editor Chefe
[email protected]
04
abril 2009
Delphi é marca registrada da Borland International,
as demais marcas citadas são registradas
pelos seus respectivos proprietários.
Vitor M. Rodrigues
O backup é mesmo importante?
de proteger seus dados...
A resposta é unânime entre os profissionais da área de informática.
“SIM! O backup é muito importante, e
bla bla bla...!”
Então faço outra pergunta.
- Porque “raios” esses mesmos profissionais que rezam a ladainha do backup não
fazem backup de seus preciosos dados?
Será que eles pensam serem imunes a
vírus, falhas de arquivos, pessoas que apagam
arquivos sem querer, etc.?
R
ecebemos todos os meses pedidos de
sócios para tentar recuperar um banco
de dados que está com “pau”, ou se conhecemos um programa para recuperar
arquivo deletado, e coisas do gênero.
A primeira coisa que os técnicos perguntam.
“Já restaurou o backup?”
A resposta é sempre a mesma.
“Hum, Backup! Não temos backup!”
Ainda tem aqueles que dizem:
- Mas como? Estava funcionando agora pouco!
Como foi estragar?
Pra esses eu digo:
“- Só estragou porque estava funcionando, se
não estivesse não estragaria.”
Já tivemos casos de pessoas que perderam o
banco de dados (provavelmente alguém apagou
por engano ou não! Vai saber...) e renomearam
um arquivo qualquer com extensão de banco de
dados e mandaram para a gente tentar “recuperar” os dados.
BACKUP!
Existem várias formas de efetuar backup, tem
pra todo gosto.
Não venham com desculpas de que dá trabalho
fazer backup, o custo de um servidor de backup é
alto, não lembro de fazer backup, etc.
Vamos derrubar as desculpas mais esfarrapadas para não fazer backup com soluções práticas.
Desculp a 1 => Não faço backup
por que o custo de um servidor é muito
alto para os padrões de minha empresa.
Desculp a 2 => Não faço backup
por que perde-se muito tempo fazendo
backup, meus funcionários não podem
perder esse tempo. Afinal eu pago eles
para trabalhar.
Desculp a 3 => Não faço backup
por que na correria acabo esquecendo.
Soluções
Se o problema é custo, pode particionar o
HD de uma de suas máquinas e usá-lo para fazer
o Backup.
Agora se o problema é tempo ou esquecimento, você pode usar um dos infinitos softwares que
realizam backup automaticamente.
Outra coisa que sempre falo:
- Trabalhamos com “tecnologia”, não com
“magia”.
Por outro lado seu o seu problema
é falta de conhecimento de como fazer
um backup vai aí à sugestão.
Se alguém fizer esse tipo de milagre, por
favor, envie seu currículo ao The Club. Contrato
imediato!
Para os demais mortais só existe uma maneira
Compre um HD externo, normalmente eles já vêm com softwares de
controle de backup.
Caso o HD que você comprou não
veio com software ou você não gostou dele compre
um que se adapte ao seu modo de trabalhar ou
baixe um gratuito.
Esses softwares fazem backup programado,
sincronismo entre pastas, e são muito simples
de utilizar.
HD externo de 1TB => R$650,00
Software de Backup => R$90,00
Tempo para instalar e configurar o
programa de backup => 05 minutos
A expressão de “bocó” quando se perde um
banco de dados sem backup => NÃO TEM
PREÇO!
Se você é desses que tem seus backups em
dia. Parabéns!
Agora se você é daqueles que recomenda, mas
não faz backup. Boa sorte!
Caso tenha alguma dúvida sobre qual programa utilizar ou como adaptar um sistema de backup
a necessidade de sua empresa entre em contato,
terei o maior prazer em ajudar.
Espero ter ajudado ou pelos menos alertado
sobre o assunto.
Em breve nesse mesmo horário e nesse
mesmo canal!
Aquele abraço e beijo nas crianças!
abril 2009
05
Delphi
MySQL entre outros.
1.
Introdução
Na primeira parte de nosso artigo sobre
DataSnap 2009 mostrei como criar um servidor
de métodos DataSnap, e uma aplicação cliente
que consumia os métodos disponíveis no servidor. Nesta segunda parte irei demonstrar como
criar um método para retornar um conjunto de
dados, ou seja, um objeto TDataset resultante de
uma consulta de dados feita na classe servidora.
Para este projeto de exemplo irei usar o projeto
iniciado na primeira parte deste artigo, assim é
muito importante que o leitor leia a primeira parte
deste artigo e faça o download de seu exemplo no
seguinte link:
Figura 1 – Conexões existentes
Figura 3 – Conexão EMPLOYEE criada
Veja a Figura 4.
3.
http://www.theclub.com.br/revista/rev0309/
Datasnap2009.rar
2.
Criando conexão
Nesta primeira etapa vamos registrar o banco
de dados na “Data Explorer” para facilitar o processo de criação da conexão e consulta de dados,
para isto na janela Data Explorer adicione uma
nova conexão no driver INTERBASE para dbExpress
como pode ver na Figura 1, na janela Add New
Connection (Figura 2) que será exibida, informe o
nome EMPLOYEE para a conexão.
06
abril 2009
Figura 2 – Nomeando nova conexão
Agora configure a conexão clicando com o
botão direito do mouse sobre a conexão EMPLOYEE
criada (figura 3), e informe em Database Name o
caminho e nome do banco, onde como estamos
usando o banco de dados Firebird o usuário será
SYSDBA e a senha masterkey (figura 4). Lembrando
que esta configuração pode ser feita também para
outros bancos de dados como, Oracle, SQLServer,
Módulo Servidor
Para facilitar o desenvolvimento deste exemplo iremos dar continuidade no projeto iniciado
no artigo anterior, assim abra o grupo de projeto
DatasnapProjectGroup.groupporj, e em Project
Manager abra o Servermodule unServerModule.
pas (figura 5), feito isto vá à janela do Data Explorer
e selecione a tabela CUSTOMER da conexão (figura
6) que criamos na etapa anterior, e “arraste” com o
mouse e solte sobre o DSServerModule1, observe
que será criado automaticamente (Figura 7) o
componente EMPLOYEE: TSQLConnection; devidamente configurado com a conexão de dados,
e componente CUSTOMER: TSQLDataSet; com
type
TDSServerModule1 =
class(TDSServerModule)
EMPLOYEE:
TSQLConnection;
CUSTOMER: TSQLDataSet;
private
{ Private declarations
}
public
function
PegaVersao:string;
function
GetCustomers:TDataset;
end;
Figura 4 – Configurando a nova conexão
a propriedade CommandType selecionada em
ctTable e CommandText com a tabela CUSTOMER
selecionada.
Para efeito de teste altere a propriedade Active
do componente TSQLDataSet CUSTOMER para true,
assim automaticamente a mesma propriedade do
componente TSQLConnection EMPLOYEE deverá
ficar true, assim estaremos testando se a conexão
e ligações foram criadas corretamente.
Criaremos agora o método de retorno de
dados, digite então na seção public da classe
TDSServerModule1, o cabeçalho da função GetCustomers, observando que a tipo do retorno da
função será uma classe de dados TDataset, ficando
da seguinte forma:
function
GetCustomers:TDataset;
Figura 5 – Selecionando o ServerModule
Figura 6– Selecionando a tabela desejada
Dica da IDE: Com o curso de digitação sobre
o nome da função pressione as teclas Shift+Ctrl+C
para executar “Complete class at cursor”, que irá
criar na seção implementation dos fontes o corpo
do método de forma automática. Adicione então
neste método os códigos para abertura da tabela
CUSTOMER e o Result da function. Veja abaixo
como será o código desta Unit:
var
DSServerModule1:
TDSServerModule1;
implementation
{$R *.dfm}
{ TDSServerModule1 }
function TDSServerModule1.
GetCustomers: TDataset;
begin
CUSTOMER.Open;
Result := CUSTOMER;
end;
function TDSServerModule1.
PegaVersao: string;
begin
Result := ‘Versão 1.0’;
end;
end.
Execute o projeto Server com a opção Run
Without Debugging Shift+Ctrl+F9, para que a
aplicação Servidora fique executando (figura 8)
independente da execução do Delphi.
unit unServerModule;
interface
uses
SysUtils, Classes,
DSServer, WideStrings,
DBXInterbase, FMTBcd, DB,
SqlExpr;
Figura 8 – Opção de execução
Figura 7 – Visualização do ServerModule
abril 2009
07
4.
Módulo Cliente
Nesta etapa vamos consumir o método de
acesso a dado criado na aplicação servidora, primeiramente vamos atualizar a classe cliente DataSnap, para isto remova a classe já criada no artigo
anterior que agora está desatualizada com relação
os novos métodos criados na aplicação servidora.
Para remover esta classe vá à janela Project Manager selecione a unit unClientClass.pas e remova do
projeto como pode observar na figura 9.
Agora clique com o botão direito do mouse
sobre o componente SQLConnection1 e selecione
a opção “Generate Datasnap cliente class” (figura
10), e salve a classe cliente com o nome já usando
anteriormente unClientClass.pas, sobrescrevendo
o arquivo criado anteriormente.
Figura 12 – Form cliente em tempo de design
der1;
•
DataSource1: TDataSource e ligue sua
propriedade Dataset ao ClientDataSet1;
•
DBGrid1: TDBGrid e ligue sua propriedade DataSource ao DataSource1;
Finalmente adicione um Button3: TButton e no
seu evento onclick abra a conexão do Clientdataset
como pode ver no código abaixo:
procedure TfrmClient.
Button3Click(Sender:
TObject);
begin
ClientDataSet1.Open;
end;
5.
Conclusão
Nestas duas partes do artigo foi possível
demonstrar novos recursos e funcionalidades do
DataSnap 2009, além é claro de como usar estes
recursos, onde o leitor pode perceber como ficou
muito mais simples trabalhar com esta tecnologia, o que no artigo não foi possível demonstrar
é como uma aplicação remota pode ficar muito
mais rápida, ou seja, não podemos demonstrar
sua performance. De qualquer forma acredito que
o leitor irá ficar muito satisfeito com o resultado
obtido desenvolvendo aplicações de acesso remoto
usando esta tecnologia.
Download:
http://www.theclub.com.br/revista/rev0309/Datasnap2009.rar
Figura 9 – Removendo classe do projeto
Referência:
http://blogs.embarcadero.com/
andreanolanusse/2008/10/16/exemplos-datasnapdbexpress-e-outros-recursos-do-delphi-2009/
Figura 10 – Gerando nova classe
Adicionaremos no form o componente SqlServerMethod2: TSqlServerMethod na sua propriedade SQLConnection selecione componente
SQLConnection1 e na propriedade ServerMethodName selecione TDSServerModule1.GetCustomers
(figura 11) criado na aplicação servidora. Agora
adicione um:
•
DataSetProvider1: TDataSetProvider e
ligue sua propriedade Dataset ao SqlServerMethod2;
•
ClientDataSet1: TClientDataSet e ligue
sua propriedade ProviderName ao DataSetProvi08
abril 2009
Sobre o autor
Figura 11 – Configurando SqlServerMethod
Verja Figura 12
Marcos César Silva, Consultor de
Sistemas na consultoria de sistemas DataSmart
e Consultor Técnico do The Club, Bacharel em
Ciência da Computação, MBA em Gestão Empresarial, Certificações MCAD (Microsoft Certified
Application Developer) e MCSD.NET (Microsoft
Certified Solution Developer .NET)
Delphi no
Windows Vista
Você já instalou qualquer versão do Delphi, abaixo da versão BDS2009, no Windows
Vista? Então você sabe que os problemas
começam logo após o fim da instalação!
Este artigo traz algumas dicas simples de como
usar o Delphi no Windows Vista.
Executando o Delphi no Windows
Vista
Após instalar o Delphi no Windows
Vista, a primeira coisa que descobrimos
é que o Vista acusa que o programa em
questão possui algum tipo de incompatibilidades e “bla, bla, bla”
Para executar o programa corretamente, clique
com o botão direito do mouse sobre o ícone do Delphi, selecione a opção “Propriedades” e, na paleta
Figura 01: Configurações de compatibilidade nas propriedades do aplicativo.
abril 2009
09
“Compatibilidade”, marque as opções de “Executar
em modo de compatibilidade para o Windows XP”,
bem como a opção de “Executar como Administrador”, conforme mostrado na Figura 01.
Depois disso, sempre que você executar o
Delphi, surgirá uma janela de aviso onde você
deve clicar na opção “Permitir”, para executar o
Delphi normalmente. O procedimento descrito
anteriormente pode ser executado para qualquer
aplicativo que informe incompatibilidade com o
Vista, e tipicamente, após executado, o aplicativo
funcionará normalmente!
Abrindo arquivos de ajuda do Delphi
(.hlp) no Windows Vista.
Figura 02: Página de download da atualização do WinHlp32.exe para Windows Vista
Bom, agora que você conseguiu executar o
Delphi normalmente, você começa a trabalhar e, de
repente, surge uma dúvida sobre algum comando
ou função específica. O que você faz? Pressiona F1
ara abrir a ajuda, claro! Neste momento você descobre que o Windows Vista não executa arquivos
de ajuda do tipo “.hlp”, pois o aplicativo WinHlp32.
exe foi removido do sistema operacional!
Acontece que todos os arquivos de ajuda do
Delphi até a versão 7 estão em formato “.hlp” e as
versões “.chm” que acompanham o Delphi a partir
da versão do BDS2007 não chegam nem aos pés
das versões anteriores, são muito incompletas e
confusas! Eu diria inclusive que a Borland, hoje
CodeGear, retrocedeu consideravelmente ao adotar este novo padrão e não garantir que os novos
arquivos “”.chm” estivesse à altura dos arquivos de
ajuda “.hlp” existentes anteriormente!
Figura 03: Atualização do WinHlp32.exe para Windows Vista
Eu não sei o que passou pela cabeça de Bill Gates e do pessoal da Microsoft quando removeram
o suporte a arquivos “.hlp” do Windows Vista, pois
é fato que muitos aplicativos ainda adotam este
padrão de arquivos de ajuda. Felizmente existe
uma solução simples para o problema.
Acesse o endereço a seguir da página de
Windows Update mostrada na Figura 02 e Figura
03 onde, após o processo de validação da autenticidade do seu sistema operacional, é possível
realizar o download da atualização que corrige o
problema.
Figura 04: Executando arquivo “.hlp” no Windows Vista
10
abril 2009
http://www.microsoft.com/downloads/details.
aspx?displaylang=pt-br&FamilyID=6ebcfad9-d3f5-4365
-8070-334cd175d4bb
Uma vez executados todos os passos da atualização, você poderá retornar à sua vida normal e
executar arquivos “.hlp” normalmente no Windows
Vista, para qualquer aplicativo, incluindo o Delphi,
conforme mostrado na Figura 04.
Parece óbvio, mas ao trocar de notebook e
começar a trabalhar com Windows Vista eu passei
alguns dias inconformado com problemas tão simples que surgiam a todo instante e atrapalhavam o
andamento das minhas atividades cotidianas.
Sobre os autores
Victory Fernandes é Engenheiro
Mestrando em Redes de Computadores, e desenvolvedor sócio da TKS Software - Soluções
de Automação e Softwares Dedicados. Pode
ser contatado em [email protected], ou
através dos sites www.igara.com.br – www.
igara.com.br/victory
abril 2009
11
Utilizando arquivo
de configuração
UDL com ADO
Introdução
Neste artigo buscaremos mostrar como acessar uma base dados do Microsoft Access, utilizando
um arquivo de configuração UDL (Universal Data
Link), utilizando para isto, os componentes ADO
do Delphi.
O arquivo UDL é um arquivo de configuração
externa do sistema, equivale a um arquivo do tipo
DSN, para um provedor OLE DB. O UDL trata-se de
um arquivo que armazena uma string de conexão,
pois conterá informações referentes à conexão com
um banco de dados, tais como:
•
Nome do Servidor
•
Provedor Utilizado
•
Método de Segurança
•
Login a ser utilizado
no próprio ambiente de produção do cliente, sendo também que o arquivo UDL não necessita ser
registrado pelo sistema operacional.
Para se criar um arquivo UDL seguiremos as
seguintes etapas:
Abra o Windows Explorer, e abra o diretório
de sua aplicação, clique em “Arquivo” no menu do
Windows Explorer, e na opção “Novo”, selecione
“Documento Texto”, nomeie o arquivo como
“Dados.udl”.
Neste momento, iremos iniciar o processo
de configuração da string de Conexão do Arquivo
UDL. Assim dê um duplo clique no arquivo “Dados.
udl”, onde será disponibilizada a seguinte tela
(Figura 1):
Veja Figura 1.
Criação do arquivo
Uma das vantagens em se utilizar um arquivo
UDL está na facilidade em se distribuir a aplicação,
pois pode-se configurar as informações da conexão
12
abril 2009
Clique na aba (alça) “Provedor”, e selecione
“Microsoft Jet 4.0 OLE DB Provider”, conforme na
tela da Figura 2:
Veja Figura 2.
Figura 1
Figura 4
Figura 2
Posteriormente, vamos para a aba “Conexão”,
e no item 1 insira o Path onde se encontra a base
de dados, como por exemplo ”C:\Arquivos de
programas\Arquivos comuns\Borland Shared\
Data\dbdemos.mdb”, no item 2 informe o usuário
que no caso do nosso banco Access será “Admin”
e marque a opção de senha em branco conforme
a tela abaixo (Figura 3):
Figura 5
Poderemos efetuar o teste de conexão, clicando em “Testar conexão”.
Clique em OK, para salvar o arquivo.
Clicando com o botão direito do mouse sobre o
arquivo “Dados.udl”, selecione abrir com, selecione
Bloco de Notas. Observe como ficou nossa String
de Conexão (Figura 4):
Veja Figura 4.
Exemplo
Neste momento, já tendo criado nossa string
de conexão, partiremos para um exemplo de
conexão via ADO, utilizando o nosso arquivo UDL
criado.
Figura 3
na propriedade “Connection”, selecione ADOConnection1, e na propriedade “SQL”, insira a seguinte
instrução: SELECT * FROM EMPLOYEE.
Abra o Delphi, clique em “New” – “Application”,
insira neste form um componente ADOConnection,
da palheta ADO, um componete ADOQuery, também da palheta ADO, um componente DataSource,
da palheta DataAccess, e por fim adicione um DBGrid e um DBNavigator, da Palheta DataControls,
conforme a figura Figura 5:
Veja Figura 5.
Na propriedade “login prompt”, do componente ADOConnection1, altere para “false”, para
que quando executarmos nosso exemplo, não seja
solicitada login e senha de acesso. Agora selecione
o componente ADOQuery1, e no Object Inspector,
Selecione o componente DataSource1, e
na propriedade “DataSet”, no Object Inspector,
selecione “ADOQuery1”.
Na propriedade
“DataSource” do Object Inspector do DBGrid1,
selecione “DataSource1”.
Também na propriedade “DataSource” do
componente DBNavigator, selecione o componente
“DataSource1”.
E por fim, vamos inserir uma rotina que será
executada no evento OnCreate do Form1, que
atribuirá dinamicamente as configurações de conexão no componente ADOConnection1, através
dos parâmetros da string de conexão criada no
arquivo UDL, como no código abaixo:
procedure AbreConexao;
procedure
FormCreate(Sender:
TObject);
private
{ Private declarations
}
public
{ Public declarations
}
end;
var
Form1: TForm1;
implementation
abril 2009
13
Figura 6
{$R *.dfm}
procedure TForm1.
AbreConexao;
begin
ADOConnection1.Close;
ADOConnection1.
ConnectionString := ‘FILE
NAME=’+ExtractFilePath(App
lication.ExeName)+’Dados.
udl’;
try
AdoConnection1.Open;
except on E: Exception
do
begin
MessageDlg(‘Atenção:
Erro ao Abrir a
conexão.’#13#10 +
‘Erro:’ +
E.Message, mtWarning,
[mbOk], 0);
end;
end;
end;
procedure TForm1.
FormCreate(Sender:
TObject);
begin
AbreConexao;
ADOQuery1.Open;
end;
end.
14
abril 2009
Quando executarmos nosso exemplo, será
retornada a seguinte tela:
Veja Figura 6
Conclusão
Como vimos neste breve artigo, a
utilização de arquivo de configuração do
tipo UDL´s, facilita em muito quando necessitarmos de distribuirmos aplicações,
onde haja a necessidade configuramos
uma string de conexão no próprio cliente,
não tendo deixando este tipo de configuração estática na aplicação.
Até uma próxima!
Sobre o autor
Marco Antonio Armando
Consultor Técnico The club
Nesse artigo irei abordar o controle de
versão com a ferramenta JEDI VCS, que vem
de encontro com as solicitações dos nossos
associados.
Muitos problemas que ocorrem durante o
desenvolvimento de software são causados por
falta de controle sobre os arquivos do projeto. Faça
uma avaliação rápida da situação da sua equipe de
desenvolvimento:
1. Já perdeu alguma versão anterior do
código do projeto?
2. Tem problemas em manter diferentes
versões do sistema ao mesmo tempo?
3. Alguém da equipe já sobrescreveu o
código de outra pessoa por acidente e acabou
perdendo as alterações?
4. Tem dificuldades em saber quais as
alterações efetuadas em um programa, quando
foram feitas e quem fez?
Se alguma das perguntas acima teve um ‘sim’
como resposta, então sua equipe necessita urgen-
temente de
u m
sistema
para controle de versão.
É sabido que a grande
maioria dos desenvolvedores, tanto
de softwares para desktop quanto para a web,
conhecem o conceito de controle de versões.
Existem no mercado várias soluções prontas, que
ajudam os programadores a organizar e gerenciar
melhor seus desenvolvimentos. Porém a maioria
destas soluções são proprietárias, e possuem uma
operacionalidade bastante complexa.
Em meio a estas exite o JediVCS, uma alternativa gratuita para realizar esta tarefa. É bastante
utilizado no mundo de desenvolvimento de softwares para desktop.
O JediVCS opera com arquitetura cliente/servidor, sendo que o servidor de aplicação pode rodar
sobre
Fireb i rd ,
MySql,
SqlServer
ou Oracle,
podendo estes
vir, opcionalmente,
embutidos no mesmo
instalador do servidor de controle
de versões.
Sua instalação e implantação inicial é bem simples, não necessitando de amplos conhecimentos
em controle de versões para iniciar sua operação.
Vantagens proporcionadas pelo JEDI
•
Backup automático dos arquivos
•
Snapshots de arquivos(versão anterior
do arquivo é preservada)
•
Acompanhamento da evolução do
projeto
•
Comparação entre versões de arquivos
abril 2009
15
Download dos arquivos
O JediVCS pode ser obtido gratuitamente no
endereço :
http://sourceforge.net/project/downloading.
php?group_id=75615&filename=JVCSv2.43SalFib.
exe&a=62044491.
Faça o download da versão 2.43 dos arquivos
Client e Server respectivamente (versão StandAlone).
Instalação do Servidor
Como utilizarei o Firebird no artigo, escolhi a
versão correspondente ao mesmo JVCSv2.43SrvFib.
exe.
Para instalar o servidor, basta seguir as instruções apresentadas pelo programa de instalação
(figura1)
Figura1
Veja Figura1.
Estamos utilizando uma versão embarcada do
servidor firebird.
Se seu Windows for em português, o script
contendo todos os comandos SQL para geração
das tabelas, triggers, generators etc se encontra
na pasta:
C:\Arquivos de programas\JEDI\JVCS\server\archive\
db_fib
Observe que na pasta há dois arquivos:
fib_ib_create.sql e fib_ib_defvalues.sql. O primeiro
cria os objetos de banco de dados e o segundo
insere valores nas tabelas
Clique OK e o servidor JEDI VCS já estará
rodando (figura 2).
Veja Figura 2
Figura2
Instalação do Cliente
A instalação do Cliente é mais tranqüila que a
instalação do servidor. Basta executar o script . Vale
a pena ressaltar uma opção: A instalação de um
plug-in para a IDE do Delphi que permite acessar
as funções do versionamento sem precisar acessar
16
abril 2009
o aplicativo clente externo. Figura 3
Veja Figura 3
Criando Usuários
O JEDI VCS permite que sejam criados usuários
para acessar o controle de versão e definir a forma
de acesso. Após rodar o script fib_ib_defvalues.sql
durante a configuração do Servidor, um usuário
chamado SYSDBA, com senha admin é criado, com
direitos plenos de acesso. É através dele que outros
usuários serão criados.
Abra o JEDI VCS Client (Iniciar>Programas>JE
DIVCS>StandAlone GUI client), e na tela de login
informe as credencias mencionadas anteriormente,
juntamente com o endereço IP da máquina onde o
servidor está rodando.
Caso o servidor esteja na mesma máquina do
cliente, não use localhost ou 127.0.0.1 . Especifique
o endereço IP exato de sua máquina ou selecione a
aba Options na tela de login e marque a caixa Use
always current local IP as host name.
Figura 4 . definindo os usuários do controle de
versão
Interface do Cliente
A figura 5 mostra a interface principal do
aplicativo cliente
Veja Figura 5
Nela podemos destacar
•
Project tree: ficam listados todos os
projetos arquivados pelo controle de versão. Pastas
podem ser criadas para agrupá-las hierarquicamente;
Figura3
Figura5
•
Modules list : Todos os arquivos pertencentes ao projeto selecionados aparecem aqui;
•
Bottom panel : várias listas com diferentes informações são exibidas, na forma de abas,
nesse painel inferior.
Projeto
Vamos criar um projeto . O JEDI VCS agrupa os
arquivos inerentes a uma solução.
Para criar um projeto, siga os seguintes
passos:
1.
Selecione o menu Project>New
2. Na caixa new Project, informe um nome
para o projeto, que é sempre em letras minúsculas;
3. Será perguntado se você deseja que o
JEDI VCS verifique se o nome informado é válido.
Clique em yes.
4. Na mensagem seguinte, clique em Sim
abril 2009
17
para criar o projeto no banco de dados do aplicativo
5. Será pedido uma descrição do
projeto(figura 6). Descreva de modo sucinto a
descrição do projeto
Figura 6
6. Será informado que o projeto foi criado
com sucesso e se você deseja criar um grupo para
o projeto recém-criado. Clique em Yes.
7. Na tela Project Hierachy todos os grupos
existentes serão exibidos, juntamente com seus
projetos. Para criar um novo, clique com botão
direito do mouse sobre o treeview e selecione
Create new Root Group, para criar um grupo no
topo da hierarquia ou Create New Sub Group , para
cirar um grupo dentro de outro;
8. Para inserir um projeto em grupo, clique
com o botão direito sobre o grupo desejado e
selecione Add Project. Selecione o item e clique
em Done .
Ao termino desses passos, o projeto aparecerá
no Project tree View (figura7)
Figura7
Figura8
Veja Figura 7
Incluindo arquivos
Há duas formas de incluir arquivos em um
projeto: individual ou em grupo. Para inserir um
arquivo específico, vá ao menu Module e clique
em add. Na caixa de dialogo que aparecer localize
o arquivo no disco e clique em Ok.
Se for necessários muitos inserir muitos arquivos de uma vez, por exemplo, todos os documentos
TXT de uma pasta que contém subpastas, escolha
Add by folder no menu Module. Especifique o
diretório inicial da pesquisa, a máscara desejada,se
irá buscar nas subpastas etc.
O JEDI trabalha com extensões associadas.
Dessa forma, quando um arquivo .pas é incluído,
todos os outros que tenham o mesmo nome e
possuem extensões do mesmo grupo também
serão. Isso implica que você não precisa adicionar
18
abril 2009
Figura9
o arquivos .dfm, somente os .pas.
Os grupos de arquivos podem ser editados
no menu Tools->File Families Manager. Nas duas
formas, individualmente ou em grupo, será solicitada uma descrição para o módulo. É recomendável
informar a descrição do arquivo(Figura 8)
Veja Figura 8
Após informar a descrição, será apresentada
a caixa de check in(figura 9).
Veja Figura 9
Nela você poderá informar o que foi feito no
arquivo. Dessa forma você poderá saber exatamente o que foi alterado na versão.
Compartilhando arquivos
No JEDI VCS um ou mais arquivos podem fazer
parte de mais de um projeto. Apenas uma versão
deles será salva no banco de dados. As alterações
feitas sobre algum arquivo compartilhado serão
refletidas automaticamente nos projetos ao quais
eles pertence.
Para compartilhar um arquivo entre projetos,
abre primeiramente o projeto que você deseja
que receba o módulo, clique no menu share>add
Module Shared. Na caixa que será exibida, indique
o projeto onde o arquivo esta incluso, clique em
Next e a seguir marque os arquivos desejados.
Clique em Ok para terminar.
Editando arquivos versionados
Uma vez adicionado ao controle de versão do
JEDI VCS, um arquivo teoricamente só deveria ser
modificado após a ferramenta de versionamento
autorizar a edição. Esse processo chama-se check
out.
Para realizar o check out de um módulo, clique
com o botão direito do mouse sobre a Module list
e selecione Check out. Observe a caixa de dialogo
(Figura 10) .
Veja Figura 10.
Lembrando que você pode fazer o Check out
de vários arquivos simultaneamente. Uma vez
marcado o check-out , o arquivo não pode ser modificado por nenhum outro usuário até a realização
do próximo Check in.
Figura10
Figura11
Desfazendo o check out.
Pode ocorrer que seja necessário desfazer as
modificações realizadas em um arquivo. Para isso,
basta selecionar o módulo em questão e , clicando
com o botão direito do mouse, escolher a opção
Undo Ckeck out.
Salvando as alterações em um arquivo
Para enviar a nova versão ao banco de dados,
após realizar o Check out e trabalhar em um ou
mais arquivos, clique com o botão direito do mouse
e selecione Check in/put. A mesma caixa da figura 8
será exibida.Note que o número da versão de cada
arquivo, será automaticamente incrementado.
Ao realizar o check in, o arquivo volta a ser
somente de leitura e outros usuários podem
trabalhar com ele.
Restaurando uma versão anterior
O JEDI VCS permite voltar a uma versão anterior do arquivo. Para isso, clique com o botão direito
do mouse sobre o arquivo desejado, e selecione
Get/Version History(Figura 11)
Veja Figura 11.
abril 2009
19
O JEDI VCS copiará os arquivos para um
pasta temporária e depois executará o programa
associado no Windows á sua extensão. Clicando
em get você irá copiar o arquivo para sua pasta
de trabalho local.
Atualizando arquivos locais
Quando se trabalha em equipe, é comum
precisarmos ter em nossos computadores a
ultima versão de cada arquivo de um projeto.
Esse processo, de assegurar que a cópia local é
idêntica à armazenada no servidor é chamada de
Synchronize.
Para executá-lo, clique no menu Projetct->
Synchronize/Restore (Figura 12)
Veja Figura 12.
Figura12
Na primeira aba serão listados todos os
arquivos do projeto selecionado. O JEDI VCS irá
compará-los com suas respectivas cópias para
saber se algo mudou. Os módulos mais novos no
servidor estarão marcados.
Para sincronizar clique em Sysnc para que o
aplicativo inicie a sincronização.
Comparando arquivos
Ao trabalhar com uma ferramenta de versionamento de arquivos, freqüentemente é necessário
realizar comparações entre arquivos. Isso é útil , por
exemplo, quando ocorre um bug em uma versão
do código fonte que não existia na versão anterior.
Comparando as versões do arquivo fica fácil achar
o código que provocou o problema.
Para comparar arquivos, selecione o modulo
desejado, clique com o botão direito do mouse e
selecione Diff/Merge. No formulário (Figura 13),
você tem a opção de comparar a versão local do arquivo com alguma versão salva no banco de dados
ou então comparar as versões armazenadas.
Figura13
VejaFigura 13.
Para iniciar a comparação, clique no botão
Compare. O JEDI VCS Diff/merge será aberto(figura
14), exibindo as duas versões do arquivo, lado a
lado.
Veja Figura(14).
20
Figura(14). Comparando dois arquivos.
abril 2009
A esquerda será mostrada a versão mais nova
do módulo, e à direita, a mais antiga. As indicações
são mostradas na barra à esquerda da tela.
Conclusão
Controle de Versão resolve diversos problemas básicos de desenvolvimento tais como uso
de diferentes versões de código, sincronização do
trabalho paralelo de desenvolvedores no mesmo
projeto, recuperação de versões anteriores e
registro do histórico de alterações. Portanto é
imprescindível adotar essa prática numa empresa
de desenvolvimento.
Sobre o autor
Fontes
http://www.pronus.eng.br/artigos_
tutoriais/gerencia_configuracao/controle_versao.php?pagNum=0
http://pt.wikipedia.org/wiki/Sistema_de_controle_de_vers%C3%A3o
Luís Alexandre de Oliveira é Técnologo em Processamento de Dados ,graduado
pela Faculdade de Técnologia de Sorocaba,
Consultor técnico do The Club.
Docente do curso técnico informática - Etec
de Avaré e do curso Tecnologia em Redes de
Computadores - Fatec Eduvale – Avaré
abril 2009
21
4.0
hoje. Foi lançado então o C# 1.0
O Visual Studio 2010 e .NET Framework
4,0 em breve estará em fase beta, e existem alguns novos recursos excelentes que
todos nós podemos esperar animados com
este novo lançamento. Juntamente com o
Visual Studio 2010 e do. NET Framework
4,0 veremos a versão 4.0 da linguagem de
programação C #. Neste artigo eu gostaria
de olhar um pouco a trás de onde começou
a linguagem de programação C # e olhar para
onde Anders Hejlsberg do C # e sua equipequerem chegar.
E
m 1998, o projeto C # começou com
o objetivo de criar uma simples,
moderna e orientada a objeto,
linguagem de programação que se
tornou conhecido como o. NET. A Microsoft lançou
o. NET e a linguagem de programação C #, em meados 2000 e desde então, C # tornou-se uma das
mais populares linguagens de programação em uso
22
abril 2009
A versão 2.0 da linguagem evoluiu de mais,
particularmente acho que e umas das maiores
evoluções em tão pouco tempo de uma linguagem
e passou a dar suporte aos genéricos, métodos anônimos, iterators, tipos parciais e tipos anuláveis.
Ao conceber a versão 3.0 da linguagem
a ênfase foi para permitir a LINQ (Language
Integrated Query), que exigia a adição das
seguintes funcionalidades:
• Implictly Typed Local Variables.
• Extension Methods.
• Lambda Expressions.
• Object and Collection Initializers.
• Annonymous types.
• Implicitly Typed Arrays.
• Query Expressions and Expression
Trees.
No passado linguagens de programação foram
projetadas com um determinado paradigma em
mente, e como tal, temos linguagens que foram,
como exemplo, destinadas a serem orientadas a objeto ou funcionais. Hoje, porém, as linguagens que
a ser concebidas com vários paradigmas em mente.
Na versão 3.0 da linguagem de programação C # adquiriu várias capacidades funcionais normalmente
associados a programação para permitir Language
Integrated Query (LINQ).
Na versão 4.0 do C # continua a evoluir, embora
desta vez, a equipe do C # foram inspiradas por
linguagens dinâmica como Perl, Python e Ruby. A
realidade é que existem vantagens e desvantagens
para ambas as linguagens seja ela escrita estaticamente e dinamicamente.
Outro paradigma alem do design e inovação é
concorrente que é um paradigma que tem certamente influenciaram o desenvolvimento do Visual
Studio 2010 e do. NET Framework 4.0.
Agora o que o C# traz de novo:
• Dynamically Typed Objects.
• Optional and Named Parameters.
• Improved COM Interoperability.
• Safe Co- and Contra-variance.
Chega de papo e vamos olhar para algum
exemplos em C # 4.0 utilizando essas inovações língua ...
Em C # Hoje você pode ter, o seguinte código
que é uma instância de uma clase escrita estaticamente . NET então chama o método Add em que a
classe para obter a soma de dois inteiros:
Calculator calc =
GetCalculator();
int sum = calc.Add(10, 20);
Nosso código fica ainda mais interessante se
a classe Calculadora não é escrita estaticamente,
mas está escrito em COM, Ruby, Python, ou mesmo
JavaScript. Mesmo se soubéssemos que a classe é
uma calculadora. objeto NET, mas não sabemos
qual o tipo específico que é, então, teria de utilizar
reflection para descobrir atributos e o tipo em
tempo de execução e, em seguida, dinamicamente
invocar o método Add.
object calc =
GetCalculator();
Type type = calc.GetType();
object result = type.
InvokeMember(“Add”,
20);
int sum = Convert.
ToInt32(result);
Com C # 4,0 teríamos simplesmente escrever
o seguinte código:
dynamic calc =
GetCalculator();
int result = calc.Add(10,
20);
No exemplo acima declaramos uma variável
calc, cujo tipo estático é dinâmico. Sim, você leu
corretamente que nós escrevemos estaticamente nosso objeto a ser dinâmico. Teremos então
dinâmico usando método invocação para chamar
o método Add e em seguida, dinâmico conversão
para converter o resultado da dinâmica de uma
invocação digitado estaticamente inteiro.
Você está ainda encorajado a usar tipagem
estática sempre que possível, porque os benefícios
que oferecem línguas escrita estaticamente nós.
Usando C # 4,0 no entanto, deve ser menos doloroso nessas ocasiões em que você tem de interagir
com objetos dinamicamente digitado.
Outro grande benefício do uso de C # 4.0 é que
a linguagem suporta agora facultativa e parâmetros
nomeados e por isso vamos agora dar uma olhada
em como esta característica irá mudar a maneira
de conceber e escrever o seu código.
Um desenho padrão você ver como muitas
vezes que um determinado método está sobrecarregado, porque o método deve ser chamado com
um número variável de parâmetros.
Vamos assumir que temos o seguinte método
OpenTextFile juntamente com três sobrecargas
do método com diferentes assinaturas. Sobrecargas do método primário em seguida chame o
método primário de passar os valores padrão no
lugar desses parâmetros para os quais um valor
não foi especificado na chamada para o método
sobrecarregado.
public StreamReader
OpenTextFile(
string path,
Encoding encoding,
bool
detectEncoding,
int bufferSize) {
}
public StreamReader
OpenTextFile(
string path,
Encoding encoding,
bool
detectEncoding) { }
public StreamReader
OpenTextFile(
string path,
Encoding encoding)
{ }
public StreamReader
OpenTextFile(string path)
{ }
BindingFlags.InvokeMethod,
null,
new object[] { 10, 20 });
int sum = Convert.
ToInt32(result);
Se a calculadora classe foi escrito em JavaScript, então nosso código ficaria algo como a
seguinte.
ScriptObect calc =
GetCalculator();
object result = calc.
InvokeMember(“Add”, 10,
abril 2009
23
No C # 4.0 O método primário pode ser refactored para usar parâmetros opcionais como mostra
o seguinte exemplo:
missing,
missing,
public StreamReader
OpenTextFile(
string path,
Encoding encoding
= null,
bool
detectEncoding = false,
int bufferSize =
1024) { }
Perante esta declaração, é agora possível
chamar o método OpenTextFile omitindo um ou
mais dos parâmetros opcionais.
missing,
missing,
ref missing,
ref missing,
ref missing,
ref missing,
ref missing,
ref missing,
ref missing,
ref missing);
ref
ref
ref
ref
Com os parâmetros opcionais e nomeado
linguagem C # 4,0 prevê melhorias significativas
na interoperabilidade COM e, portanto, o código
acima pode agora ser refactored tal que o convite
é apenas:
gerenciado. Isso não é necessário quando se utiliza C # 4.0, porque o compilador irá injetar vez o
interop tipos diretamente para as Assembly de seu
aplicativo gerenciado e só vai injetar os tipos que
você está usando e não de todos os tipos encontrados no interior da PIA.
O último aperfeiçoamento lingüístico que
vamos explorar é co-variância e contra-variância
e vamos começar por explorar com a co-variância.
NET matrizes.
string[] names = new
string[] {
“Anders Hejlsberg”,
doc.SaveAs(“foo.txt”);
“Mads
Torgersen”,
“Scott
OpenTextFile(“foo.txt”,
Encoding.UTF8);
Também é possível usar o C # 4,0 suporte para
parâmetros nomeados e, como tal, o método pode
ser chamado OpenTextFile omitindo um ou mais
dos parâmetros opcionais, enquanto especificando
também outro parâmetro pelo nome.
OpenTextFile(“foo.txt”,
Encoding.UTF8, bufferSize:
4098);
O nome dos argumentos deve ser fornecido
somente estância última embora desde quando
eles podem ser fornecidas em qualquer ordem.
Se você alguma vez escrito qualquer código
que executa um certo grau de interoperabilidade
COM você provavelmente visto como o código
seguinte.
object filename = “test.
docx”;
object missing = System.
Reflection.Missing.Value;
doc.SaveAs(ref filename,
ref missing, ref
missing, ref missing,
24
abril 2009
Ao realizar a interoperabilidade COM você
perceber que você é capaz de omitir a ref modifer
embora o uso do modificador ref ainda é necessário quando não exerçam COM interoperabilidade.
Com as versões anteriores das tecnologias
era necessário também um navio Primary Interop
Assembly (PIA), juntamente com o seu aplicativo
Wiltamuth”,
“Peter
Golde” };
Write(names);
Desde versão 1.0 em um array o. NET Framework foi co-variante significando que uma
matriz de strings, por exemplo, pode ser passada
para um método que espera um array de objetos.
Como tal, a matriz acima pode ser transmitida
para o seguinte Escreve método que espera um
array de objetos.
private void Write(object[]
objects)
{
}
Infelizmente, em matrizes. NET não são coseguro variante como podemos ver na seguinte
código. Partindo do pressuposto de que os objetos
variável é uma matriz de strings da seguinte terá
êxito.
objects[0] = “Hello World”;
Embora se uma tentativa é feita para atribuir
um inteiro à matriz de strings uma ArrayTypeMismatchException é jogado.
objects[0] = 1024;
Em ambos os C # 2.0 e C # 3,0 invariantes são
genéricos e, portanto, um erro compilador iria
resultar o seguinte código:
List<string> names = new
List<string>();
Write(names);
Quando o Escreve método é definido como:
public void
Write(IEnumerable<object>
objects) { }
Generics com C # 4,0 apoiar agora segura
co-variância e contra-variância através do uso das
palavras-chave dentro e fora contextuais. Vamos
dar uma olhada em como isso muda a definição do
<T> IEnumerable e IEnumerator <T> interfaces.
código:
public interface
IEnumerable<out T>
{
IEnumerator<T>
GetEnumerator();
}
public interface
IEnumerator<out T>
{
T Current { get; }
bool MoveNext();
}
Você perceberá que o tipo de parâmetro T
da interface IEnumerable foi prefixado com o fora
contextuais palavra-chave. Dado que a interface
IEnumerable é somente leitura, não há capacidade
especificada na interface para inserir novos elementos com a lista, ela é segura para o tratamento
de algo mais derivados como algo menos derivados.
Com a palavra-chave fora contextuais estamos
afirmando que contratualmente IEnumerable <out
T> segurança é co-variante. Dado que IEnumerable
<out T> segurança é co-variante podemos agora
escrever o seguinte código:
IComparer<object>
objectComparer =
GetComparer();
IComparer<string>
stringComparer =
objectComparer;
Embora o actual build CTP do Visual Studio
2010 e do. NET Framework 4,0 tem suporte
limitado para a variância melhorias em C # 4,0 a
próxima versão beta permite que você use o novo
para dentro e para fora contextuais tais como
palavras-chave em tipos IComparer <in T>. O. NET
Framework equipa está a atualizar os tipos, no
âmbito de ser co-seguro e contra-variante.
Eu mostrei aqui alguns recursos que você
pode achar útil para explorar as capacidades
da linguagem de programação C # 4,0 e gostaria de encorajá-lo a também fazer download
e instalar a versão beta.
Bons Códigos...
IEnumerable<string> names =
GetTeamNames();
IEnumerable<object> objects
= names;
Porque a interface IEnumerable <out T> utiliza
a palavra-chave no contexto do compilador podem
motivo que a atribuição acima é seguro.
Utilizando a palavra-chave no contexto
podemos alcançar seguro contra-variância, ou
seja, tratar algo menos derivados como algo mais
derivados.
public interface
IComparer<in T>
{
int Compare(T x, T y);
}
Dado que IComparer <in T> é segura contravariante podemos agora escrever o seguinte
Sobre o autor
Fabiano Belmonte
Senior Architect da InfoMoney.com, especialista em aplicações e-Business com larga
experiência em B2B (Submarino.Com e Saraiva.
Com). Trabalha há 5 anos com a tecnologia
.Net, aplicando conhecimentos nas diversas
áreas: instituições financeiras (sistema SPB),
e-Commerce, gerenciamento logístico entre
outras. Trabalhando com Visual Studio desde
suas primeiras versões, responsável pela
implementação de uma Metodologia de trabalho e melhoras significativas no resultados
e na qualidade do time de Desenvolvimento
de muitas empresas por onde passou como
(Saraiva.Com) e ferramentas como TFS (Team
Foundation Server).
Foi palestrante em eventos como Codificando. NET 2008 e outros eventos sobre
Tecnologia .NET.
abril 2009
25
Simulando Inumeric
com o dynamic do
C# 4.0
Quando eu escrevi a minha biblioteca
financeiro tive que pensar muito sobre a decisão de qual tipo numéricos deveria utilizar
para representar dinheiro. Pensei logo nas
casas decimal, e ai pensei vou usar o decimal
mas acabei optando pelo uso do double.
T
eoricamente, eu gostaria que as
minhas funções numéricas servissem
para trabalhar para qualquer coisa
que suporta os operadores aritméticos
básicos (isto é, +, -, * ...). Infelizmente isso não é
possível em. NET neste momento. Em essência você
tem que escrever o seu código de duas vezes para
aceitar os dois tipos ou utilizar generics mais isso
e uma outra abordagem.
static double
SumDouble(double a, double
b) { return a + b; }
static decimal
SumDecimal(decimal a,
decimal b) {return a + b;}
26
abril 2009
Nós
muitas vezes discutida
a forma de fazê-la
funcionar, mas não foi
possível encontrar uma
solução que tanto foi rápido
e barato para ser executado para que nós implementar. Mais freqüentemente do que não
estamos a ter especulado sobre numéricos tipos
específicos INumeric implementar uma interface
genérica e adicionar um constrangimento para o
C # / VB línguas para que ele funcione. Daí o título
deste post.
Como nós implementamos dinâmico em C #
4,0, ocorreu-me que você pode fingir o seu caminho para escrever o código apenas uma vez. Com
certeza, esta solução não tem as mesmas características de desempenho ‘escrever o seu código
duas vezes “, mas pelo menos ele não duplicar o
seu código.
Esta é a forma como ele se parece com:
static
dynamic
Sum1(dynamic a,
dynamic b) { return
a + b; }
A chamada para o ‘+’ operador seja resolvido
em tempo de execução, pelo C # subcapa, consequentemente, um desempenho pena é incorrido. A
pena é menor do que você possa pensar, uma vez
que a DLR caches coisas sob a capa de modo que
não v-quadro pesquisa é realizada pela segunda
vez ao redor. A coisa toda é explicado em mais
detalhes aqui. Mas mesmo assim, não é tão rápido
como uma normal ‘+’ operador, ao longo de um
tipo primitivo. Vou deixar que você aproveite este
micro desempenho testando um :-)
Um ligeiro refinamento é fazer com que o código genérico de modo que uma pessoa não vê uma
assinatura dinâmica com tipos como argumentos.
static dynamic Sum2<T1,
T2>(T1 a, T2 b)
{
dynamic ad = a;
dynamic bd = b;
return ad + bd;
}
mado ‘compilar:
Console.WriteLine(Sum2(2m,
4m));
Console.WriteLine(Sum2(2.0,
4.0));
Console.WriteLine(Sum2(new
DateTime(2000,12,1), new
TimeSpan(24,0,0)));
Console.WriteLine(Sum3(2m,
4m));
Console.WriteLine(Sum3(2.0,
4.0));
//Console.
WriteLine(Sum3(new
DateTime(2000,12,1), new
TimeSpan(24,0,0)));
Ainda outra maneira de escrever o código é
o seguinte:
Também notar que em VB você poderia ter
feito isto há muito tempo :-)
Eu poderia fazer o retorno tipo genérico, mas
que possam obrigar a pessoa a ser explícito sobre
os tipos, fazendo com que o código chamando
muito menos legível. A outra coisa boa sobre essa
assinatura é que você recebe uma chamada local
diferente a cada combinação de tipo de argumentos e, uma vez que eles são separados, os caches
vinculativo deve ficar pequena. Com a assinatura
antiga, só há uma chamada local e da cache poderá acumular até ao ponto onde o DLR decida se
desfazer dele.
Aqui é como chamar o código parece agora:
public static T Sum3<T>(T
a, T b)
{
dynamic ad = a;
dynamic bd = b;
return ad + bd;
}
Isto fica em torno do problema de mostrar
uma dinâmica retorno e dar-lhe mais algum tempo
compilar tipo verificação. Mas isso não impede a
soma coercível tipos. O compilador não permite
que você chegar lá. A última linha abaixo acostu-
Function Sum(Of T1, T2)
(ByVal a As T1, ByVal b As
T2)
Dim aa As Object = a
Dim bb As Object = b
Return aa + bb
End Function
Em resumo, usando dinâmico você pode
escrever o seu código numérico apenas uma vez,
mas você paga um preço desempenho.
Espero que tenham gostado.
Bons Códigos...
Sobre o autor
Fabiano Belmonte
Senior Architect da InfoMoney.com, especialista em aplicações e-Business com larga
experiência em B2B (Submarino.Com e Saraiva.
Com). Trabalha há 5 anos com a tecnologia
.Net, aplicando conhecimentos nas diversas
áreas: instituições financeiras (sistema SPB),
e-Commerce, gerenciamento logístico entre
outras. Trabalhando com Visual Studio desde
suas primeiras versões, responsável pela
implementação de uma Metodologia de trabalho e melhoras significativas no resultados
e na qualidade do time de Desenvolvimento
de muitas empresas por onde passou como
(Saraiva.Com) e ferramentas como TFS (Team
Foundation Server).
Foi palestrante em eventos como Codificando. NET 2008 e outros eventos sobre
Tecnologia .NET.
abril 2009
27
Dicas DELPHI
Acertar a data e hora do sistema através do programa
procedure TForm1.
Button1Click(Sender: TObject);
var
DataHora: TSystemTime;
Data, Hora: TDateTime;
Ano, Mes, Dia,
H, M, S, Mil: word;
begin
Data := StrToDate(Edit1.Text);
Hora := StrToTime(Edit2.Text);
DecodeDate(Data, Ano, Mes, Dia);
DecodeTime(Hora, H, M, S, Mil);
with DataHora do begin
wYear := Ano;
wMonth := Mes;
wDay := Dia;
wHour := H;
wMinute := M;
wSecond := S;
wMilliseconds := Mil;
end;
SetLocalTime(DataHora);
end;
Verificar o estado de NumLock e CapsLock
{ Esta função retorna true se a
tecla informada estiver
ligada. False em caso contrário }
function tbKeyIsOn(const Key:
integer): boolean;
begin
Result := GetKeyState(Key) and 1
> 0;
end;
{ Exemplo de uso: }
if tbKeyIsOn(VK_NUMLOCK) then
{ ... NumLock está ligada }
else
{ ... NumLock está desligada }
Ocultar/exibir a barra de tarefas do Windows
Evitar a proteção de tela durante seu programa
{ Na seção “private” do Form
principal acrescente: }
procedure AppMsg(var Msg: TMsg; var
Handled: Boolean);
{ Na seção “implementation”
acrescente (troque TForm1 para
o nome do seu form principal): }
procedure TForm1.AppMsg(var Msg:
TMsg; var Handled: Boolean);
begin
if (Msg.Message = wm_SysCommand)
and
(Msg.wParam = sc_ScreenSave)
then
Handled := true;
end;
{ No evento “OnCreate” do form
principal, coloque: }
Application.OnMessage := AppMsg;
28
abril 2009
procedure TForm1.
BotaoOcultarClick(Sender: TObject);
var
Janela: HWND;
begin
Janela := FindWindow(‘Shell_
TrayWnd’, nil);
if Janela > 0 then
ShowWindow(Janela, SW_HIDE);
end;
{ No evento OnClick do BotaoExibir
escreva: }
procedure TForm1.
BotaoExibirClick(Sender: TObject);
var
Janela: HWND;
begin
Janela := FindWindow(‘Shell_
TrayWnd’, nil);
if Janela > 0 then
ShowWindow(Janela, SW_SHOW);
end;
Verificar se uma string contém um valor numérico válido
{ Libera a movimentação }
ClipCursor(nil);
end;
Use uma das funções abaixo, conforme o tipo de dado que se
quer testar:
function StrIsInteger(const S:
string): boolean;
begin
try
StrToInt(S);
Result := true;
except
Result := false;
end;
end;
function StrIsFloat(const S:
string): boolean;
begin
try
StrToFloat(S);
Result := true;
except
Result := false;
end;
end;
Limitar a região de movimentação do mouse
procedure TForm1.
Button1Click(Sender: TObject);
var
R: TRect;
begin
{ Pega o retângulo da área
cliente do form }
R := GetClientRect;
{ Converte as coordenadas do form
em coordenadas da tela }
R.TopLeft := ClientToScreen(R.
TopLeft);
R.BottomRight :=
ClientToScreen(R.BottomRight);
{ Limita a região de movimentação
do mouse }
ClipCursor(@R);
ShowMessage(‘Tente mover o
mouse para fora da área cliente do
Form’);
Obter o espaço total e livre de um disco
procedure TForm1.
Button1Click(Sender: TObject);
var
SetoresPorAgrup, BytesPorSetor,
AgrupLivres,
TotalAgrup: DWord;
begin
Memo1.Clear;
if GetDiskFreeSpace(‘C:\’,
SetoresPorAgrup,
BytesPorSetor, AgrupLivres,
TotalAgrup) then
with Memo1.Lines do begin
Add(‘Setores por agrupamento: ‘
+ IntToStr(SetoresPorAgrup));
Add(‘Bytes por setor: ‘ +
IntToStr(BytesPorSetor));
Add(‘Agrupamentos livres: ‘ +
IntToStr(AgrupLivres));
Add(‘Total de agrupamentos: ‘ +
IntToStr(TotalAgrup));
Add(‘----- Resumo -----’);
Add(‘Total de bytes: ‘ +
IntToStr(TotalAgrup *
SetoresPorAgrup * BytesPorSetor));
Add(‘Bytes livres: ‘ +
IntToStr(AgrupLivres *
SetoresPorAgrup * BytesPorSetor));
end;
end;
{ O exemplo acima retorna as
medidas em Bytes, Setores e
Agrupamentos. Se preferir algo
mais simples,
use funções do Delphi. Veja: }
Memo1.Lines.Add(‘Total de bytes: ‘
+ IntToStr(DiskSize(3)));
Memo1.Lines.Add(‘Bytes livres: ‘ +
IntToStr(DiskFree(3)));
{ Onde o parâmetro (3) é o número
da unidade, sendo
1=A, 2=B, 3=C, ... }
abril 2009
29
30
abril 2009
abril 2009
abril 2009