Udostępnij za pośrednictwem

Dostosowywanie zachowania kopii

  • Artykuł

W języku specyficzne dla domeny (DSL) utworzone za pomocą Visual Studio wizualizacji i modelowania SDK można zmieniać, co się dzieje, gdy użytkownik kopiuje i wkleja elementów.

Standard Kopiuj i Wklej zachowanie

Aby włączyć funkcję kopiowania, ustaw Włączyć kopiowanie, wklejanie właściwość edytora węzeł w Eksploratorze DSL.

Domyślnie gdy użytkownik kopiuje elementy do Schowka, następujące elementy są również kopiowane:

  • Osadzone obiekty podrzędne wybranych elementów.(To znaczy elementy, które są cele osadzania relacje, które są zatrudniani na kopiowane elementy).

  • Łącza relacji między skopiowanych elementów.

Ta reguła dotyczy rekursywnie skopiowane elementy i łącza.

Skopiowane i wklejone elementy

Skopiowane elementy i łącza są szeregowane i przechowywane w ElementGroupPrototype (EPZ), która jest umieszczana w Schowku.

Obraz skopiowanych elementów jest także umieszczana w Schowku.Dzięki temu użytkownik wkleić do innych aplikacji, takich jak Word.

Użytkownika można wkleić skopiowane elementy do obiektu docelowego, który może akceptować elementy zgodnie z definicją DSL.Na przykład w DSL generowane na podstawie szablonu roztwór składników, użytkownika można wkleić portów na składniki, ale nie na diagram; i wkleić składników na diagram, ale nie na innych składników.

Dostosowywanie Kopiuj i Wklej zachowanie

Aby uzyskać więcej informacji na temat dostosowywania modelu przy użyciu kodu programu, zobacz Przeglądanie i aktualizowanie modelu w kod programu.

  • Włączanie lub wyłączanie Kopiuj, Wytnij i Wklej.
    W Eksploratorze DSL, ustaw Włączyć kopiowanie, wklejanie właściwość edytora węzła.

  • Skopiuj łącza do tej samej lokalizacji docelowej. Na przykład pole komentarza skopiowane związanych tego samego elementu tematu.
    Ustaw Propaguje kopii właściwości roli do propagowanie kopii połączyć tylko.Aby uzyskać więcej informacji, zobacz Dostosowywanie zachowania Kopiuj łącze.

  • Kopiowanie połączonych elementów. Na przykład podczas kopiowania nowego elementu kopie wszelkich komentarz połączonych pól są wprowadzane także.
    Ustaw Propaguje kopii właściwości roli do propagowanie kopię do łącza i naprzeciwko player rolę.Aby uzyskać więcej informacji, zobacz Dostosowywanie zachowania Kopiuj łącze.

  • Szybko zduplikowane elementy, kopiując i wklejając. Zwykle jest wciąż zaznaczony element, który właśnie skopiowane i nie można wkleić ten sam typ elementu, na niego.
    Należy dodać dyrektywę z scalić Element klasy domeny i ustawić ją do przodu scalenia klasy nadrzędnej.Będzie to miało ten sam efekt operacji przeciągania.Aby uzyskać więcej informacji, zobacz Dostosowywanie tworzenia elementu i przepływu.

    - lub -

    Wybierz diagram przed wklejeniem elementy, poprzez zastąpienie ClipboardCommandSet.ProcessOnPasteCommand().Dodaj ten kod w niestandardowy plik w programie project DslPackage:

    namespace Company.MyDsl {
using System.Linq;
using Microsoft.VisualStudio.Modeling.Diagrams; 
using Microsoft.VisualStudio.Modeling.Shell;
partial class MyDslClipboardCommandSet
{
  protected override void ProcessOnMenuPasteCommand()
  {
 // Deselect the current selection after copying:
 Diagram diagram = (this.CurrentModelingDocView as SingleDiagramDocView).Diagram;
    this.CurrentModelingDocView
     .SelectObjects(1, new object[] { diagram }, 0);
  }
} }

  • Utwórz dodatkowe łącza, gdy użytkownik wkleja do wybranego obiektu docelowego. Na przykład gdy pole komentarza jest wklejane na element, łącze jest dokonane między nimi.
    Należy dodać dyrektywę korespondencji seryjnej Element klasy docelowej domeny i ustawić ją przetworzyć korespondencji seryjnej przez dodawanie łączy.Będzie to miało ten sam efekt operacji przeciągania.Aby uzyskać więcej informacji, zobacz Dostosowywanie tworzenia elementu i przepływu.

    - lub -

    Zastąpić ClipboardCommandSet.ProcessOnPasteCommand() , aby utworzyć dodatkowe łącza po wywołaniu metody podstawowej.

  • Dostosowywanie formatów, które można kopiować elementy do aplikacji zewnętrznych – na przykład, aby dodać obramowanie w postaci mapy bitowej.
    Zastąpić MyDslClipboardCommandSet.ProcessOnMenuCopyCommand() w programie project DslPackage.

  • Dostosowywanie, jak elementy są kopiowane do Schowka, za pomocą polecenia Kopiuj, ale nie w operacji przeciągania.
    Zastąpić MyDslClipboardCommandSet.CopyModelElementsIntoElementGroupPrototype() w programie project DslPackage.

  • Zachowaj układ kształtu przy użyciu polecenia Kopiuj i Wklej.
    Gdy użytkownik kopiuje wiele kształtów, można zachować ich pozycji względem siebie, gdy są one wklejane.Jest to zademonstrowane w przykładzie w VMSDK: Przykładowe diagramy.

    Do osiągnięcia tego efektu, należy dodać kształty i łączniki do ElementGroupPrototype skopiowane.Najbardziej wygodną metodę, aby zastąpić to ElementOperations.CreateElementGroupPrototype().Aby to zrobić, Dodaj następujący kod do projektu Dsl:

    public class MyElementOperations : DesignSurfaceElementOperations
{
  // Create an EGP to add to the clipboard.
  // Called when the elements to be copied have been
  // collected into an ElementGroup.
 protected override ElementGroupPrototype CreateElementGroupPrototype(ElementGroup elementGroup, ICollection<ModelElement> elements, ClosureType closureType)
  {
 // Add the shapes and connectors:
 // Get the elements already in the group:
    ModelElement[] mels = elementGroup.ModelElements
        .Concat(elementGroup.ElementLinks) // Omit if the paste target is not the diagram.
        .ToArray();
 // Get their shapes:
    IEnumerable<PresentationElement> shapes = 
       mels.SelectMany(mel => 
            PresentationViewsSubject.GetPresentation(mel));
    elementGroup.AddRange(shapes);

 return base.CreateElementGroupPrototype
           (elementGroup, elements, closureType);
  }

