Use Delphi para implementar a criptografia e compactação de arquivos
Autor: e Mengyuan (Wnhoo)
Correio: [email protected]
Amor e amor
Clique para baixar este arquivo de descrição detalhado
Visão geral:
Neste documento, falaremos sobre a implementação da criptografia de dados, compactação de dados e auto-descrição de um único arquivo. Da mesma forma, a compactação de vários arquivos ou pastas pode ser alcançada com uma ligeira modificação.
Palavras -chave: compactação criptografada, zlib, fluxo, arquivos de recursos
introdução:
Na vida cotidiana, devemos ter usado software de compactação famosa, como Winzip e Winrar, o que significa que inevitavelmente encontraremos problemas como criptografia de dados e compactação de dados durante o processo de desenvolvimento de software! Este artigo discute esse problema técnico e também graças a todos os internautas por suas habilidades. Este artigo usa principalmente as poderosas habilidades de processamento de fluxo da Delph para alcançar a criptografia e a compactação de dados e é usado no desenvolvimento do programa de software real.
1. Funções do sistema
1) Compressão de dados
Use duas classes de fluxo fornecidas por Delphi (TCOMPressionstream e TDecompressionstream) para concluir a compressão e a descompressão dos dados.
2) criptografia e compressão de dados
A criptografia de dados é realizada através da aplicação de "fluxo" na programação Delphi, principalmente usando TfileStream e TMemorystream, duas classes derivadas de TStream;
3) Clique duas vezes no arquivo compactado para associar e descomprimir automaticamente
Ao alterar a associação da extensão do registro com os arquivos do programa, o Tregistry é usado principalmente;
4) pode gerar arquivos de extração de auto-extração
O arquivo autodecompressor realiza descompressão automática da compressão de dados 1) e compressão de criptografia de dados 2); A autodecompressão dos dados é alcançada.
2. Implementação do sistema
2.1
2.2.
(I) Zlib
1) Classe base tcustomzlibStream: é a classe base das classes TCOMPRESSIONS e TDECOMPRESSIONSTRAMENTE.
Formato: ProcedureOnProgress (remetente: Tobject); dinâmico;
2) Classe de compressão TCompressionsTream: Além de herdar a propriedade OnProgress da classe base, outro atributo é adicionado: compressão, que é definida da seguinte forma:
PropertyCompressionRate: SingleReadgetCompressionRate;
Através desta propriedade, a taxa de compressão pode ser obtida.
Vários métodos importantes são definidos da seguinte maneira:
ConstructortCompressionstream.create (CompressionLEvel: TCompressionLEvel; dest: tStream);
Entre eles: TCOMPRESSE Nível (tipo de compressão), é definido pelo seguinte:
1) Clnone: Nenhuma compactação de dados é realizada;
2) Clastest: realiza compressão rápida, sacrificando a eficiência da compressão;
3) CLDefault: execute compressão normal;
4) CLMAX: maximizar a velocidade de compressão e sacrifício;
Dest: Stream de destino, usado para armazenar dados compactados.
FunctComPressionstream.Write (constBuffer; count: longint): longint;
Entre eles: Buffer: dados que precisam ser compactados;
Contagem: o número de bytes de dados a serem compactados;
A função retorna o número de bytes gravados para o fluxo.
NOTA: Os dados da classe compactada TCompressionsTream só podem ser gravados. Os dados que precisam ser compactados são gravados no fluxo através do método de gravação do método e são compactados durante o processo de escrita e são salvos no fluxo de memória (TMemorystream) fornecidos pelo construtor e o evento no proco é acionado.
3) Classe de descompressão TDECOMPRESSIONSTREM: Ao contrário da classe compactada TCOMPRESSIONSTREAM, seus dados só podem ser lidos.
Seus vários métodos importantes são definidos da seguinte forma:
ConstrutorCreate (fonte: tStream);
Entre eles: a fonte é um fluxo que armazena dados compactados;
FunctionRead (varbuffer; count: longint): longint;
Função de leitura de dados, buffer: armazenar buffer de dados;
A função retorna o número de bytes de leitura. Durante o processo de leitura, os dados são descompactados e o evento noprocess é acionado.
(Ii)
Em Delphi, a classe base de todos os objetos de fluxo é a classe TStream, que define propriedades e métodos comuns de todos os fluxos.
As propriedades definidas na classe TStream são as seguintes:
1), tamanho: esta propriedade retorna o tamanho dos dados no fluxo em bytes.
2) Posição: Esta propriedade controla a posição de acessar ponteiros no fluxo.
Existem quatro métodos virtuais definidos no TStream:
1) Leia: Este método implementa dados de leitura do fluxo, e o valor de retorno é o número real de bytes lidos, que podem ser menores ou iguais ao valor especificado.
2) Escreva: Este método implementa a gravação de dados no fluxo e o valor de retorno é o número de bytes realmente gravados no fluxo.
3) Procura: Este método percebe o movimento do ponteiro de leitura no fluxo, e o valor de retorno é a posição do ponteiro após o movimento.
O protótipo da função é: functionSeek (deslocamento: longInt; Origint: word): longint; virtual; abstrato;
O deslocamento do parâmetro é o número de bytes de deslocamento.
SofRombeginning: Offset é o início dos dados da distância do ponteiro. No momento, o deslocamento deve ser maior ou igual a zero.
SofromCurrent: Offset é a posição relativa do ponteiro e do ponteiro atual após se mover.
SOFROMEND: Offset é a posição em que os dados da distância do ponteiro terminam após a mudança. Neste momento, o deslocamento deve ser menor ou igual a zero.
4) SetSize: Este método percebe a alteração do tamanho dos dados.
Além disso, vários métodos estáticos são definidos na classe TStream:
1) ReadBuffer: A função desse método é ler dados da posição atual no fluxo, o mesmo que a leitura acima.
NOTA: Quando o número de bytes lido é diferente do número de bytes a serem lidos, será gerada uma exceção ereaderror.
2) WriteBuffer: A função desse método é escrever dados no fluxo no local atual, o mesmo que a gravação acima.
NOTA: Quando o número de bytes escritos em dados é diferente do número de bytes a serem gravados, uma exceção de eWriteError será gerada.
3) CopyFrom: A função deste método é copiar fluxos de dados de outros fluxos.
O protótipo da função é: functionCopyFrom (fonte: tStream; contagem: longint): longint;
A fonte do parâmetro é o fluxo que fornece dados e a contagem é o número de bytes de dados copiados. Quando a contagem é maior que 0, cópias de cópias contam bytes de dados da posição atual do parâmetro de origem;
Classes comumente derivadas de TStream:
Tfilestream (acesso aos fluxos de arquivos)
TSTRINGSTREAM (Processos Tipo de string Dados na memória)
TMemorystream (para processamento de dados da área de memória de trabalho)
Tblobstream (processamento de dados de campos do tipo BLOB)
TwinsocketStream (Leia e grava o processamento do soquete)
Tolestream (processamento de dados da interface com)
TresourceStream (processamento de fluxos de arquivos de recursos)
O mais comumente usado é a classe TfileStream. Para acessar arquivos usando a classe TfileStream, você deve primeiro criar uma instância. A declaração é a seguinte:
construtorCreate (constFileName: string; mode: word);
O nome do arquivo é o nome do arquivo (incluindo caminho)
O modo é a maneira de abrir um arquivo.
Modo aberto:
FMcreate: Crie um arquivo com o nome do arquivo especificado e abra -o se o arquivo já existir.
FmopenRead: Abra o arquivo especificado em somente leitura
FmopenWrite: Abra o arquivo especificado de maneira somente de gravação
fmopenReadWrite: Abra o arquivo especificado no modo de escrita
Modo de compartilhamento:
fmsharecompat: o modo compartilhado é compatível com o FCBS
fmshareexclusive: nenhum outro programa pode abrir o arquivo de qualquer forma
FMSHAREDENYWRITE: Nenhum outro programa pode abrir o arquivo por escrito
fmsharedenyread: Nenhum outro programa pode abrir o arquivo no modo de leitura
fmsharedenynone: Outros programas podem abrir o arquivo de qualquer forma
(Iii) arquivo de recursos
1) Crie arquivos de recursos
Primeiro, crie um arquivo de texto simples de .rc.
Formato: Nome do arquivo de recurso de palavras -chave identificador de recursos
Identificador de recursos: um rótulo especial ao chamar um recurso no programa;
Palavras -chave: identificar o tipo de arquivo de recursos;
Onda: o arquivo de recursos é um arquivo de som;
Rcdata: arquivo jpeg;
Avi: Avi Animation;
Ícone: arquivo de ícone;
Bitmap: arquivo de bitmap;
Cursor: arquivo cursor;
Exefile: arquivo exe
Nome do arquivo de recurso: o nome completo do arquivo armazenado no disco do arquivo de recursos
Por exemplo:
myzjyexefilezjy.exe
2) Compilar arquivos de recursos
Sob /Bin of Delphi Instalation Directory, use BRCC32.EXE para compilar o recurso File.rc. Obviamente, você também pode copiar o BRCC32 para o diretório do documento do programa separadamente para uso.
Por exemplo:
BRCC32WNHOO_REG.RC
3) Referência do arquivo de recursos
...
Implementação
{$ R*.dfm}
{$ Rwnhoo_reg.res}
...
4) Ligue para arquivos de recursos
(1) Acesse o bitmap no arquivo de recursos (bitmap)
Image.picture.bitmap.handle: = loadbitmap (hinstance, 'identificador de recursos');
Nota: Se o bitmap não for carregado com sucesso, o programa ainda será executado, mas a imagem não será mais exibida. Você pode julgar se a carga é bem-sucedida com base no valor de retorno da função LoadBitmap.
Outro método de acessar e exibir bitmap é o seguinte
Image.picture.bitmap.loadFromResourceName (Hinstance, 'Identificador de Recursos');
(2) Acesse o cursor no arquivo de recursos
Screen.Cursors [] é uma matriz de cursor. Como o valor do índice de cursor padrão na matriz é 0, é melhor definir o valor do índice de cursor personalizado como 1, a menos que você queira substituir o cursor padrão.
Screen.cursors [1]: = loadcursor (hinstance, 'identificador de recursos');
Image.cursor: = 1;
(3) Acesse ícones em arquivos de recursos
Colocar o ícone no arquivo de recursos permite alterar dinamicamente o ícone do aplicativo.
Application.icon.Handle: = loadicon (Hinstance, 'Identificador de Recursos');
(4) Acesse o AVI no arquivo de recursos
Animate.ResName: = 'Myavi'; // Número do identificador de recursos
Animate.active: = true;
(5) Acesse JPEG no arquivo de recursos
Adicione a unidade JPEG à unidade de uso.
var
FJPG: TJPEGIMAGE;
FSTREAM: TRESourceStream;
Começar
Fjpg: = tjpegImage.create;
// Uso TresourceStream
FStream: = TresourceStream.create (hinstance, 'identificador de recursos', tipo de recurso);
Fjpg.loadFromStream (fStream);
Image.picture.bitmap.assign (fjpg);
(6) Onda de acesso no arquivo de recursos
Adicione o MMSystem à unidade de uso
PlaySound (PChar ('Mywav'), Hinstance, SND_ASYNCORSND_MEMORYORSND_RESOURCE);
(Iv) Operação de arquivo ini
(1) Estrutura do arquivo ini:
; Esta é a seção de comentários sobre o arquivo ini
[nó]
Palavra -chave = valor
...
O arquivo ini permite vários nós, e cada nó permite várias palavras -chave. O arquivo ini, o verdadeiro valor booleano é representado por 1 e o valor booleano falso é representado por 0). Os comentários começam com um semicolon ";".
(2) operação do arquivo ini
1. Adicione inifiles à seção de usos da interface;
2. Adicione uma linha à parte da definição da variável VAR: IniFile: TINIFILE;
3. Abra o arquivo ini: iniFile: = tinifile.create ('tmp.ini');
4. Leia o valor da palavra -chave:
A: = inifile.readstring ('nó', 'palavra -chave', valor padrão);
b: = iniFile.readInteger ('nó', 'palavra -chave', valor padrão); // tipo inteiro
C: = iniFile.readbool ('nó', 'palavra -chave', valor padrão);
Onde [padrão] é o valor padrão retornado quando a palavra -chave não existe no arquivo ini.
5. Escreva no arquivo ini:
iniFile.WritEstring ('nó', 'palavra -chave', variável ou valor da string);
infile.WriteInteger ('nó', 'palavra -chave', variável ou valor inteiro);
infile.WriteBool ('nó', 'palavra -chave', variável ou verdadeiro ou false);
Quando o nó deste arquivo ini não existe, a instrução acima também criará automaticamente o arquivo ini.
6. Excluir palavras -chave:
INIFILE.DELETEKEY ('nó', 'palavra -chave'); // Palavra -chave Excluir
iniFile.ERASESECTION ('NODE'); // Remoção do nó
7. Operação do nó:
iniFile.readSection ('nó', variável tStrings); // Todos os nomes de palavras -chave na seção especificada podem ser lidas em uma variável da lista de strings;
iniFile.readSections (variável tStrings); // Você pode ler todos os nomes de subsecção no arquivo ini em uma variável da lista de string.
iniFile.readSectionValues ('nó', variável tStrings); // Todas as linhas (incluindo palavras -chave, =, valores) na seção especificada no arquivo ini podem ser lidas em uma variável da lista de string.
8. Liberação: iniFile.Distory;
(V) Relacionamento do documento
usos
Registro, Shlobj;
// Realize o registro relacionado
ProcedureTMyzip.regzzz;
var
Reg: Tregistry;
Começar
Reg: = Tregistry.create;
reg.rootkey: = hkey_classes_root;
reg.openkey ('. Zzz', verdadeiro);
Reg.WritEstring ('', 'myzip');
Reg.CloseKey;
reg.openkey ('myzip/shell/open/comando', true);
// Programa executável usado para abrir arquivos .zzz
Reg.WritEstring ('', '"'+Application.exename+'" "%1"');
Reg.CloseKey;
reg.openkey ('myzip/defaulticon', true);
// Por favor, o ícone do programa executável atual como o ícone do arquivo .zzz
Reg.WritEstring ('', ''+Application.exename+', 0');
Reg.Free;
// Atualize agora
Shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
fim;
2.3.
1. Gere um arquivo criptografado temporário da INI
Formato de arquivo temporário para INI para criptografia:
[FILE1] // Nó, a criptografia de vários arquivos pode ser alcançada usando o File1..n no software
Nome do arquivo = nome do arquivo comprimido
Senha = senha de descompressão
FileSize = tamanho do arquivo
FileDate = Criar data
Isjm = é necessário descomprimir?
Se você implementar o armazenamento de informações de vários arquivos e pastas, poderá armazenar a palavra -chave de senha em um nó total. Este artigo implementa apenas a criptografia de um único arquivo; portanto, desde que o formato acima seja suficiente.
2. Mesclar o arquivo de dados com o arquivo ini usado para criptografia, que pode ser implementado na forma de um fluxo de arquivos.
Diagrama de estrutura de arquivos criptografado:
Figura (1)
Figura (2)
Os dois formulários acima podem ser usados de acordo com as condições reais. Este artigo adota a estrutura da Figura (1).
3. Para dados criptografados, a tecnologia ZLIB é usada para realizar o armazenamento compactado e gerar novos arquivos compactados.
2.4.
2.5
1. Crie um arquivo de programa executável especificamente a partir da descompressão
2. Crie arquivos de recursos em 1
3. Coloque o arquivo de recursos no programa desta ferramenta de compactação neste artigo e compile -o.
4. Gere um arquivo de extração de auto-extração, mesclando o arquivo de recursos com o arquivo compactado.
Diagrama de estrutura de arquivos auto-extraído:
5. Implementação de autodecompressão: ao decompor os dados compactados criptografados em seu próprio arquivo, descompactendo os dados compactados criptografados em decomposição novamente e decompondo o arquivo de dados real.
2.6 Programação do sistema
Esse é todo o código da parte principal desta implementação de software e aqui explicaremos todos os detalhes técnicos deste software em detalhes.
//wnhoo_zzz.pas
unitwnoo_zzz;
interface
usos
Windows, formulários, sysutils, aulas, zlib, registro, iniFiles, diálogos, shlobj;
tipo
pass = string [20];
tipo
Tmyzip = classe
Privado
{privateClarationShere}
protegido
{ProtectedDeclarationShere}
público
Procedureregzzz;
Procedimentos_file (Infilename, OutfileName: String; Senha: Pass; ISJM: Boolean; Ysbz: Inteiro);
functionjy_file (infilename: string; senha: pass = ''): boolean;
procedurezjywj (varfilename: string);
construtorCreate;
DestructorDestroy; substituir;
{publicDeclarationShere}
publicado
{publicedDeclarationShere}
fim;
Implementação
constructortmyzip.create;
Começar
herdedcreate; // inicialize a parte herdada
fim;
/// ###################################################d ########Omas ############################ #####
// criptografia de arquivo original
procedurejm_file (vfile: string; vartarget: tmemorystream; senha: passa; isjm: boolean);
{
VFILE: arquivo criptografado
Alvo: fluxo de destino de saída após criptografia 》》》》》
Senha: senha
ISJM: É criptografado?
-------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- ------ -----------------
Tamanho do arquivo criptografado = Tamanho do arquivo original + [Arquivo de informações compactadas criptografadas da INI] Tamanho + Tamanho Arquivo do tamanho do tipo de dados de [Arquivo de informações compactadas criptografadas ini]
-------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- ------ ------------------------
}
var
tmpStream, Instruam: TfileStream;
FileSear: Inteiro;
iniFile: Tinifile;
nome do arquivo: string;
Começar
// A abertura requer [arquivo compactado criptografado]
tmpStream: = tfilestream.create (vfile, fmopenReadorfmshareexclusive);
tentar
// Escreva [fluxo de arquivo original] até o final de [fluxo de arquivo compactado criptografado temporário]
Target.Seek (0, Sofromend);
Target.copyFrom (tmpStream, 0);
// Obtenha o caminho do arquivo e gerar [Arquivo de informações compactadas criptografadas da INI]
nome do arquivo: = extractFilePath (paramstr (0))+'tmp.in_';
iniFile: = tinifile.create (nome do arquivo);
INIFILE.WritEstring ('file1', 'FileName', ExtractFilename (VFile));
infile.WritEstring ('file1', 'senha', senha);
infile.WriteInteger ('file1', 'fileSize', Target.size);
iniFile.WriteTatETime ('FILE1', 'Filedate', agora ());
iniFile.WriteBool ('FILE1', 'ISJM', ISJM);
iniFile.Free;
// Leia em [INI Encrypted Compressed Information File Stream]
Instruam: = tfilestream.create (nome do arquivo, fmopenReadorfmShareexclusive);
tentar
// Continue a adicionar [Arquivo de informações compactadas criptografadas da INI] no final de [Stream de arquivo compactado criptografado temporário]
Instruam.Position: = 0;
Target.Seek (0, Sofromend);
Target.copyFrom (inistream, 0);
// Calcule o tamanho do atual arquivo de informações compactadas e criptografadas]
FileSize: = inistream.size;
// Continue adicionando as informações de tamanho do [Arquivo de Informações Compressas Criptografadas da Ini] no final do [arquivo criptografado temporário]
Target.WriteBuffer (FileSize, sizeof (fileSesel));
Finalmente
Instruam.Free;
deletefile (nome do arquivo);
fim;
Finalmente
tmpstream.free;
fim;
fim;
// ************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** *******************************************
// compressão de fluxo
Procedimentos_stream (Instruam, Outream: TStream; YSBZ: Integer);
{
Instruam: fluxo de arquivos criptografado a ser compactado
Fluxo de arquivo de saída de compressão de compressão
YSBZ: padrão de compressão
}
var
ys: tCompressionstream;
Começar
// O ponteiro de fluxo aponta para a cabeça
Instruam.Position: = 0;
// selecionando padrões de compactação
CasesBZof
1: ys: = tCompressionstream.create (clnone, superam); // não comprimido
2: ys: = tCompressionstream.create (clfastest, superestre); // compressão rápida
3: ys: = tCompressionstream.create (cldefault, superestre); // compressão padrão
4: ys: = tCompressionstream.create (clmax, superam); // compressão máxima
outro
ys: = tCompressionstream.create (clfastest, superam);
fim;
tentar
// fluxo de compressão
ys.copyFrom (Instruam, 0);
Finalmente
Ys.Free;
fim;
fim;
// ************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** ***************************************************
// descompressão de fluxo
Procedurejy_stream (Instruam, Outream: TStream);
{
Instruam: arquivo de fluxo compactado original
Outream: descompacte o arquivo de streaming
}
var
Jyl: tDecompressionstream;
BUF: Array [1..512] OFBYTE;
sjread: inteiro;
Começar
Instruam.Position: = 0;
jyl: = tDecomPressionstream.create (Instream);
tentar
repita
// Leia o tamanho real
sjread: = jyl.read (buf, sizeof (buf));
ifsjread> 0then
Outream.Write (BUF, SJREAD);
até (sjread = 0);
Finalmente
jyl.free;
fim;
fim;
// ************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** *******************************************
// Realize o registro relacionado
ProcedureTMyzip.regzzz;
var
Reg: Tregistry;
Começar
Reg: = Tregistry.create;
reg.rootkey: = hkey_classes_root;
reg.openkey ('. Zzz', verdadeiro);
Reg.WritEstring ('', 'myzip');
Reg.CloseKey;
reg.openkey ('myzip/shell/open/comando', true);
// Programa executável usado para abrir arquivos .zzz
Reg.WritEstring ('', '"'+Application.exename+'" "%1"');
Reg.CloseKey;
reg.openkey ('myzip/defaulticon', true);
// Por favor, o ícone do programa executável atual como o ícone do arquivo .zzz
Reg.WritEstring ('', ''+Application.exename+', 0');
Reg.Free;
// Atualize agora
Shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
fim;
// compactar arquivos
ProcedureTMYZIP.YS_FILE (Infilename, OutfileName: String; Senha: Pass; ISJM: Boolean; Ysbz: Inteiro);
{
Infilename: // Os arquivos criptografados precisam ser compactados
outfilename: // compactar o arquivo gerado após a criptografia
Senha: // Não incorpice a senha
ysbz: // padrão de compressão
}
var
Instruam: tMemorystream; // fluxo temporário após a criptografia de arquivo
Outream: tfileStream; // Compressa o fluxo de arquivos de saída
Começar
// Crie [fluxo temporário após criptografia de arquivo]
Instruam: = tmemorystream.create;
// criptografia de arquivo
JM_FILE (Infilename, Instream, Senha, ISJM);
// Crie um fluxo de arquivo de saída compactado
Outream: = tfilestream.create (outfileName, fmcreate);
tentar
// [fluxo temporário após criptografia de arquivo] Compressão
ys_stream (Instruam, supere, ysbz);
Finalmente
Superam.free;
entrantream.free;
fim;
fim;
// descompacte o arquivo
functionTMYZIP.JY_FILE (Infilename: String; Senha: Pass = ''): Boolean;
var
Instruam, Instruam, filestream_ok: tfilestream;
{
Instream: // Nome do arquivo unzip
Instruam: // Fluxo de arquivos temporários ini
filestream_ok: // descompactando o arquivo OK
}
Outream: tmemorystream; // fluxo de memória temporária
INIFILE: TINIFILE; // arquivo ini temporário
FileShize: Integer; // Tamanho do arquivo de senha
ResultValue: booleano; // Valor de retorno
Começar
tentar
Instruam: = tfilestream.create (InfileName, fmopenRead);
tentar
superam: = tmemorystream.create;
tentar
JY_STREAM (Instruam, Outream);
// gerar arquivo ini temporário
Instruam: = tfileStream.create (ExtractFilePath (paramstr (0))+'tmp.in _', fMcreate);
tentar
// apontar para a posição variável do tipo inteiro que armazena as informações decodificadas
Outream.Seek (-Sizeof (FileSize), Sofromend);
// Leia em informações variáveis
Overream.readBuffer (fileSesel, sizeof (fileSesel));
// apontar para o local da informação decodificada
Outream.Seek (-(FileSize+sizeof (fileSesel)), SOFROMEND);
// Leia as informações decodificadas no fluxo da INI
Instream.copyFrom (Outream, FileSee);
// Libere o fluxo de arquivos ini
Instruam.Free;
// Leia as informações do arquivo ini
INIFILE: = tinifile.create (ExtractFilePath (paramstr (0))+'tmp.in_');
ResultValue: = inifile.readbool ('file1', 'isjm', false);
ifResultValuethen
Começar
ifinifile.readstring ('file1', 'senha', '') = Trim (senha) então
ResultValue: = true
outro
ResultValue: = false;
fim
outro
ResultValue: = true;
ifResultValuethen
Começar
filestream_ok: = tfilestream.create (extraCtFilePath (paramstr (1))+inifile.readstring ('file1', 'nome do arquivo', 'wnhoo.zzz'), fmcreate);
tentar
Superam.Position: = 0;
filestream_ok.copyFrom (Outream, inifile.readInteger ('file1', 'fileSize', 0));
Finalmente
filestream_ok.free;
fim;
fim;
iniFile.Free;
Finalmente
// Excluir arquivo ini temporário
DeleteFile (ExtractFilePath (paramstr (0))+'tmp.in_');
fim;
//
Finalmente
Superam.free;
fim;
Finalmente
Instruam.Free;
fim;
exceto
ResultValue: = false;
fim;
Resultado: = ResultValue;
fim;
// criação auto-extractada
procedureetmyzip.zjywj (varfileName: string);
var
Myres: TRSourCestream; // Arquivo de exe extraordinário temporariamente para extrair
myFile: tfilestream; // Fluxo de arquivo original
xfilename: string; // Nome do arquivo temporário
file_ok: tmemorystream; // o fluxo de memória do arquivo gerado
FileSize: Inteiro; // Tamanho do arquivo original
Começar
iffileExists (nome do arquivo) então
Começar
// Crie fluxo de memória
file_ok: = tmemorystream.create;
// Libere o arquivo de recursos--si mesmo
Myres: = TresourceStream.create (hinstance, 'myzjy', pchar ('exefile'));
// Leia o arquivo original na memória
myFile: = tfilestream.create (nome do arquivo, fmopenRead);
tentar
myres.Position: = 0;
file_ok.copyFrom (myres, 0);
file_ok.seek (0, Sofromend);
myFile.Position: = 0;
file_ok.copyFrom (myFile, 0);
file_ok.seek (0, Sofromend);
fileSize: = myfile.size;
file_ok.writebuffer (fileSesel, sizeof (fileSesel));
file_ok.Position: = 0;
xFilename: = ChangeFileExt (nome do arquivo, '. Exe');
file_ok.savetofile (xfilename);
Finalmente
myFile.Free;
myres.free;
file_ok.free;
fim;
Deletefile (nome do arquivo);
nome do arquivo: = xfilename;
fim;
fim;
/// ###################################################d ########Omas ############################ #####
destructortmyzip.destroy;
Começar
herdeddestroy;
fim;
fim.
3. Conclusão
O novo ambiente de programação visual da Delphi nos fornece uma ferramenta de desenvolvimento de aplicativos Windows conveniente e rápida. Para desenvolvedores de programas, o uso do Delphi para desenvolver software de aplicativo, sem dúvida, melhorará bastante a eficiência da programação. Em Delphi, você pode usar facilmente fluxos para implementar vários formulários de dados, como processamento de arquivos, processamento dinâmico de memória, processamento de dados de rede etc. e programas de redação melhorarão bastante a eficiência.
Referências:
1. Ajuda do sistema Delphi
2. Feng Zhiqiang.
3. Chen Jingtao.