Handler für Wertänderungen von Domäneneigenschaften

In einer domänenspezifischen Sprache Visual Studio wenn sich der Wert einer Domäneneigenschaft ändert, werden die OnValueChanging() und OnValueChanged()-Methoden im Domäneneigenschaften Ereignishandler aufgerufen.Um die Änderungen zu reagieren, können Sie diese Methode überschreiben.

Die Eigenschaft-Handler Methoden überschreiben

Die Domäneneigenschaft einer domänenspezifischen Sprache wird durch eine Klasse behandelt, die innerhalb seiner Klasse der übergeordneten Domäne geschachtelt ist.Sein Name wird auf dem nac PropertyNameFormat PropertyHandler.Sie können diese Eigenschafthandlerklasse in der Datei Dsl\Generated Code\DomainClasses.csüberprüfen.In der OnValueChanging()-Klasse wird unmittelbar vor den Wertewandeln aufgerufen, und OnValueChanged() wird direkt nach der Wertewandeln aufgerufen.

Angenommen, Sie haben eine Domänenklasse Kommentar , die eine Zeichenfolge domäneneigenschaft verfügt, die Text und eine ganzzahlige Eigenschaft benannte TextLengthCountbenannt ist.Um TextLengthCount immer dass die Länge der Zeichenfolge enthalten soll, können Sie den folgenden Code in einer separaten Datei im Dsl-Projekt schreiben:

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

Beachten Sie die folgenden Punkte bezüglich Eigenschaft Klassenhandler:

• Der Handler Eigenschaften, Methoden, wenn der Benutzer Änderungen in einer Domäneneigenschaft vornimmt, und wenn Programmcode aufgerufen werden, einen anderen Wert für die Eigenschaft zugewiesen wird.

• Die Methoden werden aufgerufen, wenn der Wert tatsächlich ändert.Der Handler wird nicht aufgerufen, wenn Programmcode einen Wert zuweist, der gleich dem aktuellen Wert ist.

• Berechnete und benutzerdefinierte Speicher und OnValueChanged Methoden verfügen nicht domäneneigenschaften OnValueChanging.

• Ändern Sie können einen Klassenhandler nicht verwenden, um den neuen Wert zu ändern.In diesem Fall möchten, z. B. um den Wert zu einem bestimmten Gültigkeitsbereich beschränken, ChangeRuledefinieren.

• Sie können einen Klassenhandler ändern keiner Eigenschaft hinzufügen, die eine Rolle einer Beziehung darstellt.Stattdessen definieren Sie AddRule und DeleteRule , der für die Beziehungsklasse.Diese Regeln werden ausgelöst, wenn die Links erstellt oder geändert werden.Weitere Informationen finden Sie unter Regeln propagieren Änderungen im Modell .

Änderungen in und aus dem Speicher

Klassenhandler Eigenschaft Methoden werden innerhalb der Transaktion aufgerufen, die die Änderung initiiert hat.Daher können Sie weitere Änderungen im Speicher vornehmen, ohne dass eine neue Transaktion zu öffnen.Die Änderungen können weitere Handler aufgerufen wird.

Wenn eine Transaktion rückgängig gemacht bzw. wiederholt Zurücksetzen wird, sollten Sie Änderungen im Speicher, d. h. Änderungen an Modellelemente, an den Beziehungen an den Forms an den Konnektor diagrammen oder ihre Eigenschaften nicht vornehmen.

Darüber hinaus müssen Sie normalerweise keine Werte aktualisieren, wenn das Modell aus der Datei geladen wird.

Änderungen am Modell sollten daher bei einem Test so abgesichert werden:

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

Im Gegensatz dazu wenn der Eigenschaft außerhalb des Speichers für Änderungen an einer Datei, z. B. Datenbank- oder Variablen Speicher nicht weitergegeben, sollten Sie immer diese Änderungen vornehmen, damit die externen Werte aktualisiert werden, wenn die Benutzer rückgängig machen oder wiederholen aufruft.

Eine Änderung abbrechen

Wenn Sie eine Änderung verhindern möchten, können Sie die aktuelle Transaktion zurücksetzen.Beispielsweise sollten Sie sicherstellen, dass eine Eigenschaft innerhalb eines bestimmten Bereichs bleibt.

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

Alternative Verfahren: Berechnete Eigenschaften

Im vorherigen Beispiel wird gezeigt, wie OnValueChanged() verwendet werden kann, um Werte aus einer Domäneneigenschaft auf einen anderen weitergeben.Jede Eigenschaft verfügt über einen eigenen gespeicherten Wert.

Stattdessen könnten Sie die abgeleitete Eigenschaft als berechnete Eigenschaft definieren können.In diesem Fall gibt die Eigenschaft keinen Speicher und verfügt über eigene Funktion definiert, wird ausgewertet, sobald sein Wert erforderlich ist.Weitere Informationen finden Sie unter Berechnete und benutzerdefinierte Speichereigenschaften.

Anstelle des vorherigen Beispiels können Sie das Art Feld aus TextLengthCount festlegen, um Berechnet in der DSL-Definition sein.Sie können angeben, Abrufen-Methode verfügen für diese Domäneneigenschaft.Die Abrufen-Methode gibt die aktuelle Länge der Zeichenfolge zurückgeben.

Es ist ein möglicher Nachteil von berechneten Eigenschaften, dass der Ausdruck jedes Mal ausgewertet wird, wird der Wert verwendet, der möglicherweise ein Problem Klasse dargestellten Leistung.Außerdem gibt es kein OnValueChanging() und OnValueChanged() für eine berechnete Eigenschaft.

Alternative Verfahren: Änderungs-Regeln

Wenn Sie ein ChangeRule definieren, wird er am Ende einer Transaktion ausgeführt, in der die Änderung des Werts einer Eigenschaft.Weitere Informationen finden Sie unter Regeln propagieren Änderungen im Modell .

Wenn innerhalb einer Transaktion mehrere Änderungen vorgenommen werden, wird der ChangeRule aus, wenn sie alle abgeschlossen wurden.Im Gegensatz dazu das OnValue…Methoden werden ausgeführt, wenn einige Änderungen nicht ausgeführt wurden.Je nachdem, was Sie erzielen möchten, machen dieses möglicherweise ein ChangeRule mehr erforderlich.

Sie können ein ChangeRule auch verwenden, um den neuen Wert der Eigenschaft so anpassen, dass sie innerhalb eines bestimmten Bereichs zu halten.

Vorsicht
Wenn eine Regel Änderungen im Speicher Inhalt vornimmt, werden andere Regel- und Klassenhandler gestartet werden.Wenn eine Regel die Eigenschaft geändert wird, die ausgelöst wurde, wird sie erneut aufgerufen.Sie müssen sicherstellen, dass die Definitionen der Regel nicht das endlose Auslösung bewirken.

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

Beispiel

Beschreibung

Im folgenden Beispiel wird die Eigenschaft für eine Domäneneigenschaft und benachrichtigt den Benutzer, wenn eine Eigenschaft für die ExampleElement Domänenklasse geändert hat.

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

Siehe auch

Referenz

OnValueChanged

OnValueChanging