 public MyElementOperations(IServiceProvider serviceProvider, ElementOps1Diagram diagram)
      : base(serviceProvider, diagram)
  { }
}

// Replace the standard ElementOperations
// singleton with your own:
partial class MyDslDiagram // EDIT NAME
{
 /// <summary>
 /// Singleton ElementOperations attached to this diagram.
 /// </summary>
 public override DesignSurfaceElementOperations ElementOperations
  {
 get
    {
 if (singleton == null)
      {
        singleton = new MyElementOperations(this.Store as IServiceProvider, this);
      }
 return singleton;
    }
  }
 private MyElementOperations singleton = null;
}

  • Wklejanie kształtów w wybranej lokalizacji, takie jak aktualnej pozycji kursora.
    Gdy użytkownik kopiuje wiele kształtów, można zachować ich pozycji względem siebie, gdy są one wklejane.Jest to zademonstrowane w przykładzie w VMSDK: Przykładowe diagramy.

    Aby uzyskać ten efekt, należy zastąpić ClipboardCommandSet.ProcessOnMenuPasteCommand() do korzystania z wersji konkretnej lokalizacji, z ElementOperations.Merge().Aby to zrobić, Dodaj następujący kod w programie project DslPackage:

    
partial class MyDslClipboardCommandSet // EDIT NAME
{
   /// <summary>
    /// This method assumes we only want to paste things onto the diagram
    /// - not onto anything contained in the diagram.
    /// The base method pastes in a free space on the diagram.
    /// But if the menu was used to invoke paste, we want to paste in the cursor position.
    /// </summary>
    protected override void ProcessOnMenuPasteCommand()
    {

  NestedShapesSampleDocView docView = this.CurrentModelingDocView as NestedShapesSampleDocView;

      // Retrieve data from clipboard:
      System.Windows.Forms.IDataObject data = System.Windows.Forms.Clipboard.GetDataObject();

      Diagram diagram = docView.CurrentDiagram;
      if (diagram == null) return;

      if (!docView.IsContextMenuShowing)
      {
        // User hit CTRL+V - just use base method.

        // Deselect anything that's selected, otherwise
        // pasted item will be incompatible:
        if (!this.IsDiagramSelected())
        {
          docView.SelectObjects(1, new object[] { diagram }, 0);
        }

        // Paste into a convenient spare space on diagram:
    base.ProcessOnMenuPasteCommand();
      }
      else
      {
        // User right-clicked - paste at mouse position.

        // Utility class:
        DesignSurfaceElementOperations op = diagram.ElementOperations;

        ShapeElement pasteTarget = diagram;

        // Check whether what's in the paste buffer is acceptable on the target.
        if (pasteTarget != null && op.CanMerge(pasteTarget, data))
        {

        // Although op.Merge would be a no-op if CanMerge failed, we check CanMerge first
          // so that we don't create an empty transaction (after which Undo would be no-op).
          using (Transaction t = diagram.Store.TransactionManager.BeginTransaction("paste"))
          {
            PointD place = docView.ContextMenuMousePosition;
            op.Merge(pasteTarget, data, PointD.ToPointF(place));
            t.Commit();
          }
        }
      }
    }
  }

  • Umożliwia użytkownikowi przeciąganie i upuszczanie elementów.
    See Jak: Dodawanie obsługi przeciągania i upuszczania.

