06 - ClarionLanguageProgramming - En.pt

2 Guia de Programao Clarion Lngua
COPYRIGHT 1994-2003 SoftVelocity Incorporated. Todos os direitos reservados.
Esta publicao protegido por copyright e todos os direitos so reservados pela SoftVelocity Incorporated. Ele no pode, no todo ou em
parte, ser copiado, fotocopiado, reproduzido, traduzido ou reduzido para qualquer meio eletrnico ou forma legvel por mquina sem o
consentimento prvio, por escrito, de SoftVelocity Incorporated.
Esta publicao suporta Clarion. possvel que ele pode conter tcnico ou tipogrfico
erros. SoftVelocity Incorporated fornece esta publicao tal como est, sem qualquer tipo de garantia, expressa ou implcita.
SoftVelocity Incorporated
2769 Oriental Atlantic Blvd. Pompano Beach,
Florida 33062 (954) 785-4555
www.softvelocity.com
Reconhecimentos de marca registrada:
SoftVelocity marca registrada da SoftVelocity Incorporated. clarim

uma marca registrada da SoftVelocity Incorporated. Btrieve
uma marca registrada da Software Pervasive. Microsoft janelas e Visual Basic so marcas comerciais registradas da
Microsoft Corporation. Todos os outros produtos e nomes de empresas so marcas comerciais de seus respectivos proprietrios.
Impresso nos Estados Unidos da Amrica (0703)

Contedo 3
Contedo:
1 - Estrutura do Programa .............................................. .......................................... 7
Programao estruturada ................................................ .................................................. ......... 7 procedimentos
................................................ .................................................. ........................ 7
Locais Stack baseadas em dados Declaraes ............................................ ........................................... 7
MAP PROGRAMA ................................................ .................................................. ..................... 8
MDULO................................................. .................................................. ................................ 8
MEMBRO................................................. .................................................. ................................ 8
MEMBROS MAPs ................................................ .................................................. ...................... 9
Mdulos nos Estados MAPs .............................................. ........................................... 10
PROCEDIMENTO MAPs ................................................ .................................................. ............. 12
Resumo................................................. .................................................. .............................. 13
2 - facilitando em OOP ............................................. ............................................. 15

Tiros de abertura ................................................ .................................................. ....................... 15
Processual Cdigo Re-Visitou ............................................. .................................................. ..... 15
Declarao de classe ................................................ .................................................. ............... 16
Encapsulamento ................................................. .................................................. ....................... 16
Instanciao ................................................. .................................................. .......................... 17
Campo Qualificao Sintaxe ............................................... .................................................. ....... 19
Construtores and Destrutores ............................................... .................................................. 19
Mais Sobre Encapsulation ............................................... .................................................. ..... 21
Herana................................................. .................................................. ............................ 22
To fcil quanto a torta de Apple ............................................. .................................................. .............. 23
Herana mltipla ................................................ .................................................. ............... 23
Composio ................................................. .................................................. ......................... 24
E ainda mais sobre encapsulamento ............................................. ........................................ 25
E muito mais sobre Construtores e Destrutores ............................................ ............................... 26
PAI ................................................. .................................................. ............................... 27
Polimorfismo................................................. .................................................. ....................... 27
Mtodos virtuais ................................................ .................................................. ..................... 28
Mais Apple Pie ............................................... .................................................. ....................... 29
Ligao tardia ................................................ .................................................. .......................... 30
Local Derivado Mtodos ............................................... .................................................. .......... 31
Resumo................................................. .................................................. .............................. 31
3 - Programao Orientada a Objetos (OOP) .......................................... .............. 33

Objeto Overview - Quais so objetos ...........................................? .......................................... 33
Por Objects? .................................................. .................................................. ...................... 33
O que faz um objeto? ............................................. .................................................. ........... 34
Extenses OOP do Clarion ............................................... .................................................. ...... 36
A Estrutura-encapsulamento CLASSE ............................................. ...................................... 36
Propriedades de Classe ................................................ .................................................. ................. 36
Mtodos de classe ................................................ .................................................. .................... 36
Criando objetos ................................................ .................................................. .................... 37
Usando referncias como Propriedades .............................................. ............................................... 38
Construtores e destruidores ............................................... .................................................. 39

vs. pblica vs. privada protegida ........................................... ......................................... 40
Derivado classes Herana .............................................. ................................................ 42
Substituindo mtodos herdados ............................................... .................................................. .44
Herana mltipla vs. Composio ............................................. ......................................... 47
Mtodos-Polimorfismo virtuais .............................................. ............................................... 49
Local Derivado Mtodos ............................................... .................................................. .......... 51
Resumo................................................. .................................................. .............................. 52
4 - Database Design .............................................. ........................................... 53

Database Design ................................................ .................................................. ................... 53
Relational Database Design ............................................... .................................................. ... 53
Relaes de arquivo ................................................ .................................................. .................. 55
Traduzindo a Teoria Clarion ............................................. ............................................... 57
Integridade referencial ................................................ .................................................. ............... 58
Anular a chave estrangeira .............................................. .................................................. ............ 62
Resumo................................................. .................................................. .............................. 64
5 - Processamento de Arquivo de Dados ............................................. ...................................... 65
Processamento de Arquivo de Dados ............................................... .................................................. .............. 65

Arquivo Mtodos de acesso ............................................... .................................................. .............. 65
KEY e INDEX ............................................... .................................................. ..................... 65
Sequential File Access ............................................... .................................................. ........... 66
Random Access Arquivo ............................................... .................................................. .............. 69
Resumo................................................. .................................................. .............................. 71
6 - Consideraes Multiusurios ............................................ ............................. 73

Consideraes Multiusurios .............................................. .................................................. ....... 73
Abrindo arquivos ................................................ .................................................. ........................ 73
Verificao de simultaneidade ................................................ .................................................. .......... 74
Segure e solte ............................................... .................................................. ............. 79
Bloquear e desbloquear ............................................... .................................................. .............. 82
Abrao mortal .............................................. .................................................. ................... 84
Resumo................................................. .................................................. .............................. 85
7 - Desenvolvimento de aplicaes cliente / servidor ........................................... .......... 87
Introduo ao Cliente / Servidor ............................................. ............................... 87

Cliente / Servidor Definido .............................................. .................................................. .............. 87
Tipos de aplicaes cliente / servidor de banco de dados ........................................... ............................. 87
Banco de dados SQL Engines ............................................... .................................................. .......... 88
Clarion e SQL ............................................... .................................................. ..................... 88
Projeto de banco de dados e trfego de rede ............................................. ................ 89
Integridade Referencial Handling ............................................... .................................................. .89
Data de validade ................................................ .................................................. ...................... 90
Clarion Language Support Cliente / Servidor ............................................ ............. 90
A Estrutura VISTA ............................................... .................................................. ............... 90
Contedo 5
A Demonstrao BUFFER ............................................... .................................................. ........ 92

SQL embutido no Clarion .............................................. .................................................. ...... 93
Manipulao de dados NULL ............................................... .................................................. .............. 95
Tratamento de erros ................................................ .................................................. ....................... 96
ndice:................................................ .................................................. ............... 97

Estrutura do programa 7
1 - Estrutura do Programa
Programao estruturada
A estrutura adequada de um programa de computador um tema que pode ser o incio de um debate altamente carregado. Muitos
programadores tm ideias concretas, firmemente defendida, sobre o que constitui a estrutura adequado para um programa, e essas idias
nem sempre estar de acordo com os pensamentos de outro programador relativos estrutura adequada. Portanto, este ensaio uma
discusso geral sobre as ferramentas Clarion idioma que fornecem a capacidade de construir programas em seu prprio conceito de
estrutura adequada.
procedimentos
A chave para qualquer programao estruturada a capacidade de quebrar seu cdigo de programa em tarefas separadas para chamar
quando necessrio. O Clarion Idioma fornece uma declarao que permite este tipo de separao de tarefas: PROCESSO. Um
procedimento pode ser um prottipo para retornar um valor e, portanto, pode ser chamado como parte de uma lista de expresses ou
parmetro. Um procedimento que no retorna um valor s pode ser chamado explicitamente como um programa separado declarao-lo
no pode ser utilizado como parte de um lista de expresses ou parmetro.
UM PROCEDIMENTO prottipo para retornar um valor tambm pode ser chamado explicitamente como uma declarao programa
separado quando o valor retornado no importante para o contexto em que ele chamado. Fazendo isso ir gerar avisos do
compilador (que pode ser ignorada com segurana) a menos que o prottipo do procedimento tem o atributo PROC.
Em um procedimento que voc pode colocar repetitivas declaraes cdigo executvel em rotinas. Isso til para otimizar o tamanho
de seu cdigo de programa e movendo funcionalidade explcita para fora da lgica principal procedimento, tornando a lgica global fluir
mais fcil de seguir. No entanto, as rotinas so apenas local para o procedimento e s pode ser utilizado dentro do procedimento em
que ele reside. Portanto, o uso de rotinas no faz parte desta discusso.
Declaraes dados locais Stack-Based

Cada procedimento tem uma seo de declarao de dados e uma seo de cdigo executvel. A seco de declarao de dados segue a
palavra-chave PROCEDIMENTO e termina com a palavra-chave CODE. A seco de cdigo executvel segue a palavra-chave CODE.
Quaisquer variveis ou estruturas de dados declarados em um procedimento 's seo de declarao de dados so locais para esse
procedimento. Isso significa que eles s so visveis dentro desse procedimento, salvo passado como um parmetro para outro
procedimento. Variveis declaradas localmente em um procedimento (sem o atributo STATIC) so alocados dinamicamente a memria
quando o procedimento executado. A memria para um vivel local alocado na pilha do programa a menos que seja maior do que o
limiar de pilha, ento alocado no heap (mas ele se comporta o mesmo que uma varivel alocada na pilha). Quando o procedimento
retornos completos e controle do programa para o lugar de onde ele foi chamado, a memria da varivel local de- alocados e retornado
para o programa para outros usos. Somente variveis declaradas local para um procedimento so alocados dinamicamente a memria na
pilha.
Dinamicamente alocados variveis locais torna procedimento recursivo e de reentrada s possvel. Um procedimento recursivo se chama a si
mesmo dentro de seu cdigo. Cada vez que um procedimento recursivamente chamado, ele recebe uma nova cpia de suas variveis locais
no-estticos. Recurso uma tcnica de programao avanado que til para o procedimento s que deve ser executado em sucessivas
iteraes.
MAPA DO PROGRAMA
Assim como um procedimento, um programa tem uma seo de declarao de dados (entre o programa de palavras-chave e cdigo) e
uma seo de cdigo executvel (aps a palavra-chave CODE). Todas as variveis e estruturas de dados declarados na seo de
declarao de dados do programa so global (disponvel para uso em qualquer lugar do aplicativo) e so alocados memria
estaticamente. estrutura do mapa de um programa est localizado na seo global declarao de dados. Este MAP diz ao programa qual
o procedimento s so globalmente disponvel em qualquer lugar no aplicativo. Em um programa Clarion, todos os procedimentos s deve ser
um prottipo de uma estrutura MAP, a menos que eles so mtodos de uma classe (em seguida, a prpria estrutura de classe contm o
prottipo). Um prottipo de um procedimento informa o compilador o nome do procedimento, e como lidar com ele. Para uma descrio
completa de prottipos, consulte PROCEDIMENTO prottipos no Referncia da Linguagem.
MDULO
Dentro de um mapa, voc pode ter estruturas MDULO que declaram o arquivo de origem separado contendo o procedimento s prottipo
em que estrutura de mdulo. A estrutura do mdulo o mecanismo que permite que o prximo nvel de organizao programa:
procedimento agrupamento s em arquivos de origem separado.
H muitas razes para dividir off grupos de procedimento s em arquivos de origem separado. Este o ponto em que o debate entre os
programadores com diferentes pontos de vista torna-se altamente carregada. procedimento de agrupamento s que realizar tarefas
relacionadas uma abordagem. Agrupamento para otimizao dos tempos de compilao outra razo para o agrupamento de certos
arquivos juntos. Outro objetivo do procedimento de agrupamento a eventual criao de uma biblioteca de vnculo dinmico (DLL). No
importa o motivo, a estrutura mdulo define o mtodo pelo qual o seu programa pode refletir suas idias estruturais.
MEMBRO
Os prottipos para procedimento s que so definidos em um arquivo de outra fonte que no o arquivo de programa deve ser declarado em
uma estrutura de mdulo dentro de um mapa. O arquivo de cdigo fonte especificada pela estrutura MDULO deve comear com uma
declarao MEMBRO. Qualquer arquivo de cdigo fonte comeando com uma declarao MEMBRO comumente referido como um
mdulo MEMBRO. A declarao MEMBRO especifica o nome do arquivo de origem do programa ao qual o arquivo membro pertence. A
estrutura do mdulo no MAPA aponta para o arquivo de origem MEMBRO, ea declarao MEMBRO dentro desse arquivo de origem aponta
de volta para o arquivo fonte do programa.
Por exemplo, um arquivo de cdigo-fonte chamado MYPROG.CLW contm o seguinte cdigo:
PROGRAMA ! Comece seo global declarao de dados
MAPA ! A estrutura mapa global

PROCEDIMENTO Proc1 ! Um prottipo para um procedimento cuja! O
cdigo-fonte est em MYPROG.CLW
MDULO ( 'MYPROG2') ! Um arquivo de origem separado, MYPROG2.CLW
PROCEDIMENTO proc2 ! contm um outro procedimento
FIM ! MDULO End
FIM ! MAP End
CDIGO ! Comece cdigo executvel do programa

! Algum cdigo fonte executvel
PROCEDIMENTO Proc1 ! Comece seo de declarao de dados local

CDIGO ! Comece cdigo executvel procedimento! Algum
cdigo fonte executvel
Um segundo arquivo de cdigo fonte, MYPROG2.CLW, declarou na estrutura do mdulo do mapa de programa no
cdigo de exemplo acima, contm o seguinte cdigo:
MEMBRO ( 'myprog') ! Mdulo de membro do Programa em MYPROG.CLW
PROCEDIMENTO proc2 ! Comece seo de declarao de dados local

CDIGO ! Comece cdigo executvel procedimento
Neste exemplo, o programa tem duas procedimento s, Proc1 e Proc2. O cdigo fonte para Proc2 est em um arquivo separado,
MYPROG2.CLW. Portanto, o mapa de programa contm uma estrutura de mdulo que declara que Proc2 est em MYPROG2.CLW
arquivo de origem, e a primeira instruo no MYPROG2.CLW uma declarao membro que diz ao compilador o arquivo de programa
para o qual este membro pertence.
MEMBROS MAPs
Um mdulo de membros tambm tem uma seo de declarao de dados. Ele comea aps a palavra-chave Membro e
termina na primeira declarao procedimento no mdulo.
Qualquer estrutura varivel ou dados declarados na seo de declarao de dados de um mdulo MEMBRO local para esse
mdulo Membro e alocado memria esttica. Isso significa que ele pode ser acessado somente por um procedimento que reside
em que o mdulo membro, a menos passado como um parmetro a outro procedimento que reside em outro mdulo de fonte
(essencialmente tornando-os variveis privadas).
Alm de declaraes de dados, seo de declarao de dados de um mdulo MEMBRO tambm pode conter sua prpria estrutura
MAP. Este mapa estruturalmente o mesmo que o MAP no mdulo de programa, e declara prottipos de procedimento que esto
disponveis localmente dentro do mdulo MEMBRO.
Usando o exemplo anterior, um arquivo chamado MYPROG.CLW contm o seguinte cdigo:

MDULO ( 'MYPROG2')! Um arquivo de origem separado, MYPROG2.CLW Proc1
PROCEDIMENTO ! contm um procedimento
FIM ! MDULO End
FIM ! MAP End

O segundo arquivo de cdigo fonte, MYPROG2.CLW, agora contm o seguinte cdigo:
MEMBRO ( 'myprog') ! O incio dos dados de um mdulo MEMBRO! Seo de

declarao
MAPA ! A estrutura MAP MEMBRO
PROCEDIMENTO proc2 ! Um prottipo para um procedimento que ! Local para o
mdulo MYPROG2.CLW MEMBRO
FIM ! MAP End
Var1 BYTE ! Uma varivel esttica local para o MEMBRO


O procedimento Proc2 no foi declarada no mapa do programa, mas apenas em MAP do mdulo MEMBRO. Portanto, ele pode ser
chamado apenas pelo outro procedimento s dentro do mdulo MYPROG2.CLW MEMBRO (Proc1). Var1 foi declarado na seco
declarao dados de membro, por conseguinte, pode ser utilizado apenas pelo procedimento s realmente residentes nos
Estados-module-Proc1 e Proc2.
Mdulos nos Estados MAPs

Assim como no mapa do programa, MAP de um mdulo MEMBRO tambm pode conter estruturas mdulo, se o procedimento s prottipo
esto em arquivos de origem separadas. Qualquer procedimento que no um prottipo no mapa do programa deve ser um
prottipo no MAP mdulo-Membro em que reside. Isto significa que os prottipos procedimento idntico, so necessrios:
No mdulo estrutura do MAP mdulo MEMBRO no arquivo de cdigo fonte que chama o procedimento.
Na estrutura do mapa do segundo mdulo MEMBRO, que realmente contm o cdigo fonte de definio do procedimento.
Novamente usando os exemplos anteriores, um arquivo chamado MYPROG.CLW contm o seguinte cdigo:

MDULO ( 'MYPROG2') ! Um arquivo de origem separado, MYPROG2.CLW
PROCEDIMENTO Proc1 ! Contm um procedimento
FIM ! MDULO End
FIM ! MAP End
O segundo arquivo de cdigo fonte, MYPROG2.CLW, agora contm o seguinte cdigo:
MEMBRO ( 'myprog') ! O incio dos dados de um mdulo MEMBRO! seo de

declarao
MDULO ( 'MYPROG3')! Um arquivo de origem separado, MYPROG3.CLW Proc2
PROCEDIMENTO ! Contm outro procedimento
FIM ! MDULO End
FIM ! MAP End

proc2 ! Uma chamada para Proc2
Um arquivo de cdigo terceira fonte, MYPROG3.CLW, contm o seguinte cdigo:
MEMBRO ( 'myprog') ! O incio dos dados de um mdulo MEMBRO! seo de

declarao
PROCEDIMENTO proc2 ! Um procedimento prottipo idntico ao! prottipo declarado
no! MEMBRO MYPROG2.CLW mdulo MAP
FIM ! MAP End

O prottipo procedimento para Proc2 na estrutura do mdulo do MAP em MYPROG2.CLW duplicado no MAP em MYPROG3.CLW.
Esta duplicao necessria para todos os procedimentos s declarou em uma estrutura de mdulo de MAP de um mdulo MEMBRO.
O prottipo procedimento para Proc2 podem ser colocados em muitas estruturas como MAP mdulo MEMBRO (dentro da sua estrutura MDULO) como
so necessrias para permitir que muitos procedimento s para cham-lo como necessidade. Isso permite que voc declare explicitamente e usar Proc2
apenas nos mdulos que precisam dele, e no maior nmero de mdulos como realmente precisar fazer isso.
H uma vantagem de declarar explicitamente todas procedimento s no programa no Mapas locais MEMBROS em vez de um nico mapa
global. Essa vantagem o tempo de compilao-sempre que voc adicionar um procedimento para um mapa global, voc alterar o
mdulo do programa, o que obriga a re-compilao de toda a aplicao. Por prototipagem explicitamente todos os procedimentos da
aplicao s Nos Estados MAPs apenas nos mdulos em que o procedimento s so usados, voc pode eliminar muitas compilaes re-
globais, economizando tempo como voc construir a aplicao.
PROCEDIMENTO MAPs
Voc se lembra que um procedimento tem uma seo de declarao de dados, seguindo a palavra-chave PROCEDIMENTO e
terminando na declarao CODE. Alm de declaraes de dados, seo de declarao de dados de um procedimento tambm
pode conter sua prpria estrutura MAP. MAP de um procedimento pode no conter quaisquer estruturas mdulo, e declara
prottipos de procedimento que esto disponveis localmente dentro do procedimento. Estes so chamados Procedimentos
Locais.
As definies de quaisquer Procedimentos Locais deve seguir imediatamente o procedimento dentro do qual eles so declarados (no
mesmo mdulo cdigo-fonte). A vantagem de Procedimentos Locais que eles compartilham os dados e rotinas de seu
procedimento, declarando locais. Conceitualmente, um procedimento local pode ser pensado como uma rotina que pode receber
parmetros, retorna um valor, e conter suas prprias declaraes de dados.
Usando o exemplo anterior, um arquivo chamado MYPROG.CLW contm o seguinte cdigo:
MAPA ! A estrutura mapa local

PROCEDIMENTO proc2 ! contm uma declarao de procedimento local
FIM ! MAP End
ProcLocalVariable LONGO ! Uma declarao varivel local

DO MyRoutine ! Chamar uma rotina
MyRoutine ROTINA
ProcLocalVariable + = 1! Incrementar a varivel local
PROCEDIMENTO proc2 ! Definio de procedimento local! deve seguir o procedimento,

declarando no! mesmo mdulo fonte
LocalVariable LONGO ! Uma declarao varivel local

CDIGO
LocalVariable = ProcLocalVariable
Utilize uma varivel do procedimento, declarando
DO MyRoutine ! Chamar uma rotina do procedimento, declarando
O procedimento Proc2 no foi declarada no mapa de programa ou um mapa de membro, mas apenas no PROCEDIMENTO MAP Proc1.
Portanto, ele pode ser chamado apenas pelo procedimento Proc1. ProcLocalVariable foi declarado na seo de declarao de dados do
Proc1 PROCEDIMENTO, portanto, s pode ser utilizado pelo procedimento declarando e quaisquer procedimentos de Proc1 e Proc2
locais. MyRoutine ROTINA tambm est disponvel apenas para o procedimento de declarao e quaisquer procedimentos de Proc1
locais e Proc2.
Resumo
Com o Clarion Idioma voc pode separar as tarefas em processo s.
Um procedimento pode conter rotinas que optimizam cdigo fonte repetitivo.
Um procedimento pode ter variveis baseadas em pilha locais que otimizam requisitos de memria em tempo de execuo
e fazer recurso possvel.
A seco de declarao de dados PROGRAMA declara todos os dados que globalmente disponvel.
O mapa de programa declara os prottipos para todos procedimento s que esto disponveis globalmente.
A MAP pode conter uma estrutura de mdulo, que aponta para o cdigo-fonte para o procedimento s que residem
em arquivos de origem separadas.
A declarao MEMBRO aponta de volta para o arquivo fonte do programa.
A seco de declarao de dados do mdulo de membro pode declarar variveis e estruturas de dados que s esto
disponveis para o procedimento s que residem no mdulo MEMBRO.
Um mdulo de membro pode ter sua prpria estrutura MAP declarando outro procedimento s conhecido apenas localmente no
mdulo MEMBRO.
MAP de um mdulo MEMBRO podem conter estruturas MDULO que apontam para procedimento s
que residem em outros mdulos Membro. O membro que se o mdulo de pontos ao Deve tambm conter um MAP
com prottipos idnticos para aqueles procedimento s.
Explicitamente prototipagem todas procedimento de um aplicativo s em estruturas MAP mdulo MEMBRO apenas quando
realmente necessrio pode reduzir significativamente o nmero de compilaes re- globais da aplicao necessria durante o
desenvolvimento.
Procedimentos locais tm a vantagem de compartilhamento de dados e rotinas locais do seu procedimento, declarando.
Conceitualmente, isso faz deles funo como rotinas que pode declarar dados, receber parmetros e valores de retorno.
Facilitando em OOP 15
2 - facilitando em OOP
Este captulo foi derivado de um discurso proferido por Richard Taylor na Conferncia do desenvolvedor de 1997 (DevCon 97) antes
do lanamento da Clarion Verso 4. Vrios participantes sugeriram que passam a fazer parte do conjunto de documentao Clarion.
abrindo Shots
Eu sei que alguns de vocs tm tido muita experincia com Programao Orientada a Objetos em outros idiomas, enquanto outros aqui
nunca sequer disse Oops em suas vidas. Para aqueles de vocs que tm um monte de OOP fundo, por favor, tenha pacincia comigo,
porque eu vou estar explicando algumas coisas que podem parecer bastante bvio para voc. Peo desculpas antecipadamente se as
coisas parecem um pouco simplista.
Para o resto de vocs: esta ser uma viso geral bastante rpido. H muitos livros que foram escritos sobre Programao Orientada a Objetos,
ento eu s pretende bater esses conceitos uma vez mais levemente em relao forma como temos implementado-los na lngua Clarion.
OK, vamos comear a partir de um ponto que todos ns devemos estar familiarizados com - Cdigo Processual.
Processual Cdigo Re-Visitou
Ns todos sabemos que um procedimento tem uma seo de dados e uma seo de cdigo. E todos ns sabemos que as variveis de
dados locais declarados em um procedimento s so visveis dentro do procedimento e s existem enquanto o procedimento executado.
Portanto, variveis de dados locais esto no escopo somente dentro do procedimento no qual eles so declarados.
Quando o procedimento chamado, as variveis locais so automaticamente memria alocada na pilha. Isto torna-os disponveis para
uso em instrues de cdigo executveis do procedimento. Ento, quando uma instruo RETURN executado no procedimento para
voltar ao lugar de onde foi chamado, a memria usada pelas variveis locais automaticamente desalocados da pilha e retornado para
o sistema operacional.
Assim, podemos dizer que a vida e visibilidade dos dados locais em um procedimento limitado durao da execuo do
procedimento.
OK, ento o que se voc quisesse ter vrias sees de cdigo capaz de operar em um mesmo conjunto de variveis de dados? No cdigo
processual do Clarion voc poderia faz-lo de duas maneiras:
fazer as variveis globais,
ou mov-los para a seo de dados de um mdulo.
Desde Mdulo de Dados um conceito que bastante singular para Clarion, vamos apenas discutir a abordagem global nesta manh.
Ao declarar suas variveis Globalmente voc acabar com efetivamente o que voc quer: um nico conjunto de variveis de dados e
mltiplas sees de cdigo executveis que podem operar nesses dados. Uma desvantagem, porm, que as variveis de dados
global no so limitadas no tempo de vida e h vrias escolas de pensamento programao que sustentam que a proliferao de dados
global em seus programas ruim.
global de dados alocado memria esttica. Isso significa que as variveis so alocados de memria quando o programa inicia a
execuo e s desalocados quando o programa termina. By the way, a mesma coisa acontece com Mdulo de dados, para que voc
no comprar nada por ir por esse caminho, exceto que limita a visibilidade para os procedimentos dentro do mesmo mdulo.
OK, ento voc pode ter um nico conjunto de variveis que podem ser referenciados por vrias sees cdigo executvel, declarando
as variveis como dados global. E se voc queria ter mltiplos conjuntos destes dados que poderiam ser referenciado pelo mesmo
conjunto de vrias sees cdigo executvel? Em outras palavras, o que se queria reuso o mesmo cdigo executvel uma e outra vez,
mas usando diferentes conjuntos de variveis de dados de cada vez? Bem, voc poderia colocar todas as variveis global de dados
dentro de uma estrutura de fila, ento de alguma forma manipular as entradas da fila para que voc possa, de alguma forma manter a
sensatez que entrada de fila que que voc est trabalhando no momento. No entanto, isso iria ficar muito complexo muito
rapidamente. H um caminho melhor. E de que maneira a declarao de classe.
declarao de classe
A estrutura de classe Clarion permite que voc declare variveis de dados - ambos os tipos simples de dados e variveis de referncia -
e os procedimentos que operam sobre eles. Esta a estrutura declarao bsica de Programao Orientada a Objetos em Clarion. Esta
a estrutura que permite reutilizao de cdigo e outra vez para diferentes conjuntos de dados.
Minha classe CLASSE

