Personnalisation du comportement de la commande de suppression

Article
02/19/2013

Supprimer un élément entraîne généralement des éléments associés à supprimer également.Toutes les relations se sont connectés à lui, et tous les éléments enfants sont supprimés.ce comportement est nommé propagation de suppression.Vous pouvez personnaliser la propagation de suppression, par exemple pour réorganiser les éléments associés supplémentaires sont supprimés.En écrivant du code de programme, vous pouvez effectuer la suppression la propagation dépendre de l'état du modèle.Vous pouvez également provoquer d'autres modifications en réponse à une suppression.

Cette rubrique inclut les sections suivantes :

La cible par défaut le comportement de suppression
en définissant la propagation supprimez l'option d'un rôle
substituer la fermeture de suppression - utilisez cette technique où la suppression qui entraînera la suppression des éléments voisins.
À l'aide de OnDeleting et OnDeleted - utilisez ces méthodes à l'intérieur de l'emplacement de la réponse pourrait inclure d'autres actions telles que la mise à jour une valeur ou à l'extérieur de le magasin.
règles de suppression - règles d'utilisation pour propager des mises à jour de tout type dans le magasin, où une modification peut mener à d'autres.
événements de suppression - événements du magasin d'utilisation pour propager les mises à jour à l'extérieur de le magasin, par exemple à d'autres documents de Visual Studio .
Supprimez la fusion - utilisez l'opérateur pour annuler la fusion pour annuler l'opération de fusion qui a attaché un élément enfant à son parent.

comportement par défaut de suppression

par défaut, les règles suivantes régissent la propagation de suppression :

Si un élément est supprimé, tous les éléments imbriqués sont également supprimés.Les éléments incorporés sont ces qui sont les cibles des relations d'incorporation pour lesquelles cet élément est la source.Par exemple, s'il existe une relation d'incorporation de l'album à la chanson, la présence d'un album particulier est supprimé, toutes ses chansons seront également supprimées.

En revanche, la suppression d'une chanson ne supprime pas l'album.
Par défaut, la suppression ne propage pas le long de les relations de référence.S'il existe une relation ArtistPlaysOnAlbum de référence de l'album à l'artiste, la suppression d'un album ne supprime pas artiste relatif, et suppression d'un artiste ne supprime pas album.

Toutefois, la suppression propage le long de certaines relations prédéfinies.Par exemple, lorsqu'un élément de modèle est supprimé, sa forme sur le diagramme est également supprimée.L'élément et la forme sont liées par une relation de référence d' PresentationViewsSubject .
chaque relation qui est connectée à l'élément, au rôle de source ou de cible, est supprimée.Le rôle de propriété de l'élément du rôle opposé ne contient plus l'élément supprimé.

en définissant la propagation supprimez l'option d'un rôle

Vous pouvez provoquer la suppression se propager le long d'une relation de référence, ou d'un enfant incorporé à son parent.

pour définir la propagation de suppression

Sur le diagramme de définition DÉSOLÉ, sélectionnez le rôle auquel vous souhaitez que la propagation pour supprimer.Le rôle est représenté par la ligne dans le gauche ou à droite d'une zone de relation de domaine.

Par exemple, si vous souhaitez spécifier que chaque fois qu'un album est supprimé, les artistes connexes sont également supprimés, puis sélectionnez le rôle connecté à l'artiste de classe de domaine.
Dans la fenêtre Propriétés, affectez à la propriété de suppression de propagations .
Appuyez sur F5 et vérifiez que :
- Lorsqu'une instance de cette relation est supprimée, l'élément au rôle sélectionné est également supprimé.
- Lorsqu'un élément du rôle opposé est supprimé, les instances de cette relation seront supprimées, et les éléments associés à ce rôle sont supprimés.

Vous pouvez également consulter l'option de suppression de propagations dans la fenêtre de Détails DÉSOLÉ .Sélectionnez une classe de domaine et, dans la fenêtre de détails DÉSOLÉ, ouvrez la page de comportement de suppression en cliquant sur le bouton sur le côté de la fenêtre.L'option de propagation est indiquée pour le rôle opposé de chaque relation.La colonne de supprimez le style indique si l'option de propagation est à son paramètre par défaut, mais elle n'en a pas effet séparé.

