Gestionnaire de modification de la valeur de propriété du domaine

Dans un langage spécifique au domaine de Visual Studio , lorsque la valeur d'une propriété de domaine change, les méthodes d' OnValueChanging() et d' OnValueChanged() sont appelées dans le gestionnaire de propriété de domaine.pour répondre à la modification, vous pouvez substituer ces méthodes.

Substituer les méthodes du gestionnaire de propriété

Chaque propriété de domaine de votre langage spécifique au domaine est gérée par une classe imbriquée à l'intérieur de sa classe de domaine parent.son nom suit le format PropertyNamePropertyHandler.vous pouvez inspecter cette classe de gestionnaire de propriété dans le fichier Dsl\Generated Code\DomainClasses.cs.dans la classe, OnValueChanging() est appelé juste avant que la valeur change, et OnValueChanged() est appelé juste après que la valeur change.

par exemple, supposez que vous avez une classe de domaine nommée commentaire qui a une propriété de domaine de chaîne nommée texte et une propriété entière nommée TextLengthCount.Pour faire pour contenir TextLengthCount toujours la longueur de la chaîne de texte , vous pouvez écrire le code suivant dans un fichier séparé dans le projet DÉSOLÉ :

  // 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;
      }
    }
  }

Notez les points suivants à propos de les gestionnaires de propriété :

• Le gestionnaire de propriété que les méthodes sont appelées lorsque l'utilisateur effectue des modifications à une propriété de domaine, et lorsque le code du programme assigne une valeur différente à la propriété.

• Les méthodes sont appelées uniquement lorsque la valeur change réellement.Le gestionnaire n'est pas appelé si le code du programme assigne une valeur qui est égale à la valeur actuelle.

• Les propriétés de domaine calculées et personnalisées de stockage n'ont pas de méthodes d'OnValueChanged et d'OnValueChanging.

• vous ne pouvez pas utiliser un gestionnaire de modification pour modifier la nouvelle valeur.Si vous souhaitez ce faire, par exemple pour restreindre la valeur à une plage spécifique, définissent ChangeRule.

• vous ne pouvez pas ajouter un gestionnaire de modification à une propriété qui représente un rôle d'une relation.À la place, définissez AddRule et DeleteRule sur la classe de relation.Ces règles sont levées lorsque les liens sont créés ou modifiés.Pour plus d'informations, consultez Propagation de modifications dans le modèle par des règles.

Modifications en fondu dans le magasin

Les méthodes de gestionnaire de propriété sont appelées dans la transaction qui a initialisé la modification.Par conséquent, vous pouvez apporter des modifications dans le magasin sans ouvrir une nouvelle transaction.Vos modifications peuvent provoquer des appels supplémentaires de gestionnaire.

Lorsqu'une transaction sa publication est annulée, de, ou roulée, vous ne devez pas apporter de modifications dans le magasin, c. autrement dit., modifications apportées aux éléments de modèle, aux relations, pour dessiner des formes, des diagrammes de connecteurs, ou à leurs propriétés.

En outre, vous ne devez à jour généralement pas de valeurs lorsque le modèle est chargé à partir de le fichier.

Les modifications du modèle doivent être gardées par un test comme suit :

if (!store.InUndoRedoOrRollback 
         && !store. InSerializationTransaction)
{ this.TextLength = ...; // in-store changes 
}

En revanche, si votre gestionnaire de propriété propage des modifications à l'extérieur de le magasin, par exemple, dans un fichier, base de données, ou variables de la non-banque, vous devez toujours apporter modifications afin que les valeurs externes sont mises à jour lorsque l'utilisateur appelle la commande undo ou la de rétablissement.

annuler une modification

Si vous souhaitez empêcher une modification, vous pouvez restaurer la transaction en cours.Par exemple, vous pouvez garantir qu'une propriété reste dans une plage spécifique.

if (newValue > 10) 
{ store.TransactionManager.CurrentTransaction.Rollback();
  System.Windows.Forms.MessageBox.Show("Value must be less than 10");
} 

autre technique : propriétés calculées

L'exemple précédent montre comment OnValueChanged() peuvent être utilisés pour propager des valeurs d'une propriété de domaine à un autre.Chaque propriété possède sa propre valeur stockée.

À la place, vous pouvez envisager de définir la propriété dérivée en tant que propriété calculée.Dans ce cas, la propriété n'a aucun stockage de sa propre, et définit la fonction est évaluée chaque fois que sa valeur est requise.Pour plus d'informations, consultez Propriétés de stockage calculées et personnalisées.

Au lieu de l'exemple précédent, vous pouvez définir le champ de type de TextLengthCount pour être calculé dans la définition de langage spécifique à un domaine.Vous fournissez votre propre méthode d' Obtenir pour cette propriété de domaine.La méthode d' Obtenir retourne la longueur actuelle de la chaîne de texte .

Toutefois, un inconvénient potentiel des propriétés calculées est que l'expression est évaluée chaque fois que la valeur est utilisée, qui peut présenter un problème de performance.en outre, il n'y a aucun OnValueChanging() et d'OnValueChanged() sur une propriété calculée.

autre technique : règles de modification

Si vous définissez un ChangeRule, il est exécuté à la fin d'une transaction pendant laquelle une valeur de propriété change.Pour plus d'informations, consultez Propagation de modifications dans le modèle par des règles.

Si plusieurs modifications sont effectuées dans une transaction, le ChangeRule exécute lorsqu'ils sont tous complets.en revanche, l'OnValue…les méthodes sont exécutées lorsque certaines modifications n'ont pas été testés.Selon ce que vous souhaitez accomplir, cela peut rendre un ChangeRule mieux.

Vous pouvez également utiliser un ChangeRule pour ajuster la nouvelle valeur de la propriété pour la conserver dans une plage spécifique.

Attention
Si une règle effectue des modifications au contenu du magasin, d'autres gestionnaires de règles et de propriété peuvent être déclenchés.Si une règle modifie la propriété que déclenché elle, il sera appelé à nouveau.Vous devez vous assurer que vos définitions de règle n'entraînent pas le déclenchement sans fin.

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) }; 
 }
} 

Exemple

Description

L'exemple suivant remplace le gestionnaire de propriété d'une propriété de domaine et avertit l'utilisateur lorsqu'une propriété pour la classe de domaine d' ExampleElement a changé.

Code

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);
      }
    }
  }
}

Voir aussi

Référence

OnValueChanged

OnValueChanging