Propriedade LONGO
QueProperty & SomeQueue
Method1 PROCEDIMENTO
Method2 PROCEDIMENTO (LONG), FIM DE LONGA
A estrutura da classe um recipiente que contm um conjunto de variveis de dados e os procedimentos que operam sobre eles. Para
usar os termos padro da indstria para estes, a estrutura de classe contm as propriedades e mtodos. As propriedades so os
dados, e os mtodos so os procedimentos que actuam sobre essas propriedades. Tomados em conjunto, estas propriedades e
mtodos de formar um nico objecto.
OK, ento agora ns introduzimos e definido em termos Clarion trs buzzwords OOP padro: propriedades, mtodos e objetos.
Deixe-me apresentar o primeiro dos trs grandes chaves OOP: encapsulamento.
encapsulamento
A estrutura da classe um recipiente para as propriedades e mtodos. De acordo com o Dicionrio Oxford de Ingls, a palavra
Encapsulate significa: para incluir (a) em uma cpsula. Portanto, a estrutura de classe encapsula as propriedades e mtodos declarado
no seu interior. Agora, voc OOP puristas l fora, est prestes a dizer: Espere um minuto, isso significa muito mais do que isso em
OOP. E voc est certo. No uso comum para OOP, encapsulamento significa muito mais do que apenas containerizing as
propriedades e mtodos, e eu vou dar a volta a tudo isso em breve. Apenas seja paciente.
OK, ento agora temos um recipiente para propriedades e mtodos. Que bom que isso faz-nos? Bem, voc vai perceber que a
palavra-chave Clarion estamos usando aqui de classe e no objeto. A razo para isso porque uma declarao de classe declara um
tipo especfico de objeto, e tambm pode declarar uma instncia de que tipo de objeto (mas no precisa). Ento aqui est a prxima
buzzword OOP dez dlares que precisamos aprender: instanciao. Meu Dicionrio Oxford de Ingls define Instantiate como: Para
representar por uma instncia.
Ele tambm define instanciao como: O ato ou fato de instanciar; representao por um exemplo.
O verdadeiro poder da estrutura de classe que voc pode ter vrios casos do tipo de objeto da classe declara. Cada um desses casos
atribudo o seu prprio conjunto de propriedades, mas todos eles compartilham o mesmo conjunto de mtodos que operam sobre essas
propriedades. a que a verdadeira promessa de OOP encontra-se, no fato de que voc s precisa de um nico conjunto de mtodos para
operar as propriedades de qualquer instncia do objeto de uma classe particular. A memria para as propriedades de uma instncia do objeto
especfico alocada quando esse objeto instanciado (uma palavra de dez dlares para criado). OK, ento como que vamos instanciar um
objeto? H trs maneiras de fazer isso:
1. A classe declarada sem o atributo TIPO declara tanto um tipo de objeto e uma instncia desse tipo de objeto.
2. Uma declarao simples declarao com o tipo de dados sendo o rtulo de uma estrutura de classe declarado
anteriormente declara um objeto do mesmo tipo que a classe.
3. Declare uma referncia ao rtulo de uma estrutura de classe declarado anteriormente, em seguida, usar o novo e descarte
procedimentos de instanciar e destruir o objeto. assim que voc instanciar objetos. Agora voc pode perguntar: Por que ele est
fazendo um negcio to grande sobre instanciao? Boa pergunta.
A resposta tem a ver com a alocao de memria para as propriedades que cada objeto contm. Lembre-se que cada objeto recebe o
seu prprio conjunto discreto de propriedades quando o objeto instanciado, por isso importante saber quando estas coisas so
instanciado.
instanciao
Um objeto declarado na seo de dados global do seu programa instanciado para voc automaticamente para a declarao CODE
que marca o incio do cdigo executvel global. O objeto destrudo automaticamente para voc quando voc retornar de seu
programa para o sistema operacional. Portanto, o tempo de vida e visibilidade de um objeto global global.
PROGRAMA ! Global Data e Cdigo

MyClass CLASS ! Declare um objeto e
propriedade LONGO ! Um tipo de objeto
Mtodo END
PROCEDIMENTO
ClassA MyClass ! Declare MyClass objeto
ClassB & MyClass ! Declare referncia MyClass
CDIGO ! MyClass e ClassA automagicamente instanciado
ClassB & = NEW (MyClass) ! Objeto explicitamente Instantiate
! executar alguns DESFAA
cdigo (ClassB) Destrua objeto (obrigatrio)
RETORNA ! MyClass e ClassA automagicamente destruda
Objetos declarados na seo de dados de qualquer mdulo tambm so instanciado para voc automaticamente para a declarao
CODE que marca o incio do cdigo executvel Global e destrudo automaticamente para voc quando voc retornar de seu
programa para o sistema operacional. Isso faz com que sua vida Global, apesar do fato de que eles s so visveis para os
procedimentos dentro do mesmo mdulo.
MEMBRO ( 'MyApp') ! Mdulo de Dados
Minha classe CLASSE ! Declare um objeto e

Propriedade LONGO ! um tipo de objecto
Mtodo END
PROCEDIMENTO
Classe A Minha classe ! Declare MyClass objeto
ClassB &Minha classe ! Declare referncia MyClass
PROCEDIMENTO umaProc
! MyClass e ClassA so instanciado e! destrudos, ao mesmo
tempo que o! objetos globais
! ClassB deve ser explicitamente instanciado! e destrudo em

algum procedimento no! o mdulo
Objetos declarados na seo de dados de um procedimento so instanciado para voc automaticamente para a declarao CODE
que marca o incio de cdigo executvel do procedimento e destrudo automaticamente para voc quando voc retorno do
procedimento. Isso limita a sua vida e visibilidade PROCEDIMENTO dentro do qual eles so declarados.
PROCEDIMENTO umaProc ! Dados Locais e Cdigo

Minha classe CLASSE ! Declare um objeto e
Propriedade LONGO ! um tipo de objecto
Mtodo END
PROCEDIMENTO
Classe A Minha classe ! Declare MyClass objeto
ClassB &Minha classe ! Declare referncia MyClass
CDIGO ! MyClass e ClassA automagicamente instanciado
ClassB & = NEW (MyClass)! Instanciar objeto! executar alguns
DESFAA cdigo (ClassB)
Destrua objeto (obrigatrio)
RETORNA ! MyClass e ClassA automagicamente destruda
OK, tudo o que bastante simples - sobre o que esperar, certo? Os que voc tem que manter seu olho em so os objetos que voc
declara como variveis de referncia. Esses objetos s so instanciado quando voc executar uma instruo NOVO, e - agora aqui a
coisa que atente para - que nunca so destrudos automaticamente para voc, voc deve usar DESCARTE para se livrar de-los voc
mesmo. Se voc esquecer de fazer isso, voc pode acabar com um vazamento de memria no seu programa. Portanto, a questo agora
vem tona: Se cada objeto recebe o seu prprio conjunto de propriedades, mas compartilha o mesmo conjunto de mtodos, como o
cdigo executvel dentro do mtodo saber exatamente quais as propriedades do objeto para afetar? Outra boa pergunta.
O incio da resposta est na sintaxe Campo Qualificao da Clarion.

Campo Qualificao Sintaxe
As propriedades e mtodos de um objeto so referenciados no cdigo, antecedendo o nome do objeto para a propriedade ou mtodo
usando o que veio a ser conhecido como sintaxe de ponto. Esta a sintaxe bastante normal em todas as vrias linguagens que
suportam OOP. Por exemplo, suponha que voc tem um objeto chamado Fred e tem um mtodo chamado trabalho e duas
propriedades chamado Pay e Horas. Fora o prprio objeto que voc pode chamar esse mtodo em uma atribuio como Fred.Pay
= Fred.Work (Fred.Hours)
Agora, dentro dos mtodos de um objeto, no h nenhuma maneira de saber exatamente qual o objeto que est atualmente em
execuo. Lembre-se, voc pode ter vrias instncias separadas de um tipo especfico de objeto que todos compartilham o mesmo
conjunto de mtodos. Portanto, dentro dos mtodos de um objeto, em vez de usar o nome do objeto, voc usa a palavra AUTO.
Isso muda a atribuio anterior, quando feita dentro de um mtodo de um objeto, a SELF.Pay = SELF.Work (SELF.Hours) porque o
cdigo nesse ponto no sabe se ele est se referindo as propriedades do Fred objeto ou o objeto Barney, ou os objetos de Bruce ou
Richard. Ele no sabe e no se importa, porque a auto sempre significa qualquer que seja o objeto atual .
PROGRAMA
CLASSE empregado, TIPO ! Declare tipo de objeto
Pagamento DECIMAL (7,2)
horas DECIMAL (3,1)
CalcPay PROCEDIMENTO
Trabalhos PROCEDIMENTO (* decimal), FIM DECIMAL
Fred Empregado ! Declare instncias de objetos

CDIGO Employee Barney
Fred.Pay = Fred.Work (Fred.Hours) ! Cdigo fora do objeto Fred
PROCEDIMENTO Employee.CalcPay ! Mtodo Definio

CDIGO
SELF.Pay = SELF.Work (SELF.Hours) ! Cdigo dentro de mtodo de objeto
Ento a resposta para a pergunta: Como que o cdigo dentro do mtodo de saber exatamente que objeto propriedades para
afetar? a utilizao de AUTO como o nome do objeto no cdigo do mtodo.
Construtores e destruidores
Existem mais duas coisas a saber sobre o que acontece na instanciao e destruio de um objecto. Essas duas coisas adicionar
mais dois buzzwords OOP para a nossa coleo: Construtores e Destrutores.
Quando se fala de Construtores e Destrutores em outras linguagens OOP que voc est realmente falando so Construtores
automticas e Destrutores. Clarion apoia plenamente construtores e destruidores automtica.
Um Construtor automtica um mtodo especfico que chamado automaticamente para voc quando um objeto instanciado, no importa
como esse objeto instanciado (seja declarado em uma seo de dados ou explicitamente instanciado com o procedimento NOVO).
Para declarar um construtor automtico em Clarion, tudo que voc precisa fazer criar um mtodo CONSTRUCT nomeado em
sua classe. O mtodo CONSTRUCT no pode receber nenhum parmetro e no pode retornar um valor.
O uso mais tpico de Construtores automticas em outros idiomas alocar memria para propriedades e inicializar-los. No Clarion,
desde que a memria alocado automaticamente para variveis, o uso mais comum seria provavelmente para inicializar
propriedades para valores de partida especficos e para inicializar propriedades variveis de referncia.
Um Destructor automtica um mtodo especfico que chamado automaticamente para voc quando um objeto destrudo, no importa
como esse objeto destrudo (seja pelo retorno a partir do limite do seu mbito local ou explicitamente destrudo com o procedimento
DESCARTE).
Semelhante ao Construtor, voc declarar um Destructor Automtico como um mtodo chamado DESTRUCT na sua classe. O mtodo
DESTRUCT tambm no pode receber nenhum parmetro e no pode retornar um valor.
O uso mais tpico de Destructors automticas em outros idiomas de-alocar a memria usada para as propriedades. No Clarion,
desde memria alocada automaticamente tambm automaticamente de- alocado, o uso mais comum seria provavelmente de dispor
de quaisquer propriedades varivel de referncia que necessitam de destruio.
Minha classe CLASSE

Propriedade LONGO
Mtodo PROCEDIMENTO
construir PROCEDIMENTO ! Construtor automtica
Destruct PROCEDIMENTO ! Destructor automtica
FIM
H mais sobre Construtores e Destrutores automticas, e discutido um pouco mais tarde.

Mais Sobre Encapsulation

Para muitos puristas OOP, o encapsulamento tudo sobre se escondendo as propriedades e mtodos da classe do resto do programa,
no apenas containerizing eles. Isso os torna propriedade privada e a linguagem Clarion apoia totalmente esta com o atributo
PRIVATE.
O atributo PRIVATE em uma declarao de propriedade ou um prottipo mtodo significa que a propriedade ou mtodo visvel
apenas para os outros mtodos dentro dessa classe. Este esconde-los de tudo fora da classe. Sem o atributo PRIVATE, as
propriedades e mtodos so pblico e o resto do seu programa pode acess-los quando o objeto foi instanciado e est no escopo.
PROGRAMA
MyClass CLASSE
MyProperty LONG, PRIVATE !Propriedade privada
Mtodo PROCEDIMENTO
MyMethod PROCEDIMENTO, PRIVATE ! Mtodo particular
FIM
CDIGO
MyClass.MyMethod ! Invlido aqui
MyClass.Method ! Vlido aqui
MyClass.MyProperty = 10 ! Invlido aqui
Cdigo de Processo MyClass.Method
SELF.MyMethod ! Vlido aqui

SELF.MyProperty = 10 ! Vlido aqui
H ainda mais a dizer sobre encapsulamento e pblico versus coisas particulares em Clarion, mas primeiro precisamos introduzir
outro conceito OOP.
Herana
OK, at agora ns aprendemos algumas grandes chaves OOP: propriedades, mtodos, objetos, encapsulamento, instanciao,
construtores e destruidores. O prximo Herana. Vocs todos sabem o que herana , no ? Herana quando algum morre e
deixa um milho de dlares, certo? Bem, quase.
A herana estreitamente ligado a outro termo OOP comum: para derivar. Meu fiel define Dicionrio de Ingls Oxford derivar como: Para
transmitir a partir de uma (tratado como uma fonte) para um outro, como pela transmisso, descida, etc .; para transmitir, comunicar,
comunicar, transmitir, distribuir diante.
Para derivar uma nova classe, voc simplesmente nomear a classe pai como o parmetro para a nova declarao de Classe ea nova
declarao de classe comea com tudo o que a classe pai tinha. A diferena aqui que, em OOP ningum tem que morrer para que a
criana herdar. Isso traz um par de termos OOP mais comuns: classe base e Classes derivadas. A classe base uma classe que no
tem nenhum parmetro para sua declarao CLASS - o que significa que no herdar nada - enquanto uma classe derivada sempre tem
um parmetro de nomear sua classe pai. Repare que eu no disse que o parmetro para os nomes das demonstraes classe
derivada de uma classe base - isso no acontece. O parmetro para um nomes instruo class sua classe pai Derivado, o que poderia
ser uma classe qualquer base ou de outra classe derivada. Isso significa que voc pode ter vrias geraes de herana.
PROGRAMA
MyClass CLASSE ! Declare Base Class
Propriedade LONGO
MyProperty LONG, PRIVATE! Privada = nenhum acesso no Mtodo classe derivada
END
PROCEDIMENTO
Classe A CLASS (MyClass)! Declare classe Derived
aProperty LONGO ! que herda
Um mtodo PROCEDIMENTO ! MyClass.Property e
FIM ! MyClass.Method
CDIGO
ClassA.Method ! Chamada de mtodo vlido
ClassA.MyProperty = 10! Invlido, no acessvel fora MyClass MyClass.Amethod
! Invlido, a herana apenas uma maneira
Ento, de volta herana. Uma classe derivada herda todas as propriedades pblicas e mtodos de sua classe pai. Ele tambm herda
as propriedades e mtodos privados, mas no pode acess-los em qualquer um dos mtodos de classe derivada porque eles so
verdadeiramente a propriedade privada da classe que lhes declara.
O que tudo isto significa que, quando voc derivar uma classe de uma classe pai, no h necessidade de duplicar todas as
funcionalidades j na classe pai, porque a classe derivada herda tudo.
Ento, por que derivam em tudo? Ento voc pode voltar a usar seu cdigo e mant-lo em um s lugar. Porque, quando
adequadamente concebido, um conjunto de classes tem todas as propriedades e mtodos mais comuns para objectos com o mesmo
ou muito semelhante tipo declarado na classe base. Classes derivadas, em seguida, s precisa de declarar as propriedades e mtodos
que os diferenciam de outras classes que podem ser derivados a partir do mesmo pai.
To fcil quanto a torta de Apple
Um exemplo deste tipo de projeto seria projetar classes para tortas de Apple. A classe de base iria conter todas as propriedades
padro comum a todas as tortas de Apple, tais como as propriedades da Apple e crosta e um mtodo de assar. No entanto, para os
diversos tipos de tortas de Apple a classe derivada deve conter as diferenas entre as diversas variedades de tortas de Apple. Por
exemplo, a Holands ApplePie Classe derivada pode conter uma propriedade CrumbleTop, o tradicional americano ApplePie Classe
derivada pode conter uma propriedade TopCrust, eo
As avs ApplePie Classe derivada pode conter uma propriedade CaramelTop.
PROGRAMA
ApplePie CLASS, TIPO ! Declare Base Class

ma CORDA (20)
crosta CORDA (20)
assar END
PROCEDIMENTO
holands CLASSE (ApplePie) ! Declare classe derivada

CrumbleTop STRING (20)
FIM
CLASSE americano (ApplePie) ! Declare classe derivada

TopCrust CORDA (20) FIM
Avs CLASSE (ApplePie) ! Declare classe derivada

CaramelTop STRING (20) Cozer
PROCEDIMENTO ! Mtodo substitudo
FIM
Uma outra coisa que voc pode fazer usando herana para substituir os mtodos. Dando um mtodo em uma classe derivada
exatamente o mesmo prottipo (nome, lista de parmetros, e qualquer tipo de dados de retorno) como um mtodo Parent classe, voc
substituir o mtodo na classe derivada. Isso permite que voc fornecer funcionalidade ligeiramente diferente em uma classe derivada, se
voc precisa.
Herana mltipla
Voc vai notar que a sintaxe Herana do Clarion s permite que voc derivar de um nico pai. Isso chamado de herana simples.
No existe tal coisa como herana mltipla em teoria OOP, mas voc pode agradecer-nos para no dar a voc.
Ao no dar-lhe herana mltipla, h um outro chavo de dez dlares que voc NO tem que aprender alguma coisa sobre -
disambiguate! Desde que voc no precisa saber nada sobre isso, eu no estou indo para defini-lo.
Para os casos em que a herana mltipla seria til, no uma tcnica de OOP chamado Composio que lhe d os benefcios da
herana mltipla sem a necessidade de disambiguate nada!
Composio
A tcnica Composio significa simplesmente herdar de uma classe e tambm declarar uma referncia a outro objeto como uma
propriedade de sua classe derivada. Portanto, a sua classe derivada herda as propriedades e mtodos de sua classe pai, e tambm
contm uma referncia para o segundo objecto (e implicitamente, todas as suas propriedades e mtodos) em vez de herdar-los. Isto d
a classe derivada acesso pleno e completo a todas as propriedades herdadas e mtodos e todas as propriedades e mtodos do objeto
referenciado que ele contm. As classes ABC Biblioteca usar Composio em vrios lugares, onde apropriado para eles.
PROGRAMA
ApplePie CLASS, TIPO ! Declare Base Class

mas CORDA (20)
crosta CORDA (20)
assar END
PROCEDIMENTO
IceCream CLASS, TIPO ! Declare Base Class

Sabor CORDA (20)
concha END
PROCEDIMENTO
moda CLASS (ApplePie) Composio: Derive de uma classe

OnTheSide & IceCream ! e incluir uma referncia a
Servir PROCEDIMENTO ! um objecto de outro CLASSE
FIM
E ainda mais sobre encapsulamento

Alm de propriedades e mtodos pblicas e privadas, tambm h propriedades e mtodos protegidos. Voc se lembra que o atributo
private significa que a propriedade ou mtodo visvel apenas dentro dos mtodos da classe em que a propriedade privada ou mtodo
declarado, e no acessvel por qualquer classe derivada. E sem o atributo PRIVATE as propriedades e mtodos so pblico e
visveis e disponveis para qualquer cdigo, se esse cdigo est em um mtodo de classe ou no. Bem, s vezes voc no quer seja
privada ou pblica. s vezes voc s deseja uma propriedade ou mtodo para estar disponvel dentro da classe em que declarado, ou
qualquer classe derivada dela. Isso o que o atributo PROTEGIDO para.
PROGRAMA
Minha classe CLASSE ! Declare Base Class

Propriedade LONGO
MyProperty LONG, PROTEGIDO !Semi-privado
Mtodo END
PROCEDIMENTO
Classe A CLASSE (MyClass) ! Declare classe derivada

AProperty LONGO
aMethod END
PROCEDIMENTO
CDIGO
ClassA.MyProperty = 10 ! Invlido fora do mtodo
Cdigo de Processo ClassA.Amethod
SELF.MyProperty = 1 ! Vlido no mtodo
propriedades e mtodos particulares no pode ser acedido por classes derivadas, mas propriedades e mtodos protegido pode ser.
propriedades e mtodos protegidas no so visveis fora da classe dentro do qual eles so declaradas ou qualquer classe derivada a
partir dessa classe. Eu acho que isso faz com que as propriedades e mtodos protegidos espcie de semi-privado.
E muito mais sobre Construtores e Destrutores
E enquanto ns estamos indo para trs, lembro um tempo atrs eu disse que havia mais a dizer sobre construtores e destruidores
automtica? Bem, agora um bom momento para falar sobre herana e como isso afeta construtores e destruidores automtica.
O que acontece quando uma classe pai tem um mtodo de construir e a classe derivada tambm precisa de um? Ns j falamos
sobre a substituio de mtodos em classes derivadas, ento voc pode imaginar que o mtodo de classe CONSTRUCT Derivado
seria simplesmente substituir o mtodo Parent CLASS. Essa suposio seria errado, claro.
Ento por que errado? Porque substituindo a classe construtor pai pode significar que o cdigo que necessrio para inicializar as
propriedades herdadas no seria executado. Se as propriedades de classe pai herdados no foram devidamente inicializado, voc pode
acabar com um comportamento inesperado em sua classe derivada. Portanto, Construtores automticas no so substitudas
automaticamente. Em vez disso, por padro, todos eles executar em ordem quando o objeto instanciado.
Em primeiro lugar, o construtor pai CLASSE executa, ento a classe derivada Construtor executa. Eles so executados na ordem
de sua derivao. Construtores classe base sempre executado em primeiro lugar, seguido por quaisquer Construtores classe
derivada, na ordem em que eles foram obtidos. O construtor da classe mais derivada sempre executa passado.
O mesmo raciocnio vlido para Destructors automticas, exceto a ordem de sua execuo invertida. A destruio de classe mais
derivado executa automaticamente pela primeira vez quando o objecto destrudo, e para baixo na corrente de derivao at a
destruio de classe base executa ltima. Em outras palavras, LIFO: ltimo In First Out
Isso tudo bastante normal. A maneira automtica Construtores e Destrutores trabalho por padro na lngua Clarion a mesma forma
como eles funcionam na maioria das outras linguagens OOP. No entanto, Clarion d-lhe alguma flexibilidade que outras linguagens
OOP no. Eu lhe disse que Construtores e Destrutores automticas no so substitudas automaticamente no Clarion. A palavra chave
aqui automaticamente. Voc pode substituir-los em Clarion, se voc quiser - algo que voc no pode fazer em algumas outras
linguagens OOP. Se voc adicionar o atributo REPLACE para o prottipo de seu construir ou DESTRUCT mtodo, voc est dizendo
ao compilador que voc quer substituir o mtodo.
Ento, o que isso te comprar? Suponha que, por algum motivo, voc precisa inicializar uma varivel em sua classe derivada antes o
construtor pai CLASSE executa? A nica maneira de fazer isso para substituir o construtor. Basta colocar o atributo REPLACE no
prottipo do mtodo CONSTRUCT classe derivada, em seguida, escrever o seu cdigo.
E agora voc vai perguntar: E o seu grande argumento contra imperiosas automaticamente Construtores e Destrutores? J se
esqueceu disso?O argumento contra automaticamente Construtores primordiais e Destrutores ainda vlido, e precisa ser
considerada com cuidado quando voc decide explicitamente substitu-los. Mas temos pensado nisso.
PAIS
Voc se lembra que o caminho para fazer referncia ao objeto atual no cdigo de um mtodo usar AUTO vez do nome do objeto?
Bem, ns fornecemos uma outra ferramenta na sintaxe OOP da Clarion que permite que voc chamar um mtodo de uma classe pai,
mesmo quando voc substitudo esse mtodo. Prepending pai para o nome do mtodo chama explicitamente o mtodo da classe pai,
embora tenha sido substitudo. Esta tcnica vlido no s para Construtores e Destrutores, mas tambm para qualquer mtodos
substitudos.
PROGRAMA
Minha classe CLASSE, tipo ! Declare Base Class

Propriedade LONGO
Mtodo PROCEDIMENTO
Construir END
PROCEDIMENTO
Classe A CLASS (MyClass)! Declare classe Derived

aProperty LONGO
Construir PROCEDIMENTO, REPLACE
FIM
CDIGO ! ClassA instanciao aqui
Cdigo de Processo ClassA.Construct
SELF.Aproperty = 1 ! Initialize em seguida, chamar

