Delen via

Een activiteit tijdens runtime maken met DynamicActivity

  • Artikel

DynamicActivity is een concrete, verzegelde klasse met een openbare constructor. DynamicActivity kan worden gebruikt om activiteitsfunctionaliteit tijdens runtime samen te stellen met behulp van een activiteitS-DOM.

DynamicActivity-functies

DynamicActivity heeft toegang tot uitvoeringseigenschappen, argumenten en variabelen, maar geen toegang tot runtimeservices, zoals het plannen van onderliggende activiteiten of het bijhouden van onderliggende activiteiten.

Eigenschappen op het hoogste niveau kunnen worden ingesteld met behulp van werkstroomobjecten Argument . In imperatieve code worden deze argumenten gemaakt met behulp van CLR-eigenschappen voor een nieuw type. In XAML worden ze gedeclareerd met behulp van x:Class en x:Member tags.

Activiteiten die zijn samengesteld met behulp van DynamicActivity interface met de ontwerpfunctie.ICustomTypeDescriptor Activiteiten die in de ontwerpfunctie zijn gemaakt, kunnen dynamisch worden geladen met behulp van Load, zoals in de volgende procedure wordt gedemonstreerd.

Een activiteit tijdens runtime maken met imperatieve code

  1. OpenVisual Studio 2010.

  2. Selecteer Bestand, Nieuw, Project. Selecteer Workflow 4.0 onder Visual C# in het venster Projecttypen en selecteer het knooppunt v2010 . Selecteer Sequentiële werkstroomconsoletoepassing in het venster Sjablonen . Geef het nieuwe project de naam DynamicActivitySample.

  3. Klik met de rechtermuisknop op Workflow1.xaml in het Project HelloActivity en selecteer Verwijderen.

  4. Open Program.cs. Voeg de volgende instructie toe aan het begin van het bestand.

    using System.Collections.Generic;

  5. Vervang de inhoud van de Main methode door de volgende code, waarmee een Sequence activiteit wordt gemaakt die één WriteLine activiteit bevat en deze toewijst aan de Implementation eigenschap van een nieuwe dynamische activiteit.

    //Define the input argument for the activity  
var textOut = new InArgument<string>();  
//Create the activity, property, and implementation  
            Activity dynamicWorkflow = new DynamicActivity()  
            {  
                Properties =
                {  
                    new DynamicActivityProperty  
                    {  
                        Name = "Text",  
                        Type = typeof(InArgument<String>),  
                        Value = textOut  
                    }  
                },  
                Implementation = () => new Sequence()  
                {  
                    Activities =
                    {  
                        new WriteLine()  
                        {  
                            Text = new InArgument<string>(env => textOut.Get(env))  
                        }  
                    }  
                }  
            };  
//Execute the activity with a parameter dictionary  
            WorkflowInvoker.Invoke(dynamicWorkflow, new Dictionary<string, object> { { "Text", "Hello World!" } });  
            Console.ReadLine();

  6. Voer de toepassing uit. Er wordt een consolevenster met de tekst 'Hallo wereld!' weergegeven.

Een activiteit tijdens runtime maken met behulp van XAML

  1. Open Visual Studio 2010.

  2. Selecteer Bestand, Nieuw, Project. Selecteer Workflow 4.0 onder Visual C# in het venster Projecttypen en selecteer het knooppunt v2010 . Selecteer De werkstroomconsoletoepassing in het venster Sjablonen . Geef het nieuwe project de naam DynamicActivitySample.

  3. Open Workflow1.xaml in het Project HelloActivity. Klik op de optie Argumenten onderaan de ontwerpfunctie. Maak een nieuw In argument met de naam TextToWrite van het type String.

  4. Sleep een WriteLine-activiteit vanuit de sectie Primitieven van de werkset naar het ontwerpoppervlak. Wijs de waarde TextToWrite toe aan de eigenschap Text van de activiteit.

  5. Open Program.cs. Voeg de volgende instructie toe aan het begin van het bestand.

    using System.Activities.XamlIntegration;

  6. Vervang de inhoud van de methode Main door de volgende code.

    Activity act2 = ActivityXamlServices.Load(@"Workflow1.xaml");  
                results = WorkflowInvoker.Invoke(act2, new Dictionary<string, object> { { "TextToWrite", "HelloWorld!" } });  
Console.ReadLine();

  7. Voer de toepassing uit. Er wordt een consolevenster met de tekst 'Hallo wereld!' weergegeven.

  8. Klik met de rechtermuisknop op het bestand Workflow1.xaml in Solution Explorer en selecteer Code weergeven. Houd er rekening mee dat de activiteitsklasse wordt gemaakt met x:Class en dat de eigenschap wordt gemaakt met x:Property.

Zie ook