Dostosowywanie zachowania Kopiuj łącze

Gdy użytkownik kopiuje element, standardowe zachowanie jest wszelkie elementy osadzone są również kopiowane.Można modyfikować standardowy, kopiowanie zachowanie.W definicji DSL, wybierz rolę, po jednej stronie relacji i zestawu właściwości okna Propaguje kopii wartości.

Propaguje właściwości kopii roli domeny

Istnieją trzy wartości:

  • Nie propagować kopii

  • Propagowanie kopii połączyć tylko - po wklejeniu grupy nową kopię tego łącza będzie odnosić się do istniejącego elementu na drugim końcu łącza.

  • Propagowanie kopii połączyć i naprzeciwko player roli - skopiowane grupy zawiera kopię elementu na drugim końcu łącza.

Efekt kopiowania z PropagateCopyToLinkOnly

Wprowadzone zmiany wpływają zarówno elementy, jak i obrazu, który jest kopiowany.

Programowanie Kopiuj i Wklej zachowanie

Wiele aspektów zachowanie DSL, w odniesieniu do kopiowania, wklejania, tworzenia i usuwania obiektów są regulowane przez wystąpienie ElementOperations , jest sprzężona z diagramu.Można zmodyfikować zachowanie modem DSL, wynikające z klasy z ElementOperations i przesłanianie ElementOperations właściwości klasy diagramu.

PoradaPorada

Aby uzyskać więcej informacji na temat dostosowywania modelu przy użyciu kodu programu, zobacz Przeglądanie i aktualizowanie modelu w kod programu.

Diagram sekwencji dla operacji kopiowaniaDiagram sekwencji operacji wklejania

Aby zdefiniować własne ElementOperations

  1. W nowym pliku projektu DSL, należy utworzyć klasę, która wywodzi się z DesignSurfaceElementOperations.

  2. Dodawanie definicji częściowej klasy dla swojej klasy diagramu.Nazwa tej klasy można znaleźć w Dsl\GeneratedCode\Diagrams.cs.

    W klasie diagram, należy zastąpić ElementOperations do zwracania wystąpienie podklasa użytkownika ElementOperations.Należy zwrócić tym samym wystąpieniu na każdym wywołaniu.

Dodaj ten kod w pliku kodu niestandardowego w programie project DslPackage:

using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;
using Microsoft.VisualStudio.Modeling.Diagrams.ExtensionEnablement;

  public partial class MyDslDiagram
  {
    public override DesignSurfaceElementOperations ElementOperations
    {
      get
      {
        if (this.elementOperations == null)
        {
          this.elementOperations = new MyElementOperations(this.Store as IServiceProvider, this);
        }
        return this.elementOperations;
      }
    }
    private MyElementOperations elementOperations = null;
  }

  public class MyElementOperations : DesignSurfaceElementOperations
  {
    public MyElementOperations(IServiceProvider serviceProvider, MyDslDiagram diagram)
      : base(serviceProvider, diagram)
    { }
    // Overridden methods follow
  }

