Seguem abaixo os slides da apresentação feita em sala
http://rapidshare.com/files/72302036/Slides_Delphi.ppt.html
domingo, 25 de novembro de 2007
sábado, 17 de novembro de 2007
Eventos
Os eventos são blocos de comandos que associam a ocorrência de alguma atividade a uma ação a ser tomada. O Delphi possui mais de 130 eventos pré-definidos, que estão associados à ocorrência de ações, nas mais diversas classes.
Uma linguagem de programaçao orientada a eventos não tem necessariamente um início ou final lógico, isto é, de acordo com um sequência de comandos, pois só são realizadas a partir do instante que ocorre um evento.
Um evento pode estar associado a:
On Active: ocorre quando o programa ativa o objeto pela primeira vez, ou quando se retorna de um outro aplicativo.
OnClick: ocorre quando o usuário dá um clicque no botão esquerdo do mouse
OnCreate: ocorre quando o objeto é criado.
Tais eventos são encontrados no Object Inspector do ambiente do Delphi como vemos abaixo:
Uma linguagem de programaçao orientada a eventos não tem necessariamente um início ou final lógico, isto é, de acordo com um sequência de comandos, pois só são realizadas a partir do instante que ocorre um evento.
Um evento pode estar associado a:
- clique ou movimento do mouse;
- acionamento do teclado;
- operações sobre janelas (abrir, fechar, criar, redimensionar, mover, ...);
- erros de execução; etc.
On Active: ocorre quando o programa ativa o objeto pela primeira vez, ou quando se retorna de um outro aplicativo.
OnClick: ocorre quando o usuário dá um clicque no botão esquerdo do mouse
OnCreate: ocorre quando o objeto é criado.
Tais eventos são encontrados no Object Inspector do ambiente do Delphi como vemos abaixo:
segunda-feira, 5 de novembro de 2007
Procedimentos e Funções Predefinidas usuais do Object Pascal
A linguagem Pascal coloca disponível aos usuários um conjunto de funções e procedimentos distribuídos em UNITS (as units são rotinas compiladas separadamente do programa principal), com a finalidade de facilitar e agilizar a programação.
1.1 Manipulação de strings
1.1.1 CHR
Retorna o carácter correspondente ao código ASCII fornecido.
Ex:
Var
P : TextFile;
Begin
AssignPrn(P);
Rewrite(P);
Writeln(P, chr(12) , ‘Testando a Impressora’);
CloseFile(P);
End;
1.1.2 CONCAT
Concatenar as strings especificadas.
Ex:
var
S: string;
Begin
S := Concat('ABC', 'DEF'); { 'ABCDEF' }
End;
1.1.3 COPY
Retorna uma substring de uma string , isto é, retorna uma parte se S, desde inicio e com o tamanho especificado.
Ex:
var
s, s1 : string;
begin
s := 'ABCDEF';
s1 := Copy(s, 2, 3) { 'BCD' }
End;
1.1.4 DELETE
Elimina parte da string S; começa em inicio com o tamanho especificado.
Ex:
var
s: string;
Begin
s := 'Honest Abe Lincoln';
Delete(s,8,4);
WriteLn(s); { 'Honest Lincoln' }
End.
1.1.5 INSERT
Insere um string origem em s a partir da posição inicio.
Ex:
var
s: string;
Begin
s := 'Honest Lincoln';
Insert('Abe ', s, 8);
WriteLn(s); { 'Honest Abe Lincoln' }
End.
1.1.6 LENGTH
Retorna o número de caracteres da string.
Ex:
var
S : string;
Begin
read(S);
write(length(S));
End.
1.1.7 POS
Retorna a posição do inicio da string s1 dentro do string s2. (retorna 0 se não encontrar)
Ex:
var s: string;
Begin
s := ' 123.50';
{ Converte espaços para zeros }
while Pos(' ', s) > 0 do
s[Pos(' ', s)] := '0';
End.
1.1.8 UPPERCASE - LOWERCASE
Uppercase - Retorna o String com letras maiúsculas.
Lowercase - Retorna o String com letras minúsculas.
Ex:
Uses Sysutils;
var
s : string;
i : Integer;
Begin
Write('Digite um string: ');
ReadLn(s);
WriteLn('Conversão do string para maiúsculo: ',Uppercase(s));
Readln;
End.
1.1.9 STR
Transforma um número em representação string; x pode ser inteiro ou real; S passa a conter representação string de x com a largura e casas decimais especificadas.
Ex:
var
F : string;
N : integer;
begin
N:=1492;
str(N:7,F);
write(F); (* ' 1492' *)
end.
1.1.10 VAL
Converte string S em numero n. A posição de qualquer erro na string S é reportada no parâmetro código. Se código = 0, a conversão foi feita com sucesso.
Ex:
Program conver;
var
X : string;
Y,Z : integer;
begin
X:='9876';
Val(X,Y,Z);
writeln(Y);
writeln(Z);
readln;
end.
1.1.11 TRIM – TRIMLEFT - TRIMRIGHT
Trim - Retira espaços a esquerda e direita da string
TrimLeft - Retira espaços a esquerda da string
TrimRight - Retira espaços a direita da string
Ex:
If Trim(EditNome.Text) = ‘’ then
Begin
ShowMessage(‘Falta Informar o Nome’);
EditText.SetFocus;
Exit;
End;
1.1.12 ORD
Retorna o código ASCII do caractere da variável x.
Ex:
program MINUSCULA;
var I:integer;
(* MINUSC retorna um string com caracteres Minúsculos*)
function MINUSC(C : STRING) : STRING;
var
I : integer;
begin
for I := 1 to length(C) do
if (ord(C[I]) >= 65) and (ord(C[I]) <= 90)
then
C[I] := chr(ord(C[I])+32);
MINUSC := C;
end;
begin
writeln(MINUSC('ABCDEFGHIJKLMNOPQRSTUVWXYZ'));
writeln(MINUSC('FACE FUMEC.'));
readln;
end.
1.2 Manipulação Numérica
Retorna o valor absoluto de x.
Ex:
var
r: real;
i: Integer;
begin
r := Abs(-2.3); { 2.3 }
i := Abs(-157); { 157 }
end.
1.2.2 EXP
Retorna o valor de e(e=2.7182818285E+00) elevado a potência x.
Exemplo:
begin
WriteLn('e = ',Exp(1.0));
end.
1.2.3 LN
Retorna o logaritmo natural de x (base e=2.7182818285E+00).
Exemplo:
program exponencial;
var
I : integer;
{ função para calcular um exponencial }
function pot (X,Y : real) : real; {X**Y}
begin
pot:=exp(Y*ln(X));
end;
{ Programa Principal }
begin
for I:=1 to 10 do
begin
writeln (I:2 , '**' , 3 ,' = ',pot(I,3):0:2);
end;
readln;
end.
1.2.4 FRAC
Retorna a parte fracionaria de x.
Exemplo:
var
S : string;
str(Frac(123.456):7:3,S); { 0.456 }
Writeln(S);
str(Frac(-123.456):7:3,S); { -0.456 }
Writeln(S);
readln;
end.
1.2.5 INT
Retorna a parte inteira de x.
Exemplo:
var
r: real;
begin
r := Int(123.456); { 123.0 }
r := Int(-123.456); { -123.0 }
end.
1.2.6 ROUND
Retorna o valor de x arredondado para um inteiro.
Exemplo:
begin
WriteLn(1.4, ' arredonda para ', Round(1.4));
WriteLn(1.5, ' arredonda para ', Round(1.5));
WriteLn(-1.4, ' arredonda para ', Round(-1.4));
WriteLn(-1.5, ' arredonda para ', Round(-1.5));
Readln;
end.
1.2.7 TRUNC
Retorna a parte inteira de x descartando a parte decimal.
Exemplo:
begin
WriteLn(1.4, ' truncar para ', Trunc(1.4));
WriteLn(1.5, ' truncar para ', Trunc(1.5));
WriteLn(-1.4, ' truncar para ', Trunc(-1.4));
WriteLn(-1.5, ' truncar para ', Trunc(-1.5));
Readln;
end.
1.2.8 SQR
Retorna o quadrado de x.
Exemplo:
writeln (‘O quadrado de x = ‘ , SRQ(X));
Retorna a raiz quadrada de x
Exemplo:
begin
WriteLn('5 ao quadrado = ', Sqr(5));
WriteLn('A raiz quadrada de 2 = ', Sqrt(2.0));
end.
1.2.10 ODD
Retorna true se o valor de X e um número impar.
Exemplo:
If ODD(X) then Write(‘X é um número Impar’);
1.3 MANIPULAÇÃO DE TIPOS ESCALARES
Função encarregada de reconhecer o elemento, que antecede X no conjunto considerado. O resultado e do mesmo tipo do
parâmetro X.
Exemplo:
var
x : char;
begin
x:=‘C’;
write(PRED(x)); { ‘B’ }
end.
1.3.2 SUCC
Função encarregada de reconhecer o elemento, que sucede X no conjunto considerado. O resultado e do mesmo tipo do
parâmetro X.
Exemplo:
var
x : char;
begin
x:=‘C’;
write(SUCC(x)); { ‘D’ }
1.4 Controle de memória
1.4.1 SIZEOF
Retorna o número de bytes ocupados pelo argumento.
Exemplo:
var
s : string[35];
begin
write(sizeof(S)); { 36 }
Readln;
end.
1.5 Interagindo com o sistema operacional
1.5.1 CHDIR
ChDir muda de diretório corrente.
Exemplo:
begin
{$I-}
{ mudar para o diretório especificado em Edit1 }
ChDir(Edit1.Text);
if IOResult <> 0 then
ShowMessage('Diretório não foi encontrado');
end;
1.5.2 GETDIR
Retorna o path do diretório ativo do drive especificado (acionador default=0,A=1,B=2,...). Retorna -1 se o drive não estiverpresente.
Exemplo:
var
s : string;
begin
GetDir(0,s); { 0 = Current drive }
writeln('Drive e diretório corrente: ' + s);
readln;
end.
1.5.3 MKDIR
Cria um subdiretório especificado em PATH.
Exemplo:
Mkdir(‘\tp\fontes\tmp’);
Exemplo:
Rmdir (\ tp\fontes\tmp’);
1.6 Comandos de desvio
Outro recurso que existe na linguagem Object Pascal é a capacidade de desviar no código, isto é a capacidade de pular para outra parte do código, quando necessário.
1.6.1 GOTO
A instrução GOTO permite que você salte de onde está no programa para uma linha rotulada específica.
Exemplo:
Var
Resp: char;
Begin
Inicio:
Writeln(‘Ok’);
Writeln(‘Quer repetir?’);
Readln(Resp);
If Resp = ‘S’ then GOTO Inicio
End.
1.6.2 Comandos Break / Continue ( Desvios dentro da repetição)
Estes comandos, à exceção daqueles demonstrados até agora, não são de repetição condicional, mas possuem importante papel junto á estes. Eles são usados em apenas duas situações: (1) quando se deseja interromper o processamento de um estrutura de repetição - Break; (2) quando for necessário garantir a continuidade do processamento de uma estrutura de repetição - Continue.
Exemplo:
Var
I : Integer;
Begin
For I := 1 to 3 do If (I mod 2) <> 0 then Continue;
For I := 1 to 3 do If (I mod 2) = 0 then Break;
End;
1.6.3 EXIT
Use o comando EXIT para sair do bloco corrente. Se o bloco corrente é o programa principal EXIT faz o programa terminar. Se o bloco corrente está aninhado, EXIT faz com que o bloco mais externo continue na instrução imediatamente após a que passou o controle para o bloco aninhado. Se o bloco corrente é uma procedure ou função, EXIT provoca a saida da função ou procedure para continuar após o ponto em que foi chamado.
Exemplo:
Procedure Teste ( X : Integer) ;
Begin
IF X = 0 then EXIT;
...
...
End;
Comandos
Permite atribuir a uma variável o resultado de uma expressão, valor de uma outra variável ou uma constante.Editar postagens
Sintaxe:
<> := <>;
O comando IF é um dos comandos mais importantes e básicos da programação Object Pascal. Ele é utilizado para determinar o fluxo do programa a partir de determinada condição. Caso a situação pela qual o programa estiver passando confirme uma dada
condição, o programa executará os comandos abaixo da cláusula Then; caso contrário, executará as instruções abaixo da cláusula Else. A cláusula Else, em funçaõ das necessidades do programa pode ser omitida. Neste caso, se a situação da execução do
programa não satisfazer a condição estabelecida no IF, prosseguirá no seu funcionamento normal.
Alternativa Simples
Alternativa Simples
BEGIN
<>;
¦ <>;
¦ <>;
...
END;
Alternativa Composta
IF <> THEN
<>
ELSE
<> ;
Alternativa Composta
IF <> THEN
BEGIN
<>;
END
ELSE
BEGIN
...
END;
2.2 Comando Case
O Case é uma estrutura que permite que o programador avalie o valor de uma determinada variável. A avaliação é sempre realizada em relação a constante ou intervalos de valores. Poderíamos dizer que o Case funciona de maneira similar ao IF, embora do ponto de vista prático, seja completamente diferente, pois permite obter o mesmo efeito de vários comandos IF em funcionamento conjunto com apenas um comando Case.
Exemplo:
Case NotaFinal of
100 : Begin
ShowMessage (‘Aprovado – Excelente’);
Contador := Contador + 1;
End;
80..99 : ShowMessage (‘Aprovado’);
0..79 : ShowMessage (‘Reprovado’);
End;
2.3 Estrutura de Repetição
É muito comum para o programador surgir situações em que se faz necessário a repetição de determinado conjunto de comandos. Na verdade estas situações nos levam a utilizar comandos muito interessantes que sem dúvida serão capazes de resolver o problema. Contudo para que seja assim, é muito importante que o programador determine até quando deseja que os comandos sejam repetidos. Existem algumas opções: (1) um número determinado de vezes e (2) até que determinada condição seja atendida.
2.3.1 Comando For
A estrutura FOR permite que um conjunto de comandos sejam executados num determinado número de vezes. O Número de
vezes é armazenado em uma variável inteira de controle da repetição.
Exemplo:
Var
I : Byte;
Begin
For I := 1 to 10 do
Begin
ShowMessage (‘Esta é a mensagem número: ‘ + IntToStr(I));
End;
End;
2.3.2 Comando WHILE
A estrutura do comando while também possibilita a repetição de um conjunto determinado de comandos. No entanto, diferentemente do For, permite a definição de condições para o término da repetição que não estão limitadas necessariamente a
uma contagem. S condições são verificadas no inicio do processamentoe, uma vez satisfeitas, os comandos internos a ela começam a ser repetidos até que alguma situação permita negar as condições iniciais.
Var
Digitos : Integer ;
Terminas : Boolean ;
Begin
Digitos :=0;
Termina := True;
While Termina do
Begin
Digitos := Digitos + 1;
If Digitos = 100 then Termina := False;
End;
End.
O comando Repeat funciona de maneira análoga ao comando While. Na verdade entre eles existe apenas duas diferenças: (1) ao invés do Repeat verificar se as condições da repetição estão sendo atendidas no ínicio de seu processamento, ele as verifica ao final da repetição; (2) dispensa o uso dos comandos Begin e End.
Exemplo:
Var
Digitos : Integer ;
Terminas : Boolean ;
Begin
Digitos :=0;
Termina := False;
Repeat
Digitos := Digitos + 1;
If Digitos = 100 then Termina := True;
Until Termina;
End.
Amarrações
Declaração de Constantes
Constantes são valores especiais que geralmente são definidos no ínicio do programa e, se destinam a armazenar informações ou valores que não se alteram ao longo da execução do programa. Veja abaixo um exemplo de declaração de constantes no Delphi.
PI = 3.1416;
Linguagem : String = ‘Delphi’;
dia : array [0..6] of String[9] = ('Domingo' , 'Segunda' , 'Terça' , 'Quarta' , 'Quinta' , 'Sexta', 'Sábado');
As declarações de constantes não alocam recursos do sistema. De fato, isto somente ocorre quando elas forem utilizadas na aplicação. Contudo, a constante Linguagem terá um tratamento diferente, uma vez que ela é uma constante tipada, ou seja, seu tipo (string) já foi previamente definido.
A maior diferença entre constantes do C e do Object Pascal é que Object Pascal, assim como Visual Basic, não requer que você declare o tipo constante junto com o valor na declaração. O compilador do Delphi automaticamente aloca espaço apropriado para a constante baseado nos seus valores, ou, no caso de constantes escalares tais como Inteiros, o compilador fiscaliza os valores que ele manipula, e espaços nunca são alocados.
Os valores das constantes são substituídos em tempo de compilação. Ou seja, os valores são definidos estaticamente.
Declaração de Variáveis
Sempre que desenvolvemos nossas aplicações, surge a necessidade de armazenarmos temporariamente certas informações. Para isto utilizamos variáveis. No Delphi podemos Ter diversos tipos de variáveis com características de armazenamento próprias.
Tais variáveis devem ser sempre bem definidas antes de tentarmos utilizá-las. Ao definir ou declarar uma variável, indique seu nome seguido do tipo de informação que deseja que ela armazene.
As variáveis estão dispostas em cinco grupos:
Numéricas: Podem ser números inteiros ou reais, formadas pelos dígitos de
Alfanuméricas: Podem ser formadas pôr qualquer tipo de caractere da tabela ASCII.
Lógicas: Podem assumir apenas dois valores: TRUE para valores verdadeiros ou FALSE para falsos.
Data/Hora: Podem armazenar data e hora, permitindo um processamento simples de data/hora.
Ponteiros: Podem armazenar apenas endereços de memória.
O nome da variável deve ser único em cada bloco do programa e deve conter até 255 caracteres, podendo ser composto pôr letras, números e sublinhado “_” , porém serve sempre iniciar com uma letra e não pode ser uma palavra reservada pelo Object Pascal.
É aconselhável que defina o nome da variável de forma que esta nós lembre a função que ela terá no contexto do programa. Além disso, o nome de uma variável não deve conter símbolos especiais (p.e. &%#@!), , nem ser igual ao nome de uma palavra reservada do Object Pascal.
O formato de declaração de variáveis deve ter a seguinte sintaxe:
VAR
nome_da_variável [, nome_da_variável ...] : tipo;
Exemplo N_Pessoas : Byte;
:
Var
Nome, SobreNome : String;
Idade : Integer;
O compilador Delphi entende que todos os dados globais são automaticamente inicializados com zero. Quando sua aplicação é iniciada, todo tipo inteiro possui 0, tipos ponto-flutuante possuem 0.0, ponteiros serão nil, strings estarão vazias, e assim em diante.Então, não é necessário inicializar com zero dados globais em seu código fonte.
Procedimentos e Funções
Como um programador, você já deve estar familiarizado com os conceitos de funções e procedimentos. Um procedimento é uma parte discreta do programa que efetua alguma tarefa particular quando ele é chamado e então retorna a parte do seu código que o chamou. Uma função trabalha da mesma forma exceto pelo fato de que ela retorna um valor depois de sua saída para a parte do programa que a chamou.
Se você está familiarizado com C ou C++, considere que um procedimento em Pascal é equivalente a uma função em C ou C++ que retorna void, enquanto que uma função corresponde a uma função do C ou C++ que retorna um valor.
A variável local Result na função merece atenção especial. Toda função
Você também pode retornar um valor de uma função atribuindo ao nome de uma função o valor dentro do código da função. Esta é a sintaxe padrão do Pascal e costume das versões anteriores do Borland Pascal.
Passando Parâmetros
Pascal possibilita que você passe parâmetros por valor ou por referência para funções e procedimentos. Os parâmetros que você passa podem ser de qualquer tipo básico ou definido pelo usuário, ou open array (open arrays serão discutidos nesse tutorial). Parâmetros também podem ser constantes se seus valores não mudarem no procedimento ou função.
Parâmetros Valor
Parâmetros valor são o modo default de passagem de parâmetros. Quando um parâmetro é passado por valor, significa que uma cópia local daquela variável é criada, e a função ou procedimento opera sobre a cópia. Considere o exemplo a seguir:
procedure Foo(s: string);
Quando você chama um procedimento desta forma, uma cópia da string s será criada, e Foo() operará sobre a cópia local de s. Isto significa que você pode escolher o valor de s sem ter qualquer efeito sobre a variável passada para dentro de Foo().
Parâmetros Referência
Pascal permite que você passe variáveis para funções e procedimentos por referência; parâmetros passados por referência são também chamados parâmetros variáveis. Passar por referência significa que a função ou procedimento ao receber a variável pode modificar o valor daquela variável. Para passar uma variável por referência, use a palavra var na lista de parâmetros da função ou procedimento:
procedure ChangeMe(var x: longint);
begin
x := 2; { x agora é alterado na chamada do procedimento }
end;
Em vez de fazer uma cópia de x, a palavra reservada var faz com que o endereço do parâmetro seja copiado de forma que seu valor possa ser diretamente alterado.
Usar parâmetros var é equivalente a passar variáveis por referência em C++ usando o operador &. Assim como o operador & do C++, a palavra var faz com que o endereço da variável seja passado para a função ou procedimento, e não o valor da variável.
Parâmetros Constantes
Se você não quiser que o valor de um parâmetro passado para dentro de uma função seja alterado, você pode declará-lo com a palavra chave const. const não apenas impede que você modifique o valor dos parâmetros, mas ele também gera código mais otimizado para strings e registros passados para dentro de procedimentos ou funções. Aqui está um exemplo de uma declaração de procedimento que receber um parâmetro string constante:
procedure Goon(const s: string);
Parâmetros Open Array
Parâmetros open array permite que você passe um número variável de argumentos para funções e procedimentos. Você pode passar ou open arrays de algum tipo homogêneo ou arrays constantes de tipos diferentes. O código seguinte declarar uma função que aceita um open array de inteiros:
function AddEmUp(A: array of Integer): Integer;
Você pode passar variáveis, constantes ou expressões constantes para funções ou procedimentos de open array. O código a seguir demonstra isto chamando AddEmUp() e passando uma variedade de elementos diferentes.
var
i, Rez: Integer;
const
j = 23;
begin
i := 8;
Rez := AddEmUp([i, 50, j, 89]);
Para funcionar com um open array dentro de um a função ou procedimento, você pode usar as funções High(), Low() e SizeOf() para obter informação sobre o array. Para ilustrar isto, o código seguinte mostra uma implementação da função AddEmUp() que retorna a soma de todos os números passados em A:
function AddEmUp(A: array of Integer): Integer;
var
i: Integer;
begin
Result := 0;
for i := Low(A) to High(A) do
inc(Result, A[i]);
end;
Escopo
Escopo refere-se a alguma parte de seu programa na qual uma dada função ou variável é conhecida pelo compilador. Uma constante global está no escopo em todos os pontos de seu programa, por exemplo, enquanto uma variável local para algum procedimento tem escopo apenas dentro daquele procedimento.
program Foo;
const
AlgumConstant = 100;
var
AlgumGlobal: Integer;
R: Real;
procedure AlgumProc(var R: Real);
var
LocalReal: Real;
begin
LocalReal := 10.0;
R := R - LocalReal;
end;
begin
AlgumGlobal := AlgumConstant;
R := 4.593;
AlgumProc(R);
end.
AlgumConstant, AlgumGlobal e R tem escopo global—seus valores são conhecidos pelo compilador em todos os pontos dentro do programa. O procedimento AlgumProc() tem duas variável na qual o escopo é local para aquele procedimento: R e LocalReal. Se você tentar acessar LocalReal fora de AlgumProc(), o compilador mostrará um erro de identificador desconhecido. Se você acessar R dentro de AlgumProc(), você estará referindo a versão local, mas se você acessar R fora daquele procedimento, você estará referindo à versão global.
Object Pascal permite o uso de funções em tempo de compilação em declarações const e var. Essas rotinas incluem: Ord(), Chr(), Trunc(), Round(), High(), Low(), e SizeOf(). Por exemplo, todos os códigos seguintes são válidos:
type
A = array[1..2] of Integer;
const
w: Word = SizeOf(Byte);
var
i: Integer = 8;
j: SmallInt = Ord(‘a’);
L: Longint = Trunc(3.14159);
x: ShortInt = Round(2.71828);
B1: Byte = High(A);
B2: Byte = Low(A);
C: char = Chr(46);
Introduzindo o Coletor de lixo - Gerenciamento de Memória em Delphi
Como já explicamos anteriormente, a partir de 2002 (delphi 7), além de manter sua compatibilidade com as versões anteriores, agora permite que o desenvolvedor disponibilize seus aplicativos para serem executados sobre a arquitetura .NET.
sexta-feira, 2 de novembro de 2007
A Evolução do Delphi e Curiosidades
| 1994 | Nasce o Delphi 1 , versão 16 bits. |
| 1995 | Com o lançamento do Windows 95, primeira versão 32 bits do Windows, foi lançado o Delphi 2 mantendo total compatibilidade com a versão 16 bits. |
| 1997 | Acontece o grande "BOOM" da internet. E o Delphi 3 traz suporte à construção de aplicações para internet com CGI e ISAPI/NSAPI. Era a primeira ferramenta com suporte para construção de aplicações multi-camadas (usando DCOM), com ambiente RAD (MIDAS). |
| 1998 | A Borland disponibiliza o Delphi 4 com suporte aos mais recentes padrões de mercado, tais como o CORBA e Oracle 8 , trazendo aumento de produtividade do ambiente de desenvolvimento, com a possibilidade de depuração remota de aplicações, e wizards para a construção de controles ActiveX/ActiveForms. |
| 1999 | A onda do momento era o XML e, como não poderia deixar de ser, o Delphi 5 massacra qualquer concorrente com suas facilidades na manipulação de arquivos XML. Mantendo sua característica de suportar diversas tecnologias, a Borland disponibiliza um conjunto de componentes para utilização da tecnologia ADO (Microsoft) de acesso a dados. As ferramentas TeamSource e TranslationSuite também são novidades nessa versão. |
| 2001 | A estrela do momento é o Linux e a Borland é a primeira a disponibilizar uma ferramenta RAD nativa "Cross-plataform". Os Web Services eram também destaque, e o Delphi 6 é a primeira ferramenta comercial a ter suporte para essa tecnologia. Nasce o Kylix , o Delphi para Linux. BizSnap, DataSnap e WebSnap também são novidades. |
| 2002 | Chegou o .NET . O que fazer agora? Jogar o Delphi fora? É certo que a Borland jamais deixaria isto acontecer. O Delphi 7 , além de manter total compatibilidade com as versões anteriores, agora permite que o desenvolvedor disponibilize seus aplicativos para serem executados sobre a arquitetura .NET . |
(*) RAD ( Rapid Aplication Development ) - significa "Ambiente Rápido de desenvolvimento" . Um RAD diminui bastante o tempo necessário para o desenvolvimento de aplicações. Mas como isso é possível? Um RAD traz em seu ambiente formas de diminuir o trabalho de um programador. No Delphi, por exemplo, quando criamos um botão, ao invés de digitarmos todo o código fonte para tal criação, simplesmente arrastamos o botão para a tela. O Delphi se encarrega de fazer toda a programação necessária para a criação deste botão. Em geral ferramentas do tipo RAD, economizam “trabalho braçal” do programador.
Assinar:
Postagens (Atom)