PARENT.Construct ! construtor pai
Portanto, quando voc precisa controlar explicitamente a ordem de execuo de seus construtores ou destruidores, voc simplesmente
colocar o atributo REPLACE no prottipo, em seguida, em seu construtor ou do cdigo de chamar diretamente mtodo Destructor
PARENT.CONSTRUCT ou PARENT.DESTRUCT no ponto exato dentro de seu lgica que mais adequado para o que voc precisa
fazer. Isso poderia ser antes, depois ou no meio do cdigo do seu classe derivada - onde quer que voc precisa que ele seja.
Polimorfismo
OK, h um ltimo realmente grande chavo, OOP voc tem que aprender: Polimorfismo. Este realmente um grande problema, e
isso a chave que faz Programao Orientada a Objetos to poderoso. Ento, vamos comear com a definio de Ingls Oxford
Dictionary of Polimorfismo: A condio ou carter de polimorfa; a ocorrncia de algo em vrias formas diferentes.
Agora a linguagem Clarion teve algumas formas de polimorfismo para j muito tempo. Por exemplo, o *? e? tipos de parmetros que
indicam um tipo de dados desconhecido para passagem de parmetros permitem que voc escreva procedimentos polimrficas.
Clarion teve estes desde os dias do DOS. No Clarion para Windows verso 2.0, introduzimos Procedimento sobrecarga que lhe
permite criar vrios procedimentos com o mesmo nome, mas tendo diferentes listas de parmetros - uma outra forma de
polimorfismo.
OK, sobre a direita agora todos os puristas OOP na platia esto dizendo a si mesmos: Isso no tem nada a ver com o
polimorfismo em OOP tenho, e eles esto certos.
Tudo o que a funcionalidade polimrfico que te dei em verses anteriores do Clarion, indo todo o caminho de volta para a verso
original DOS 1.0, no tem nada a ver com o que OOP quer dizer quando fala sobre Polimorfismo.
Mtodos virtuais
H um termo OOP mais comum que praticamente sinnimo de Polimorfismo: Virtual Mtodos.
Agora, este o ponto onde OOP comea a ficar um pouco complicado, por isso vocs que so novos para OOP - no se preocupe
se voc no pegar imediato de conversa desta manh. Esta a parte que faz com que as pessoas digam que leva pelo menos
seis meses para realmente pegar OOP e como programar nele. Se voc j entendeu OOP ou no, a Biblioteca ABC um
excelente exemplo de aulas bem concebido que voc pode estudar e aprender.
Mtodos virtuais so o que os puristas OOP esto realmente falando quando dizem Polimorfismo. O que um mtodo virtual?
A resposta simples para isso : Um mtodo virtual um mtodo cujo prottipo est presente em ambos um pai e estrutura de classe
derivada, e tem o atributo VIRTUAL em ambos. Isto significa que mtodos virtuais devem ter o mesmo prottipo exato tanto um pai e
classe derivada, e que ambos devem ter o atributo virtual. Essa a mecnica de mtodos virtuais.
Ento, agora que voc tenha obtido a mecnica de mtodos virtuais para baixo, ns podemos ir para as coisas realmente importantes,
como - o que eles so bons eo que eles fazem?
Voc lembrar que um objeto classe derivada herda os mtodos de sua classe pai? Isso efetivamente significa que uma classe derivada
pode chamar para baixo para executar um mtodo Parent CLASS. Bem, mtodos virtuais so o oposto - eles permitem mtodos
Parent classe para chamar para executar um mtodo de classe derivada.
Para repetir, mtodos virtuais permitem que o cdigo em mtodos Parent classe para executar mtodos classe derivada.
Mais Apple Pie

A maneira mais fcil de ver como isso funciona com um exemplo. Vamos voltar para nossas aulas ApplePie. Vamos adicionar um
mtodo PreparePie para a classe base, porque cada tipo de torta de Apple precisa de preparao. Algumas outras tarefas comuns que
o cdigo em PreparePie ter de executar ser CreateCrust e MakeFilling, por isso vamos prottipo mtodos para cada uma dessas
tarefas.
Torta de ma CLASSE, tipo

PreparePie PROCEDIMENTO
CreateCrust PROCEDIMENTO, VIRTUAL ! mtodos virtuais
MakeFilling PROCEDIMENTO, END VIRTUAL
holands CLASSE (ApplePie)

CreateCrust PROCEDIMENTO, VIRTUAL ! mtodos virtuais
MakeFilling PROCEDIMENTO, END VIRTUAL
CDIGO
Dutch.PreparePie ! Vai chamar Virtuals do objeto Holands
Cdigo de Processo ApplePie.PreparePie
SELF.CreateCrust
SELF.MakeFilling
Estes dois mtodos so virtual porque o cdigo real para realiz-los, provavelmente ser um pouco diferente para cada tipo de torta de
que derivam. No entanto, ns Faz saber que estes so sempre os passos que voc precisa tomar para se preparar qualquer torta de
ma, ento podemos escrever esse cdigo no mtodo PreparePie classe base e sei que isso no vai mudar. Agora vamos derivar o holands
ApplePie CLASS. Observe que os prottipos para CreateCrust e MakeFilling so exatamente o mesmo que na classe base, incluindo o
atributo virtual. Agora, voc executar o mtodo Dutch.PreparePie. Este um mtodo herdado, por isso a classe derivada chamar
para baixo ao seu mtodo Parent CLASS - ApplePie.PreparePie. Isso significa que o cdigo que executa o cdigo dentro do mtodo
ApplePie.PreparePie.
A primeira instruo que executa no mtodo PreparePie a chamada para SELF.CreateCrust. Assim, a pergunta , qual o mtodo
CreateCrust vai realmente executar? Neste momento, temos dois definida: a do Torta de ma Classe de base, e o outro no
holands Classe derivada. A resposta , o mtodo real que ir executar o mtodo Dutch.CreateCrust, porque a chamada original
para PreparePie referenciada a holands objeto. O mtodo ApplePie class Base PreparePie est chamando acima A cadeia de
derivao para o mtodo CreateCrust da classe derivada.
OK, ento agora voc v como tudo funciona - Mtodos virtuais so uma espcie de herana reversa.
O cdigo de classe base chama um mtodo e, no momento em que o cdigo compilado, ele no tem qualquer idia do que cdigo
real ter de executar como resultado da chamada do mtodo virtual. Por causa do prottipo na classe base, ele sabe que no h um
mtodo com esse nome que ele pode chamar para realizar um determinado trabalho, ele simplesmente no sabe exatamente como
esse cdigo far sua tarefa - e no se importa. O ApplePie classe base informa o objeto atual para criar sua crosta e ele vai embora e
faz.
Agora, eu sei que alguns que voc est se perguntando: Como pode este tipo de cdigo de compilao? Lembro-me de minha classe
compilador na faculdade e o compilador precisa resolver tudo procedimento chama em tempo de compilao A resposta est usando uma outra
tcnica de OOP comum:. Ligao tardia.
ligao tardia
Ligao inicial o tipo de coisa que voc foi ensinado em sua classe teoria compilador onde todas as chamadas de procedimento so resolvidos em
tempo de compilao. No entanto, uma vez que as chamadas para o mtodo virtual no pode ser resolvido em tempo de compilao, o compilador deve
construir o que chamado de tabela mtodo virtual em tempo de compilao e definir a chamada de mtodo para ligao tardia. No tempo de
execuo, quando a chamada para o Mtodo virtual executa, meios de ligao tardia que o mtodo para chamar determinada por uma pesquisa na
tabela de mtodos virtual. Tenho certeza que todos vocs sabem muito sobre pesquisas, j que uma tcnica de design do aplicativo de banco de
dados bastante normal!
Agora, em muitas outras linguagens OOP esta ligao tardia para mtodos virtuais pode causar um impacto no desempenho real. No entanto, em
Clarion todo o processo de ligao tardia leva referncia apenas mais um extra em tempo de execuo de ligao antecipada faz, ento no h virtualmente
nenhuma desempenho atingido com o uso de mtodos virtuais em Clarion.
Por uma questo de fato, mtodos virtuais em Clarion so to eficientes que, quando voc olha para o cdigo gerado pelo novo ABC
modelos voc vai descobrir que quase todo o cdigo gerado est agora em mtodos virtuais. Isso significa que voc provavelmente j
viu o ltimo de todos os erros limite Pool! Isso me leva ltima questo OOP Eu quero dizer-lhe sobre esta manh - escopo. Na verso
mais antiga do Clarion, voc deve ter notado que alguns dos problemas de converso maiores reside no fato de que muitos dos pontos
incorporar modelo foram transferidos para mtodos virtuais. Isto significava que voc tinha duas solues disponveis para voc: mover
qualquer dados local procedimento que voc queria fazer referncia nesses pontos incorporar fora do prprio e em dados Mdulo
PROCEDIMENTO; ou saltar atravs de algumas aros ainda mais difcil atravs da criao de variveis de referncia para cada uma das
variveis que voc queria fazer referncia e de referncia, atribuindo-lhes, em seguida, alterando o seu cdigo para se referir a essas
variveis de referncia. Escusado ser dizer, este foi um muito mais trabalho do Clarion programadores se acostumaram a!
Ento, para resolver esse problema, Clarion suporta uma tcnica chamada de mtodos derivados Local.
Mtodos derivados locais
Mtodos derivados locais so declarados em uma estrutura de classe derivada dentro de um procedimento. As definies mtodo
derivado local (seu cdigo executvel, que ) deve seguir imediatamente o fim do procedimento no qual eles so declarados.
Ento, qual a vantagem que voc comea a partir dessas coisas? Mtodos derivados locais herdar o escopo do procedimento no qual
eles so declarados. Isso significa que as variveis de dados locais todos do procedimento e rotinas so visveis e disponveis dentro
dos mtodos derivados Local. Que elimina todos os aros que voc teve que saltar atravs de verses mais antigas para acessar seus
dados locais nesses pontos incorporar virtuais. E tambm permite que voc chamar rotinas do procedimento a partir dentro deles,
tambm, como se o seu cdigo ainda estavam dentro do prprio procedimento. By the way, para aqueles de vocs que ainda se
lembram alguns Pascal na faculdade, este conceito muito semelhante aos procedimentos aninhados de Pascal.
Esta nova implementao do escopo de mtodos derivados locais o que permitiu uma grande flexibilidade e funcionalidade no
Modelos e ABC Biblioteca ABC. Tudo que voc precisa fazer executar o Assistente App em qualquer dicionrio em seguida olhar
para o cdigo gerado para ver que os procedimentos mais gerados agora contm muito pouco cdigo - tudo foi movido para
Mtodos derivados locais. E voc, na sua maioria ainda ser capaz de escrever o seu cdigo como se fosse dentro do prprio
procedimento.
Resumo
Voc j tenha sido exposto s trs principais buzzwords OOP: encapsulamento, herana e polimorfismo; e como temos
implementado-los na lngua Clarion. Voc tambm j ouviu a maioria dos outros termos OOP padro: propriedades, mtodos,
objetos, instanciao, classes base, classes derivadas, auto, pai, Construtores e Destrutores, mtodos virtuais, a ligao tardia. . .
E no vamos esquecer o que voc no tem que aprender: disambiguate!

Programao Orientada a Objetos 33
3 - Objeto Programao Orientada (OOP)
Objeto Overview - Quais so objetos?

Um objeto uma coisa. Single
Ns, seres humanos tendem a agrupar o que vemos no mundo em classes de coisas. Ns agrup-los de acordo com as
propriedades e comportamentos que eles tm em comum. Portanto, as coisas que pertencem a uma nica classe tem propriedades
e comportamentos que descrevem o tipo de coisa que eo que ele faz.
Ns tambm tendem a dividir as classes de coisas que vemos em uma hierarquia em forma de rvore de classes. A rvore de
hierarquia comea com o mais geral na parte inferior e cresce at o mais especfico. Cada ramo da rvore representa uma classe
separada que partilha as propriedades comuns da classe acima, ao qual ele est ligado (o seu pai) porque ele derivado a partir do
progenitor. Cada classe derivada tambm deve ter caractersticas que so nicas para que a separam da me e de outras classes
derivadas do mesmo pai.
Um objeto uma instncia de uma classe de coisas, geralmente a partir do nvel mais baixo da rvore de hierarquia. Ele tem
propriedades e comportamentos que definem o que . Por exemplo, vemos duas classes principais de coisas em nosso mundo: os seres
vivos, e as coisas no-vivos. Podemos dividir a classe Living Things em duas sub-categorias: plantas e animais. Dentro da classe Animal
podemos ver muitos sub-classes: mamferos, pssaros, peixes, etc. Em seguida, estes sub-classes so ainda sub-dividido em
sub-sub-classes ... Esta sub-diviso de classes continua at chegar todo o caminho para o objeto individual (a coisa single).
Por Objects?
-Programao Orientada a Objetos (OOP) tcnicas foram desenvolvidas para deixar-nos modelar mais de perto os programas que
escrevem sobre a forma como olhamos para o mundo real. Projetando uma hierarquia de classes para resolver um problema do mundo
real uma questo de olhar para o problema da mesma perspectiva que olhamos para o mundo natural. Comeamos nas classes mais
abstratas-geral que possuem as propriedades e comportamentos comuns a todos os membros da classe-em seguida, retirar dessas
classes abstratas As classes especficas que descrevem completamente o conjunto de objetos individuais no problema. Um dos
principais benefcios da programao orientada a objeto extensa reutilizao de cdigo. Uma vez que um comportamento (mtodo)
foi codificado para a classe mais geral, nunca precisa ser re-escrito para as classes derivadas em que ele no precisa de mudar. Assim
sendo,
O que faz um objeto?

Existem trs principais conceitos em objeto-orientao: encapsulamento, herana e polimorfismo. A linguagem Clarion contm
extenses orientadas a objetos que cobrem todos esses conceitos.
encapsulamento
Encapsulamento significa agregao as propriedades de uma classe (os seus membros de dados), em conjunto com os seus mtodos (os
procedimentos que operam sobre os membros de dados) em uma unidade coerente. O benefcio mais importante do encapsulamento a
capacidade de tratar o objeto como uma nica entidade completa. Isso nos permite usar o objeto sem saber tudo sobre ele. Ele tambm nos
permite mudar um objeto sem afetar outros objetos no relacionados.
As propriedades de um objeto so as coisas que o objeto sabe sobre si mesmo, e os mtodos so os seus comportamentos das operaes
que podem ser executadas. Cada objeto tem suas prprias propriedades exclusivo para si, e compartilha os mesmos mtodos com todos os
outros objetos do mesmo tipo (outras instncias de objetos da mesma classe).
Por exemplo, objetos que pertencem a uma classe (como a classe seres humanos saudveis normais) cada um tem seu prprio conjunto
de propriedades (como olhos azuis ou olhos castanhos), mas todos eles compartilham as mesmas habilidades bsicas comuns classe de
objetos a que pertencem (viso).
Herana
Herana o mecanismo que nos permite construir hierarquias de classes. Uma classe derivada herda todas as propriedades e
mtodos da classe da qual ele derivado (a sua classe de base). Isto proporciona a classe derivado com um ponto de partida de
todas as propriedades e mtodos da classe mais geral (resumo) comuns. Em seguida, a classe de derivados pode adicionar as
propriedades e mtodos que diferenciam a partir da sua me.
A herana tambm um elemento de ncleo do objecto-a orientao que fornece para o cdigo re-utilizao. O cdigo para mtodos herdados
que no so substitudas na classe de derivados existe apenas uma vez na classe em que eles so definidos.
Polimorfismo
Polimorfismo genericamente significa ser capaz de chamar um mtodo que opera de forma diferente dependendo de como ele chamado.
Por exemplo, a declarao Clarion OPEN polimrfico porque ele executa operaes diferentes dependendo se ele dado um arquivo ou
uma janela para abrir. Este tipo de polimorfismo geralmente chamado de Procedimento de sobrecarga porque voc est
sobrecarregar o que parece ser uma chamada de procedimento com mltiplas operaes. Na verdade, o procedimento de sobrecarga
simplesmente feito em Clarion, definindo procedimentos separados com o mesmo nome, mas listas de parmetros diferentes. Veja
Procedimento Sobrecarga na referncia da linguagem para uma discusso completa deste tpico.
Polimorfismo em linguagem orientada a objetos mais comumente entendido como a capacidade de um mtodo de classe base para
chamar mtodos de classes derivadas da base de classe sem saber em tempo de compilao exatamente o mtodo realmente vai ser
chamado. Isso chamado usando mtodos virtuais. Se voc olhar para a herana como a classe derivada ser capaz de fazer descer para
mtodos de classe base, ento voc tambm pode olhar para mtodos virtuais como a classe base sendo capaz de chamar a mtodos de
classe derivadas. Este parece ser um pouco de magia, uma vez que a classe base nunca pode saber o que as classes foram derivada dela.
Para lidar com mtodos virtuais, o compilador deve implementar ligao tardia em vez de ligao inicial ao criar o executvel. Com ligao
antecipada, o compilador pode resolver uma chamada de procedimento no-virtual em tempo de compilao para um endereo de cdigo
especfico no executvel. Isto significa que uma chamada direta para o procedimento, que muito eficiente.
No entanto, com a ligao tardia, o compilador deve, em tempo de compilao, criar um mtodo Tabela Virtual (VMT) que contm os endereos de
cdigo especficas de todos os mtodos virtuais. Em seguida, ele deve inserir o cdigo que resolve, em tempo de execuo, cada chamada para
um mtodo virtual pela primeira procurando o mtodo na VMT, em seguida, chamando o mtodo apropriado. Isto pode parecer como criaria uma
bastante grande impacto na performance, mas com o compilador Clarion altamente eficiente, na verdade quase to rpido como chamar um
mtodo no-virtual.
Este tipo de mtodo virtual de polimorfismo o mecanismo que permite lidar com as diferenas individuais entre as classes derivadas da
mesma classe de base ao mesmo tempo, permitindo que a classe base ignorar estas diferenas. Isto permite um mtodo comum em uma
classe base chamar um mtodo de uma das suas classes derivadas especificamente para lidar com uma operao de uma maneira
apropriada para a classe derivado especfico.
Por exemplo, suponha que temos uma classe de veculos, que contm um mtodo virtual para dirigir o veculo, porque todos os veculos
devem ter alguma forma de orientar-se. Quando voc derivar uma classe de bicicleta a partir da classe de veculo, a classe derivada contm
o seu prprio mtodo virtual Steer especfico apropriado a uma bicicleta. Ento, quando voc derivar uma classe de carro a partir da classe
de veculo, ele tambm contm a sua prpria de mtodo virtual Steer especfico para um carro. Naturalmente, tanto a bicicleta e aulas de
viaturas derivada tambm herdam um mtodo Move comum que chama o mtodo Steer. O mtodo Move herdou no saber ou se importar
se ele est realmente chamando o mtodo Steer do carro ou mtodo Steer da bicicleta em tempo de execuo, ele simplesmente diz ao
objeto (se um carro ou uma bicicleta) para Steer si (e faz).
Extenses OOP da Clarion

A sintaxe da linguagem Clarion especfica que permite que voc declare classes de objetos e derivar classes a partir de classes de base
tenham sido previamente declarados comea com a estrutura de classe.
A classe de Estrutura-encapsulamento
A estrutura da classe Clarion declara uma classe de objecto que contm as propriedades e declarar os mtodos que operam estas
propriedades. Em cristalino, as propriedades da classe so os membros de dados declarados na CLASSE e mtodos so os
procedimentos prototipados na estrutura de classes.
Esse exemplo declara uma estrutura de classe muito simples:
SomeClass CLASS, MDULO ( 'SomeClas.CLW')

PropertyA LONGO ! Membro de Dados (propriedade)
PropertyB LONGO
ManipulateAandB PROCEDIMENTO !Mtodo
FIM
Esta classe chamado SomeClass e contm duas propriedades (membros de dados): PropertyA e PropertyB. Ele tambm contm um
mtodo: o PROCEDIMENTO ManipulateAandB. O atributo mdulo sobre a declarao CLASS especifica que o cdigo que define o
PROCEDIMENTO ManipulateAandB existe no arquivo SomeClas.CLW.
Propriedades de Classe
As propriedades membros (dados) que uma classe podem conter so limitadas aos tipos de dados que so apropriadas para ter em uma
estrutura de grupo. Isto significa que todos os tipos de dados simples so permitidos (longo, curto, REAL, etc.), incluindo estruturas de
grupo, mas os tipos de dados complexos (FILE, FILA, janela, etc.) no so permitidos. Permitindo apenas tipos de dados simples em uma
classe pode parecer uma limitao, mas na verdade no porque as variveis de referncia tambm esto autorizados (mais sobre isso
depois).
mtodos de classe
Os mtodos (procedimentos) declarados em uma classe so definidos no arquivo de origem chamado no atributo MDULO. Este
encapsula todos os mtodos em um nico arquivo de origem, tornando a manuteno mais fcil, e tambm oferece algumas outras
vantagens que vamos chegar tarde. Para a declarao de classe acima, o arquivo SomeClas.CLW iria conter cdigo semelhante
ao seguinte:
Cdigo de Processo SomeClass.ManipulateAandB
MENSAGEM ( 'A =' & SELF.PropertyA)

MENSAGEM ( 'B =' & SELF.PropertyB)
O rtulo da declarao procedimento comea com o nome da classe qual o mtodo pertence, anexado ao nome do mtodo, e
conectado com um ponto. Voc tambm pode rotular o mtodo e nome da classe a que pertence como um primeiro parmetro implcito
(e rotular o AUTO classname), como este:
PROCESSO ManipulateAandB (SomeClass SELF) CDIGO
MENSAGEM ( 'A =' & SELF.PropertyA)

MENSAGEM ( 'B =' & SELF.PropertyB)
Dentro de um mtodo, voc usa a palavra-chave SELF, no o rtulo CLASS, para tratar de uma propriedade ou mtodo de
instncia atual da classe (o objeto atual) no qual o mtodo est em funcionamento.
Criao de objetos
Um objecto um exemplo especfico de uma classe que contm o seu prprio conjunto de propriedades, especfico para que um exemplo. Todas as
instncias de objetos de uma classe compartilham todos os mtodos da classe, para os mtodos de existir apenas uma vez cada.
A declarao da classe com o atributo TIPO nica declara a classe-no existem objetos at que voc crie uma instncia da classe
(tambm chamado de instanciao). A declarao de classe, sem o tipo de atributo tanto declara a classe e instancia-lo (cria o primeiro
objeto). Existem duas maneiras de criar um objeto: declare-lo em uma seo dados, ou criar uma dinmica em cdigo executvel
usando NOVO. Para declarar um objeto na seo dados, basta citar a classe como o tipo de dados:
PROGRAMA
SomeClass CLASSE ! Cria uma classe e uma instncia
PropertyA LONGO
PropertyB LONGO
ManipulateAandB END
PROCEDIMENTO
Minha classe CLASSE, tipo ! Cria apenas um CLASS
PropertyA LONGO
PropertyB LONGO
ManipulateAandB END
PROCEDIMENTO
SomeClassObject1 SomeClass Crie uma instncia de SomeClass
SomeClassObject2 SomeClass ! Outro exemplo de SomeClass
MyClassObject1 Minha classe Crie uma instncia de MyClass
MyClassObject2 Minha classe ! Outra instncia de MyClass
CDIGO
Um objeto declarado em uma seo de dados automaticamente destrudo para voc quando se sai do escopo. Por exemplo, um
objeto declarado na seo de dados local do PROCEDIMENTO sai do escopo (e destrudo) mediante retorno do procedimento.
Objetos declarados em uma seo de dados global ou mdulo de sair do escopo (e so destrudos) somente quando o programa
termina.
Para criar um objeto dinamicamente no cdigo executvel usando NOVO, declare uma varivel de referncia para a classe, em seguida,
executar um comando de atribuio de referncia para a varivel de referncia, nomeando a classe como o parmetro para NEW:
PROGRAMA
SomeClass CLASSE, tipo
PropertyA LONGO
PropertyB LONGO
ManipulateAandB END
PROCEDIMENTO
SomeClassObjectRef & SomeClass ! Uma referncia a um objeto SomeClass
CDIGO
SomeClassObjectRef & = NEW (SomeClass) Crie o objeto
importante notar que quando voc usa NOVO para instanciar o objeto, voc tambm deve usar DESCARTE para destru-lo quando
ele sai do escopo-o objeto no destrudo automaticamente para voc. A vantagem de usar NOVO a capacidade de colocar a
varivel de referncia que pontos de o objeto dentro de outro objeto como uma propriedade.
Usando referncias como propriedades
Desde variveis de referncia so vlidos para usar em qualquer lugar a etiqueta do tipo de dados que eles fazem referncia podem ser
usados, eles permitem que uma classe para acessar todos os tipos de estruturas complexas que no podem ser diretamente declarados dentro
da classe. Quando voc acopla com isso, o uso de novas e dispor de criar e destruir variveis e objetos dinamicamente, voc dar uma aula a
capacidade de conter quase todas estas estruturas complexas.
Por exemplo, usando uma varivel de referncia na classe, pode declarar uma referncia a uma fila (FILA &), que passado para os
mtodos de classe. A mesma coisa vale para todos os tipos de dados complexos (& FILA, & ARQUIVO, e KEY, e BLOB, e VIEW, ou &
JANELA). Embora a classe no pode conter diretamente a declarao de dados dessas estruturas complexas, os mtodos de classe
podem agir como se possuir a estrutura da mesma forma como a instncia possui seu prprio conjunto de propriedades (membros
de dados). Por exemplo, embora uma declarao do arquivo deve ser externo a uma estrutura de classe, ao declarar uma varivel de
referncia para o arquivo (& FILE) dentro da classe, em seguida, executar um comando de atribuio de referncia para uma estrutura
de arquivo especfico para (uma instncia especfica de um objeto do CLASSE) varivel de referncia,
Tambm pode declarar uma referncia a um tipo especfico de FILA, grupo ou estrutura de classes (QueueName &, &
Nome_do_grupo, ou & NomeDaClasse) que um mtodo de classe pode ento criar dinamicamente. Isso permite que a classe a
conter tipos especficos de filas e outras classes nomeadas sem a necessidade de declar-los dentro da estrutura de classes.
Este exemplo declara uma estrutura de classe simples contendo uma varivel de referncia que aponta para um tipo especfico de
estrutura de fila:
MyQueue Fila, digite ! Definir um tipo especfico de fila