Odbieranie elementy przeciągnięte z innych modeli

ElementOperations można również zdefiniować zachowanie kopiowania, przenoszenia, usuwania i przeciągania i upuszczania.Pokaz wykorzystania ElementOperations przykład definiuje niestandardowe zachowania Przeciągnij i upuść.Jednakże, w tym celu należy rozważyć alternatywne podejście opisane w Jak: Dodawanie obsługi przeciągania i upuszczania, który jest bardziej rozszerzonego.

Zdefiniuj dwie metody w klasie ElementOperations:

  • CanMerge(ModelElement targetElement, System.Windows.Forms.IDataObject data)które określa, czy element źródłowy może być przeciągnięty na kształtu docelowego, łącznika lub diagramu.

  • MergeElementGroupPrototype(ModelElement targetElement, ElementGroupPrototype sourcePrototype)element źródłowy która łączy do obiektu docelowego.

Ff521398.collapse_all(pl-pl,VS.110).gifCanMerge()

[CanMerge()]nazywa się do określenia informacji zwrotnych, który należy do użytkownika przesuwającego myszy diagram.Parametry metody są element, w którym jest kursora myszy i dane dotyczące źródła, z którego została wykonana operacji przeciągania.Użytkownik może przeciągać z dowolnego miejsca na ekranie.W związku z tym obiekt źródłowy może być wiele różnych typów i może być serializowany w różnych formatach.Jeśli źródłem jest model modemu DSL lub UML, parametr danych jest serializacji ElementGroupPrototype.Operacje przeciągania, kopiowania i przyborniku użyć ElementGroupPrototypes do reprezentowania fragmenty modeli.

Prototyp grupy Element może zawierać dowolną liczbę elementów i łącza.Typy elementów można zidentyfikować przez ich identyfikatorów GUID.Identyfikator GUID jest kształtu, który został przeciągnięty nie podstawowym elementem modelu.W poniższym przykładzie CanMerge() zwraca wartość true, jeśli klasa kształtu z diagramu UML jest przeciągnięty na tym diagramie.

public override bool CanMerge(ModelElement targetShape, System.Windows.Forms.IDataObject data)
 {
  // Extract the element prototype from the data.
  ElementGroupPrototype prototype = ElementOperations.GetElementGroupPrototype(this.ServiceProvider, data);
  if (targetShape is MyTargetShape && prototype != null &&
        prototype.RootProtoElements.Any(rootElement => 
          rootElement.DomainClassId.ToString() 
          ==  "3866d10c-cc4e-438b-b46f-bb24380e1678")) // Guid of UML Class shapes
          // or SourceClass.DomainClassId
        return true;
   return base.CanMerge(targetShape, data);
 }

MergeElementGroupPrototype()

Metoda ta jest wywoływana, gdy użytkownik porzuca elementu na diagramie, kształtu lub łącznika.Należy go scalić zawartości przeciągany element docelowy.W tym przykładzie kod określa, czy rozpoznaje kombinacji typów prototyp i docelowe; w takim przypadku metoda konwertuje przeciąganych elementów prototyp elementów, które mają być dodane do modelu.Wykonać scalanie, albo elementy konwertowanych lub nieprzekonwertowane wywoływana jest metoda podstawowego.

    public override void MergeElementGroupPrototype(ModelElement targetShape, ElementGroupPrototype sourcePrototype)
    {
      ElementGroupPrototype prototypeToMerge = sourcePrototype;
      MyTargetShape pel = targetShape as MyTargetShape;
      if (pel != null)
      {
        prototypeToMerge = ConvertDraggedTypeToLocal(pel, sourcePrototype);
      }
      if (prototypeToMerge != null)
        base.MergeElementGroupPrototype(targetShape, prototypeToMerge);
    }

