Como o Delphi adota uma abordagem totalmente orientada a objetos, o compilador mais rápido do mundo atualmente e a tecnologia de banco de dados líder, especialmente sua total compatibilidade com a API do Windows e excelentes recursos de geração automática de código... as pessoas perceberam isso em pouco tempo Nos últimos anos, o Delphi se destacou entre muitas ferramentas de desenvolvimento! São as muitas qualidades excelentes do Delphi que permitem aos programadores desenvolver software aplicativo de nível profissional em um curto período de tempo, fazendo muito pouco trabalho!
Como diz o ditado: Vamos melhorar! Como devemos aproveitar ao máximo as vantagens do Delphi para projetar programas mais rapidamente?
1. Aproveite ao máximo o compartilhamento completo de código (Jubang):
O objetivo disso não é apenas ser “preguiçoso”, é também uma forma de otimizar o código do programa. Claro, a primeira coisa a considerar é se ele pode ser compartilhado (isso é muito simples, veja se está incluído na coleção suspensa do evento), e a segunda coisa a prestar atenção é se haverá " problema" após o compartilhamento, porque a correção é o primeiro passo. É necessário buscar a otimização somente quando for garantido que está correto!
Por exemplo: damos uma mensagem de confirmação antes que o usuário exclua os dados:
Procedimento TForm1.Table1BeforeDelete(DataSet: TDataSet);
começar
//Confirma a exclusão do registro
if MessageBox(handle,'Tem certeza que deseja excluir o registro atual?','Confirm',MB_IconQuestion+MB_YesNo)=IDNO then
Abortar;
fim;
Então, desde que você permita que o usuário confirme antes de excluir o registro de dados, você pode compartilhar completamente esse código no evento TDataSet.BeforeDelete (BeforeDelete da Tabela2, BeforeDelete da Tabela3...). A boa sorte não acontece todos os dias, às vezes não é tão direta e simples...
A palavra "As" não é extremamente útil apenas em inglês, mas também em Delphi! Isso entra em ação quando queremos compartilhar código para vários componentes "semelhantes": só precisamos escrever código para um deles.
Por exemplo, se quisermos que a cor de fundo de um grupo de caixas de edição de texto mude para marrom quando receberem o foco de entrada e restaurar a cor do sistema quando perderem o foco, podemos compartilhar o código assim (deixar os eventos de cada caixa de edição de texto compartilhe o seguinte código):
procedimento TForm1.Edit1Enter(Remetente: TObject);
começar
(Remetente como TEdit).color:=ClTeal; //Obter foco de entrada
fim;
procedimento TForm1.Edit1Exit(Remetente: TObject);
começar
(Remetente como TEdit).color:=ClWindow; //Perdeu o foco de entrada
fim;
O exemplo acima parece um pouco específico. E se eu prestar atenção especial apenas a alguns dos componentes? Ainda tomando o exemplo acima, por exemplo, existem duas caixas de entrada de texto que exigem a inserção de números para atrair a atenção do usuário, a cor muda para azul quando o foco é recebido, mas ainda não quero escrever. código para cada componente separadamente.
Para resolver este problema, você pode usar o atributo Tag do componente. Primeiro, atribua Tags diferentes de zero e desiguais aos componentes a serem especialmente processados (deve-se observar que o Delphi não verificará se os valores dos Tag são iguais, e você mesmo deve controlá-lo durante o design); em seguida, escreva o código da seguinte maneira. Você ainda pode compartilhar:
procedimento TForm1.Edit1Enter(Remetente: TObject);
começar
case (Remetente como TEdit).Tag de
10,20:(Sender as TEdit).Color:=clBlue //Caixa de texto para inserir números
outro
(Remetente como TEdit).Color:=clTeal; //Outras caixas de texto
fim;
fim;
(As observações a seguir são consideradas sob as condições padrão do Delphi)
1. Use a palavra-chave Self:
Talvez alguém pense que estou enganado! Na verdade, o que quero apresentar aqui é mais um “truque” do “agressor habitual” do autor (devido à sua memória fraca). Às vezes, podemos não conseguir lembrar o nome exato do componente. Neste momento, se você retornar ao formulário para confirmá-lo novamente (a maioria dos meus amigos deveria ser assim), seria uma pena. É particularmente econômico usar Self, porque Self no Delphi se refere explicitamente à forma onde o componente está localizado. Portanto, podemos inserir Self seguido de uma vírgula para ativar o código do Delphi. Ao finalizar, o sistema exibirá imediatamente uma lista suspensa contendo todos os componentes do formulário e as propriedades do próprio formulário, a partir da qual você poderá selecionar os componentes necessários. Dessa forma, evita-se a carga de trabalho de alternar entre formulários e tabelas.
2. Use o preenchimento de código (Completamento de Código):
Não precisamos mais lembrar de muitos detalhes dos parâmetros por causa da função de preenchimento de código do Delphi. Antes de explicar em detalhes, quero ser um pouco prolixo. As teclas de atalho padrão do Code Completion do Delphi entrarão em conflito com algumas das teclas de atalho que usamos (por exemplo, Ctrl+Espaço entra em conflito com as teclas de atalho para abrir e fechar. o método de entrada de caracteres chineses). Portanto, resolva esse problema primeiro.
Claro, o Code Completion geralmente será ativado automaticamente, mas não pense que tudo ficará bem. Acho que o Delphi deveria aprender com o VB para esta tecnologia. Por exemplo: quando você digita StrToint(edit1., o Delphi não exibirá automaticamente as propriedades de edit1. Neste momento, você usará Ctrl+Espaço para ativar a conclusão do código. Especialmente quando o aninhamento é profundo, o Delphi parece confuso. .
3. Use parâmetros de código:
A tecla de atalho de ativação é Ctrl+Shift+Espaço. Esta função também é implementada automaticamente pelo Delphi Como mencionado acima, quando alternamos ou movemos o cursor, esta função desaparecerá. Quando precisarmos confirmar os parâmetros específicos da função, podemos abri-la com esta tecla de atalho. .
4. Use modelos de código:
Esta tecnologia reflete mais uma vez a excelente tecnologia dos engenheiros da equipe de desenvolvimento Delphi da Inprise e seu nobre caráter moral de sempre pensar nos usuários! (Só não quero ouvir falar de outra pessoa sendo caçada pela Microsoft)
A tecla de atalho de ativação é Ctrl+J. O mecanismo de implementação desta função é semelhante ao preenchimento de código, exceto que não é automático. Claro, o aspecto mais interessante é que os usuários podem definir seus próprios modelos. Por exemplo, um modelo definido pelo autor: atalho -> "msg" -> "MessageboxMessageBox(;
handle,'|',',MB_Icon...+MB_...);", assim que eu digito msg e pressiono Ctrl+J, todo o código "se destaca", e move o cursor para o local onde Eu deveria adicionar a entrada, é tão legal!
Nota: Se você definiu muitos modelos bonitos para si mesmo e está relutante em jogá-los fora, você também pode fazer backup do arquivo Delphi32.dci no diretório Delphi4Bin e substituí-lo por este arquivo após reinstalar o Delphi.
Este tópico não deveria ser escrito aqui, mas não posso deixar de...
1. Se você pode usar o observador de objetos para configurá-lo diretamente sem afetar a operação normal do programa, não há necessidade de escrever código:
Como este tópico é muito amplo, aqui está apenas um exemplo: Por exemplo, você deseja implementar prompts automáticos na barra de status do Delphi4 sem ser muito "duro".
Condição "Hint", não precisamos mais definir um processo (ShowMyHint(...)) como antes, e então inicializá-lo onde o programa
Atribua o valor dela ao evento OnHin do Tapplication. Porque basta definir a propriedade AutoHint da barra de status como True! Claro, parece que ela só pode
Exibido no primeiro Painel (isto é, quando não há condições muito "severas"). Claro, me culpe por ser prolixo, alguns amigos não conhecem a dica do Delphi
Os atributos são compostos de duas partes. Este não é o lugar para falar. Se você estiver interessado, acesse a página pessoal do autor www.zg169.net/~delphiok (recém-aberta).
Zhang, ainda não há muitas coisas).
2. Salve o código:
Se você pode escrever menos código, não há necessidade de escrever mais código. Se você pode refiná-lo, não há necessidade de ser redundante:
Por exemplo, os dois trechos de código a seguir implementam exatamente a mesma função. Qual trecho você prefere usar?
Trecho de código um:
se ToolButton1.Down=true então
começar
Dbgrid1.show;
DelBtn.Enabled:=true;
fim
outro
começar
Dbgrid1.Hide;
DelBtn.Enabled:=falso;
fim;
Trecho de código dois:
Dbgrid1.Visible:=ToolButton1.Down;
DelBtn.Enabled:=ToolButton1.Down;
Portanto, depois de terminarmos de escrever o programa, não devemos apenas prosseguir com o ajuste do programa, mas também fritar o código do programa.
3. Salve variáveis:
Alguns programadores definem variáveis onde elas não são necessárias e definem variáveis redundantes onde variáveis são necessárias. Pessoalmente, acho que isso não é bom.
Os hábitos, especialmente o hábito de definir variáveis globais a cada passo, são ainda mais questionáveis. Alguns leitores podem pensar que sou um avarento. As velocidades do processador de hoje são.
Que época estamos... Mas vou simplesmente mostrar um trecho de código e você entenderá:
procedimento TForm1.Button1Click(Remetente: TObject);
Var s1,s2:Sequência;
começar
s1:=Inputbox('dados','Digite o nome de usuário',');
se s1<>' então
começar
Btn_Name.Enabled:=Verdadeiro;
s2:=Inputbox('dados','Por favor insira o endereço do usuário',');
se s2<>' então
Btn_Adress.Enabled:=Verdadeiro;
fim;
fim;