Field1 LONGO
Field2 CORDA (20) FIM
SomeClass CLASSE
QueRef & MyQueue ! Uma fila com uma longa e uma corda (20)
CreateQue PROCEDIMENTO Crie a fila para cada objeto
FIM
PROCEDIMENTO SomeClass.CreateQue
CDIGO
SELF.QueRef & = NEW (MyQueue) Crie uma fila para o objeto atual
SELF.QueRef.Field1 = 1
ADD SELF.QueRef.Field2 = 'primeira entrada'
(SELF.QueRef) ! e adicione a primeira entrada para a fila
IF ERRORCODE () depois parar (ERROR ()).
Utilizando estes denominados referncias de nomenclatura e uma referncia para uma estrutura de classe especfica faz com que seja possvel
para um objecto para efectivamente contm um exemplo de um outro objecto. Esta uma tcnica de OOP conhecido como composio, que
fornece uma alternativa para herana mltipla (que vamos chegar a pouco, quando discutirmos herana).
Construtores e destruidores
Construtores e destruidores so uma caracterstica de muitas linguagens orientadas a objeto. Estes so os mtodos (que voc deve
escrever) que executam automaticamente, sem ser explicitamente chamado. Um construtor executado quando o objeto criado, e
um destruidor executado quando o objeto destrudo.
A finalidade mais comum de um mtodo construtor em outras linguagens orientadas a objeto alocar memria para o objeto e inicializar
membros de dados para evitar erros que poderiam ser causados por variveis no inicializadas. mtodos destructor em outras
linguagens orientadas a objetos geralmente apenas de- alocar a memria para o objeto. A linguagem Clarion aloca automaticamente e
de-aloca memria e inicializa variveis em branco, zero, ou o valor nomeado na declarao da varivel. Isto significa que a maior razo
para apoiar os construtores automticos e destruidores no existe no Clarion. No entanto, Clarion oferece suporte a construtores
automticos e destruidores de qualquer maneira.
Se uma classe contm um mtodo chamado Construct (que deve ser um procedimento que leva sem parmetros), depois que o
mtodo de construo chamado automaticamente quando o objeto instanciado. Se uma classe contm um mtodo chamado
Destruct (tambm um procedimento que leva sem parmetros), depois que o mtodo Destruct automaticamente chamado quando o
objeto destrudo. Desde Clarion automaticamente cuida da alocao de memria e inicializao, o uso mais comum de construtores e
destruidores em um programa Clarion seria para inicializar e dispor de variveis de referncia de um objeto.

ObjectQ & MyQueue ! A referncia a um tipo especfico de FILA
Construir PROCEDIMENTO ! Mtodo construtor
Destruct PROCEDIMENTO ! Mtodo Destructor
FIM
ClassRef & SomeClass ! A referncia a um objeto SomeClass
CDIGO
ClassRef e = NOVO (SomeClass) Crie um objeto SomeClass! que auto-chama seu mtodo
construtor
ELIMINAR (ClassRef) Destrua o objeto SomeClass! que auto-chama seu mtodo
destrutor
PROCEDIMENTO SomeClass.Construct
CDIGO
SELF.ObjectQ & = NEW (MyQueue)! Criar a fila
PROCEDIMENTO SomeClass.DEstruct
CDIGO
FREE (SELF.ObjectQ) ! Liberar quaisquer entires FILA
ELIMINAR (SELF.ObjectQ) ! Destruir a FILA
Em Clarion (ao contrrio de muitas outras linguagens orientadas a objeto), voc tambm pode chamar explicitamente os mtodos construtor e
destruidor. Isso permite que voc re-start um objeto a qualquer momento simplesmente chamando destruidor do objeto (limp-lo), ento seu
construtor (reinicializar-lo).
Public vs. vs. privada protegida

Todas as propriedades e mtodos de uma classe so pblicos, a menos que declarado explicitamente com o atributo particular ou
protegido. Neste caso, pblico, eles so visveis e disponveis para uso em qualquer lugar que o objecto est no escopo.
PRIVADO
O atributo PARTICULAR especifica que a propriedade ou mtodo em que colocado visvel apenas com os processos definidos no
interior do mdulo de fonte contendo os mtodos da estrutura de classes. Este encapsula completamente os dados e mtodos de outras
classes.
SomeClass CLASS, MDULO ( 'SomeClas.CLW'), TYPE

PublicVar LONGO ! Declare uma propriedade pblica
PrivateVar LONG, PRIVATE ! Declare uma propriedade privada
BaseProc PROCEDIMENTO (Parm REAL) ! Declare um mtodo Public
Proc PROCEDIMENTO (Real Parm), PARTICULAR ! Declare um mtodo Privada
FIM
TwoClass SomeClass ! Declare um objeto

CDIGO
TwoClass.PublicVar = 1 ! Atribuio Legal
TwoClass.PrivateVar = 1 ! Atribuio ilegal
TwoClass.Proc (2) ! Chamada ilegal de Proc
! O arquivo de cdigo fonte SomeClas.CLW contm:
MEMBRO ( 'myprog') MAP

! Um mapa local que declara
SomeLocalProc PROCEDIMENTO (SomeClass) ! Um amigo de SomeClass e! Passar objeto
atual a ele
FIM
SomeClass.BaseProc PROCEDIMENTO (Parm REAL)

CDIGO
SELF.PrivateVar = Parm ! Atribuio Legal
SELF.Proc (Parm) ! Chamada Legal para Proc
SomeLocalProc (SELF)
! Ligue para o amigo, passando-a instncia do objeto atual
SomeClass.Proc PROCEDIMENTO (Parm REAL)

CDIGO
RETURN (Parm)
SomeLocalProc PROCEDIMENTO (PassedObject) ! Visvel somente neste mdulo

CDIGO
PassedObject.PrivateVar = 1 ! Atribuio Legal
Um outro benefcio da implementao Clarion de propriedades e mtodos privados so amigos. Em C ++, o conceito de um amigo
um procedimento que, embora no seja um mtodo de uma classe, compartilha as propriedades particulares da classe. No exemplo
acima, SomeLocalProc um amigo de OneClass porque ele definido no mesmo mdulo cdigo-fonte como os mtodos que
pertencem a OneClass, que lhe d acesso aos membros de dados privados. Passando o objecto actual para SomeLocalProc lhe
permite tratar directamente as propriedades particulares do objecto actual (a ocorrncia actual da classe).
PROTEGIDO
O atributo PROTEGIDO especifica que a propriedade ou mtodo em que colocado visvel apenas com os processos definidos
no interior do mdulo de fonte contendo os mtodos da estrutura de classes e os mtodos de qualquer classe derivada a partir
dessa classe. Isto s encapsula o mtodo de dados ou de outras classes no derivada da classe em que foi declarado (ou de
qualquer outro cdigo no-classe).
O objetivo do atributo PROTEGIDO fornecer um nvel de encapsulamento entre pblico e privado. dados ou mtodos protegidos
esto disponveis para uso dentro de sua prpria classe e classes derivadas, mas no est disponvel para qualquer cdigo fora
essas classes especficas.
Classes derivadas-Inheritance
Clarion suporta herana e uma declarao de classe pode ser construda sobre o fundamento de propriedades e mtodos de outra
classe. A classe de que uma classe derivada geralmente referida como a sua classe de base. A estrutura da classe derivada herda
todos os membros de dados pblicas e protegidos e mtodos da classe base como um ponto de partida (mas no os membros de
dados privados e mtodos). Isto significa que os membros de dados herdadas e mtodos so visveis e esto disponveis para
utilizao nos mtodos declarados dentro da estrutura de classes derivadas. Este exemplo declara uma estrutura de classe derivada
de outra:
SomeClass CLASSE ! Declare uma classe base

PropertyA LONGO
PropertyB LONGO
ManipulateAandB END
PROCEDIMENTO
AnotherClass CLASSE (SomeClass) ! Derivado do SomeClass

PropertyC LONGO
ManipulateAndC END
PROCEDIMENTO
Neste exemplo simples, AnotherClass derivado de SomeClass (sua classe base), herdar todas as propriedades e mtodos que
existem na SomeClass. AnotherClass tambm declara uma nova propriedade e um novo mtodo que no existem no SomeClass.
Portanto, os objectos que pertencem a SomeClass tm duas propriedades e um mtodo enquanto que os objectos que pertencem a
AnotherClass tem trs propriedades e dois mtodos.
Dadas as duas declaraes classe acima, as seguintes instrues executveis so todos vlidos:
CDIGO
SomeClass.PropertyA = 10 ! Atribuir valores s propriedades
SomeClass.PropertyB = 10
SomeClass.ManipulateAandB ! Chamar o mtodo do objeto
AnotherClass.PropertyA = 10 ! Atribuir valores s propriedades

AnotherClass.PropertyB = 10 = 10
AnotherClass.PropertyC
AnotherClass.ManipulateAandB ! Chamar mtodos do objeto
AnotherClass.ManipulateAndC
Alm disso, dadas as declaraes acima, as seguintes instrues executveis no so vlidos:
SomeClass.PropertyC = 10! Invlido, objeto no tem esta propriedade SomeClass.ManipulateAndC! Invlido,

objeto no tiver este mtodo
Estas declaraes so invlidos, porque, apesar do objecto derivado contm todas as propriedades e mtodos da classe da qual
derivada, o inverso no verdadeiro-herana unidireccional. H um mecanismo que recebe em torno deste e permite que mtodos
de classe base para chamar mtodos de classe derivados (mtodos virtuais) que vamos chegar tarde.
Substituindo mtodos herdados
H circunstncias em que uma classe de derivados podem necessitar de substituir um mtodo herdada para fornecer a
funcionalidade explcito necessrio para essa classe especfica de objecto. Isto simples de realizar em Clarion, apenas
re-declarar o mtodo na classe derivada (com exatamente a mesma lista de parmetros), em seguida, re-definir o mtodo na
classe derivada para a nova funcionalidade. Este exemplo substitui um mtodo herdado:
SomeClass CLASSE
PropertyA LONGO
PropertyB LONGO
ManipulateAandB END
PROCEDIMENTO
AnotherClass CLASSE (SomeClass)

PropertyC LONGO
ManipulateAandB PROCEDIMENTO ! Substitua o mtodo herdado
ManipulateAndC END
PROCEDIMENTO
SomeClass.ManipulateAandB PROCEDIMENTO produtos

LONGO
CDIGO
Produto = SELF.PropertyA * SELF.PropertyB MENSAGEM (
'produto de A * B ' & Product)
PROCEDIMENTO AnotherClass.ManipulateAandB ! Substitua o mtodo herdado