Propagation de suppression à l'aide de le code de programme

Les options dans le fichier de définition DÉSOLÉ vous avez uniquement autorisé choisir des propagations de suppression à un voisin immédiat.Pour implémenter un schéma plus complexe pour la propagation de suppression, vous pouvez écrire le code du programme.

[!REMARQUE]

Pour ajouter le code de programme à votre définition DÉSOLÉ, créez un fichier de code distinct dans les définitions partielles de projet et d'écriture d' Dsl d'augmenter les classes dans le dossier de code généré.Pour plus d'informations, consultez Écriture de code pour personnaliser un langage spécifique à un domaine.

définir une fermeture de suppression

L'opération de suppression utilise la classe YourModelDeleteClosure pour déterminer les éléments à supprimer, avec une première sélection.Il appelle ShouldVisitRelationship() et ShouldVisitRolePlayer() à plusieurs reprises, parcourir le graphique des relations.vous pouvez substituer ces méthodes.ShouldVisitRolePlayer est fourni de l'identité d'un lien et de l'élément à un des rôles du lien.Il doit retourner une des valeurs suivantes :

VisitorFilterResult.Yes- l'élément doit être supprimé et le l'doit continuer à essayer d'autres liens de l'élément.
VisitorFilterResult.DoNotCare - l'élément ne doit pas être supprimé sauf que les autres réponses de requête qu'il doit être supprimé.
VisitorFilterResult.Never - l'élément ne doit pas être supprimé, même si une autre requête répond à Yes, et le l'ne doit pas essayer d'autres liens de l'élément.

// When a musician is deleted, delete their albums with a low rating.
// Override methods in <YourDsl>DeleteClosure in DomainModel.cs
partial class MusicLibDeleteClosure
{
  public override VisitorFilterResult ShouldVisitRolePlayer
    (ElementWalker walker, ModelElement sourceElement, ElementLink elementLink, 
    DomainRoleInfo targetDomainRole, ModelElement targetRolePlayer)
  {
    ArtistAppearsInAlbum link = elementLink as ArtistAppearsInAlbum;
    if (link != null 
       && targetDomainRole.RolePlayer.Id == Album.DomainClassId)
    {
      // Count other unvisited links to the Album of this link.
      if (ArtistAppearsInAlbum.GetLinksToArtists(link.Album)
              .Where(linkAlbumArtist => 
                     linkAlbumArtist != link &&
                     !walker.Visited(linkAlbumArtist))
              .Count() == 0)
      {
        // Should delete this role player:
        return VisitorFilterResult.Yes; 
      }
      else
        // Don’t delete unless another relationship deletes it:
        return VisitorFilterResult.DoNotCare; 
    }
    else 
    {
      // Test for and respond to other relationships and roles here.

      // Not the relationship or role we’re interested in.
      return base.ShouldVisitRolePlayer(walker, sourceElement, 
             elementLink, targetDomainRole, targetRolePlayer);
    }
  }
}

La technique de fermeture garantit que l'ensemble d'éléments et de liens à supprimer est déterminé avant la suppression démarre.Le l'associe également les résultats de votre fermeture avec ceux des autres parties du modèle.

Toutefois, la technique suppose que la suppression n'affecte que ses voisins dans le graphique des relations : vous ne pouvez pas utiliser cette méthode pour supprimer un élément à une autre partie du modèle.Vous ne pouvez pas utiliser si vous souhaitez ajouter des éléments ou apporter d'autres modifications en réponse à une suppression.

À l'aide de OnDeleting et OnDeleted

vous pouvez substituer OnDeleting() ou OnDeleted() dans une classe de domaine, ou dans une relation de domaine.

OnDeleting est appelé lorsqu'un élément est sur le point d'être supprimé, mais avant que ses relations ont été déconnectées.Elle est encore de navigation vers et à partir de autres éléments, et est toujours dans store.ElementDirectory.

Si plusieurs éléments sont supprimés en même temps, OnDeleting est appelé pour tous avant d'exécuter les suppressions.

