Ou reavaliar novamente?

Este artigo irá explicar, em ECO derivados membros. É a principal finalidade é descrever a diferença entre o ReEvaluateSubscriber e ReSubscribeSubscriber parâmetros quando você derivar membros no código.

Um dos excelentes recursos do Negrito que fizeram durante a transição em ECO é derivado membros. Derivadas Um membro é um pouco como um campo calculado sobre um conjunto de dados, exceto, é calculada apenas a primeira vez que você solicitar o seu valor e, em seguida, esse valor é cache para processamento tempo.

Tome FullName da pessoa como um exemplo. Nome completo seria calculada como

Resultado: = Título + '' + FirstName + '' + LastName;

O primeiro passo importante no sentido de criar esse tipo de ECO é um atributo para marcar o atributo derivado. É realmente possível indicar alguns "Derivation OCL" e têm o sistema ECO derivar tudo para você

title + '' firstname + + '' + LastName

mas este artigo destina-se a mostrar-lhe como lidar com situações muito mais complicadas.

Com uma típica DataSet campo calculado que pode esperar o método a ser calculado a cada vez que o valor seja solicitada. Se o objeto atual está sendo exibido como uma lista no DataGrid aa então chamando este método para cada instância a cada vez que o DataGrid repaints pode ser intensivo da CPU , Especialmente se o valor é calculado a partir de muitos outros atributos / objetos.

Na ECO o método é executado pela primeira vez, o valor é pedido, mas em seguida o resultado será automaticamente armazenada dentro do espaço ECO. Future pedidos para o valor desse derivado membro irá devolver o valor em cache em seu lugar. O potencial de poupança de CPU está aqui óbvia, especialmente com rotinas complicadas.

Um código derivado do método para que um membro tem um nome específico + parâmetro lista, ECO usa reflexão para encontrar o método. A estrutura é

função <MemberName> DeriveAndSubscribe (ReEvaluateSubscriber,
ReSubscribeSubscriber: ISubscriber): <MemberType>;

FullName ECO no nosso exemplo seria de esperar para encontrar

função FullNameDeriveAndSubscribe (ReEvaluateSubscriber,
ReSubscribeSubscriber: ISubscriber): string;

O problema aqui é esse. Se o valor do derivado membro é calculado apenas uma vez e, em seguida, em cache, o que acontece se o valor do título, FirstName, ou LastName mudanças?

O ECO-quadro tem, obviamente, não faz idéia do que fizemos para derivar o valor deste membro, nem que outros objetos / membros eram usadas para calculá-lo. ECO Para garantir que nunca retorna um valor incorreto que precisa de saber quando esse membro deverá ser recalculada. De fato, o que ele realmente precisa saber é quando esse membro devem ser marcadas como "inválida", ele costuma ser recalculados até que o seu valor for solicitado.

O ECO-quadro utiliza uma espécie de observador padrão para assistir os objetos / membros, quando um desses sejam alteradas as EcoSpace irá marcar o derivado membro inválidos (decorrentes de um membro através de "Derivation OCL" vai colocar estas inscrições automaticamente). Portanto, a nossa código agora é algo como isto

função FullNameDeriveAndSubscribe (ReEvaluateSubscriber, ReSubscribeSubscriber: ISubscriber): string;
começo
Resultado: = Título + '' + FirstName + '' + LastName;
/ / Agora vamos colocar ou "Inscrições"
Self.AsIObject (). Properties [ 'Título']. SubscribeToValue (ReEvaluateSubscriber);
Self.AsIObject (). Properties [ 'Nome']. SubscribeToValue (ReEvaluateSubscriber);
Self.AsIObject (). Properties [ 'Sobrenome']. SubscribeToValue (ReEvaluateSubscriber);
final;

O "ReEvaluateSubscriber" é um observador objeto que é passado para nós de algum lugar dentro do funcionamento interno da ECO-quadro. Tudo o que precisamos fazer é ter certeza de que ele assine a todos os objetos / membros. Quando uma dessas pessoas dependentes elementos têm seu valor alterado, o ReEvaluateSubscriber dirá o ECO-quadro que o valor de membro ou deveria ser "reavaliada" próxima vez que for solicitado.

Ou reavaliar novamente?
Isto leva-me ao último ponto. Existem duas passadas para os nossos assinantes método ", ReEvaluateSubscriber" e "ReSubscribeSubscriber", assim o que um faz o outro faz, e quando ele deve ser usado?

No exemplo anterior foi utilizado o ReEvaluateSubscriber porque só precisava saber quando os valores do Título, Nome, Apelido ou alterar. Em um exemplo mais complicado talvez seja necessário fazer algo mais complicada estruturalmente, como através de cada iteração de um pedido e PurchaseOrder a contratação de membros desses objetos relacionados vez.

Neste tipo de situação, o que acontece se for acrescentado um novo pedido? Não podemos eventualmente já se inscreveu em um objeto que ainda não tinha existido na altura em que colocou as nossas inscrições? E se um pedido for removido ou excluído?

Este é exatamente o que é para o ReSubscribeSubscriber. Este assinante deverá ser acionado quando queremos dizer "Despejo de todas as subscrições depositei última vez, vamos começar de novo". Basicamente, não são os "valores" dos elementos que constituem mudar, temos de substituir as nossas assinaturas, porque há mais / menos objetos de levar em consideração.

função OrderValueDeriveAndSubscribe (ReEvaluateSubscriber,
ReSubscribeSubscriber: ISubscriber): Decimal;
var
CurrentOrderLine: pedido;
começo
Resultado: = 0;
CurrentOrderLine para nos fazer Self.OrderLines
começo
Resultado: Resultado = + CurrentOrderLine.LineValue;
/ / Assinar o membro do actual objeto filho
CurrentOrderLine.AsIObject (). Properties [ 'LineValue']. SubscribeToValue (ReEvaluateSubscriber);

final;
/ / Finalmente, se a lista Self.OrderLines muda de forma alguma
/ / é preciso demolir todas as nossas assinaturas e começar de novo.
Self.AsIObject (). Properties [ 'OrderLines']. SubscribeToValue (ReSubscribeSubscriber);
final;

Conclusão
Esperemos que este tenha sido um opener do olho como para as habilidades de código-membros em derivados ECO. Se você não tiver feito isso já recomendaria a leitura Rolf Lampa o artigo da Dinâmica de navegação para maior desempenho, ela foi escrita por Negrito, mas os princípios são os mesmo.