DoubleProduct LONGO
CDIGO
DoubleProduct = (SELF.PropertyA * SELF.PropertyB) * 2 MENSAGEM ( 'Double o
produto de um * B ' & DoubleProduct)
AnotherClass.ManipulateAndC PROCEDIMENTO
DoubleProduct LONGO
CDIGO
DoubleProduct = (SELF.PropertyA * SELF.PropertyC) * 2 MENSAGEM ( 'Double o
produto de um * C ' & DoubleProduct)
Neste exemplo, AnotherClass substitui o mtodo ManipulateAandB com sua prpria verso que contm um algoritmo
ligeiramente diferente. Observe que as listas de parmetros so os mesmos (nenhum mtodo recebe parmetros). Esta a
chave para substituir os mtodos em classes derivadas; as listas de parmetros deve ser a mesma.
Se as listas de parmetros dos dois mtodos ManipulateAandB neste exemplo eram diferentes, ento voc teria procedimento
sobrecarga no AnotherClass; isto , AnotherClass iria realmente conter dois mtodos chamados ManipulateAandB eo compilador teria
que resolver qual a chamar por meio dos parmetros diferentes. Veja Sobrecarga de funo na referncia da linguagem para uma
discusso completa desta tcnica.
Simplesmente substituir um mtodo em uma classe derivada no significa que voc automaticamente tambm no pode chamar o mtodo da
classe base de dentro mtodos de classe derivadas. Prepending PAI para a chamada de mtodo (como SELF) permite que uma classe de
derivados de chamar explicitamente mtodos de classe base (PARENT.MethodName). Isso permite que voc incremental mtodos de
substituio sem exigir que voc duplicar o cdigo de classe base no mtodo de classe derivada que substitui-lo (supondo que voc ainda
precisa a funcionalidade do mtodo de classe base).
Este exemplo substitui um mtodo herdado e chama o mtodo classe base da classe derivada:
SomeClass CLASSE
PropertyA LONGO
PropertyB LONGO
ManipulateAandB END
PROCEDIMENTO
AnotherClass CLASSE (SomeClass)

ManipulateAandB END
PROCEDIMENTO
SomeClass.ManipulateAandB PROCEDIMENTO produtos

LONGO
CDIGO
Produto = SELF.PropertyA * SELF.PropertyB MENSAGEM (
'produto de A * B ' & Product)
AnotherClass.ManipulateAandB PROCEDIMENTO
DoubleProduct LONGO
CDIGO
PARENT.ManipulateAandB ! Chamar o mtodo pai primeiro
DoubleProduct = (SELF.PropertyA * SELF.PropertyB) * 2 MENSAGEM ( 'Double o
produto de um * B ' & DoubleProduct)
Para os mtodos do construtor e destructor, simplesmente re-declarando a construir ou mtodo Destruio na classe derivada no
substituir o mtodo herdado a menos que o atributo SUBSTITUIR especificado no prottipo mtodo. Sem o atributo REPLACE, um
construtor de classe derivada chama automaticamente o construtor da classe base primeiro (antes do construtor da classe derivada
executa), e um destruidor de classe derivada chama automaticamente o destruidor de classe base de passado (aps o destruidor de
classe derivada executa).
Se o atributo REPLACE est presente no Construct ou prottipo do mtodo Destruct, ento o mtodo de classe derivada no chama
automaticamente o mtodo da classe base. No entanto, o mtodo da classe base pode ser chamado de dentro do cdigo do mtodo de
classe derivada chamando explicitamente PARENT.Construct ou PARENT.Destruct. Isso permite que voc incremental personalizar
construtores de classe derivados ou destruidores sem completamente re-escrever o cdigo de classe base.
MyQueue Fila, digite ! Declarar um tipo de fila com um campo

Field1 CORDA (10) ! contendo 10 bytes de dados de cadeia
FIM
SomeClass CLASSE, tipo ! Classe base

ObjectQ & MyQueue
Construir PROCEDIMENTO ! Mtodo construtor
Destruct PROCEDIMENTO ! Mtodo Destructor
FIM
AnotherClass CLASSE (SomeClass) ! Class Derived
Construir PROCEDIMENTO, REPLACE! Substituir o fim do construtor
ClassRef & AnotherClass ! A referncia a um objeto SomeClass

CDIGO
ClassRef & = NEW (AnotherClass) Crie um objeto AnotherClass que! chama o construtor da
classe derivada
ELIMINAR (ClassRef) Destrua o objeto
! que chama o destruidor de classe base
PROCEDIMENTO SomeClass.Construct ! Construtor da classe base

CDIGO
SELF.ObjectQ & = NEW (MyQueue)
PROCEDIMENTO SomeClass.Destruct ! Destruidor de classe base

CDIGO
FREE (SELF.ObjectQ) DESCARTE
(SELF.ObjectQ)
AnotherClass.Construct PROCEDIMENTO! Class Derived MyString construtor

CORDA (10), DIM (10)
CDIGO
LOOP X # = 1 a 10 ! Fazer algum trabalho preliminar, em seguida,
MyString [X #] = 'entrada' e formato (X #, @ N02) END
PARENT.Construct ! chamar o construtor da classe base

LOOP X # = 1 a 10 ! em seguida, terminar a construo
SELF.ObjectQ.Field1 = MyString [X #] ADD
(SELF.ObjectQ) afirmam (~ ERRORCODE ()) FIM
Herana mltipla vs. Composio

herana simples significa que uma classe de derivados possui apenas uma classe de base a partir da qual ele herda propriedades e mtodos. Clarion suporta diretamente herana
simples. Alguns linguagens OOP (mais notavelmente, C ++) permitir que a herana mltipla, em que uma classe de derivados herda propriedades e mtodos de vrias classes. Isto
tem a vantagem de combinar facilmente classes existentes para criar classes derivadas. Ele tambm tem a desvantagem de que o compilador tem que lidar com um grande potencial
ambiguidade se duas ou mais das classes a partir do qual a nova classe derivada conter mtodos com o nome-voc mesmo deve escrever cdigo extra para disambiguate os
mtodos sobrecarregados. Embora Clarion suporta apenas herana simples (como muitas outras linguagens OOP) pode facilmente contornar essa limitao usando uma tcnica de
OOP padro chamado Composio. Composio significa colocar um objeto de uma classe dentro de outra. Composio fornece os benefcios de herana mltipla sem a
ambiguidade potencial. Para os casos em que voc precisa herana mltipla, simplesmente decidir qual classe derivar e coloque um objeto de outra classe (o objeto contido) na nova
classe (o objeto container). Ento voc precisa para implementar um mtodo construtor para instanciar o objeto contido. Voc implementar composio em Clarion, colocando um
referncia ao objeto na declarao da classe, como este: simplesmente decidir qual classe derivar e coloque um objeto de outra classe (o objeto contido) na nova classe (o objeto
container). Ento voc precisa para implementar um mtodo construtor para instanciar o objeto contido. Voc implementar composio em Clarion, colocando um referncia ao
objeto na declarao da classe, como este: simplesmente decidir qual classe derivar e coloque um objeto de outra classe (o objeto contido) na nova classe (o objeto container).
Ento voc precisa para implementar um mtodo construtor para instanciar o objeto contido. Voc implementar composio em Clarion, colocando um referncia ao objeto na
declarao da classe, como este:
PROGRAMA
PropertyA LONGO
PropertyB LONGO
ManipulateAandB END
PROCEDIMENTO
AnotherClass CLASSE, tipo

PropertyC LONGO
ManipulateAndC END
PROCEDIMENTO
multiCLASS CLASS (SomeClass), TIPO! Herda de SomeClass e

AnotherClassRef & AnotherClass ! contm um objecto AnotherClass
Construir PROCEDIMENTO ! e um mtodo Construtor
FIM
MClass multiCLASS ! Declare um objeto

MClassRef & multiCLASS ! Declare uma referncia de objeto
CDIGO ! Construtor instancia o objeto contido! quando o objecto recipiente entra em

escopo
MClassRef & = NEW (multiclasse) Crie um novo objeto recipiente! que auto-chama seu
construtor
PROCEDIMENTO MultiClass.Construct
CDIGO
SELF.AnotherClassRef & = NEW (AnotherClass) Crie o objeto contido
Esta mesma tcnica tambm d aulas recursiva, colocando uma referncia a um objeto da mesma classe na declarao, como este:
SomeClass CLASSE, tipo ! SomeClass recurses em si por

SomeClassRef & SomeClass ! contendo um objeto SomeClass
PropertyA LONGO
PropertyB LONGO
ManipulateAandB PROCEDIMENTO
Construir END
PROCEDIMENTO
Virtuais Mtodos-Polimorfismo
Herana permite que uma classe derivada de chamar para baixo para os mtodos que herdou de sua classe base. mtodos virtuais,
por outro lado, permitir que os mtodos em uma classe base para chamar a mtodos in classes derivadas apesar no saber
exatamente o que est sendo chamado. Para conseguir isso, voc deve prottipo do mtodo virtual, tanto na classe base e a classe
derivada. O atributo virtual no prottipo de um mtodo declara um mtodo virtual. Esse atributo deve aparecer no prottipo do mtodo,
tanto na classe base e a classe derivada. Normalmente, a definio de classe base do mtodo virtual um procedimento fictcio (um
que no faz nada) ou um que fornece algumas funcionalidades padro simples para as classes derivadas que no precisam sua
prpria definio do mtodo.
Este exemplo define dois mtodos virtuais simples em duas classes derivadas:

PropertyA LONGO
PropertyB LONGO
InitAandB PROCEDIMENTO (LONGO PassedA, LONGO PassedB)
ManipulateAandB PROCEDIMENTO, VIRTUAL ! Declara o mtodo base virtual
FIM
AnotherClass CLASSE (SomeClass), TIPO
ManipulateAandB PROCEDIMENTO, VIRTUAL Re-declarar o mtodo virtual
FIM
DifferentClass CLASSE (SomeClass), ManipulateAandB
TIPO PROCEDIMENTO, VIRTUAL Re-declarar o mtodo virtual
FIM
Object1 AnotherClass ! Declare um objeto

Object2 DifferentClass ! Declare um objeto diferent
CDIGO
Object1.InitAandB (10,20)! InitAandB ir chamar o mtodo AnotherClass Object2.InitAandB (30,40)! InitAandB
ir chamar o mtodo DifferentClass
PROCESSO SomeClass.InitAandB (LONGO PassedA, LONGO PassedB)

CDIGO
SELF.PropertyA = PassedA
SELF.PropertyB = PassedB
SELF.ManipulateAandB ! Chamar qualquer mtodo virtual ! apropriado
para o atual
objeto
SomeClass.ManipulateAandB PROCEDIMENTO! Mtodo de classe base faz

CDIGO ! nada
PROCEDIMENTO AnotherClass.ManipulateAandB ! Mtodo Virtual

CDIGO
MENSAGEM ( 'produto de A * B ' & (SELF.PropertyA * SELF.PropertyB)) DifferentClass.ManipulateAandB
PROCEDIMENTO ! Mtodo Virtual
CDIGO
MENSAGEM ( 'A soma de A + B ' & (+ SELF.PropertyA SELF.PropertyB))
Neste exemplo, o mtodo ManipulateAandB virtual. O mtodo InitAandB chama SELF.ManipulateAandB sem saber qual o mtodo
real vai executar. Quando a instruo Object1.InitAandB (10,20) executa, SELF.ManipulateAandB chama
AnotherClass.ManipulateAandB, e quando a declarao Object2.InitAandB (30,40) executado, ele chama o mtodo
DifferentClass.ManipulateAandB.
Um mtodo virtual na classe derivada pode explicitamente chamar o mtodo com o mesmo nome da classe base, chamando
PARENT.VirtualMethodName. Esta apenas a mesma tcnica como anteriormente demonstrado em mtodos herdados Substituindo.
Mtodos derivados locais
Mtodos prototipados em uma declarao de classe derivada dentro de seo de dados local de um procedimento de compartilhar mbito
do procedimento, declarando para todas as declaraes de dados locais e rotinas. O requisito para isso que os mtodos devem ser
definidos dentro do mesmo mdulo de origem como o procedimento, declarando e deve seguir imediatamente o procedimento dentro
dessa fonte. Isto , os mtodos devem vir aps quaisquer rotinas e antes de quaisquer outros procedimentos que podem estar no mesmo
mdulo de origem. Isto significa declaraes de dados local do procedimento e rotinas so visveis e podem ser referenciadas dentro
desses mtodos.
A necessidade mais comum para este escopo a definio dos mtodos virtual para um objeto derivado declarado localmente a um
procedimento para servir a algum propsito para o procedimento de declarao. Normalmente, esses mtodos virtuais precisam ter
acesso a dados locais do procedimento para executar a funo pretendida. Por exemplo:
MEMBRO ( 'MyApp') ! Um mdulo de fonte

SomeClass CLASSE, tipo, MDULO ( 'SomeClass.CLW')
PropertyA LONGO
PropertyB LONGO
InitAandB PROCEDIMENTO (LONGO PassedA, LONGO PassedB)
ManipulateAandB PROCEDIMENTO, END VIRTUAL
MyProc PROCEDIMENTO ! Alguns procedimento no-objeto

LocalVar LONGO ! Varivel local
AnotherClass CLASSE (SomeClass) ! Declare um objeto no local de dados

ManipulateAandB PROCEDIMENTO, END VIRTUAL
CDIGO
DO MyRoutine
AnotherClass.InitAandB (10,20) ! Mtodo de classe base chamada
MyRoutine ROTINA ! Rotina local para MyProc e
LocalVar + = 10 ! AnotherClass.ManipulateAandB
AnotherClass.ManipulateAandB PROCEDIMENTO! Mtodo virtual com acesso a X
LONGO ! dados e rotinas locais
CDIGO
LOOP 10 VEZES
X = (SELF.PropertyA * SELF.PropertyB * LocalVar) MENSAGEM ( 'produto
de A * B * LocalVar ' & X) DO MyRoutine
! Incrementar a varivel local
FIM
! MDULO ( 'SomeClass.CLW') contm:
PROCESSO SomeClass.InitAandB (LONGO PassedA, LONGO PassedB)
CDIGO
SELF.PropertyA = PassedA
SELF.PropertyB = PassedB
SELF.ManipulateAandB ! Chamar qualquer mtodo virtual ! apropriada para o
objeto atual
SomeClass.ManipulateAandB PROCEDIMENTO! Mtodo da classe base no faz nada
CDIGO
Resumo
Os trs conceitos mais importantes na orientao a objetos so: encapsulamento, herana e polimorfismo.
A estrutura da classe cria encapsulamento.
O cdigo fonte para todos os mtodos em uma nica classe residir em um nico mdulo de origem, tornando a manuteno
mais fcil.
Um objecto um exemplo de uma classe com o seu prprio conjunto de membros de dados (propriedades) que compartilha mtodos com
todas as outras instncias da classe (e tambm quaisquer classes de derivados).
Uma classe pode conter membros de dados (propriedades) declarou como tipos de dados simples ou como variveis de referncia
para os tipos de dados complexos (incluindo outras classes).
Dentro dos mtodos de classe, os membros de dados e mtodos apropriados para a instncia de objecto actual so
referenciados utilizando SELF tal como o nome do objecto (SELF.DataMemberName ou SELF.MethodName).
mtodos de construtor e destruidor nomeados Construct e Destruct so automaticamente chamado quando um objeto
criado ou destrudo, e tambm pode ser explicitamente chamado.
Todas as propriedades e mtodos so pblicos, a menos que declarado explicitamente com o atributo particular ou
protegido.
Hereditariedade conseguido atravs da derivao de uma classe de outro.
Voc pode substituir mtodos herdados por re-declarar e re-definindo-os na classe derivada, usando exatamente a
mesma lista de parmetros.
mtodos herdados substitudo e mtodos virtuais podem chamar seus eleitores de classe base usando PAIS
(assim como SELF).
Composio proporciona uma alternativa vivel herana mltipla.
mtodos virtuais permitem Polimorfismo OOP padro, enquanto do Clarion procedimento sobrecarga permite
uma forma no-POO de polimorfismo.
Mtodos virtuais so prottipo em ambas a base e classes derivadas.
Objetos local para um procedimento de aces variveis locais e rotinas com o procedimento declarar.
Database design 53
4 - Database Design
Database design
H uma srie de mtodos de organizao do banco de dados em uso hoje. A Lista Modelo invertido, o modelo hierrquico e modelo de
rede trs so os que tm sido amplamente utilizados no passado. Principalmente, esses modelos tm sido usados em computadores
mainframe, e no foram implementados sistemas de PC de forma generalizada. A linguagem Clarion tem as ferramentas para que voc
possa utilizar qualquer um destes mtodos, se assim o desejarem.
De longe, o mtodo mais comum de organizao do banco de dados em sistemas PC hoje o modelo relacional, conforme definido pela EF
Codd. No h nenhum programa de banco de dados que implementa completamente todas as regras de Codd sobre banco de dados relacional,
porque um modelo matemtico extremamente complexa. No entanto, a maioria dos programas de banco de dados implementar um
sub-conjunto suficiente de regras de Codd para permitir a utilizao prtica dos princpios do modelo relacional. Este ensaio um breve resumo
dos aspectos mais fundamentais do design de banco de dados relacional como eles afetam a programao de negcios.
Relational Database Design

Um princpio bsico do banco de dados relacional envolve o design de um item de dados de banco de dados deve ser armazenado uma vez que-no
duplicado em muitos lugares. H dois benefcios para isso: baixou os requisitos de espao em disco e mais fcil manuteno de dados. Para atingir
este fim, um design bancos de dados relacionais divide os dados em arquivos separados, relacionados. Por exemplo, suponha um sistema de
entrada de pedidos muito simples que precisa armazenar os seguintes dados:
Nome Cliente Endereo

ShipTo ordenada
Endereo Order Produto
Data quantidade
encomendada Preo
unitrio
Estes dados poderiam ser armazenados em cada registro de um arquivo, mas isso seria muito ineficiente. O nome do cliente,
endereo, endereo ShipTo, e Ordem Data seria duplicado para cada item solicitado em cada ordem. Para eliminar a duplicao,
voc dividir os dados em arquivos separados.
Arquivo Cliente: Nome do cliente

Endereo do cliente
Fim do arquivo: ShipTo Endereo Data
do Pedido
Arquivo Item: Produto quantidade
encomendada ordenada
Preo unitrio
Com esta configurao de arquivo, o arquivo do cliente contm todas as informaes do cliente, o arquivo order contm toda a
informao que pertinente a um fim, e o item de arquivo contm todas as informaes para cada item na ordem. Isso certamente
elimina dados duplicados. No entanto, como voc diz que recorde em que arquivo relaciona com o que outros registros em que outros
arquivos? Este o propsito dos termos relacionais chave primria e chave estrangeira.
A chave primria um ndice para um arquivo com base em um campo (ou campos) que no pode conter valores duplicados ou nulos. Para
traduzir isso para termos de linguagem Clarion: uma chave primria seria uma chave nica (nenhum atributo DUP) com componentes-chave que
so todos os campos para entrada de dados. Em estrita projeto de banco de dados relacional, uma chave primria necessrio para cada arquivo.
Uma chave estrangeira um ndice para um arquivo com base em um campo (ou campos) que contm valores que duplicam os valores contidos nos
campos de chave primria de outra, relacionados, arquivo. Para voltar a este estado, uma chave externa contm uma referncia para a chave primria
de outro arquivo.
Chaves primrias e chaves estrangeiras formam a base das relaes de arquivos no banco de dados relacional. Os valores correspondentes contidos nas
chaves primrias e estrangeiras so os ponteiros para os registros relacionados. Os registros de chave estrangeira no Arquivo um ponto de volta para
o registro de chave primria em Arquivo B, e a chave primria em pontos Arquivo B para os registros de chave estrangeira no Arquivo A.
Definindo as chaves primrias e estrangeiras para o exemplo acima requer que voc adicione alguns campos para os arquivos para cumprir
as exigncias relacionais.
Arquivo Cliente: Nmero de Cliente - Chave Primria

Cliente Endereo Nome
do cliente
Fim do arquivo: Nmero de Pedido - Key Nmero principal

cliente - Key ShipTo Endereo fim Data
Foreign
Arquivo Item: Nmero de Pedido - 1 Primria componente chave e Key Foreign produto encomendado -
componente chave 2 primria quantidade encomendada Preo unitrio
No arquivo do cliente, no h nenhuma garantia de que no poderia haver nomes de clientes duplicados. Portanto, o campo Nmero do cliente
adicionado para se tornar a chave primria. O nmero de ordem foi adicionada ao arquivo de Ordem como a chave primria, porque no h
nenhum outro campo que absolutamente nico em que arquivo. O nmero do cliente tambm foi adicionado como uma chave estrangeira
para relacionar o arquivo order ao arquivo do cliente. O item de arquivo agora contm o nmero do pedido como uma chave estrangeira para se
relacionar com o arquivo order. Ele tambm se torna o primeiro componente do componente mltipla (Nmero de Ordem, produto
encomendado) de chave primria.
Database design 55
As definies relacional da chave primria e chaves estrangeiras no requerem necessariamente a declarao de uma chave Clarion com base
na primria ou chave estrangeira. Isto significa que, apesar do fato de que existem estas chaves em teoria, voc s vai declarar uma CHAVE
Clarion se o seu aplicativo realmente precisa dele para algum acesso de arquivo especfico. De um modo geral, a maioria das todas as chaves
primrias ter um Clarion KEY, mas menos Foreign Keys precisa ter chaves Clarion declarados.
Relaes de arquivo
Existem trs tipos de relacionamentos que podem ser definidos entre quaisquer dois arquivos em um banco de dados relacional: One-to-One;
Um-para-muitos (tambm chamado de pai-filho) e seu ponto de vista inverso, muitos-para-um; e muitos-para-muitos. Essas relaes referem-se
ao nmero de registros em um arquivo que esto relacionados com um determinado nmero de registros no segundo arquivo.
No exemplo anterior, a relao entre o arquivo do cliente eo arquivo Ordem um para vrios. Um cliente de registro de arquivo pode
estar relacionado a vrios registros ordem dos arquivos. O arquivo de pedido e no item Arquivo tambm tm um relacionamento
um-para-muitos, uma vez que uma ordem pode ter vrios itens. Em aplicaes de banco de dados de negcios, um-para-muitos
(pai-filho) a relao mais comum entre os arquivos.
Um relacionamento One-to-One significa que exatamente um registro em um arquivo pode estar relacionado a exatamente um registro em outro
arquivo. Isso til em situaes em que um determinado arquivo pode, ou no, precisa ter dados em alguns campos. Se todos os campos esto
contidos em um arquivo, voc pode perder um monte de espao em disco com campos vazios nesses registros que no precisam das informaes
extra. Portanto, voc cria um segundo arquivo com um relacionamento um-para-um para o primeiro arquivo, para manter os campos possivelmente
desnecessrios.
Para expandir o exemplo anterior, uma Ordem pode, ou no, precisa ter um ShipTo Endereo separado. Assim, voc pode adicionar
um arquivo ShipTo ao projeto de banco de dados.
Fim do arquivo: Nmero de Pedido - Key nmero de cliente

preliminar - Chave fim Data Foreign
Arquivo ShipTo: Nmero de Ordem - Chave primria e chaves estrangeiras

Enviar para o endereo
Neste exemplo, um registro ser adicionada ao arquivo ShipTo somente se uma Ordem tem de ser enviado para um endereo
diferente do endereo no arquivo do cliente. O Arquivo ShipTo tem um relacionamento um-para-um com o arquivo order.
Muitos-para-muitos a relao de arquivos mais difceis com que lidar. Isso significa que vrios registros em um arquivo esto
relacionados com vrios registros em outro arquivo. Expandir o exemplo anterior para atender a uma preocupao de fabricao que
compra peas e torna os produtos. Uma parte pode ser usado em muitos produtos diferentes, e um produto poderia usar muitas peas.
Peas arquivo: Nmero da pea - chave primria da

pea Descrio
Arquivo produto: o nmero do produto - chave primria
Descrio do Produto
Sem entrar na teoria, deixe-me simplesmente afirmar que esta situao tratada atravs da definio de um terceiro arquivo, comumente
referido como um arquivo Join. Este arquivo Junte cria duas relaes um-para-muitos, como neste exemplo:
Peas arquivo: Nmero da pea - chave primria da

pea Descrio
Arquivo Parts2Prod:
Parte Number - Componente 1 chave primria e chave nmero do produto Exterior -
componente chave 2 primria e Quantidade Key estrangeiras utilizadas
Arquivo produto: o nmero do produto - chave primria

Descrio do Produto
O Arquivo Parts2Prod tem um componente mltipla chave primria e duas chaves estrangeiras. A relao entre as partes e Parts2Prod
um-para-muitos, ea relao entre o produto e Parts2Prod tambm um-para-muitos. Isso faz com que o arquivo Junte-se
intermedirio entre dois arquivos com um relacionamento muitos-para-muitos.
Uma vantagem de usar um arquivo Junte que geralmente h um pouco mais de informaes que logicamente devem ser armazenados l.
Neste caso, a quantidade utilizada (de uma parte em um produto) logicamente pertence somente no arquivo Parts2Prod.
Database design 57
Traduzindo a Teoria Clarion

Em design prtico de dados relacional, a Clarion CHAVE podem no precisam ser declarados para o chave primria em alguns arquivos. Se
nunca h uma necessidade de acessar diretamente os registros individuais a partir desse arquivo, em seguida, uma definio de chave
baseado na chave primria no necessrio. Normalmente, este seria o arquivo Child (de uma relao pai-filho) cujos registros so
necessrios apenas em conjunto com o registro pai.
A CHAVE Clarion tambm pode no precisam ser declarados para uma chave estrangeira. A determinao para declarar uma KEY
dependente de como voc est indo para acessar o arquivo que contm a chave estrangeira. Se voc precisar acessar os registros de
chave estrangeira da chave primria, a Clarion KEY necessrio. No entanto, se o nico propsito da chave estrangeira garantir que o
valor no valor do campo chave estrangeira vlida, no necessrio CHAVE Clarion. Pegue os exemplos tericos prvios e criar
definies de arquivo Clarion:
Cliente ARQUIVO, DRIVER ( 'Clarion'), PRE (Cus)

CustKey CHAVE (Cus: CustNo) !Chave primria
Registro REGISTRO
CustNo LONGO ! Nmero de cliente - Chave Primria
Nome CORDA (30) !Nome do cliente
Endereo CORDA (30) !Endereo do cliente
. .
Ordem ARQUIVO, DRIVER ( 'Clarion'), PRE (Ord)

OrderKey CHAVE (Ord: OrderNo) !Chave primria
CustKey CHAVE (Ord: CustNo), DUP ! Chave estrangeira
Registro REGISTRO
OrderNo LONGO ! Nmero de Ordem - Chave Primria
CustNo LONGO ! Nmero de Cliente - Chave estrangeira
Encontro LONGO !Data do pedido
. .
Enviar para ARQUIVO, DRIVER ( 'Clarion'), PRE (SHP)

OrderKey CHAVE (SHP: OrderNo) !Chave primria
Registro REGISTRO
OrderNo LONGO ! Order Number - chave primria e chaves estrangeiras
Endereo CORDA (30) !Enviar para o endereo
. .
Item ARQUIVO, DRIVER ( 'Clarion'), PRE (ITM)

OrderKey CHAVE (ITM: OrderNo, Itm: NPROD) chave primria!
Registro REGISTRO
OrderNo LONGO ! Order - Componente primria e chaves estrangeiras
NPROD LONGO ! Prod. - Componente primria e chaves estrangeiras
Quantidade CURTO !Quantidade encomendada
Preo DECIMAL (7,2) !Preo unitrio
. .
produtos ARQUIVO, DRIVER ( 'Clarion'), PRE (Pro)

ProdKey KEY (Pro: NPROD) !Chave primria
Registro REGISTRO
NPROD LONGO ! Nmero do produto - chave primria
Descrio CORDA (30) !Descrio do Produto
. .
Parts2Prod ARQUIVO, DRIVER ( 'Clarion'), PRE (P2P) ProdPartKey CHAVE (P2P:

NPROD, P2P: partno) Primria CHAVE PartProdKey CHAVE! (P2P: partno, P2P:
NPROD)! Alternate tecla Gravar
REGISTRO
partno LONGO ! Parte - Componente primria e chaves estrangeiras
NPROD LONGO ! Prod. - Componente primria e chaves estrangeiras
Quantidade CURTO
. .
Parts ARQUIVO, DRIVER ( 'Clarion'), PRE (Par)

PartKey CHAVE (Par: partno) !Chave primria
Registro REGISTRO
partno LONGO ! Nmero da pea - chave primria
Descrio CORDA (30) !Descrio parcial
. .
Observe que apenas uma chave estrangeira (no arquivo de Ordem) foi declarado explicitamente como uma chave Clarion. Um nmero de chaves
estrangeiras foram includos como parte das declaraes de chave primria, mas esta foi simplesmente sorte.
A chave primria (ITM: OrderKey) definido no arquivo item est l para garantir que uma ordem no contm produtos duplicados
ordenada. Se isso no fosse uma considerao, Itm: OrderKey que contm apenas Itm: OrderNo, e teria o atributo DUP para permitir
valores de chave duplicada. Isso tornaria uma chave estrangeira em vez de uma chave primria, eo arquivo no teria uma chave
definida para a chave primria.
O arquivo Item e do arquivo do produto tem um relacionamento muitos-para-um, que um-para-muitos olhou para a partir da perspectiva inversa.
Este ponto de vista inverso mais frequentemente usado para a verificao de entrada de dados look-up. Isso significa que o nmero do produto
entrou em processo de entrada de dados do arquivo do item pode olhar-up e verificar o nmero do produto contra os registros no arquivo do
produto.
Integridade referencial
H uma questo mais fundamental no modelo relacional que deve ser abordada: integridade referencial Este um problema que
deve ser resolvido no cdigo fonte executvel para um aplicativo, porque envolve a ativa, run-time inter-relao de os dados dentro do
banco de dados.
Integridade referencial significa que nenhuma chave estrangeira pode conter um valor que no acompanhada por algum valor de chave
primria. Manter a integridade referencial no banco de dados gera duas perguntas que devem ser resolvidos:
O que voc faz quando o usurio deseja excluir o registro chave primria?
Database design 59
O que voc faz quando o usurio quer mudar o valor da chave primria? As trs respostas mais comuns a cada uma
dessas perguntas so: Restringir a ao, Cascade a ao, ou (menos comumente) anular os valores da chave estrangeira. Claro, pode
haver tambm respostas especficas de aplicativos, como cpia de todas as informaes de arquivos de histrico antes de realizar a
ao, que deve ser implementado conforme exigido em programas individuais.
Restringir a ao
Restringir a ao significa que quando o usurio tenta excluir o registro de chave primria, ou alterar o valor da chave primria, a ao s
permitido se no houver chaves estrangeiras que fazem referncia a essa chave primria. Se Chaves estrangeiras relacionadas no
existir, a ao no permitida. Usando os arquivos definidos anteriormente, aqui est um exemplo de como o cdigo executvel pode
olhar para restringir exclui ou uma mudana do valor da chave primria.
ChangeRec EQUATE (2) ! Ao Alterar EQUATE

DeleteRec EQUATE (3) ! Equiparar Excluir valor de Aco para a legibilidade
SaveKey LONGO ! Chave primria salvar varivel
CDIGO
SaveKey = Cus: CustNo valor Key! Salvar primria
ABERTO (janela)
ACEITAR
CASE aceite () ! Entrada de processo
! Processamento de controle individual de?
OKButton ! Boto concluso Tela
SE Action = ChangeRec E Cus: CustNo <> SaveKey
! Verifique se h valor da chave primria mudou
Cus: CustNo = SaveKey ! mud-lo de volta
MENSAGEM ( 'alteraes campo de chave no permitido!') ! Dizer ao usurio
SELECCIONAR (1) ! Recomear
CICLO
ELSIF Action = DeleteRec ! Verifique a ao de excluso
Ord: CustNo = Cus: CustNo ! Inicializar campo Chave
GET (Ordem, Ord: CustKey) ! e tentar obter um registro relacionado
SE NO ERRORCODE () ! Se o GET foi bem sucedida
MENSAGEM ( 'no exclui permitido!')! contar usurio SELECT (1)
! Recomear
MAIS
CICLO ! Se GET no foi bem sucedido
APAGAR (Customer) ! V em frente e exclu-lo
PAUSA ! E sair
FIM
! Outras declaraes de processamento executveis end end end
Cascata a ao
Cascade a ao significa que quando o usurio tenta excluir o registro de chave primria, ou alterar o valor da chave primria, as cascatas
de ao para incluir quaisquer chaves estrangeiras que fazem referncia a essa chave primria. Se Chaves estrangeiras relacionadas
existem, a ao de excluso tambm exclui os registros, ea ao mudana tambm altera os valores nas chaves estrangeiras que fazem
referncia a essa chave primria.
H uma considerao que deve ser observado quando voc Cascade a ao. E se o arquivo que voc Cascade a (o arquivo Criana)
tambm o pai de outro arquivo Criana? Esta uma situao que tem de detectar e tratar, porque a ao Cascade deve afetar
todos os registros de arquivos dependentes. Quando voc est escrevendo cdigo fonte para lidar com esta situao, voc precisa
estar ciente das relaes de arquivo e escrever cdigo que Cascades a ao, tanto ele precisa ir para garantir que nada pendurado
esquerda.
Mais uma vez usando os arquivos definidos anteriormente, aqui est um exemplo de como o cdigo executvel pode olhar para Cascade
exclui ou uma mudana do valor da chave primria.

CDIGO
ABERTO (janela)
ACEITAR
DO ChangeCascade ! e em cascata a mudana
DO DeleteCascade ! e cascata a excluso
FIM
! Outras declaraes de processamento executveis fim fim
ChangeCascade ROTINA
Ord: CustNo = SaveKey ! Inicializar o campo de chave
SET (Ord: CustKey, Ord: CustKey) ! e definido para processar todos de um mesmo
LOOP ! os pedidos dos clientes
Prximo pedido) ! um por vez
IF Ord: CustNo <> SaveKey OU ERRORCODE () em seguida, quebrar.
! Verifique para final de cust. e sair
Ord: CustNo = Cus: CustNo ! Mudar para novo valor
PUT (Ordem) ! e colocar o registro de volta
IF ERRORCODE () depois parar (ERROR ()). FIM
DeleteCascade ROTINA
Database design 61

LIMPAR (ITM: Record) ! Limpar o buffer de registro
ITM: OrderNo = Ord: OrderNo ! Inicializar o campo de chave
SET (ITM: OrderKey, Itm: OrderKey) ! e definido para processar todos de um mesmo
Loop at EOF (ponto) ! itens da ordem
NEXT (item) ! um por vez
IF Itm: OrderNo <> Ord: OrderNo OU ERRORCODE () em seguida, quebrar.
! Verifique para o final da ordem e sair do ciclo do item
Apagar item) ! e excluir o registro do item
! End loop de arquivo do item
Shp: OrderNo = Ord: OrderNo ! Verifique se h registro ShipTo
GET (ShipTo, SHP: OrderKey) SE NO
ERRORCODE () ! Se GET foi bem sucedida
APAGAR (ShipTo) ! excluir o registro ShipTo
APAGAR (Ordem) ! e excluir o registro Order

! End loop de arquivo Order
Anular a chave estrangeira
Anular a chave estrangeira significa que quando o usurio tenta excluir o registro de chave primria, ou alterar o valor da chave primria, as
chaves estrangeiras que fazem referncia a essa chave primria so alterados para valores nulos (se os campos de chave externos permitir
valores nulos).
Mais uma vez usando os arquivos definidos anteriormente, aqui est um exemplo de como o cdigo executvel ficaria para anular as chaves
estrangeiras na excluso ou a alterao do valor da chave primria.

CDIGO
ABERTO (janela)
ACEITAR
DO ChangeNullify ! e anular os registros filho
DO DeleteNullify ! e anular os registros filho
FIM
! Outras declaraes de processamento executveis fim fim
ChangeNullify ROTINA
Ord: CustNo = 0 ! Mude para valor nulo
DeleteNullify ROTINA
Ord: CustNo = 0 ! Mude para valor nulo
Database design 63
A opo Nullify no requer tantas mudanas como a opo Cascade. Isso ocorre porque o Cascade tem que apagar todos os registros
relacionados em quantos arquivos esto relacionados. Anular s precisa nulo fora as chaves estrangeiras individuais que fazem
referncia a chave primria a ser alterados ou excludos.
Resumo
Cada item de dados deve ser armazenado uma vez.
arquivos separados so usados para eliminar a duplicao de dados.
Os arquivos so relacionados por primria e chaves estrangeiras.
Uma chave primria um ndice exclusivo (e no nulo) em um arquivo que prev o acesso registro individual.
A chave externa contm uma referncia para a chave primria de algum outro arquivo.
Um-para-muitos relacionamentos de arquivo so os mais comuns. Eles tambm so referidos como pai-filho e
Many-to-One (mesma relao, vista reverso).
relaes de arquivo one-to-One so mais comumente criado para armazenar dados que no so sempre necessrios em cada
registro.
Muitos-para-muitos relacionamentos exigem um arquivo de Join que atua como um intermedirio entre os dois arquivos. O arquivo
Junte insere dois relacionamentos um-para-muitos entre o relacionamento muitos-para-muitos.
Apenas as chaves primrias e estrangeiras que as necessidades de aplicao (como uma considerao prtica) para
acesso especfico para os arquivos precisa ter Clarion Keys declarou.
Integridade referencial significa que todas as chaves estrangeiras conter referncias vlidas para chaves primrias.
Manter a integridade referencial requer cdigo executvel que testa Atualizar ou excluir dos valores chave primria.
As trs solues comuns para manter a integridade referencial so: Restringir (update / delete no permitido), em cascata
(tambm atualizar / excluir a chave estrangeira), ou anular a chave estrangeira (atribuir valores nulos para a chave
estrangeira).
Processamento de Arquivo de Dados 65
5 - Processamento de Arquivo de Dados
Processamento de Arquivo de Dados
aplicaes personalizadas de banco de dados, por definio, armazenar dados em arquivos. Obtendo dados para esses arquivos, e process-lo por
algum tipo de sada significativa, o objetivo principal de qualquer aplicao de banco de dados. Este ensaio uma discusso sobre as ferramentas de
linguagem Clarion que permitem ao programador acessar e arquivos de dados do processo.
Mtodos de acesso de arquivos
De um modo geral, os registros so colocados em arquivos de dados no final do arquivo na seqncia em que so adicionados (isso nem
sempre verdade, mas geralmente verdade). Isso cria a fsica, ordem do nmero de Gravao do arquivo-a ordem fsica em que os
registros aparecem dentro do arquivo. Esta ordem fsica no corresponde necessariamente a qualquer sequncia significativa ou til. H duas
maneiras de acessar os registros dentro de um arquivo: acesso sequencial e de acesso aleatrio. Acesso sequencial significa que voc obtenha
o nmero de registros em uma sequncia especificada, o processamento de cada registro em ordem. acesso aleatrio significa que voc
recuperar e processar um registro especfico. Ambos os mtodos de acesso so usados em quase todas as aplicaes de banco de dados de
negcios. Se voc s precisa acessar registros sequencialmente em seu desenvolvimento fsico, a fim nmero recorde, nada mais do que o
arquivo de dados necessria. Se voc precisar acessar aleatoriamente um registro, e voc sabe exatamente qual a posio que ocupa no
arquivo (seu nmero de registro), a mesma coisa verdade. No entanto, para a maioria das aplicaes, estes constrangimentos seria muito
limitante.
KEY e INDEX
A chave eo ndice de declaraes Clarion criar ordens de classificao alternativos para os registros no arquivo. Estes permitem acesso
seqencial ou aleatrio para um arquivo de dados em alguma ordem que no a fsica, a fim recorde de nmero. A ordem determinada pelos
campos componentes que compem a chave ou ndice. Cada componente chave ou ndice podem ser por ordem ascendente ou descendente.
A principal diferena entre CHAVE e INDEX reside no fato de que uma tecla mantida de forma dinmica. Cada vez que um registro
adicionado, alterado ou excludo, a chave tambm atualizado. Uma vez que sempre mantido atualizado, uma chave deve ser usada para
ordens de classificao que so frequentemente utilizados na aplicao.
Um ndice no mantida e deve ser reconstrudo imediatamente antes de ser usado para garantir que ele reflete com preciso o estado
atual do arquivo. A declarao BUILD usado para reconstruir um ndice. Por causa do fator tempo na reconstruo, e o fato de que o
acesso ao arquivo exclusivo necessrio para a construo, um ndice deve ser usado para ordens de classificao que so pouco
usados. Uma forma especial de INDEX o ndice dinmico. Este um ndice cujos campos componente no so declarados na
definio arquivo. Os campos de componentes de um ndice dinmico so declarados em tempo de execuo na declarao BUILD.
Ao contrrio de um INDEX esttico, voc pode construir um ndice dinmico com o arquivo aberto em qualquer modo de acesso. A
vantagem deve ser ordens de classificao imediatamente bvio-end-user-definvel.
Amostra ARQUIVO, DRIVER ( 'TopSpeed'), PRE (Sam)

Field1Key KEY (Sam: Field1) ! KEY no campo 1
Field2Ndx INDEX (Sam: Field2) ! ndice esttico em Field2
DynNdx NDICE() ! ndice dinmico
Registro REGISTRO
Field1 LONGO
Field2 CORDA (10)
Field3 DECIMAL (7,2)
. .
CDIGO
ABERTO (Amostra, 42h) ! Abra leitura / gravao Negar nenhum
LOCK (Amostra) ! Lock para acesso exclusivo
CONSTRUIR (Sam: Field2 ! Para construir o ndice
DESBLOQUEAR (Amostra) ! em seguida, desbloquear o arquivo
CONSTRUIR (Sam: DynNdx, '- Sam: Field1, + Sam: Field2') ! Criar o ndice dinmico
Neste exemplo, a tecla ON Sam: Field1 ser sempre atual, o ndice de Sam: Field2 construda quando o arquivo aberto e bloqueado (acesso
exclusivo necessria). O ndice dinmico construdo em tempo de execuo em ordem decrescente Sam: Field1 e ascendente Sam: ordem de
classificao Field2. Claro, ele poderia ser construdo em qualquer ordem de classificao possvel para o arquivo.
Outros que a sua manuteno, KEY e INDEX so funcionalmente equivalentes. Eles compartilham o mesmo tipo de formato de arquivo e podem
ser usados indistintamente em todas as declaraes de acesso a arquivos executveis que requerem um parmetro chave ou ndice. Para
simplificar esta discusso, onde quer que o KEY e / ou INDEX frase seria apropriado, ele substitudo com o ndice termo genrico. Todas as
referncias ao ndice aplicam-se igualmente para as duas chaves e os ndices, a menos que indicado de outra maneira.
Sequential File Access

Existem trs declaraes Clarion que executam acesso a arquivos sequenciais: SET, NEXT, e ANTERIOR. A instruo SET inicia o
processamento-lo seqencial no l um registro. O prximo e declaraes anteriores ler os registos em ordem ascendente
(PRXIMA) ou descendente (ANTERIOR) dentro da sequncia estabelecida pelo SET.
A instruo SET o elemento dominante no processamento de arquivos sequenciais. A instruo SET deve vir antes NEXT ou
PREVIOUS para inicializar o ponto de partida e sequncia na qual os registros sero lidos. Normalmente, a instruo SET a ltima
instruo executvel antes de a estrutura LOOP que processa sequencialmente os registros no arquivo. Seguinte ou anterior , ento,
a primeira instruo dentro do loop, como neste exemplo de cdigo utilizando a definio de arquivo de exemplo anterior:
SET (Sam: Field1Key) ! Defina para cima de arquivo, a fim CHAVE

LOOP ! Loop at o final do arquivo de Amostra
NEXT (Amostra) ! Leia cada registro por sua vez,
SE ERRORCODE () em seguida, quebrar. ! Quebre no final do arquivo
! declaraes de processamento de registro
FIM ! Loop End
H sete formas da instruo SET listados no Manual de Referncia da Linguagem. Estes essencialmente se dividem em duas
categorias: trs pontos de partida para o acesso de pedidos recorde-nmero fsico, e quatro pontos de partida para o acesso ordem
indexada.
ordem fsica ordem indexada

Superior / inferior de Arquivo Superior / inferior de Arquivo
Physical Record Number ndice Record Number
Valor do ndice Valor do ndice
ndice de Valor e Fsica Record Number
SET inicializa o ponteiro do registro de processamento seqencial, e emprega um tipo de lgica fuzzy. Quando voc define a parte
superior / inferior do arquivo, o ponteiro registro no realmente apontando para qualquer um. Se voc emitir uma prxima aps a SET,
voc ler os registros para a frente a partir do incio do arquivo. Se voc emitir um anterior em vez, voc l registros para trs a partir do
final do arquivo. Uma vez que voc emitiu a seguinte ou anterior para comear registros de leitura em uma direo, voc no pode ir para
trs na parte superior / inferior do arquivo, sem outra SET.
A mesma lgica fuzzy ativa quando voc definir para um valor de ndice. Se SET encontra um registro que contm uma correspondncia exata
para que o valor do ndice, que aponta para esse registro especfico. Neste caso, ou NEXT ou PREVIOUS iria ler o mesmo registro.
Se, no entanto, no h nenhuma correspondncia exata para o valor do ndice, pontos de ajuste entre o ltimo registro em
seqncia contendo um valor inferior a (ou maior do que, em um ndice descendente) o valor do ndice e o prximo registro em
seqncia contendo uma valor maior do que (ou menos do que, em um ndice descendente), o valor de ndice. Neste caso,
seguintes e anteriores no iria ler o mesmo registro. Em seguida seria lido o registo seguinte na sequncia de ndice, ANTERIOR
iria ler o registo anterior na sequncia de ndice.
A vantagem desta lgica fuzzy reside na sua utilizao com um ndice de mltiplos componentes, como neste exemplo.
Amostra ARQUIVO, DRIVER ( 'TopSpeed'), PRE (Sam)

FieldsKey KEY (Sam: Field1, Sam: Field2), DUP ! KEY no Campo 1 e Campo 2
Registro REGISTRO
Field1 LONGO
Field2 CORDA (10)
Field3 DECIMAL (7,2)
. .
CDIGO
CLEAR (Sam: Record) ! Limpar o buffer de registro
Sam: Field1 = 10 ! Inicializar o componente de primeira CHAVE
SET (Sam: FieldsKey, Sam: FieldsKey) ! Sequncia de teclas, comeam em 10-roupa
LOOP ! Processe cada registro
NEXT (Amostra) ! um por vez
IF Sam: Field1 <> 10 ! Verifique para o final do grupo
PAUSA ! se assim for, sair da malha do processo
FIM
! Processamento de registro de declaraes END
! Lao processo End
Este cdigo primeiro limpa o buffer de ficha, a atribuio de zeros para Sam: Sam e campo1: Field3, e espaos em branco para Sam: Campo2. O
primeiro campo componente de Sam: FieldsKey inicializado com o valor que deve estar nos registros que voc precisa para processar. A instruo
SET configura o processamento sequencial de modo indexado, comeando com o ndice de valor, neste caso, um valor de 10 em Sam: campo1 e
espaos em branco em Sam: Campo2.
Registros arquivo de exemplo: ndice Record # Field1 Field2 Field3

1 5 abc 14,52
2 5 DEF 14,52
Ponteiro de registro Aps SET >>
3 10 abc 14,52
4 10 abc 29.04
5 10 DEF 14,52
6 15 abc 14,52
7 15 DEF 14,52
SET deixa o ponteiro de registo posicionado como mostrado acima, porque no h correspondncia exacta. A ficha 2 do valor de 5-DEF
menos do que 10 em branco, e ficha 3 de valor 10-ABC maior do que 10 em branco, por conseguinte, o ponteiro do registo deixado
entre os dois. A primeira vez atravs do lao, PRXIMO l registro de nmero 3. A declarao IF termina o ciclo de processamento
aps a prxima l ficha 6.
H uma ntida diferena entre a Fsica Record Number eo ndice Record Number. A Physical Record Number a posio fsica
relativa dentro do arquivo de dados como retornado pelo ponteiro (Etiqueta de um arquivo) procedimento. O ndice da ficha do
nmero a posio ficha relativa dentro da sequncia do ndice tal como devolvido pelo ponteiro (Etiqueta de um ndice)
procedimento.
Em ordem fsica, o mesmo arquivo pode ter esta aparncia (claro, os nmeros de registro fsicos e ndices no so armazenados no
arquivo de dados):
Arquivo de exemplo: Physical Record # ndice Record # Field1 Field2 Field3

1 3 10 abc 14,52
2 6 15 abc 14,52
3 5 10 DEF 14,52
4 2 5 DEF 14,52
5 4 10 abc 29.04
6 7 15 DEF 14,52
7 1 5 abc 14,52
As formas de SET que utilizam nmeros de registro como o ponto de partida so muito semelhantes, portanto, voc precisa ser muito
claro sobre o que voc est usando (Fsica vs. Index).
SET (Amostra, 1) ! Ordem fsica, jogos para rec fsica 1, ndice de rec 3
SET (Sam: FieldsKey, 1)

! ndice, conjuntos para indexar rec 1, rec fsica 7
Sam: Field1 = 10 Sam: Field2

= 'ABC'
SET (Sam: FieldsKey, Sam: FieldsKey, 5)
! ndice, conjuntos para indexar rec 4, rec fsica 5
Esta ltima forma de SET permite que voc defina a um registro especfico dentro de uma seqncia de registros que contm valores de
campo de ndice duplicados. Ele procura as entradas de ndice duplicados para uma entrada de ndice que aponta para o nmero de registro
fsico especificado como o terceiro parmetro. Isso til em arquivos onde h vrios registros com valores de ndice duplicados e voc
precisa para comear o processamento em um registro especfico dentro desses duplicatas.
Random Access Arquivo
H apenas uma declarao Clarion que realiza acesso aleatrio aos registros individuais dentro de um-arquivo declarao GET. Ao
contrrio SET, GET ou l o registro voc tentar recuperar, ou retorna um erro. No h lgica fuzzy com GET.
Existem trs formas da declarao GET. Eles permitem que voc recuperar um registro com base em um valor de ndice,
Physical Record Number, ou ndice Record Number.
Sam: Field1 = 15 Sam: Field2 = 'ABC'

GET (Sample, Sam: FieldsKey)
! GETs ndice rec 6, rec fsica 2
GET (Amostra, 1) ! GETs rec fsica 1, ndice de rec 3
GET (Sam: FieldsKey, 1) ! GETs ndice rec 1, rec fsica 7
O primeiro exemplo GET recupera o primeiro registo na ordem de ndice que contm os valores nos campos do componente de ndice
no momento do GET emitido. O segundo exemplo recupera o primeiro registro no arquivo, a fim Physical Record Number. O terceiro
recupera o primeiro registro no arquivo, a fim ndice Record Number.
GET sempre procura uma correspondncia exata para o valor do ndice e retorna um erro se no encontrar um. Portanto, todos os
campos que compem um ndice de mltiplos componentes deve ser inicializado antes de emitir um GET.
GET completamente independente de processamento sequencial SET / NEXT ou SET / anterior. Isto significa que um GET para um
ficheiro que est a ser processado sequencialmente no altera o ponteiro de registo para o processamento sequencial.
SET (Sam: FieldsKey) ! Defina para cima de arquivo

LOOP ! Processe cada registro na ordem do ndice
NEXT (Amostra) ! Obtm cada registro seqencial
! Recordes sequencial declaraes de processamento GET (Sam:
FieldsKey, 1) ! Obtm o primeiro registro na ordem do ndice
! Aleatrio registro de acesso de processamento de declaraes END
Este cdigo de exemplo processa atravs de todo o arquivo na ordem do ndice. Depois de cada ficha processado, o primeiro registo
na ordem do ndice recuperado e processado. Isso no afeta a seqncia, portanto PRXIMO vai progredir atravs do arquivo,
apesar do GET do primeiro registro de cada vez atravs do loop.
Resumo
Acesso Seqencial e de acesso aleatrio so os dois mtodos usados para recuperar registros de um arquivo.
A chave eo ndice de declaraes Clarion definir ordens de classificao suplentes do arquivo no qual eles so declarados.
Uma chave mantida de forma dinmica e est sempre pronto para uso. Um ndice no mantida e deve ser
construda antes do uso.
A INDEX dinmica permite ordens de classificao a ser definida em tempo de execuo.
A instruo SET inicializa o ponto de processamento sequencial e de partida. A SET necessria antes de o primeiro
NEXT ou PREVIOUS.
SET emprega lgica fuzzy para determinar o ponto de partida. Ele ou aponta para um registo especfico, ou entre os registos na
posio em que determinados nenhuma gravao encaixar os parmetros do ponto de partida que lhe foi conferido.
Nmeros fsica e ndice de registro so muito diferentes e no deve ser confundido com o outro.
A declarao GET executa acesso registro aleatrio dentro de um arquivo.
GET completamente independente do conjunto / NEXT e / processamento de gravao sequencial ANTERIOR SET.
Consideraes Multi-User 73
6 - Consideraes Multi-User
Consideraes Multi-User
O mundo do banco de dados de programao aplicaes est rapidamente caminhando para networking. aplicaes autnomas esto se
expandindo em ambientes multi-usurio, conforme mais empresas conectar seus PCs a redes locais (LANs). aplicativos de mainframe em
grandes empresas esto sendo direita tamanho e re-escrito para a operao LAN. Com o surgimento de multi-threading, sistemas
operacionais multitarefa para PCs, mesmo computadores autnomos precisa de aplicaes que so escritas com multi-usurio
consideraes de acesso compartilhado em mente. Este ensaio uma discusso sobre as ferramentas de linguagem Clarion fornecidos
para escrever aplicativos projetados especificamente para uso em ambientes multi-usurio.
Arquivos de abertura
Antes de qualquer arquivo de dados pode ser processado, ele deve primeiro ser aberto. As demonstraes ABERTOS e compartilhar
fornecer esta funo. Abra e partilhe so funcionalmente equivalentes, a nica diferena entre os dois o valor padro do segundo
parmetro (modo de acesso) de cada. O modo de acesso especifica o tipo de acesso que o usurio abrir o arquivo recebe, e o tipo de
acesso permitido a outros usurios do arquivo. Estes dois valores so somados para criar o cdigo de acesso DOS para o arquivo. Os
valores de modo de acesso so:
Acesso Dezembro Hex.

Acesso do Usurio: Somente leitura 0 0h
Somente Gravao 1 1h
Ler escrever 2 2h
Acesso do outro: negar Todos 16 10h

negar gravao 32 20h
negar Leia 48 30h
negar nenhum 64 40h
modo de acesso padro da instruo OPEN leitura / gravao Negar gravao (22h), que s permite (monousurio) acesso de
gravao de disco exclusivo para o usurio abrir o arquivo. modo de acesso padro do extrato de aes leitura / gravao Negar
nenhum (42h), permitindo o acesso no-exclusiva (multi-user) para quem abre o arquivo. Abrir ou social poder abrir o arquivo em
qualquer um dos possveis modos de acesso.
Abrir arquivo) ! Abra leitura / gravao Negar gravao

Open (FILE, 22h) ! Abra leitura / gravao Negar gravao
SHARE (arquivo, 22h) ! Abra leitura / gravao Negar gravao
SHARE (arquivo) ! Abra leitura / gravao Negar nenhum
SHARE (arquivo, 42h) ! Abra leitura / gravao Negar nenhum
Open (FILE, 42h) ! Abra leitura / gravao Negar nenhum
Open (FILE, 40h) ! Abrir Read Only Negar nenhum
SHARE (arquivo, 40h) ! Abrir Read Only Negar nenhum
Estes exemplos demonstram os trs modos de acesso mais vulgarmente utilizados. Para aplicaes multi-usurio, o modo de acesso mais
comum leitura / gravao Negar nenhum (42h), que permite que todos os usurios acesso completo ao arquivo. Somente leitura Negar Nenhum
(40h) normalmente usado em situaes multi-usurio onde o usurio no ir actualizar o ficheiro (um ficheiro s de pesquisa), mas pode haver
algum outro usurio que pode precisar de escrever para esse arquivo.
verificao de simultaneidade
O maior considerao a ter em mente sobre o acesso multi-usurio para arquivos a possibilidade de que vrios usurios podem estar
atualizando o mesmo registro ao mesmo tempo. Um processo conhecido como verificao de simultaneidade impede o arquivo de dados de ser
corrompido por vrias atualizaes do usurio para o mesmo registro. verificao de simultaneidade significa determinar que o registro em disco,
que est prestes a ser substitudo, ainda contm os mesmos valores que ele fez quando foi recuperada para atualizao. Obviamente, no h
necessidade de qualquer tipo de verificao de simultaneidade quando um registro est sendo adicionado. Se o arquivo tem uma chave nica,
dois usurios adicionando o mesmo registro duas vezes impossvel, porque o segundo ADD retorna um Cria Duplicate Key erro sem adicionar
o registro. Se chaves duplicadas so permitidos, no existe uma maneira genrica para o cdigo do programa para verificar se h duplicatas
inadvertidas (incorretos) em oposio a deliberar (correta) registros duplicados. Tambm no h necessidade de verificao de simultaneidade
quando um registro est sendo excludo. Uma vez que o primeiro usurio tenha excludo o registro, ele se foi. Qualquer usurio subseqente que
tenta excluir esse registro no ser capaz de obt-lo em primeiro lugar.
verificao de simultaneidade necessrio quando um usurio est fazendo uma mudana para um recorde. O processo de mudana de
um registro : obter o registro, faa as alteraes, e escrever as alteraes de volta para o arquivo. O problema que, durante o tempo
que leva o primeiro usurio a fazer alteraes no registro, um segundo usurio (a mais rpida datilgrafo) poderia: obter o mesmo
registro, fazer alguma mudana, e escrever o registro alterado volta para o disco. Quando chega a hora para o primeiro usurio para
escrever seus / suas alteraes no disco, o registro em disco j no a mesma de quando ele foi recuperado em primeiro lugar. Ser o
primeiro usurio simplesmente substituir as alteraes do segundo (mais rpido) do usurio? Caso ambos os usurios esto mudando
diferentes elementos de dados desse registro e ambas as alteraes so vlidas, substituindo mudanas do segundo usurio no pode
ser permitido. Mesmo que ambos esto fazendo o mesmo mudana,
O mtodo de concorrncia verificao mais simples executar a instruo RELGIO apenas antes de obter o registro do disco. Isso diz
ao driver de arquivo para executar automaticamente verificao de simultaneidade e relatar um erro na declarao PUT se houver um
conflito. Infelizmente, nem todos os arquivos drivers suportam isso.
Para o mtodo de verificao de simultaneidade mais simples sem o uso de relgio, seu cdigo de programa deve: 1
Salve uma cpia do registro antes de quaisquer alteraes so feitas. 2
Re-ler o registro imediatamente antes de escrever as alteraes no disco, e compar-lo com o original salvo. 3
Se os dois so o mesmo, permitir que as alteraes do usurio para ser gravados no disco. Se no, alertar o usurio e exibir
o registro, como alterado por outro usurio.
Assuma as seguintes declaraes globais e compilador equivale:
Amostra ARQUIVO, DRIVER ( 'TopSpeed'), PRE (Sam) ! A declarao de arquivo de dados

Field1Key KEY (Sam: Field1)
Registro REGISTRO
Field1 LONGO
Field2 CORDA (10)
. .
Aao LONGO ! Varivel ao de atualizao Registro
AddRec EQUATE (1)
ChangeRec EQUATE (2)
Suponha que algum procedimento permite ao usurio selecionar um registro a partir do arquivo, define a ao arquivo esperado (adicionar,
alterar ou excluir o registro), em seguida, chama um procedimento de atualizao. O procedimento de atualizao funciona apenas nesse
registro selecionado e realiza a ao que o usurio definido no procedimento anterior. A lgica do procedimento de atualizao seria algo
como isto:
Atualizar PROCEDIMENTO ! Um procedimento de atualizao

Tela JANELA
! declaraes tela de entrada de dados aqui END
SaveQue FILA, PR (SAV) ! Gravar salvar fila uma cpia

SaveRecord SIMILAR (Sam: Record), PRE (Sav) do registro de buffer END do arquivo!
! Com um prefixo diferente
SavRecPos CORDA (512) ! Posio Registro salvar varivel
CDIGO
ABERTO (Tela)
Sav: SaveRecord = Sam: Record ! Salvar cpia do registro
ADD (SaveQue, 1) ! para a fila de entrada 1
SavRecPos = POSIO (Amostra) ! Salvar posio registro
EXIBIO ! Mostrar o registro na tela
ACEITAR ! Lao processo campo Tela
CASE aceite ()
! Campo de tela Individual editar o cdigo vai aqui OF? OKButton
! Campo concluso Tela
SE Action = ChangeRec ! Se mudar um registro existente
Sav: SaveRecord = Sam: Registro salvar as alteraes feitas ADD (SaveQue,
2) ! para a fila de entrada 2
GET (SaveQue, 1) ! Obter registro original da fila
Reget (Amostra, SavRecPos) ! Obter registro de arquivo novamente
SE ERRORCODE ()
Se o erro () = 'registro no encontrado'! Ser que algum exclu-lo? Action = AddRec
! mudar Ao para adicion-lo de volta
GET (SaveQue, 2) ! Obter alteraes desse usurio
Sam: Record = Sav: SaveRecord! coloc-los em buffer de registro PARAR MAIS
(ERROR ())
Pare em qualquer outro erro
FIM
ELSIF Sav: SaveRecord <> Sam: Registro Compare para alteraes de outros Sav: SaveRecord =
Sam: Record! Gravar novo ADD registro em disco (SaveQue, 1)
! para a fila de entrada 1
EXIBIO ! Mostrar alteraes de outros
BIP ! Alertar o usurio
MENSAGEM ( 'alterado por outro estao') SELECT (1)
! e comear de novo
CICLO ! no primeiro campo

OUTRO ! Se ningum mudou
GET (SaveQue, 2) ! Obter alteraes desse usurio
Sam: Record = Sav: SaveRecord! coloc-los de volta no buffer de registro
. .
EXECUTAR Ao ! Execute de escrita do disco
ADD (Amostra) ! Se Action = 1 (AddRec)
PUT (Amostra) ! Se Action = 2 (ChangeRec)
APAGAR (Amostra) ! Se Action = 3 (DeleteRec)
END ErrorCheck
! Um procedimento de verificao de erro genrica
FREE (SaveQue) ! Libera a memria usada por entradas da fila
PAUSA ! E sair do loop de processo
. . ! Loop End e caso
Este cdigo de exemplo demonstra o tipo mais simples de simultaneidade verificar que voc pode fazer sem o uso de relgio. Ele
salva o registro original na entrada da fila de memria um, e a posio de que o registro em uma varivel de cadeia. Depois disso, o
usurio tem permisso para fazer as alteraes para os dados da tela. O cdigo para verificar as alteraes do outro usurio est
contido no campo CASE () DE? OKButton. Este seria o campo que o usurio completa quando ele / ela terminar de fazer alteraes
e est pronto para gravar o registro em disco.
Para verificar as alteraes de outros usurios, o cdigo primeiro salva as alteraes do usurio a uma segunda entrada de fila de
memria, em seguida, recebe o registro original salvo da fila. A posio registro salvo usado para obter o registro do arquivo de dados
novamente. Se o registro no for encontrado no arquivo, algum j excluiu. Portanto, uma vez que este usurio alter-lo, basta
adicionar o registro alterado novamente para o arquivo. Se o registro no foi excludo, ele comparado com a cpia original salva. Se
eles no so os mesmos, o registro alterado guardado para a mesma entrada fila de memria (uma) que continha o registro original.
Em seguida, o usurio alertado para o problema e enviado de volta para o primeiro campo na tela para re-introduzir as alteraes (se
necessrio). Se o registro ainda o mesmo, alteraes do usurio so recuperados a partir da segunda entrada de fila memria e
colocado no buffer de registro para a gravao do disco. Este mtodo bastante simples e lgica. No entanto, ele usa trs pedaos
suplementares de memria o tamanho do buffer de registro: tampo da fila de memria, e as duas entradas em que a fila (mais gerais de
28 bytes de cada entrada de fila). Se voc est lidando com um arquivo que possui muitos campos, o buffer de registro pode ser muito
grande e isso poderia usar uma quantidade significativa de Memria.
Outro mtodo de verificao de simultaneidade no copiar e salvar o registro original, mas sim calcula uma soma de verificao ou
valor de Redundncia Cclica (CRC). O clculo realizado no registro antes que as mudanas so feitas, em seguida, o registro
recuperado do disco eo clculo realizado novamente. Se os dois valores no so os mesmos, o registro foi alterado. Este mtodo
ainda exige uma rea, exceto por alteraes do usurio, porque o registro deve ser lido novamente para o segundo clculo, e todos
leituras de disco so colocados no buffer de registro. Sem uma rea salvar, alteraes do usurio sero substitudos.
Aqui est o exemplo de um processo CRC de 16 bits, e seu prottipo para a estrutura MAP. Este semelhante ao clculo CRC
utilizados em alguns protocolos de comunicao serial. Uma matriz de campos byte passado para o procedimento, ele calcula um
valor de CRC de 16 bits para que a matriz, e retorna-o para um USHORT (16 bits sem sinal) varivel.
MAPA ! O prottipo procedimento para a MAP.

CRC16 (* BYTE []), USHORT ! CRC16 espera um array de bytes a serem
FIM ! passado para ele, retorna um valor USHORT
! ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~ CRC16
PROCEDIMENTO (Array) ! 16 Bit CRC Verificao
CRC ULONG ! Varivel Trabalho
CDIGO
LOOP X # = 1 ao mximo (Array, 1)! Percorre matriz inteira
CRC = BOR (CRC, Matriz [X #]) ! Concatenar um byte matriz para CRC
LOOP 8 vezes ! Loop atravs de cada bit
CRC = BSHIFT (CRC, 1) ! Deslocar CRC deixou um pouco
IF BAND (CRC, 1000000h)! Foi CRC bit 24 antes de mudar? CRC = BXOR (CRC, 102100h)!
XOR valor deslocado com mscara CRC
. . . ! Termine ambos os loops
RETURN (BAND (BSHIFT (CRC, -8), 0000FFFFh))! Shift e valor de retorno mscara
Usando este procedimento de verificao de CRC, o cdigo de exemplo anterior teria de ser alterado para se parecer com:

Tela JANELA
! declaraes tela de entrada de dados aqui END
Sav: SaveRecord SIMILAR (Sam: Record), PRE (Sav), STATIC

! Buffer de registro salvar a rea! Com
um prefixo diferente
Passarray BYTE, DIM (SIZE (Sam: Record), OVER (Sam: Record)
! Declare variedade SOBRE Sam: Record
SavRecPos CORDA (512) ! Posio Registro salvar varivel
SavCRC USHORT ! Valor CRC salvar varivel
CDIGO
ABERTO (Tela)
SavCRC = CRC16 (Passarray) Economia ao valor original CRC
SavRecPos = POSIO (Amostra) ! Salvar posio registro
CASE aceite ()
Sav: SaveRecord = Sam: Record ! salvar as alteraes feitas
SE ERRORCODE ()
Se o erro () = 'registro no encontrado'! Ser que algum exclu-lo? Action = AddRec
Sam: Record = Sav: SaveRecord ! coloc-los em buffer de registro
PARAR MAIS (ERROR ())
Pare em qualquer outro erro
FIM
ELSIF SavCRC <> CRC16 (Passarray)! Comparar CRCs para mudanas SavCRC = CRC16
(Passarray) ! Salve o novo valor de CRC
Se a mensagem ( 'alterado por outra estao'). SELECCIONAR (1)
! e comear de novo
Sam: Record = Sav: SaveRecord ! colocar alteraes de volta em tampo
. .
END ErrorCheck
PAUSA ! e sair do circuito de processo de
. . ! Loop End e caso
Voc pode ver que o cdigo do procedimento de atualizao usando este mtodo um pouco menor e mais fcil de seguir logicamente.
H duas novas declaraes de dados: SavCRC declarado para salvar o clculo do CRC original, e Passarray uma matriz declarada
SOBRE buffer de registro do arquivo. A declarao Passarray simplesmente fornece uma maneira de passar o procedimento CRC16
todo o registro como uma matriz de bytes, no alocar qualquer memria.
Uma pergunta vlida neste momento seria, Por que o Sav: SaveRecord declarou neste cdigo com um atributo esttico? H quatro
razes:
A rea de economizar ainda necessria para manter temporariamente alteraes do usurio enquanto clculos verificao de
simultaneidade esto sendo realizadas.
Variveis declaradas localmente em um procedimento so atribudos memria na pilha quando o procedimento

chamado.
A rea de economia para uma buffer de registro grande poderia facilmente ter mais memria do que est disponvel na pilha.
Portanto, a rea salvar deve estar na memria esttica.
Em um procedimento, apenas as estruturas de dados (Janela, RELATRIO, Arquivo, Exibir, e fila) e variveis com o atributo
STATIC so atribudos memria esttica. Claro, se a rea salvar foram declarados na seo de dados global (entre o programa de
palavras-chave e CODE), ou seo de dados de um mdulo MEMBRO (entre os Estados palavras-chave e PROCEDIMENTO), ele
no precisa ser declarada com o attribute- STATIC ele seria automaticamente atribudo memria esttica.
Segure e solte
Uma ferramenta para impedir que outros usurios fazer alteraes em um registro enquanto ele est sendo atualizado a declarao HOLD.
ESPERA diz o seguinte GET, NEXT, ou declarao anterior para obter o registro e definir um sinalizador que diz qualquer outro usurio tentar
obter esse registro que ele est em uso-a O registro permanece realizada at que seja bloqueio de registro.: Explicitamente lanado com
uma declarao RELEASE; implicitamente lanado por um PUT ou DELETE, desse registro; ou, lanado implicitamente recuperando outro
recorde do mesmo arquivo.
A linguagem Clarion suporta vrios sistemas de arquivos atravs da sua tecnologia de driver de arquivo. Cada sistema de arquivos pode
implementar bloqueio de registro no uma maneira diferente. Portanto, o efeito real da HOLD est dependente do driver de arquivo, o que
leva qualquer ao que apropriado para o sistema de arquivos. Em alguns sistemas de arquivos, um poro em um recorde permite que
outros usurios ler o registro, mas no escrever para ele. Em outros, HOLD blocos outros usurios a partir de qualquer acesso ao registro.
Alguns sistemas de arquivos liberar a espera automaticamente se o sistema falhar, outros no e deix-la marcada como realizada. A ao
especfica de HOLD descrito na documentao de cada motorista arquivo. Se voc mantiver um registro quando recuperada, e liber-lo
quando voc escrev-lo de volta, voc pode eliminar a necessidade para o tipo de concorrncia verificao descrito anteriormente. Isso
uma boa ideia, Apesar? Dependendo da implementao real da HOLD na sistema de arquivos a ser utilizado, a resposta pode ser Sim ou
No
Se seus blocos do sistema de arquivos de outros usurios de todo o acesso ao registo, ou existe a possibilidade de uma falha do sistema
poderia deix-lo em um estado de espera, a resposta provavelmente No. Isso no significa que voc no deve usar ESPERA em tudo . Isso
no significa que voc no deve usar ESPERA onde um registro seria realizada durante a entrada do usurio (uma quantidade de tempo
indeterminado). Mais provavelmente, voc usaria segurar durante a verificao de simultaneidade descrito acima. Isso para se certificar de
que ningum muda o registro entre o segundo GET (para verificao de simultaneidade) eo PUT que grava as alteraes do usurio no disco.
Usando Espera desta maneira s muda o cdigo no caso aceite () DE? OKButton.
DE? OKButton ! Campo concluso Tela

Sav: SaveRecord = Sam: Record ! salvar as alteraes feitas
HOLD (Amostra, 1) ! Segure durante a verificao de alteraes
SE ERRORCODE ()
ERROR () = IF 'registro j REALIZADA'! Tem algum entendeu? BIP
! Alertar o usurio
SHOW (25,1, 'detidos por outra estao') SELECT (1)
! e comear de novo
ELSIF ERROR () = 'registro no encontrado'! Ser que algum exclu-lo? Action = AddRec
Sam: Record = Sav: SaveRecord ! coloc-los de volta no buffer de registro
OUTRO
STOP (ERRO ()) Pare em qualquer outro erro
FIM
ELSIF SavCRC <> CRC16 (Passarray)! Comparar valores CRC para mudanas RELEASE (Amostra)
! Liberar a espera
SavCRC = CRC16 (Passarray) ! Salve o novo valor de CRC
Se a mensagem ( 'alterado por outra estao'). SELECCIONAR (1)
! e comear de novo
Sam: Record = Sav: SaveRecord ! colocar estas modificaes nos locais tampo
. .
END ErrorCheck
Esta mudana coloca uma reteno sobre o registro apenas o tempo suficiente para determinar se ele o mesmo registro que o usurio comeou
com e escrever as alteraes no disco. Se algum tem um poder sobre o registo, o utilizador alertado para esse fato e permitiu para tentar
novamente. Se o registro vem continuamente como realizada por outra estao, ento ele provavelmente foi deixado num estado de reteno por
uma falha no sistema. Nesse caso, a reteno deve ser lanado por qualquer ao apropriado para esse sistema de arquivos. Cdigo pode ser
escrito para lidar com essa eventualidade, mas seria especfico para o sistema de arquivos e este genrico exemplo de cdigo.
Se a preveno de conflitos de atualizao de registro uma preocupao de misso crtica, ento segure poderia ser usado para manter o controle do
registro durante a entrada de dados do usurio. Um trade-off com este uso de HOLD est o incmodo de lidar com registros que so deixados bloqueado
quando acidente sistemas dos usurios, enquanto os registros so mantidos. Corrigir essa situao poderia envolver algum trabalho manual com utilitrios
do sistema de arquivos, ou pode ser simplesmente uma questo de consideraes de codificao especfica para o sistema de arquivo que est sendo
usado. Outra preocupao com o uso Segure esta maneira vem, quando o sistema de arquivo que est sendo usado no permite que outros usurios leiam
os registros mantidos. Os registros mantidos parece desaparecer depois reaparecer de tempos em tempos como os usurios MANTER registros. De
qualquer maneira, este mtodo provavelmente no deve ser utilizado se a aplicao realmente exige.
Para utilizar esta tcnica, HOLD teria que ser no procedimento que na verdade recupera o registro do arquivo. Na maioria dos casos,
esse procedimento iria mostrar algum tipo de lista de registros, geralmente exibidos em uma caixa de lista de rolagem. O seguinte
exemplo de cdigo demonstra isso.
DE? Lista !LISTA

CASO CASE () DE EVENTO:
Aceite ! Um registro existente foi selecionado
GET (TableQue, escolha ()) ! Obter nmero recorde da fila
HOLD (Amostra, 1) ! Arme HOLD
Reget (Amostra, Que: RecPosition) ! e obter o registro do arquivo
ERROR () = IF 'registro j REALIZADA'! Tem algum entendeu? BIP
! Alertar o usurio
Se a mensagem ( 'retidas por uma outra estao'). SELECT (?
List) ! tentar novamente
MAIS
CICLO ! Se ningum mais tem
Action = ChangeRec ! Configure a ao de disco para a mudana
Atualizar ! e chamar o procedimento de atualizao
FIM
! Cdigo de lidar com outros keycodes vai aqui END
Esta tcnica grosseiramente simplifica o cdigo do procedimento atualizao, como neste exemplo:

Tela JANELA
! controles de entrada de dados aqui END CODE
ABERTO (Tela)
CAMPO DO CASO ()
CASE EVENTO () DE EVENTO:
aceitado EXECUTAR Ao
! Execute de escrita do disco
END
ErrorCheck ! Um procedimento de verificao de erro genrica
. . . ! Loop End e caso
A declarao conter apenas permite que cada usurio mantenha um registro em cada arquivo. Se voc precisa atualizar vrios registros em um
arquivo e voc deve ter certeza de que nenhum outro usurio faz alteraes a esses registros, enquanto eles esto sendo atualizados, ento
voc deve bloquear o arquivo.
Bloquear e desbloquear
A declarao bloqueio impede que outros usurios acessem os registros em um arquivo, at que voc desbloque-lo. Assim como ESPERA, o
efeito do fechamento depende do driver de arquivo que leva qualquer ao que apropriado para o sistema de arquivos. Em alguns sistemas
de arquivos, uma falha no sistema destrava automaticamente o arquivo, e em outros, esquerda est bloqueada. O bloqueio ao especfica
que necessrio descrito na documentao de cada motorista arquivo.
Porque os outros usurios esto completamente impedidos de acessar registros no arquivo bloqueado, bloqueio no comumente usado. O
uso mais comum de BLOQUEIO seria para construir um ndice antes de o utilizar (e que no sequer necessrio que seja um INDEX
dinmica). O tipo de processamento de atualizao em lote, que exigiria um arquivo a ser bloqueado por um perodo significativo de tempo
geralmente melhor deixar at depois de horas, quando todos os usurios sumiram. Alm de criar um ndice, um bloqueio de arquivo
normalmente s necessrio durante Transaction Processing, que o tema de um ensaio separado. Se um aplicativo verdadeiramente exige
um bloqueio de arquivo, ento o perodo de tempo durante o qual os outros usurios no tm acesso devem ser mantidos a um mnimo
absoluto. O cdigo entre o bloqueio de arquivo e sua declarao posterior desbloqueio no deve exigir qualquer entrada do usurio. Isto
significa que o cdigo deve ser escrito de tal forma que um usurio final no pode ir almoar deixando um arquivo bloqueado. Especificamente,
BLOQUEIO deve vir imediatamente antes de ocorrer o BUILD, e o arquivo deve ser desbloqueada assim que for concluda.
ReportProc PROCEDIMENTO
Amostra ARQUIVO, DRIVER ( 'TopSpeed'), PRE (Sam)! A declarao de arquivo de dados
Field1Key KEY (Sam: Field1)
Field2Ndx INDEX (Sam: Field2) ! Um INDEX
Registro REGISTRO
Field1 LONGO
Field2 CORDA (10)
. .
Relatrio RELATRIO
Relatar instrues de declarao aqui END CODE

LOCK (Amostra, 1) ! Bloquear o arquivo
SE erro () = 'ficheiro j LOCKED' ! Verifique se h outros bloqueios
MENSAGEM ( 'bloqueado por outra estao') RETURN
! e sair
FIM
CONSTRUIR (Sam: Field2Ndx) Construa o ndice
DESBLOQUEAR (Amostra) ! Desbloqueie o arquivo
ABERTO (Relatrio) SET (Sam:
Field2Ndx) ! Use o ndice
LOOP
NEXT (Amostra)
SE ERRORCODE () em seguida, quebrar. ! Cdigo de
processamento Relatrio vai aqui END
Este cdigo abre o arquivo no modo de acesso 42h (leitura / gravao Negar nenhum) para acesso totalmente partilhada. O bloqueio tentada
para um segundo. Se for bem sucedido, o BUILD executa imediatamente. Se o bloqueio no foi bem sucedida, o usurio alertado e voltou para
o procedimento que chamou o relatrio. Quando a instalao for concluda, DESBLOQUEAR mais uma vez permite que outros usurios o acesso
ao arquivo e o relatrio executado com base na ordem de classificao do ndice.
Abrao mortal
H duas formas de abrao mortal. A primeira ocorre quando dois usurios tentam bloquear o mesmo conjunto de arquivos em ordens
separadas de sequncia. O cenrio : fechaduras usurio um arquivo A
fechaduras usurio B arquivo B ao mesmo tempo
Um usurio tenta bloquear arquivo B e no pode porque o usurio B tem bloqueado as tentativas do usurio B para bloqueio de arquivo A
e no pode porque o usurio A tenha trancado Isso deixa os usurios desligou a tentativa de ganhar o controle dos arquivos. A soluo
para este dilema a adoo de uma conveno de codificao simples: arquivos Bloqueie sempre na mesma ordem (obras alfabticos
apenas multa) e armadilha para fechaduras de outros usurios. Este exemplo demonstra o princpio:
LOOP
LOCK (FileA, 1) ! BLOQUEIO Tentativa durante 1 segundo
Se o erro () = 'ficheiro j estar fechado' CICLO
! e tente novamente
FIM
LOCK (FileB, 1) ! BLOQUEIO Tentativa durante 1 segundo
Se o erro () = 'ficheiro j LOCKED' DESBLOQUEAR (FileA)
! Desbloqueie o arquivo bloqueado
CICLO ! e tente novamente
final
break ! Quebre de loop quando ambos bloqueado
FIM
Este cdigo ir eventualmente bloquear a arquivos. Se FileA j est bloqueado por outro usurio, o loop vai tentar novamente. A nica
pausa segunda permite que o outro usurio a chance de completar a sua aco. Se o primeiro bloqueio for bem sucedida, a fechadura
da FileB tentada. Se FileB j est bloqueado por outro usurio, FileA imediatamente desbloqueado para uso de outro usurio, em
seguida, re-experimentar seqncia ocorre novamente. A ruptura com o LOOP neste exemplo s permitido depois que ambos os
ficheiros so bloqueados com sucesso. Misturando o uso de espera e bloqueio pode resultar na segunda forma de abrao mortal. Em
alguns sistemas de arquivos, BLOQUEIO e mantenha so completamente independentes, portanto, possvel para um usurio para
realizar um registro em um arquivo, e outro usurio bloqueio que mesmo arquivo. O usurio com o poro no pode escrever o recorde
de volta, ou mesmo liber-lo,
Esta situao pode ser resolvida em uma de duas maneiras:
Voc pode optar por nunca misture segurar e LOCK no mesmo arquivo. Isso limita-lo para o uso de conter apenas (a soluo mais
comum), ou bloquear apenas. Esta soluo deve ser utilizado em todas as aplicaes que escrevem a um conjunto comum de
arquivos.
Voc pode optar por sempre armadilha para registros mantidos enquanto o arquivo est bloqueado. Isto implica que voc sabe
como voc deseja lidar com o registro de mortal abrao quando detectado.
A primeira soluo , de longe, o mais vulgarmente utilizado. A segunda leva voc para uma rea de programao que
provavelmente melhor servido por Transaction Processing, que incluiria realizar interceptao de registro.
Uma nota final: Alguns motoristas de arquivos podem realizar bloqueios exclusivos internamente em operaes de atualizao e STREAM. O uso
de uma declarao ao vivo no est a salvo de impasse em mltiplos arquivos para operaes de gravao. Voc deve usar LOGOUT vez de
BLOQUEIO nestas situaes.
Resumo
Um arquivo deve ser aberto antes de seus registros podem ser acessados.
O modo de acesso determina o tipo de acesso DOS concede ao usurio abrir o arquivo e quaisquer outros usurios.
programao multi-usurio deve sempre levar em considerao a possibilidade de vrios usurios acessando o
mesmo registro ao mesmo tempo.
verificao de simultaneidade feito para garantir que as atualizaes do usurio no substituir as alteraes do outro usurio para os
registros.
ESPERA mais comumente usado em conjunto com a simultaneidade verificao para garantir que nenhum outro usurio pode
alterar o registro enquanto ele est sendo comparado para as mudanas anteriores.
BLOQUEIO mais comumente usado para obter o controle exclusivo de um arquivo enquanto voc criar um ndice.
O abrao mortal uma considerao de programao mais facilmente tratadas atravs da adopo de convenes
programa de codificao consistentes.
Desenvolvendo aplicaes cliente / servidor 87
7 - Desenvolvimento de aplicaes cliente / servidor
Introduo ao Cliente / Servidor
Cliente / Servidor Definido
O que constitui exatamente a computao cliente / servidor? Para alguns, ele indica o uso de groupware (programas como o Lotus
Notes), ou Object Linking and Embedding (OLE) entre o cliente OLE e aplicativos de servidor OLE, ou apenas qualquer programa
que divide a concluso de tarefas entre estaes de trabalho cliente e servidores de rede. H tambm muitos buzzwords que vo
junto com o assunto, como downsizing e rightsizing.
Em seu nvel mais bsico, a definio mais ampla da computao cliente / servidor se resume a isto: um computador estao de
trabalho cliente envia uma mensagem (solicitando algum tipo de servio) atravs de uma rede de algum tipo a um computador
servidor, que processa a solicitao de servio e responde com uma mensagem de retorno (retornando dados solicitados) ou uma
confirmao. No importa a forma que toma, o propsito ltimo da computao cliente / servidor fazer com que o uso mais eficiente
dos recursos computacionais disponveis, numa base de toda a empresa.
Clarion otimizado para criar aplicaes de banco de dados de negcios. Isto significa que o tipo mais comum de aplicaes cliente / servidor
criados com o Clarion o tipo onde o programa executado em uma estao de trabalho cliente e acessa um motor de servidor de banco de
dados (frequentemente baseadas em SQL) localizado em um servidor de banco de dados na rede.
Portanto, para os fins desta discusso, a definio de computao cliente / servidor que vamos usar esta: as aplicaes de banco
de dados que criam que, logicamente particionar a carga de trabalho entre as estaes de trabalho cliente eo motor de banco de
dados baseado em servidor para que a mxima eficincia de desempenho mantido durante todo a rede.
Tipos de aplicaes de banco de dados cliente / servidor
Existem duas grandes categorias de aplicaes de banco de dados cliente / servidor: On Line Transaction Processing (OLTP),
e Sistemas de Apoio Deciso (DSS).
On Line Transaction Processing (OLTP)

aplicaes OLTP so construdos para manter e atualizar o banco de dados em tempo real, continuamente. Isto significa que as aplicaes
OLTP exigem alto desempenho tanto do hardware e software para que os usurios no so mantidos espera de qualquer informao
solicitada por mais de alguns poucos segundos.
Sistemas de Apoio Deciso (DSS)
aplicaes DSS so normalmente utilizados pela administrao de uma empresa para armazenado ou consultas ad hoc para monitorar o
estado da empresa. Isto significa geralmente que os dados no precisa ser to at o minuto e tempos de resposta no so to crtica.
Frequentemente, as aplicaes DSS so construdos para acessar dados de arquivo on-line ou a replicao do banco de dados que
atualizado somente em intervalos de tempo.
Clarion cliente / aplicativos de servidor
aplicaes de banco de dados cliente / servidor Normalmente, Clarion-criadas se enquadram na categoria On Line Transaction Processing
(OLTP), em vez dos Sistemas de Apoio Deciso (SAD) utilizados para consultas ad hoc. Seus usurios podem usar ReportWriter da
Clarion para o produto Windows para gerar relatrios padro ou ad hoc do banco de dados (assim, proporcionando-lhes funcionalidade
DSS).
Motores de banco de dados SQL
A maioria dos aplicativos cliente / servidor so front-ends rodando em uma estao de Cliente e solicitando servios de dados a partir de um
motor de banco de dados (como Oracle ou Sybase) rodando em um servidor de rede. A maioria desses bancos de dados so acessados
atravs de Structured Query Language (SQL). SQL foi originalmente desenvolvido como uma linguagem de consulta ad hoc para permitir que
os usurios para recolher informaes de um banco de dados. Ao longo dos anos, a linguagem SQL foi aprimorada para permitir o acesso
programtico aos bancos de dados, alm de seu original hoc misso consulta ad.
SQL tornou-se a ferramenta padro usada para acessar as bases de dados utilizadas no SQL computao de programtico cliente /
servidor a ferramenta mais utilizada para executar as tarefas de acesso a dados nos programas que so executados em estaes de
Cliente. No entanto, SQL no uma linguagem de programao completa (por exemplo, ele no tem capacidades de design de interface
de usurio), de modo que o SQL deve ser incorporado em uma linguagem mais programao de propsito geral (como C ++ ou
Clarion) para criar uma completa programa.
Clarion e SQL
tecnologia de driver de arquivo da Clarion permite escrever aplicativos que acessam bancos de dados SQL, sem a necessidade de escrever
qualquer SQL em tudo-o motorista arquivo Clarion para qualquer banco de dados SQL se comunica com o servidor de banco de dados back-end,
gerando automaticamente as instrues SQL que o motor de banco de dados requer a partir de seu arquivo de idioma Clarion I / o padro de
sintaxe. Uma vez que os motoristas de arquivo Clarion SQL so projetados especificamente para falar com um nico SQL banco de dados
back-end (exceto o driver ODBC, claro, que um driver de arquivo SQL genrico), o SQL gera otimizado para usar recursos especficos para
esse banco de dados back-end. Isto significa que um programador Clarion no obrigado a aprender (ou utilizao) SQL em tudo para escrever
aplicativos eficientes cliente / servidor.
O fato de que um programador Clarion no obrigado a escrever SQL no limita de modo algum a capacidade de Clarion para gerar
programas de cliente / servidor. Voc pode incorporar sua prpria instruo SQL para estender o que o motorista arquivo faz para voc, ou
voc pode assumir o controle total do banco de dados se a realizar qualquer tarefa que precisa ser feito.
Existem diversas maneiras de incorporar diretamente suas prprias instrues SQL em um programa de Clarion, se assim o desejarem. Isto
d-lhe, o programador Clarion, a flexibilidade de apenas deixar acontecer de uma forma padro (deixando driver de arquivo do Clarion lidar
com todo o SQL), ou para fazer acontecer qualquer outra maneira que voc escolher escrevendo diretamente o seu prprio SQL, conforme
adequado s exigncias de sua aplicao individual.
PROP: SQL uma propriedade de uma estrutura de arquivo ou exibio que permite enviar qualquer instruo SQL diretamente para o servidor de
banco de dados back-end. PROP: SQLFilter uma propriedade de uma estrutura VISTA que lhe permite anexar o seu prprio SQL clusula
WHERE para o SQL gerado enviado para o banco de dados back-end. Alm destes, existem tambm vrias outras propriedades disponveis que
so usados para aumentar o SQL gerado pelo driver de arquivo (alguns so de arquivos especfica do driver). Em ambos os casos, o driver de
arquivo coloca o conjunto do banco de dados back-end no buffer de registro de arquivo apropriado dados retornados, permitindo que voc use
sintaxe Clarion padro para manipular o seu valor, ou atribuir os valores de dados para outros campos.
Projeto de banco de dados e trfego de rede

O aspecto mais importante para a criao de aplicativos eficientes cliente / servidor o projeto do banco de dados. Quando projetado
corretamente, o banco de dados permite mais facilmente que voc escreva suas aplicaes de forma que o trfego de rede pode ser
minimizado. Quando o trfego de rede reduzido ao mnimo, o tempo de resposta de dados (o aspecto mais crtico de sistemas OLTP) pode
ser mantido o mais rpido possvel, mesmo quando o sistema est escalado para o nvel da empresa.
Manipulao de integridade referencial
Manter a integridade referencial (RI) de um banco de dados um elemento chave para o design de banco de dados relacional.
Integridade referencial significa que para cada relacionamento um-para-Muitos (pai-filho) entre as tabelas no banco de dados existe um
registro Pai para cada registro Criana (sem rfos registros). Para coloc-lo em termos mais formais, deve haver um valor de chave
primria vlida para cada chave estrangeira existente no banco de dados.
rfos registros pode ocorrer quando o registro pai excludo, o valor da chave primria (que fornece o link para a chave estrangeira no registro Criana) alterado. Prevenir
esses registros rfos requer que o banco de dados contm regras que estipulam que ao ocorrer quando o usurio final tenta excluir o registro pai, ou alterar o valor da chave
primria. As regras mais comuns do RI so restringir (no permitem a excluso ou mudana) e cascata (excluir os registros filho relacionados ou alterar seus valores de chave
estrangeira para coincidir com o novo valor da chave primria no registro pai). Uma regra raramente usada claro (alterar os valores de chave estrangeira para NULL quando o
registro pai for excludo ou o valor da chave primria nas mudanas registro pai). aplicao da restrio RI melhor tratada em aplicaes cliente / servidor, especificando as regras
IR no servidor de base de dados back-end, geralmente atravs da definio de gatilhos, procedimentos armazenados ou declaraes declarativa pelo RI. Ao fazer isso, o servidor
de banco de dados pode manipular automaticamente a aplicao RI sem enviar quaisquer registros filho atravs da rede para o aplicativo cliente para processamento. Por exemplo,
se a regra para Excluir cascata, o servidor de banco de dados pode simplesmente executar todas as excluses de registro filho necessrios ao excluir o registro pai do banco de
dados sem enviar nada de volta atravs da rede para o aplicativo cliente. o servidor de banco de dados pode manipular automaticamente a aplicao RI sem enviar quaisquer
registros filho atravs da rede para o aplicativo cliente para processamento. Por exemplo, se a regra para Excluir cascata, o servidor de banco de dados pode simplesmente
executar todas as excluses de registro filho necessrios ao excluir o registro pai do banco de dados sem enviar nada de volta atravs da rede para o aplicativo cliente. o servidor
de banco de dados pode manipular automaticamente a aplicao RI sem enviar quaisquer registros filho atravs da rede para o aplicativo cliente para processamento. Por exemplo,
se a regra para Excluir cascata, o servidor de banco de dados pode simplesmente executar todas as excluses de registro filho necessrios ao excluir o registro pai do banco de
dados sem enviar nada de volta atravs da rede para o aplicativo cliente.
No Clarion Dicionrio Editor, quando voc estabelecer uma relao entre dois arquivos (tabelas), voc tambm pode especificar as regras
do RI para essa relao. Como o servidor de banco de dados ser realmente lidar com a funcionalidade de RI, a forma mais adequada
para especificar as regras de RI no Clarion Dicionrio de Dados seria especificar nenhuma ao para que o cliente no faz nada.
Data de validade
validao de dados, a execuo de regras de negcio (que voc especificar) quanto ao que valores so vlidos para qualquer campo especfico no
banco de dados. regras de validao de dados tpicos impor tais coisas como: um campo no pode ser deixado vazio (em branco ou zero), ou o
valor do campo deve ser um ou zero (verdadeiro ou falso) ou dentro de um determinado intervalo numrico especificado, ou o valor do campo deve
existir como um valor de chave primria em outro arquivo (tabela).
Estas regras de validao de dados pode ser especificado no aplicativo Cliente ou no servidor de banco de dados back-end. A melhor
maneira de lidar com a implementao regras de validao de dados em seus aplicativos cliente / servidor, de modo a gerar trfego de
rede mnima, especificar as regras de negcio, tanto o aplicativo cliente e o servidor de banco de dados:
Atravs da aplicao de regras de validao de dados no aplicativo cliente voc garante que todos os dados enviados para o
back-end j vlido. Por sempre recebendo dados vlidos do servidor de banco de dados no ir gerar mensagens de erro de volta
para o aplicativo cliente. O efeito lquido disso para reduzir o trfego de rede de volta do servidor de banco de dados.
Atravs da aplicao de regras de validao de dados no servidor de banco de dados back-end que voc garantir que os dados
sempre vlida, no importa qual aplicativo usado para atualizar o banco de dados, mesmo atualizando os dados com SQL
interativa no pode corromper os dados. Portanto, voc est coberto de ambos os sentidos.
Impor estas regras em ambas as suas aplicaes Clarion e o servidor de banco de dados pode parecer um monte de trabalho. No
entanto, o Dicionrio de Dados do Editor Clarion permite que voc especifique as regras mais comuns, basta selecionar um boto de
opo no separador de validade Cheques da definio do campo afetada. Ao fazer isso, o cdigo real para executar a validao de
dados escrito para voc por modelos Gerador de Aplicao.
Clarion idioma do cliente / Suporte do Servidor

A linguagem Clarion contm uma srie de declaraes que so explicitamente projetados para suportar programao de aplicaes
cliente / servidor.
A Estrutura VISTA
A estrutura VISTA uma estrutura de dados que define automaticamente duas operaes da base de dados relacional padro: o projecto
e JOIN operaes. A viso tambm ir filtrar automaticamente e encomendar o conjunto de resultados. O servidor de banco de dados
back-end executa todas estas operaes, retornando somente o conjunto de resultados que o aplicativo cliente precisa para realizar o
seu trabalho. Embora seja realmente possvel criar uma estrutura de exibio que junta mesas de diferentes servidores de banco de
dados back-end (como Oracle e AS / 400), isso no seria uma maneira muito eficiente para escrever um aplicativo cliente / servidor
porque o JOIN (e qualquer filtragem) teria que ser processado no cliente, eliminando a vantagem de computao cliente / servidor.
Portanto, no vamos abordar esta possibilidade neste artigo.
PROJETO
A operao do projeto relacional diz ao servidor de banco de dados back-end para retornar apenas para o aplicativo cliente de um
sub-conjunto especfico de colunas em uma tabela (reduzindo assim o trfego de rede). Por exemplo, a seguinte estrutura VISTA
retornar apenas os campos especificados (colunas) do arquivo de Estudantes (tabela):
MyView VISTA (estudantes)

PROJETO (STU: Sobrenome, STU: nome, STU: Major) END Cadastre
O relacional operao de juno linhas automaticamente une relacionados de vrias tabelas em um nico conjunto de resultados que o
servidor de banco de dados de volta para o aplicativo cliente. Os padres de estrutura vista a uma juno externa esquerda, a menos que o
atributo INNER especificado na estrutura JOIN. A juno externa esquerda retorna todas as linhas externas, seja l esto relacionados linhas
internas para retornar ou no. Para os registos exteriores sem registos internos relacionados, os campos no registo interno so deixados
vazios (branco ou zero). Por exemplo a seguinte estrutura VISTA retornar todos os registros (linhas) nos estudantes arquivo (tabela), se h ou
no esto relacionados registros do arquivo Majors:

PROJECTO (STU: sobrenome, STU: nome, STU: Major) JOIN (MAJ:
KeyNumber, STU: Major)
PROJETO (MAJ: Descrio, MAJ: Number) END END
Adicionando o atributo interior para a estrutura ADERIR especifica uma juno interna que retorna apenas as linhas exteriores com filas
interiores relacionados. Por exemplo, a seguinte estrutura VISTA ir retornar apenas os registros (linhas) nos estudantes arquivo (tabela), onde
no esto relacionados registros do arquivo Majors:

PROJECTO (STU: sobrenome, STU: nome, STU: Major) JOIN (MAJ:
KeyNumber, STU: Major), INNER
PROJETO (MAJ: Descrio, MAJ: Number) END END
FILTRO
O atributo FILTER em uma viso permite especificar uma expresso condicional para filtrar os registros indesejados. Isso ir gerar uma
clusula WHERE na instruo SQL SELECT gerada. Por exemplo, o seguinte VISTA voltar arquivar registros cujo sobrenome
Taylor apenas os alunos:
MyView VISTA (estudantes), FILTER ( 'STU: LastName = '' Taylor' '')

PROJETO (STU: Sobrenome, STU: nome, STU: Major) END
ORDEM
O atributo ORDER em uma viso permite que voc especifique a ordem de classificao no conjunto de resultados retornado pelo servidor de
banco de dados. Isso ir gerar uma clusula ORDER BY na instruo SQL SELECT gerada. Por exemplo, a seguinte exibio retorna os
registros do arquivo Os alunos classificados em ordem decrescente sobrenome e ordem crescente primeiro nome:
MyView VISTA (estudantes), ordem ( '- STU: LastName, + STU: nome')

Naturalmente, todos esses atributos podem ser combinados de modo a que o conjunto de resultados retorna para o aplicativo cliente
filtrada, ordenou, projetada e juntou-se. Ao permitir que o servidor de banco de dados back-end para fazer este trabalho, o nico trfego de
rede gerado o mnimo necessrio para dar a aplicao cliente os dados solicitados.
A Demonstrao BUFFER
A declarao Clarion buffer pode ter um tremendo impacto sobre o desempenho das aplicaes cliente / servidor. BUFFER diz o motorista
arquivo para criar um buffer para armazenar anteriormente ler os registros e um buffer read-ahead para aviso antecipado de busca.
tambm especifica um perodo de tempo durante o qual os dados do buffer considerado vlido (aps o que os dados so re-lido a partir do
servidor de banco de dados de back-end).
Quando o driver de arquivo sabe que tem buffers para manter vrios registros que podem otimizar as instrues SQL que gera para o servidor de
banco de dados back-end. Isso permite que o servidor de banco de dados back-end para retornar um conjunto de registros em vez de um nico
registro de cada vez (tambm chamado de buscas de gordura). O efeito lquido desta para mudar o padro de trfego de rede a partir de muitos
pequenos pedaos de dados para menos mas maiores blocos de dados, contribuindo para uma utilizao mais eficiente da rede geral. O uso mais
comum de tampo provavelmente seria em procedimentos que permitem que o utilizador final navegar atravs da base de dados.
Atravs da criao de buffers para manter j ler os registros, a mquina cliente obtm registros do buffer local quando o usurio tiver
paginado frente, em seguida, retorna a uma pgina anterior de registros, em vez de gerar um outro pedido para o servidor de banco de
dados back-end para a mesma pgina de registros. Isso elimina o trfego de rede que normalmente seriam gerados para os pedidos
subsequentes para o mesmo conjunto de registros.
Configurando buffers de read-ahead permite que o aplicativo cliente para antecipar a solicitao do usurio para a prxima pgina de registros
e receb-los a partir do servidor de banco de dados back-end, enquanto o usurio ainda est examinando a primeira pgina. Portanto, quando
o usurio finalmente faz solicitar a pgina seguinte, os registros tambm so buscados no buffer local na mquina do cliente, dando ao usurio
final de recuperao de banco de dados aparentemente instantnea.
Por exemplo, a seguinte declarao BUFFER diz o motorista arquivo para considerar 10 registros como um nico pgina, para
amortecer 5 anteriormente ler pginas, ler 2 pginas adiante, e considerar os registros em buffer vlido por 5 minutos (300
segundos):
Tampo (MyView, 10,5,2,300)! 10 recs por pgina, 5 pginas para trs, 2 read-ahead
! Com um tempo limite 5 minutos
SQL embutido em Clarion

tecnologia de driver de arquivo da Clarion permite que o programador Clarion aprender e usar apenas a sintaxe do arquivo de entrada / sada da linguagem
Clarion, no importa qual sistema de arquivos contm os dados. O driver de arquivo converte automaticamente as instrues de linguagem Clarion em
qualquer forma o sistema de arquivos necessita para o seu cumprimento de solicitaes de dados. Portanto, para os motoristas de arquivo que interface para
servidores de banco de dados baseados em SQL, o prprio driver de arquivo gerar as instrues SQL necessrias para recuperar os dados a partir do
servidor de banco de dados.
Dada toda a informao de que o driver de arquivo podem obter a partir de declaraes de estrutura de arquivos, declaraes estrutura
vista, eo comunicado buffer, o SQL resultante gerado pelo driver de arquivo pode ser bastante eficiente. No entanto, ainda h momentos
em que um programador de SQL experiente e conhecedor vai querer estender a funcionalidade do driver de arquivo, ou assumir o controle
total para realizar uma tarefa que melhor realizado em SQL-alguma tarefa que o driver de arquivo normalmente no geram ( como a
excluso de um bloco inteiro de registros de uma vez, ou atualizar um nico campo em todas as linhas de uma tabela para um novo valor).
Para cobrir estas circunstncias, a linguagem Clarion fornece um mecanismo para permitir o envio de qualquer instruo SQL diretamente
para o servidor de banco de dados back-end: PROP: SQL.
PROP: SQL
A sintaxe de PROP: SQL o mesmo que qualquer outra declarao atribuio de propriedade linguagem Clarion, com a meta de ser o
rtulo de qualquer declarao de arquivo (ou VIEW) que usa o driver de arquivos SQL. Por exemplo:
MyFile {PROP: SQL} = 'SELECT * FROM SomeTable'
Esta declarao envia a instruo SQL SELECT especificado para o servidor de banco de dados back-end. Note-se que o alvo do
PROP: SQL MeuArquivo enquanto a declarao SQL SELECT direcionado para SomeTable. Voc pode enviar qualquer instruo
SQL para apoiar: SQL, independentemente do alvo de PROP: SQL afetado pelo SQL ou no no arquivo alvo apenas o mecanismo
pelo qual o driver de arquivo correto processa o seu SQL. Uma vez que esta instruo SQL SELECT ir retornar um conjunto de
resultados, voc deve usar a instruo Clarion NEXT para recuperar o resultado definir um recorde de cada vez, ea declarao arquivo
referenciado na instruo Next devem ter o mesmo nmero de campos como SomeTable. Obviamente, este exemplo especfico no
demonstrar o mtodo preferido de trabalhar em Clarion, uma vez que o prprio driver de arquivo ir gerar mais do que adequadamente
essas simples SQL SELECT para voc.
A verdadeira utilidade de PROP: SQL executar funes SQL que no tm corolrio direto na linguagem Clarion. Um exemplo disso
a tabela de criao (arquivo) no servidor de banco de dados. A linguagem Clarion instruo CREATE certamente permitem criar novas
tabelas no banco de dados e o driver de arquivo ir gerar um SQL apropriado instruo CREATE para executar a tarefa. No entanto, o
Clarion instruo CREATE limitado s informaes armazenadas em sua declarao FILE. muito melhor usar PROP: SQL para
enviar uma instruo SQL CREATE para o servidor de banco de dados, porque o SQL CRIAR pode ento implementar quaisquer
restries de validao de dados ou gatilhos que o servidor de banco de dados suporta, permitindo-lhe fazer pleno uso das
capacidades da servidor de banco de dados.
Por exemplo, o seguinte cdigo cria uma tabela Estudantes com Nome e Sobrenome, Major, e colunas de atribuio do dormitrio:
MyView {PROP: SQL} = 'Criar ESTUDANTES tabela' &|

'(NMERO DE IDENTIDADE INTEGER NOT NULL, ' &|
'LTIMO NOME VARCHAR (25) NOT NULL, ' &|
'PRIMEIRO NOME VARCHAR (25) NOT NULL, ' &|
'PRINCIPAL VARCHAR (10) NOT NULL, ' &|
'DORMITRIO INTEGER, ' &|
'CHAVE PRIMRIA (NMERO DE IDENTIDADE), ' &|
'FOREIGN KEY MAJORS_IN (MAJOR), ' &|
'REFERNCIAS MAIORAIS, ' &|
'ON DELETE RESTRINGIR)'
Esta instruo SQL CREATE especifica dois itens que no so possveis para especificar usando o Clarion instruo CREATE. O
atributo NO NULL especifica que os dados devem estar presentes nestas colunas sempre que um novo registo adicionado base
de dados. A clusula ON DELETE especifica que a restrio RESTRINGIR integridade referencial aplica ao excluir um registro Majors,
de modo que no h registro de estudante pode ter um valor de campo major que no existe na tabela de Majors. Outro uso primrio do
PROP: SQL chamar quaisquer procedimentos armazenados que voc criou no seu banco de dados back-end. Na maioria dos
servidores de banco de dados baseados em SQL, um procedimento armazenado um conjunto pr-compilado de instrues SQL que
permitem pr-definir aes para o motor de banco de dados a ser executada quando o procedimento chamado. Desde procedimentos
armazenados so uma parte da base de dados,
PROP: SQLFilter
PROP: SQLFilter muito semelhante ao PROP: SQL. PROP: SQLFilter permite que voc especifique uma condio de filtro para
uma estrutura VISTA usando a sintaxe SQL em vez da sintaxe Clarion exigida no atributo FILTER.
Por padro, o PROP: condio de filtro SQLFilter substitui qualquer expresso no atributo FILTER. No entanto, ao iniciar o seu
PROP: expresso SQLFilter com um sinal de adio (+), o motorista arquivo ir anexar o seu PROP: declarao SQLFilter para SQL
gerado do atributo FILTER. A vantagem de usar PROP: SQLFilter em vez do atributo FILTER permitir que a clusula WHERE para
usar os recursos especficos do banco de dados ou especficas de SQL que voc pode incluir usando seu prprio SQL (como uma
clusula IN SQL). Por exemplo, o cdigo a seguir usa uma condio de filtro para limitar a exibio apenas aos alunos com Cincia
da Computao como sua principal:
MyView VISTA (estudantes), FILTER ( 'STU: Major = '' Computer Science' '')
O cdigo a seguir substitui o filtro com PROP: SQLFilter:

PROJETO (STU: Sobrenome, STU: nome, STU: Major) CODE END
ABERTO (MyView)
MyView {PROP: SQLFilter} = 'Students.Major = '' Computer Science' ''
Ambos os exemplos retornam o mesmo definido para a sua aplicao Clarion resultado.
O cdigo a seguir usa a condio de filtro para limitar a exibio apenas aos alunos com Computer Science como sua principal, em
seguida, acrescenta uma clusula IN SQL ao gerado clusula WHERE para limitar ainda mais o conjunto de resultados apenas os
estudantes de Cincia da Computao que tambm vivem na moradia 1, 5, ou 9:
MyView VISTA (estudantes), FILTER ( 'STU: Major = '' Computer Science' '')
PROJECTO (STU: sobrenome, STU: nome, STU: Major, STU: Dormitrio) CDIGO FIM
ABERTO (MyView)
MyView {SUPORTE: SQLFilter} = '+ Students.Dormitory IN (1, 5, 9)'
Manipulao de dados NULL
Um conceito comum em servidores de banco de dados baseados em SQL o conceito de dados NULL. O conceito de um valor nulo em
um campo de um arquivo ou VISTA indica que o usurio nunca entrou dados no campo. Null na verdade significa valor desconhecido
para o campo. Isto completamente diferente de um valor em branco ou nulo, e faz com que seja possvel detectar a diferena entre um
campo que nunca teve de dados, e um campo que tem um (verdadeiro) valor em branco ou zero. A linguagem Clarion suporta dados NULL
manipulao atravs dos procedimentos NULL, SetNull e SETNONULL. Em expresses, null no igual em branco ou zero. Portanto,
qualquer expresso que compara o valor de um campo de um arquivo ou VISTA com outro valor ser sempre avaliar como desconhecido
se o campo nulo. Isto verdadeiro mesmo se o valor de ambos os elementos na expresso so valores desconhecidos (nulo). Por
exemplo a expresso condicional pre: campo1 = Pr: Campo2 avaliar como verdadeiro somente se ambos os campos contm valores
conhecidos. Se ambos os campos so nulos, o resultado da expresso tambm desconhecido.
Conhecido = Known ! Avalia como Verdadeiro ou Falso

Conhecido = Desconhecido ! Avalia como desconhecido
Desconhecido = desconhecido ! Avalia como desconhecido
Desconhecido <> 10 ! Avalia como desconhecido
1 + Desconhecido ! Avalia como desconhecido
Os nicos quatro excees a essa regra so expresses booleanas utilizando ou e E, onde apenas uma parte de toda a expresso
desconhecido e a outra poro da expresso satisfaz os critrios de expresso:
Desconhecido ou verdadeiro ! Avalia como verdadeiro

Verdadeiro ou desconhecida ! Avalia como verdadeiro
Desconhecido e falso ! Avalia como False
Falso e desconhecidas ! Avalia como False
Suporte para nulos valores em um arquivo ou VIEW totalmente dependente do driver de arquivo. A maioria dos sistemas de banco de dados com base
SQL-apoiar o conceito de campo nulo, enquanto a maioria dos bancos de dados no-SQL no.
Voc usar o procedimento NULL Clarion para detectar se um item de dados retornados do banco de dados de back-end nulo ou no. Para os campos
que devem permanecer nula quando voc re-escrever os dados para o banco de dados, voc deve chamar explicitamente SETNULL apenas antes de
escrever os dados de volta para o banco de dados. Por exemplo:
NEXT (AMinhaTabela) !Obter dados

MyFieldFlag = NULL (MyField) ! Lembre-se um campo nulo ou no
!
! Processar os dados!
IF MyFieldFlag E NO MyField! Detectar campo nulo ainda vazia

SETNULL (MyField) ! e redefini-la como nula
FIM
PUT (AMinhaTabela) ! Escrever os dados de volta
Tratamento de erros
Sempre que qualquer operao de I / O executa h a possibilidade de uma condio de erro ocorra. No importa qual o servidor de banco
de dados back-end que voc usa, o motorista arquivo Clarion desse banco de dados mapeia os erros mais comuns para os cdigos de
erro Clarion padro apropriados. No entanto, h sempre alguns erros para o qual no existe equivalente Clarion direta.
Sempre que ocorre um erro para o qual no h Clarion equivalente direto, o procedimento Clarion ERRORCODE retorna 90 eo
procedimento ERROR retorna Erro Driver File. Para determinar o erro exato retornado pelo servidor de banco de dados back-end,
neste caso, Clarion oferece a FILEERRORCODE e FileError procedimentos.
Os procedimentos FILEERRORCODE e FileError retornar valores de erro do servidor de banco de dados back-end quando a corrente
Clarion ERRORCODE 90. Isso permite que voc detectar qualquer erro o servidor de banco de dados pode emitir, em seguida, procure
na documentao do servidor de banco de dados back-end para as possveis causas e remdios para tudo o erro ocorreu.
ndice 97
ndice:
INDEX dinmica ....................................... 62 BLOQUEIO ................................................. ........ 78
Classe base .............................................. 20 BUFFER MAP ................................................. ............ 7
................................................ .... 87 MEMBRO ................................................. .... 7
Cascata................................................. .... 57 MDULO................................................. ..... 7
Clarion e SQL ........................................ 83 Herana mltipla .................................... 21
CLASSE................................................. 14, 33 mtodos de Consideraes Multiusurios ......................... 69
classe ........................................ 33 O trfego de rede ........................................... 84
CLASSE Propriedades ..................................... 33 Manipulao de dados NULL .................................. 90
Cliente / Servidor .............................................. 82 Anular a chave estrangeira ............................... 59
Composio ......................................... 22, 44 Concorrncia Programao Orientada a Objetos ................... 13
Verificao ... ........................... 70 Objetos ................................................. ...... 30
Construtores ........................................ 17, 36 criao de OLTP ................................................. ......... 82
objetos .... .................................... 34 OOP ................................................. .......... 13
declarao de dados ........................................... 6 Arquivos de abertura ............................................. 69
Validao de dados .......................................... 85 ORDEM................................................. ..... 87
Database Design ....................................... 50 Substituindo ................................................. .41
Mortal abrao ........................................ 80 PAI ................................................. ... 25
Classe derivada ......................................... 20 Polimorfismo ............................... 25, 31, 46 PARTICULAR
destruidores ................................................. 36 ............ ........................... 19, 37, 38 PROCEDIMENTO
Destruidores ................................................ 17 ................. ............................. 6
ELIMINAR ................................................. ..18 Procedimento Sobrecarga .............................. 25
DSS ................................................. .......... 82 programa................................................. ....... 6
SQL embutido ......................................... 88 PROJETO ................................................. .86
Encapsulamento ...................................... 14, Manuseamento PROP: SQL ........................................... 84, 88 PROP :
31 erro ...... ..................................... 91 SQLFilter ........................................ 89
Campo Qualificao Sintaxe .......................... 16 PROTEGIDO ................................ 23, 37, 39 Pblico ...........
Arquivo Mtodos de acesso ................................. 62 .............................................. 37
Relaes de arquivo ...................................... 52 Random Access Arquivo .................................. 66
FileError .............................................. 91 variveis de referncia .................................... 35
FILEERRORCODE .................................... 91 Integridade Referencial .............................. 55, 84 Relational
FILTER ................................................. ..... 86 Database Design ............ .......... 50
Chave estrangeira ............................................... 51 LANAMENTO ................................................. .75
AGUARDE................................................. ........ 75 SUBSTITUIR ................................................. .43
NDICE................................................. ....... 62 Restringir................................................. ...... 56
herana ................................................. 39 AUTO ................................................. ......... 17
Herana........................................... 20, 31 de instanciao Sequential File Access .............................. 63
.............................................. .15 DESBLOQUEAR ................................................. ... 78
CHAVE................................................. ........... 62 Variveis ................................................. ..... 6
ligao tardia ................................................ 32 VISO................................................. ......... 85
Ligao tardia ............................................... 28 Mtodos virtuais .................................... 26, 46
Mtodos derivados local ........................ 29, 48

06 - ClarionLanguageProgramming - En.pt

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

06 - ClarionLanguageProgramming - En.pt

Încărcat de

Drepturi de autor:

Formate disponibile

2 Guia de Programao Clarion Lngua

COPYRIGHT 1994-2003 SoftVelocity Incorporated. Todos os direitos reservados.

Reconhecimentos de marca registrada:

SoftVelocity marca registrada da SoftVelocity Incorporated. clarim

Impresso nos Estados Unidos da Amrica (0703)

2 - facilitando em OOP ............................................. ............................................. 15

3 - Programao Orientada a Objetos (OOP) .......................................... .............. 33

Construtores e destruidores ............................................... .................................................. 39

4 - Database Design .............................................. ........................................... 53

5 - Processamento de Arquivo de Dados ............................................. ...................................... 65

Processamento de Arquivo de Dados ............................................... .................................................. .............. 65

6 - Consideraes Multiusurios ............................................ ............................. 73

7 - Desenvolvimento de aplicaes cliente / servidor ........................................... .......... 87

Introduo ao Cliente / Servidor ............................................. ............................... 87

A Demonstrao BUFFER ............................................... .................................................. ........ 92

ndice:................................................ .................................................. ............... 97

Declaraes dados locais Stack-Based

Por exemplo, um arquivo de cdigo-fonte chamado MYPROG.CLW contm o seguinte cdigo:

PROGRAMA ! Comece seo global declarao de dados

MAPA ! A estrutura mapa global

CDIGO ! Comece cdigo executvel do programa

PROCEDIMENTO Proc1 ! Comece seo de declarao de dados local

MEMBRO ( 'myprog') ! Mdulo de membro do Programa em MYPROG.CLW

PROCEDIMENTO proc2 ! Comece seo de declarao de dados local

Usando o exemplo anterior, um arquivo chamado MYPROG.CLW contm o seguinte cdigo:

PROGRAMA ! Comece seo global declarao de dados

MAPA ! A estrutura mapa global

CDIGO ! Comece cdigo executvel do programa

O segundo arquivo de cdigo fonte, MYPROG2.CLW, agora contm o seguinte cdigo:

MEMBRO ( 'myprog') ! O incio dos dados de um mdulo MEMBRO! Seo de

PROCEDIMENTO Proc1 ! Comece seo de declarao de dados local

PROCEDIMENTO proc2 ! Comece seo de declarao de dados local

Mdulos nos Estados MAPs

PROGRAMA ! Comece seo global declarao de dados

O segundo arquivo de cdigo fonte, MYPROG2.CLW, agora contm o seguinte cdigo:

MEMBRO ( 'myprog') ! O incio dos dados de um mdulo MEMBRO! seo de

PROCEDIMENTO Proc1 ! Comece seo de declarao de dados local

Um arquivo de cdigo terceira fonte, MYPROG3.CLW, contm o seguinte cdigo:

MEMBRO ( 'myprog') ! O incio dos dados de um mdulo MEMBRO! seo de

FIM ! MAP End

PROCEDIMENTO proc2 ! Comece seo de declarao de dados local

Usando o exemplo anterior, um arquivo chamado MYPROG.CLW contm o seguinte cdigo:

PROCEDIMENTO Proc1 ! Comece seo de declarao de dados local

MAPA ! A estrutura mapa local

ProcLocalVariable LONGO ! Uma declarao varivel local

CDIGO ! Comece cdigo executvel procedimento

PROCEDIMENTO proc2 ! Definio de procedimento local! deve seguir o procedimento,

LocalVariable LONGO ! Uma declarao varivel local

Um procedimento pode conter rotinas que optimizam cdigo fonte repetitivo.

A declarao MEMBRO aponta de volta para o arquivo fonte do programa.

Processual Cdigo Re-Visitou

fazer as variveis globais,

ou mov-los para a seo de dados de um mdulo.

Minha classe CLASSE

PROGRAMA ! Global Data e Cdigo

MEMBRO ( 'MyApp') ! Mdulo de Dados

Minha classe CLASSE ! Declare um objeto e

! ClassB deve ser explicitamente instanciado! e destrudo em

PROCEDIMENTO umaProc ! Dados Locais e Cdigo

O incio da resposta est na sintaxe Campo Qualificao da Clarion.

Campo Qualificao Sintaxe

Fred Empregado ! Declare instncias de objetos

Fred.Pay = Fred.Work (Fred.Hours) ! Cdigo fora do objeto Fred