Manipuladores de alteração de valor de propriedade de domínio
Em um Visual Studio linguagem específica de domínio, quando o valor de uma propriedade de domínio for alterada, o OnValueChanging() e OnValueChanged() métodos são invocados no manipulador de propriedade de domínio.Para responder à alteração, você pode substituir esses métodos.
Substituindo os métodos do manipulador de propriedades
Cada propriedade de domínio de sua linguagem específica de domínio é tratada por uma classe que está aninhada dentro de sua classe de domínio pai.Seu nome segue o formato PropertyNamePropertyHandler.Você pode inspecionar a essa classe de manipulador de propriedade no arquivo Dsl\Generated Code\DomainClasses.cs.Na classe, OnValueChanging() é chamado imediatamente antes do valor é alterado, e OnValueChanged() é chamado imediatamente após a alteração de valor.
Por exemplo, suponha que você tenha uma classe de domínio chamada comentário que tem uma propriedade de domínio de seqüência de caracteres denominada texto e uma propriedade de inteiro chamado TextLengthCount.Para fazer com que TextLengthCount sempre para ter o comprimento do texto seqüência de caracteres, você poderia escrever o código a seguir em um arquivo separado do projeto de Dsl:
// Domain Class "Comment":
public partial class Comment
{
// Domain Property "Text":
partial class TextPropertyHandler
{
protected override void OnValueChanging(CommentBase element, string oldValue, string newValue)
{
base.OnValueChanging(element, oldValue, newValue);
// To update values outside the Store, write code here.
// Let the transaction manager handle undo:
Store store = element.Store;
if (store.InUndoRedoOrRollback || store.InSerializationTransaction) return;
// Update values in the Store:
this.TextLengthCount = newValue.Length;
}
}
}
Observe os seguintes pontos sobre os manipuladores de propriedade:
Os métodos do manipulador de propriedade são chamados quando o usuário faz alterações em uma propriedade de domínio, e quando o código de programa atribui um valor diferente para a propriedade.
Os métodos são chamados somente quando o valor for alterado.O manipulador não é invocado se o código de programa atribui um valor que seja igual ao valor atual.
Propriedades de domínio de armazenamento personalizada e calculado não têm métodos OnValueChanged e OnValueChanging.
Você não pode usar um manipulador de alteração para modificar o novo valor.Se você desejar fazer isso, por exemplo, para restringir o valor para um determinado intervalo, definir um ChangeRule.
Você não pode adicionar um manipulador de alteração a uma propriedade que representa um papel de um relacionamento.Em vez disso, defina um AddRule e um DeleteRule na classe de relação.Essas regras são acionadas quando os links são criados ou alterados.Para obter mais informações, consulte Regras de propagam alterações dentro do modelo.
.gif "Bb126481.collapse_all(pt-br,VS.110).gif")
Alterações e saia do armazenamento
Métodos de manipulador de propriedade são chamados dentro da transação que iniciou a alteração.Portanto, você pode fazer mais alterações no armazenamento, sem abrir uma nova transação.Suas alterações podem resultar em chamadas do manipulador adicionais.
Quando uma transação está sendo desfeita, refeito, ou revertida, você não deve fazer alterações no armazenamento, ou seja, altera para elementos de modelo, relacionamentos, diagramas de conectores, formas ou suas propriedades.
Além disso, você normalmente não atualizaria valores quando o modelo está sendo carregado a partir do arquivo.
As alterações no modelo, portanto, devem ser protegidas por um teste como este:
if (!store.InUndoRedoOrRollback
&& !store. InSerializationTransaction)
{ this.TextLength = ...; // in-store changes
}
Por outro lado, se seu manipulador de propriedade propaga alterações fora do armazenamento, por exemplo, para um arquivo, banco de dados ou variáveis sem armazenamento, em seguida, você deve sempre fazer essas alterações para que os valores de externos são atualizados quando o usuário chama desfazer ou refazer.
O cancelamento de uma alteração
Se você quiser impedir que uma alteração, você pode reverter a transação atual.Por exemplo, você poderá garantir que uma propriedade permaneça em um intervalo específico.
if (newValue > 10)
{ store.TransactionManager.CurrentTransaction.Rollback();
System.Windows.Forms.MessageBox.Show("Value must be less than 10");
}
A técnica alternativa: calculado propriedades
O exemplo anterior mostra como o OnValueChanged() pode ser usado para propagar valores de propriedade de um domínio para outro.Cada propriedade tem seu próprio valor armazenado.
Em vez disso, você poderia considerar definindo a propriedade derivada como uma propriedade calculada.Nesse caso, a propriedade não tem nenhum armazenamento de si próprio e está definindo a função é avaliada sempre que seu valor é exigido.Para obter mais informações, consulte Propriedades de armazenamento de calculado e personalizadas.
Em vez do exemplo anterior, você poderia definir a tipo campo de TextLengthCount ser calculado na definição de DSL.Você deve fornecer o seu próprio obter método para essa propriedade de domínio.O obter método retornaria o comprimento atual da texto seqüência de caracteres.
No entanto, uma desvantagem em potencial das propriedades calculadas é que a expressão é avaliada toda vez que o valor é usado, o que pode representar um problema de desempenho.Além disso, não há nenhum OnValueChanging() e OnValueChanged() em uma propriedade calculada.
A técnica alternativa: regras de alteração
Se você definir um ChangeRule, ele é executado no final de uma transação em que um valor de propriedade é alterada.Para obter mais informações, consulte Regras de propagam alterações dentro do modelo.
Se várias alterações são feitas em uma transação, o ChangeRule executa quando todas forem concluídas.Por outro lado, o OnValue...métodos são executados quando algumas das alterações não foram executadas.Dependendo do que você deseja atingir, isso pode fazer uma ChangeRule mais apropriado.
Você também pode usar um ChangeRule para ajustar o valor da propriedade novo para mantê-lo em um intervalo específico.
.gif "Observação de cuidado") Cuidado |
|---|
Se uma regra faz alterações no conteúdo do armazenamento, outras regras e manipuladores de propriedade podem ser acionados.Se uma regra altera a propriedade que disparou a ele, ele será chamado novamente.Você deve certificar-se de que suas definições de regra não resultam em interminável de disparo. |
using Microsoft.VisualStudio.Modeling;
...
// Change rule on the domain class Comment:
[RuleOn(typeof(Comment), FireTime = TimeToFire.TopLevelCommit)]
class MyCommentTrimRule : ChangeRule
{
public override void
ElementPropertyChanged(ElementPropertyChangedEventArgs e)
{
base.ElementPropertyChanged(e);
Comment comment = e.ModelElement as Comment;
if (comment.Text.StartsWith(" ") || comment.Text.EndsWith(" "))
comment.Text = comment.Text.Trim();
// If changed, rule will trigger again.
}
}
// Register the rule:
public partial class MyDomainModel
{
protected override Type[] GetCustomDomainModelTypes()
{ return new Type[] { typeof(MyCommentTrimRule) };
}
}
Exemplo
Descrição
O exemplo a seguir substitui o manipulador de propriedades de uma propriedade de domínio e notifica o usuário quando uma propriedade para o ExampleElement a classe de domínio foi alterado.
Código
using DslModeling = global::Microsoft.VisualStudio.Modeling;
using DslDesign = global::Microsoft.VisualStudio.Modeling.Design;
namespace msft.FieldChangeSample
{
public partial class ExampleElement
{
internal sealed partial class NamePropertyHandler
{
protected override void OnValueChanged(ExampleElement element,
string oldValue, string newValue)
{
if (!this.Store.InUndoRedoOrRollback)
{
// make in-store changes here...
}
// This part is called even in undo:
System.Windows.Forms.MessageBox.Show("Value Has Changed");
base.OnValueChanged(element, oldValue, newValue);
}
}
}
}