W tym przykładzie zajmuje przeciągnięte z diagramu UML klasa elementów klasy UML.Modem DSL nie jest przeznaczony do przechowywania klasy UML bezpośrednio, ale zamiast możemy utworzyć element DSL dla każdej klasy przeciągany UML.To byłoby przydatne, na przykład, jeśli modem DSL jest diagramie instancji.Użytkownik może przeciągnij klas diagramu do tworzenia instancji tych klas.

    private ElementGroupPrototype ConvertDraggedTypeToLocal (MyTargetShape snapshot, ElementGroupPrototype prototype)
    {
      // Find the UML project:
      EnvDTE.DTE dte = snapshot.Store.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
      foreach (EnvDTE.Project project in dte.Solution.Projects)
      {
        IModelingProject modelingProject = project as IModelingProject;
        if (modelingProject == null) continue; // not a modeling project
        IModelStore store = modelingProject.Store;
        if (store == null) continue;
        // Look for the shape that was dragged:
        foreach (IDiagram umlDiagram in store.Diagrams())
        {
          // Get modeling diagram that implements UML diagram:
          Diagram diagram = umlDiagram.GetObject<Diagram>();
          Guid elementId = prototype.SourceRootElementIds.FirstOrDefault();
          ShapeElement shape = diagram.Partition.ElementDirectory.FindElement(elementId) as ShapeElement;
          if (shape == null) continue;
          IClass classElement = shape.ModelElement as IClass;
          if (classElement == null) continue;
          
          // Create a prototype of elements in my DSL, based on the UML element:
          Instance instance = new Instance(snapshot.Store);
          instance.Type = classElement.Name;
          // Pack them into a prototype:
          ElementGroup group = new ElementGroup(instance);
          return group.CreatePrototype();
        }
      }
      return null;
    }

Standardowe zachowanie kopii

Pokazuje kod w tej sekcji można zastąpić, metody, które użytkownik może zmienić zachowanie kopiowania.Do pomocy, można zobaczyć, jak osiągnąć swoje własne dostosowań, w tej sekcji przedstawiono kod, który zastępuje metod zaangażowanych w kopiowanie, ale nie zmienia zachowanie standardowe.

Gdy użytkownik naciśnie klawisze CTRL + C lub używa polecenia Kopiuj menu Metoda ProcessOnMenuCopyCommand jest wywoływana.Można zobaczyć, jak to ustawia się w DslPackage\Generated Code\CommandSet.cs.Aby uzyskać więcej informacji na temat sposobu polecenia set up zobacz Jak: Dodawanie polecenia do Menu skrótów.

ProcessOnMenuCopyCommand można zastąpić przez dodanie definicji częściowej klasy MyDslClipboardCommandSet w programie project DslPackage.

using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;

partial class MyDslClipboardCommandSet
{
  /// <summary>
  /// Override ProcessOnMenuCopyCommand() to copy elements to the
  /// clipboard in different formats, or to perform additional tasks
  /// before or after copying – for example deselect the copied elements.
  /// </summary>
  protected override void ProcessOnMenuCopyCommand()
  {
    IList<ModelElement> selectedModelElements = this.SelectedElements;
    if (selectedModelElements.Count == 0) return;

    // System container for clipboard data.
    // The IDataObject can contain data in several formats.
    IDataObject dataObject = new DataObject();
      
    Bitmap bitmap = null; // For export to other programs.
    try
    {
      #region Create EGP for copying to a DSL.
      this.CopyModelElementsIntoElementGroupPrototype
                     (dataObject, selectedModelElements);
      #endregion
      
      #region Create bitmap for copying to another application. 
      // Find all the shapes associated with this selection:
      List<ShapeElement> shapes = new List<ShapeElement>(
        this.ResolveExportedShapesForClipboardImages
              (dataObject, selectedModelElements));

      bitmap = this.CreateBitmapForClipboard(shapes);
      if (bitmap != null)
      {
        dataObject.SetData(DataFormats.Bitmap, bitmap);
      }
      #endregion 
     
      // Add the data to the clipboard:
      Clipboard.SetDataObject(dataObject, true, 5, 100);
    }
    finally
    {
      // Dispose bitmap after SetDataObject:
      if (bitmap != null) bitmap.Dispose();
    }
  }
/// <summary>
/// Override this to customize the element group that is copied to the clipboard.
/// </summary>
protected override void CopyModelElementsIntoElementGroupPrototype(IDataObject dataObject, IList<ModelElement> selectedModelElements)
{
  return this.ElementOperations.Copy(dataObject, selectedModelElements);
}
}