IsDeleting est true.
OnDeleted est appelé lorsque l'élément a été supprimé.Elle reste dans le tas CLR afin qu'une annulation puisse être exécutée si nécessaire, mais elle est supprimé d'autres éléments et supprimée dans store.ElementDirectory.Pour les relations, les rôles référencent toujours le rôle de lecteurs ancien.IsDeleted est true.
OnDeleting et OnDeleted sont appelés lorsque l'utilisateur appelle la commande de restauration après la création d'un élément, et lorsqu'une suppression précédemment est répétée dans la de rétablissement.Utilisation this.Store.InUndoRedoOrRollback d'éviter de mettre à jour des éléments de le magasin dans ces cas.Pour plus d'informations, consultez Comment : utiliser des transactions pour mettre à jour le modèle.

Par exemple, le code suivant supprime un album lorsque sa dernière chanson enfant est supprimée :

// Delete the parent Album when the last Song is deleted.
// Override methods in the embedding relationship between Album and Song:
partial class AlbumHasSongs
{
  protected override void OnDeleted()
  {
    base.OnDeleted();
    // Don't perform in-store actions in undo:
    if (this.Store.InUndoRedoOrRollback) return;
    // Relationship source and target still work:
    // Don't bother if source is already on its way out:
    if (!this.Album.IsDeleting && !this.Album.IsDeleted)
    {
      if (this.Album.Songs.Count == 0)
      { 
        this.Album.Delete();
} } } }

Il est souvent plus utile de déclencher de la suppression de la relation que le rôle d'élément, car cela fonctionne les deux lorsque l'élément est supprimé, et lorsque la relation elle-même est supprimée.Toutefois, pour une relation de référence, vous souhaitez peut-être propager la suppression lorsqu'un élément associé est supprimé, mais pas lorsque la relation elle-même est supprimée.Cet exemple supprime un album lorsque son dernier artiste contributeur est supprimé, mais il ne répond pas si les relations sont supprimées :

using System.Linq; ...
// Assumes a many-many reference relationship 
// between Artist and Album.  
partial class Artist
{
  protected override void OnDeleting()
  {
    base.OnDeleting();
    if (this.Store.InUndoRedoOrRollback) return;
    List<Album> toDelete = new List<Album>();
    foreach (Album album in this.Albums)
    {
      if (album.Artists.Where(artist => !artist.IsDeleting)
                        .Count() == 0)
      {
        toDelete.Add(album);
      }
    }
    foreach (Album album in toDelete)
    {
      album.Delete();
} } }

Lorsque vous effectuez Delete sur un élément, OnDeleting et OnDeleted seront appelés.Ces méthodes sont toujours inline effectué - c. autrement dit., immédiatement avant et après la suppression réelle.Si votre code supprime deux éléments ou plus, OnDeleting et OnDeleted seront appelés dans l'alternative sur tous après.

règles et événements de suppression

Comme alternative aux gestionnaires d'OnDelete, vous pouvez définir des règles de suppression les événements et de suppression.

Deleting et les règles d' Delete sont déclenchés uniquement dans une transaction, et pas dans une opération d'annulation ou de rétablissement.Vous pouvez les définir à mettre en file d'attente pour exécuter à la fin de la transaction pendant laquelle la suppression est exécutée.Suppression de règles sont toujours être exécutés avant toutes les règles supprimées présents dans la file d'attente.

Règles d'utilisation pour propager des modifications qui affectent uniquement des éléments dans le magasin, y compris des relations, des éléments de diagramme et leurs propriétés.En général, une règle de suppression est utilisée pour propager la suppression, et une règle de suppression est utilisée pour créer des éléments et des relations de remplacement.

Pour plus d'informations, consultez Propagation de modifications dans le modèle par des règles.

l'événement de magasins d'Deleted est appelé à la fin d'une transaction, et est appelé après une opération d'annulation ou de rétablissement.Il peut donc être utilisées pour propager les suppressions aux objets à l'extérieur de le magasin telle que les fichiers, les entrées de base de données ou d'autres objets dans Visual Studio.

Pour plus d'informations, consultez Propagation de modifications en dehors du modèle par des gestionnaires d'événements.

Attention
Lorsqu'un élément a été supprimé, vous pouvez accéder à ses valeurs de propriété de domaine, mais vous ne pouvez pas naviguer des liens de relation.Toutefois, si vous définissez un événement supprimé dans une relation, vous pouvez également accéder aux deux éléments qui étaient son rôle de lecteurs.Par conséquent, si vous souhaitez répondre à la suppression d'un élément de modèle mais souhaiter accéder à un élément auquel il a été lié, définissez un événement delete sur la relation au lieu de la classe du domaine de l'élément de modèle.

Lorsqu'un élément a été supprimé, vous pouvez accéder à ses valeurs de propriété de domaine, mais vous ne pouvez pas naviguer des liens de relation.Toutefois, si vous définissez un événement supprimé dans une relation, vous pouvez également accéder aux deux éléments qui étaient son rôle de lecteurs.Par conséquent, si vous souhaitez répondre à la suppression d'un élément de modèle mais souhaiter accéder à un élément auquel il a été lié, définissez un événement delete sur la relation au lieu de la classe du domaine de l'élément de modèle.

règles de suppression d'exemple

  [RuleOn(typeof(Album), FireTime = TimeToFire.TopLevelCommit)]
  internal class AlbumDeletingRule : DeletingRule
  {
    public override void ElementDeleting(ElementDeletingEventArgs e)
    {
      base.ElementDeleting(e);
      // ...perform tasks to propagate imminent deletion
    }
  }
  [RuleOn(typeof(Album), FireTime = TimeToFire.TopLevelCommit)]
  internal class AlbumDeletedRule : DeleteRule
  {
    public override void ElementDeleted(ElementDeletedEventArgs e)
    {
      base.ElementDeleted(e);
      // ...perform tasks such as creating new elements
    }
  }

  // The rule must be registered:
  public partial class MusicLibDomainModel
  {
    protected override Type[] GetCustomDomainModelTypes()
    {
      List<Type> types = new List<Type>(base.GetCustomDomainModelTypes());
      types.Add(typeof(AlbumDeletingRule));
      types.Add(typeof(AlbumDeletedRule));
      // If you add more rules, list them here. 
      return types.ToArray();
    }
  }

événement supprimé par exemple

  partial class NestedShapesSampleDocData
  {
    protected override void OnDocumentLoaded(EventArgs e)
    {
      base.OnDocumentLoaded(e);
      DomainRelationshipInfo commentRelationship = 
            this.Store.DomainDataDirectory
            .FindDomainRelationship(typeof(CommentsReferenceComponents));
     
      this.Store.EventManagerDirectory.ElementDeleted.Add(commentRelationship,
        new EventHandler<ElementDeletedEventArgs>(CommentLinkDeleted));
    }

    private void CommentLinkDeleted (object sender, ElementDeletedEventArgs e)
    {
      CommentsReferenceComponents link = e.ModelElement as CommentsReferenceComponents;
      Comment comment = link.Comment;
      Component component = link.Subject;
      if (comment.IsDeleted)
      {
        // The link was deleted because the comment was deleted.
        System.Windows.Forms.MessageBox.Show("Removed comment on " + component.Name);
      }
      else
      {
        // It was just the link that was deleted - the comment itself remains.
        System.Windows.Forms.MessageBox.Show("Removed comment link to " 
             + component.Name);
      }
    }
  }

Supprimez la fusion

L'opération qui attache un élément enfant à son parent est appelée fusion.Il se produit lorsqu'un nouvel élément ou groupe d'éléments est créé à partir de la boîte à outils, soit déplacé d'une autre partie du modèle, ou copié dans le presse-papiers.En plus de créer une relation d'incorporation entre le parent et son nouvel enfant, l'opération de fusion peut également installer des relations supplémentaires, crée des éléments auxiliaires, et les valeurs de propriété définies dans les éléments.l'opération de fusion est encapsulée dans une directive de fusion d'élément (EMD).

Un EMD encapsule également le complément annule la fusion ou l'opération d' MergeDisconnect .Si vous avez un cluster des éléments qui a été construit à l'aide d'une fusion, il est recommandé d'utiliser le associé annulent la fusion pour supprimer un élément de celui-ci, si vous souhaitez quitter les éléments restants dans un état incohérent.L'opération d'annuler la fusion utilise généralement les techniques décrites dans les sections précédentes.

Pour plus d'informations, consultez Personnalisation de la création et du mouvement des éléments.