Każdy diagram ma singleton wystąpienia ElementOperations.Można podać własne pochodnej.Ten plik, które mogą być umieszczane w projekcie DSL, byłoby działają tak samo, jak kod, który zastępuje ona:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;

namespace Company.MyDsl
{
  partial class MyDslDiagram
  {
    /// <summary>
    /// Singleton ElementOperations attached to this diagram.
    /// </summary>
    public override DesignSurfaceElementOperations ElementOperations
    {
      get
      {
        if (this.elementOperations == null)
        {
          this.elementOperations = new MyElementOperations(this.Store as IServiceProvider, this);
        }
        return this.elementOperations;
      }
    }
    private MyElementOperations elementOperations = null;
  }

  // Our own version of ElementOperations so that we can override:
  public class MyElementOperations : DesignSurfaceElementOperations
  {
    public MyElementOperations(IServiceProvider serviceProvider, ElementOps1Diagram diagram)
      : base(serviceProvider, diagram)
    { }


     
    /// <summary>
    /// Copy elements to the clipboard data.
    /// Provides a hook for adding custom data.
    /// </summary>
    public override void Copy(System.Windows.Forms.IDataObject data, 
      ICollection<ModelElement> elements, 
      ClosureType closureType, 
      System.Drawing.PointF sourcePosition)
    {
      if (CanAddElementGroupFormat(elements, closureType))
      {
        AddElementGroupFormat(data, elements, closureType); 
      }

      // Override these to store additional data:
      if (CanAddCustomFormat(elements, closureType))
      {
        AddCustomFormat(data, elements, closureType, sourcePosition);
      }
    }
     
    
    protected override void AddElementGroupFormat(System.Windows.Forms.IDataObject data, ICollection<ModelElement> elements, ClosureType closureType)
    {
      // Add the selected elements and those implied by the propagate copy rules:
      ElementGroup elementGroup = this.CreateElementGroup(elements, closureType);

      // Mark all the elements that are not embedded under other elements:
      this.MarkRootElements(elementGroup, elements, closureType);

      // Store in the clipboard data:
      ElementGroupPrototype elementGroupPrototype = this.CreateElementGroupPrototype(elementGroup, elements, closureType);
      data.SetData(ElementGroupPrototype.DefaultDataFormatName, elementGroupPrototype);
    }

    /// <summary>
    /// Override this to store additional elements in the element group:
    /// </summary>
    protected override ElementGroupPrototype CreateElementGroupPrototype(ElementGroup elementGroup, ICollection<ModelElement> elements, ClosureType closureType)
    {
      ElementGroupPrototype prototype = new ElementGroupPrototype(this.Partition, elementGroup.RootElements, elementGroup);
      return prototype;
    }

    /// <summary>
    /// Create an element group from the given starting elements, using the 
    /// copy propagation rules specified in the DSL Definition.
    /// By default, this includes all the embedded descendants of the starting elements,
    /// and also includes reference links where both ends are already included.
    /// </summary>
    /// <param name="startElements">model elements to copy</param>
    /// <param name="closureType"></param>
    /// <returns></returns>
    protected override ElementGroup CreateElementGroup(ICollection<ModelElement> startElements, ClosureType closureType)
    {
      // ElementClosureWalker finds all the connected elements, 
      // according to the propagate copy rules specified in the DSL Definition:
      ElementClosureWalker walker = new ElementClosureWalker(this.Partition, 
        closureType, // Normally ClosureType.CopyClosure
        startElements, 
        true, // Do not load other models.
        null, // Optional list of domain roles not to traverse.
        true); // Include relationship links where both ends are already included.
      
      walker.Traverse(startElements);
      IList<ModelElement> closureList = walker.ClosureList;
      Dictionary<object, object> closureContext = walker.Context;

      // create a group for this closure
      ElementGroup group = new ElementGroup(this.Partition);
      group.AddRange(closureList, false);

      // create the element group prototype for the group
      foreach (object key in closureContext.Keys)
      {
        group.SourceContext.ContextInfo[key] = closureContext[key];
      }

      return group;
    }
  }
}

Zobacz też

Koncepcje

Dostosowywanie tworzenia elementu i przepływu

Jak: Dodawanie obsługi przeciągania i upuszczania

Dostosowywanie zachowania usunięcia

Inne zasoby

Próbki: Przykładowe diagramy VMSDK