Procedure: De definitie van een actief werkstroomexemplaren bijwerken

Artikel
03/02/2024

Dynamische update biedt ontwikkelaars van werkstroomtoepassingen een mechanisme voor het bijwerken van de werkstroomdefinitie van een persistent werkstroomexemplaren. De vereiste wijziging kan zijn om een foutoplossing, nieuwe vereisten te implementeren of om onverwachte wijzigingen aan te passen. Deze stap in de zelfstudie laat zien hoe u dynamische updates kunt gebruiken om persistente exemplaren van de v1 werkstroom voor het raden van getallen te wijzigen, zodat deze overeenkomt met de nieuwe functionaliteit die is geïntroduceerd in Procedure: Meerdere versies van een werkstroom hosten naast elkaar.

In dit onderwerp

Het project CreateUpdate Kaarten maken

Klik met de rechtermuisknop op WF45GettingStartedTutorial in Solution Explorer en kies Toevoegen, Nieuw project.
Selecteer in het geïnstalleerde knooppunt Visual C#, Windows (of Visual Basic, Windows).

Notitie

Afhankelijk van de programmeertaal die is geconfigureerd als de primaire taal in Visual Studio, bevindt het knooppunt Visual C# of Visual Basic zich mogelijk onder het knooppunt Overige talen in het geïnstalleerde knooppunt.

Zorg ervoor dat .NET Framework 4.5 is geselecteerd in de vervolgkeuzelijst .NET Framework-versie. Selecteer Consoletoepassing in de Windows-lijst . Typ CreateUpdate Kaarten in het vak Naam en klik op OK.
Klik met de rechtermuisknop op CreateUpdate Kaarten in Solution Explorer en kies Verwijzing toevoegen.
Selecteer Framework in het knooppunt Assembly's in de lijst Verwijzing toevoegen. Typ System.Activities in het vak Zoekassembly's om de assembly's te filteren en de gewenste verwijzingen gemakkelijker te selecteren.
Schakel het selectievakje naast System.Activities in de lijst met zoekresultaten in.
Typ serialisatie in het vak Zoekassembly's en schakel het selectievakje naast System.Runtime.Serialization in de lijst met zoekresultaten in.
Typ System.Xaml in het vak Zoekassembly's en schakel het selectievakje naast System.Xaml in de lijst met zoekresultaten in.
Klik op OK om Reference Manager te sluiten en de verwijzingen toe te voegen.

Voeg de volgende using (of Imports) instructies toe boven aan het bestand met de andere using (of Imports) instructies.

Imports System.Activities
Imports System.Activities.Statements
Imports System.Xaml
Imports System.Reflection
Imports System.IO
Imports System.Activities.XamlIntegration
Imports System.Activities.DynamicUpdate
Imports System.Runtime.Serialization
Imports Microsoft.VisualBasic.Activities

using System.Activities;
using System.Activities.Statements;
using System.IO;
using System.Xaml;
using System.Reflection;
using System.Activities.XamlIntegration;
using System.Activities.DynamicUpdate;
using System.Runtime.Serialization;
using Microsoft.CSharp.Activities;

Voeg de volgende twee tekenreeksleden toe aan de Program klasse (of Module1).

Const mapPath = "..\..\..\PreviousVersions"
Const definitionPath = "..\..\..\NumberGuessWorkflowActivities_du"

const string mapPath = @"..\..\..\PreviousVersions";
const string definitionPath = @"..\..\..\NumberGuessWorkflowActivities_du";

Voeg de volgende StartUpdate methode toe aan de Program klasse (of Module1). Met deze methode wordt de opgegeven xaml-werkstroomdefinitie in een ActivityBuildergeladen en vervolgens aangeroepen DynamicUpdate.PrepareForUpdate. PrepareForUpdate maakt een kopie van de werkstroomdefinitie in de ActivityBuilder. Nadat de werkstroomdefinitie is gewijzigd, wordt deze kopie samen met de gewijzigde werkstroomdefinitie gebruikt om de updatetoewijzing te maken.

Private Function StartUpdate(name As String) As ActivityBuilder
    'Create the XamlXmlReaderSettings.
    Dim readerSettings As XamlReaderSettings = New XamlXmlReaderSettings()
    'In the XAML the "local" namespace refers to artifacts that come from
    'the same project as the XAML. When loading XAML if the currently executing
    'assembly is not the same assembly that was referred to as "local" in the XAML
    'LocalAssembly must be set to the assembly containing the artifacts.
    'Assembly.LoadFile requires an absolute path so convert this relative path
    'to an absolute path.
    readerSettings.LocalAssembly = Assembly.LoadFile(
        Path.GetFullPath(Path.Combine(mapPath, "NumberGuessWorkflowActivities_v1.dll")))

    Dim fullPath As String = Path.Combine(definitionPath, name)
    Dim xamlReader As XamlXmlReader = New XamlXmlReader(fullPath, readerSettings)

    'Load the workflow definition into an ActivityBuilder.
    Dim wf As ActivityBuilder = XamlServices.Load(
        ActivityXamlServices.CreateBuilderReader(xamlReader))

    'PrepareForUpdate makes a copy of the workflow definition in the
    'ActivityBuilder that is used for comparison when the update
    'map is created.
    DynamicUpdateServices.PrepareForUpdate(wf)

    Return wf
End Function

private static ActivityBuilder StartUpdate(string name)
{
    // Create the XamlXmlReaderSettings.
    XamlXmlReaderSettings readerSettings = new XamlXmlReaderSettings()
    {
        // In the XAML the "local" namespace refers to artifacts that come from
        // the same project as the XAML. When loading XAML if the currently executing
        // assembly is not the same assembly that was referred to as "local" in the XAML
        // LocalAssembly must be set to the assembly containing the artifacts.
        // Assembly.LoadFile requires an absolute path so convert this relative path
        // to an absolute path.
        LocalAssembly = Assembly.LoadFile(
            Path.GetFullPath(Path.Combine(mapPath, "NumberGuessWorkflowActivities_v1.dll")))
    };

    string path = Path.Combine(definitionPath, name);
    XamlXmlReader xamlReader = new XamlXmlReader(path, readerSettings);

    // Load the workflow definition into an ActivityBuilder.
    ActivityBuilder wf = XamlServices.Load(
        ActivityXamlServices.CreateBuilderReader(xamlReader))
        as ActivityBuilder;

    // PrepareForUpdate makes a copy of the workflow definition in the
    // ActivityBuilder that is used for comparison when the update
    // map is created.
    DynamicUpdateServices.PrepareForUpdate(wf);

    return wf;
}

Voeg vervolgens het volgende CreateUpdateMethod toe aan de Program klasse (of Module1). Hiermee maakt u een dynamische updatetoewijzing door DynamicUpdateServices.CreateUpdateMap aan te roepen en slaat u de updatekaart vervolgens op met behulp van de opgegeven naam. Deze updatetoewijzing bevat de informatie die nodig is voor de werkstroomruntime om een persistent werkstroomexemplaren bij te werken die is gestart met de oorspronkelijke werkstroomdefinitie die is opgenomen in de ActivityBuilder werkstroomdefinitie, zodat deze wordt voltooid met behulp van de bijgewerkte werkstroomdefinitie.

Private Sub CreateUpdateMaps(wf As ActivityBuilder, name As String)
    'Create the UpdateMap.
    Dim map As DynamicUpdateMap =
        DynamicUpdateServices.CreateUpdateMap(wf)

    'Serialize it to a file.
    Dim mapFullPath As String = Path.Combine(mapPath, name)
    Dim sz As DataContractSerializer = New DataContractSerializer(GetType(DynamicUpdateMap))
    Using fs As FileStream = File.Open(mapFullPath, FileMode.Create)
        sz.WriteObject(fs, map)
    End Using
End Sub

private static void CreateUpdateMaps(ActivityBuilder wf, string name)
{
    // Create the UpdateMap.
    DynamicUpdateMap map =
        DynamicUpdateServices.CreateUpdateMap(wf);

    // Serialize it to a file.
    string path = Path.Combine(mapPath, name);
    DataContractSerializer sz = new DataContractSerializer(typeof(DynamicUpdateMap));
    using (FileStream fs = System.IO.File.Open(path, FileMode.Create))
    {
        sz.WriteObject(fs, map);
    }
}

Voeg de volgende SaveUpdatedDefinition methode toe aan de Program klasse (of Module1). Met deze methode wordt de bijgewerkte werkstroomdefinitie opgeslagen zodra de updatetoewijzing is gemaakt.

Private Sub SaveUpdatedDefinition(wf As ActivityBuilder, name As String)
    Dim xamlPath As String = Path.Combine(definitionPath, name)
    Dim sw As StreamWriter = File.CreateText(xamlPath)
    Dim xw As XamlWriter = ActivityXamlServices.CreateBuilderWriter(
        New XamlXmlWriter(sw, New XamlSchemaContext()))
    XamlServices.Save(xw, wf)
    sw.Close()
End Sub

private static void SaveUpdatedDefinition(ActivityBuilder wf, string name)
{
    string xamlPath = Path.Combine(definitionPath, name);
    StreamWriter sw = File.CreateText(xamlPath);
    XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(
        new XamlXmlWriter(sw, new XamlSchemaContext()));
    XamlServices.Save(xw, wf);
    sw.Close();
}

StateMachineNumberGuessWorkflow bijwerken

Voeg een CreateStateMachineUpdateMap toe aan de Program klasse (of Module1).

Private Sub CreateStateMachineUpdateMap()

End Sub

private static void CreateStateMachineUpdateMap()
{
}

Maak een aanroep naar StartUpdate en haal vervolgens een verwijzing op naar de hoofdactiviteit StateMachine van de werkstroom.

Dim wf As ActivityBuilder = StartUpdate("StateMachineNumberGuessWorkflow.xaml")

'Get a reference to the root StateMachine activity.
Dim sm As StateMachine = wf.Implementation

ActivityBuilder wf = StartUpdate("StateMachineNumberGuessWorkflow.xaml");

// Get a reference to the root StateMachine activity.
StateMachine sm = wf.Implementation as StateMachine;

Werk vervolgens de expressies van de twee WriteLine activiteiten bij die aangeven of de schatting van de gebruiker te hoog of te laag is, zodat deze overeenkomen met de updates die zijn aangebracht in Procedure: Meerdere versies van een werkstroom hosten naast elkaar.

'Update the Text of the two WriteLine activities that write the
'results of the user's guess. They are contained in the workflow as the
'Then and Else action of the If activity in sm.States[1].Transitions[1].Action.
Dim guessLow As Statements.If = sm.States(1).Transitions(1).Action

'Update the "too low" message.
Dim tooLow As WriteLine = guessLow.Then
tooLow.Text = New VisualBasicValue(Of String)("Guess.ToString() & "" is too low.""")

'Update the "too high" message.
Dim tooHigh As WriteLine = guessLow.Else
tooHigh.Text = New VisualBasicValue(Of String)("Guess.ToString() & "" is too high.""")

// Update the Text of the two WriteLine activities that write the
// results of the user's guess. They are contained in the workflow as the
// Then and Else action of the If activity in sm.States[1].Transitions[1].Action.
If guessLow = sm.States[1].Transitions[1].Action as If;

// Update the "too low" message.
WriteLine tooLow = guessLow.Then as WriteLine;
tooLow.Text = new CSharpValue<string>("Guess.ToString() + \" is too low.\"");

// Update the "too high" message.
WriteLine tooHigh = guessLow.Else as WriteLine;
tooHigh.Text = new CSharpValue<string>("Guess.ToString() + \" is too high.\"");

Voeg vervolgens de nieuwe WriteLine activiteit toe waarmee het afsluitende bericht wordt weergegeven.

'Create the new WriteLine that displays the closing message.
Dim wl As New WriteLine() With
{
    .Text = New VisualBasicValue(Of String) _
        ("Guess.ToString() + "" is correct. You guessed it in "" & Turns.ToString() & "" turns.""")
}

'Add it as the Action for the Guess Correct transition. The Guess Correct
'transition is the first transition of States[1]. The transitions are listed
'at the bottom of the State activity designer.
sm.States(1).Transitions(0).Action = wl

// Create the new WriteLine that displays the closing message.
WriteLine wl = new WriteLine
{
    Text = new CSharpValue<string>("Guess.ToString() + \" is correct. You guessed it in \" + Turns.ToString() + \" turns.\"")
};

// Add it as the Action for the Guess Correct transition. The Guess Correct
// transition is the first transition of States[1]. The transitions are listed
// at the bottom of the State activity designer.
sm.States[1].Transitions[0].Action = wl;

Nadat de werkstroom is bijgewerkt, roept CreateUpdateMaps u aan en SaveUpdatedDefinition. CreateUpdateMaps maakt en slaat de DynamicUpdateMap, en SaveUpdatedDefinition slaat de bijgewerkte werkstroomdefinitie op.

'Create the update map.
CreateUpdateMaps(wf, "StateMachineNumberGuessWorkflow.map")

'Save the updated workflow definition.
SaveUpdatedDefinition(wf, "StateMachineNumberGuessWorkflow_du.xaml")

// Create the update map.
CreateUpdateMaps(wf, "StateMachineNumberGuessWorkflow.map");

// Save the updated workflow definition.
SaveUpdatedDefinition(wf, "StateMachineNumberGuessWorkflow_du.xaml");

Het volgende voorbeeld is de voltooide CreateStateMachineUpdateMap methode.

Private Sub CreateStateMachineUpdateMap()
    Dim wf As ActivityBuilder = StartUpdate("StateMachineNumberGuessWorkflow.xaml")

    'Get a reference to the root StateMachine activity.
    Dim sm As StateMachine = wf.Implementation

    'Update the Text of the two WriteLine activities that write the
    'results of the user's guess. They are contained in the workflow as the
    'Then and Else action of the If activity in sm.States[1].Transitions[1].Action.
    Dim guessLow As Statements.If = sm.States(1).Transitions(1).Action

    'Update the "too low" message.
    Dim tooLow As WriteLine = guessLow.Then
    tooLow.Text = New VisualBasicValue(Of String)("Guess.ToString() & "" is too low.""")

    'Update the "too high" message.
    Dim tooHigh As WriteLine = guessLow.Else
    tooHigh.Text = New VisualBasicValue(Of String)("Guess.ToString() & "" is too high.""")

    'Create the new WriteLine that displays the closing message.
    Dim wl As New WriteLine() With
    {
        .Text = New VisualBasicValue(Of String) _
            ("Guess.ToString() + "" is correct. You guessed it in "" & Turns.ToString() & "" turns.""")
    }

    'Add it as the Action for the Guess Correct transition. The Guess Correct
    'transition is the first transition of States[1]. The transitions are listed
    'at the bottom of the State activity designer.
    sm.States(1).Transitions(0).Action = wl

    'Create the update map.
    CreateUpdateMaps(wf, "StateMachineNumberGuessWorkflow.map")

    'Save the updated workflow definition.
    SaveUpdatedDefinition(wf, "StateMachineNumberGuessWorkflow_du.xaml")
End Sub

private static void CreateStateMachineUpdateMap()
{
    ActivityBuilder wf = StartUpdate("StateMachineNumberGuessWorkflow.xaml");

    // Get a reference to the root StateMachine activity.
    StateMachine sm = wf.Implementation as StateMachine;

    // Update the Text of the two WriteLine activities that write the
    // results of the user's guess. They are contained in the workflow as the
    // Then and Else action of the If activity in sm.States[1].Transitions[1].Action.
    If guessLow = sm.States[1].Transitions[1].Action as If;

    // Update the "too low" message.
    WriteLine tooLow = guessLow.Then as WriteLine;
    tooLow.Text = new CSharpValue<string>("Guess.ToString() + \" is too low.\"");

    // Update the "too high" message.
    WriteLine tooHigh = guessLow.Else as WriteLine;
    tooHigh.Text = new CSharpValue<string>("Guess.ToString() + \" is too high.\"");

    // Create the new WriteLine that displays the closing message.
    WriteLine wl = new WriteLine
    {
        Text = new CSharpValue<string>("Guess.ToString() + \" is correct. You guessed it in \" + Turns.ToString() + \" turns.\"")
    };

    // Add it as the Action for the Guess Correct transition. The Guess Correct
    // transition is the first transition of States[1]. The transitions are listed
    // at the bottom of the State activity designer.
    sm.States[1].Transitions[0].Action = wl;

    // Create the update map.
    CreateUpdateMaps(wf, "StateMachineNumberGuessWorkflow.map");

    // Save the updated workflow definition.
    SaveUpdatedDefinition(wf, "StateMachineNumberGuessWorkflow_du.xaml");
}

FlowchartNumberGuessWorkflow bijwerken

Voeg het volgende CreateFlowchartUpdateMethod toe aan de Program klasse (of Module1). Deze methode is vergelijkbaar met CreateStateMachineUpdateMap. Het begint met een aanroep naar StartUpdate, werkt de werkstroomdefinitie van het stroomdiagram bij en wordt voltooid door de updatetoewijzing en de bijgewerkte werkstroomdefinitie op te slaan.

Private Sub CreateFlowchartUpdateMap()
    Dim wf As ActivityBuilder = StartUpdate("FlowchartNumberGuessWorkflow.xaml")

    'Get a reference to the root Flowchart activity.
    Dim fc As Flowchart = wf.Implementation

    'Update the Text of the two WriteLine activities that write the
    'results of the user's guess. They are contained in the workflow as the
    'True and False action of the "Guess < Target" FlowDecision, which is
    'Nodes[4].
    Dim guessLow As FlowDecision = fc.Nodes(4)

    'Update the "too low" message.
    Dim trueStep As FlowStep = guessLow.True
    Dim tooLow As WriteLine = trueStep.Action
    tooLow.Text = New VisualBasicValue(Of String)("Guess.ToString() & "" is too low.""")

    'Update the "too high" message.
    Dim falseStep As FlowStep = guessLow.False
    Dim tooHigh As WriteLine = falseStep.Action
    tooHigh.Text = New VisualBasicValue(Of String)("Guess.ToString() & "" is too high.""")

    'Create the new WriteLine that displays the closing message.
    Dim wl As New WriteLine() With
    {
        .Text = New VisualBasicValue(Of String) _
            ("Guess.ToString() + "" is correct. You guessed it in "" & Turns.ToString() & "" turns.""")
    }

    'Create a FlowStep to hold the WriteLine.
    Dim closingStep As New FlowStep() With
    {
        .Action = wl
    }

    'Add this new FlowStep to the True action of the
    '"Guess = Guess" FlowDecision
    Dim guessCorrect As FlowDecision = fc.Nodes(3)
    guessCorrect.True = closingStep

    'Add the new FlowStep to the Nodes collection.
    'If closingStep was replacing an existing node then
    'we would need to remove that Step from the collection.
    'In this example there was no existing True step to remove.
    fc.Nodes.Add(closingStep)

    'Create the update map.
    CreateUpdateMaps(wf, "FlowchartNumberGuessWorkflow.map")

    'Save the updated workflow definition.
    SaveUpdatedDefinition(wf, "FlowchartNumberGuessWorkflow_du.xaml")
End Sub

private static void CreateFlowchartUpdateMap()
{
    ActivityBuilder wf = StartUpdate("FlowchartNumberGuessWorkflow.xaml");

    // Get a reference to the root Flowchart activity.
    Flowchart fc = wf.Implementation as Flowchart;

    // Update the Text of the two WriteLine activities that write the
    // results of the user's guess. They are contained in the workflow as the
    // True and False action of the "Guess < Target" FlowDecision, which is
    // Nodes[4].
    FlowDecision guessLow = fc.Nodes[4] as FlowDecision;

    // Update the "too low" message.
    FlowStep trueStep = guessLow.True as FlowStep;
    WriteLine tooLow = trueStep.Action as WriteLine;
    tooLow.Text = new CSharpValue<string>("Guess.ToString() + \" is too low.\"");

    // Update the "too high" message.
    FlowStep falseStep = guessLow.False as FlowStep;
    WriteLine tooHigh = falseStep.Action as WriteLine;
    tooHigh.Text = new CSharpValue<string>("Guess.ToString() + \" is too high.\"");

    // Add the new WriteLine that displays the closing message.
    WriteLine wl = new WriteLine
    {
        Text = new CSharpValue<string>("Guess.ToString() + \" is correct. You guessed it in \" + Turns.ToString() + \" turns.\"")
    };

    // Create a FlowStep to hold the WriteLine.
    FlowStep closingStep = new FlowStep
    {
        Action = wl
    };

    // Add this new FlowStep to the True action of the
    // "Guess == Guess" FlowDecision
    FlowDecision guessCorrect = fc.Nodes[3] as FlowDecision;
    guessCorrect.True = closingStep;

    // Add the new FlowStep to the Nodes collection.
    // If closingStep was replacing an existing node then
    // we would need to remove that Step from the collection.
    // In this example there was no existing True step to remove.
    fc.Nodes.Add(closingStep);

    // Create the update map.
    CreateUpdateMaps(wf, "FlowchartNumberGuessWorkflow.map");

    //  Save the updated workflow definition.
    SaveUpdatedDefinition(wf, "FlowchartNumberGuessWorkflow_du.xaml");
}

SequentialNumberGuessWorkflow bijwerken

Voeg het volgende CreateSequentialUpdateMethod toe aan de Program klasse (of Module1). Deze methode is vergelijkbaar met de andere twee methoden. Het begint met een aanroep naar StartUpdate, werkt de sequentiële werkstroomdefinitie bij en wordt voltooid door de updatetoewijzing en de bijgewerkte werkstroomdefinitie op te slaan.

Private Sub CreateSequentialUpdateMap()
    Dim wf As ActivityBuilder = StartUpdate("SequentialNumberGuessWorkflow.xaml")

    'Get a reference to the root activity in the workflow.
    Dim rootSequence As Sequence = wf.Implementation

    'Update the Text of the two WriteLine activities that write the
    'results of the user's guess. They are contained in the workflow as the
    'Then and Else action of the "Guess < Target" If activity.
    'Sequence[1]->DoWhile->Body->Sequence[2]->If->Then->If
    Dim gameLoop As Statements.DoWhile = rootSequence.Activities(1)
    Dim gameBody As Sequence = gameLoop.Body
    Dim guessCorrect As Statements.If = gameBody.Activities(2)
    Dim guessLow As Statements.If = guessCorrect.Then
    Dim tooLow As WriteLine = guessLow.Then
    tooLow.Text = New VisualBasicValue(Of String)("Guess.ToString() & "" is too low.""")
    Dim tooHigh As WriteLine = guessLow.Else
    tooHigh.Text = New VisualBasicValue(Of String)("Guess.ToString() & "" is too high.""")

    'Create the new WriteLine that displays the closing message.
    Dim wl As New WriteLine() With
    {
        .Text = New VisualBasicValue(Of String) _
            ("Guess.ToString() + "" is correct. You guessed it in "" & Turns.ToString() & "" turns.""")
    }

    'Insert it as the third activity in the root sequence
    rootSequence.Activities.Insert(2, wl)

    'Create the update map.
    CreateUpdateMaps(wf, "SequentialNumberGuessWorkflow.map")

    'Save the updated workflow definition.
    SaveUpdatedDefinition(wf, "SequentialNumberGuessWorkflow_du.xaml")
End Sub

private static void CreateSequentialUpdateMap()
{
    ActivityBuilder wf = StartUpdate("SequentialNumberGuessWorkflow.xaml");

    // Get a reference to the root activity in the workflow.
    Sequence rootSequence = wf.Implementation as Sequence;

    // Update the Text of the two WriteLine activities that write the
    // results of the user's guess. They are contained in the workflow as the
    // Then and Else action of the "Guess < Target" If activity.
    // Sequence[1]->DoWhile->Body->Sequence[2]->If->Then->If
    DoWhile gameLoop = rootSequence.Activities[1] as DoWhile;
    Sequence gameBody = gameLoop.Body as Sequence;
    If guessCorrect = gameBody.Activities[2] as If;
    If guessLow = guessCorrect.Then as If;
    WriteLine tooLow = guessLow.Then as WriteLine;
    tooLow.Text = new CSharpValue<string>("Guess.ToString() + \" is too low.\"");
    WriteLine tooHigh = guessLow.Else as WriteLine;
    tooHigh.Text = new CSharpValue<string>("Guess.ToString() + \" is too high.\"");

    // Add the new WriteLine that displays the closing message.
    WriteLine wl = new WriteLine
    {
        Text = new CSharpValue<string>("Guess.ToString() + \" is correct. You guessed it in \" + Turns.ToString() + \" turns.\"")
    };

    // Insert it as the third activity in the root sequence
    rootSequence.Activities.Insert(2, wl);

    // Create the update map.
    CreateUpdateMaps(wf, "SequentialNumberGuessWorkflow.map");

    // Save the updated workflow definition.
    SaveUpdatedDefinition(wf, "SequentialNumberGuessWorkflow_du.xaml");
}

De CreateUpdate Kaarten-toepassing bouwen en uitvoeren

Werk de Main methode bij en voeg de volgende drie methode-aanroepen toe. Deze methoden worden toegevoegd in de volgende secties. Elke methode werkt de bijbehorende werkstroom voor schattingen bij en maakt een DynamicUpdateMap werkstroom die de updates beschrijft.

Sub Main()
    'Create the update maps for the changes needed to the v1 activities
    'so they match the v2 activities.
    CreateSequentialUpdateMap()
    CreateFlowchartUpdateMap()
    CreateStateMachineUpdateMap()
End Sub

static void Main(string[] args)
{
    // Create the update maps for the changes needed to the v1 activities
    // so they match the v2 activities.
    CreateSequentialUpdateMap();
    CreateFlowchartUpdateMap();
    CreateStateMachineUpdateMap();
}

Klik met de rechtermuisknop op CreateUpdate Kaarten in Solution Explorer en kies Instellen als Opstartproject.
Druk op Ctrl+Shift+B om de oplossing te bouwen en druk vervolgens op Ctrl+F5 om de CreateUpdateMaps toepassing uit te voeren.

Notitie

De CreateUpdateMaps toepassing geeft geen statusinformatie weer tijdens het uitvoeren, maar als u in de map NumberGuessWorkflowActivities_du en de map PreviousVersions kijkt, ziet u de bijgewerkte werkstroomdefinitiebestanden en de updatetoewijzingen .

Zodra de updatetoewijzingen zijn gemaakt en de werkstroomdefinities zijn bijgewerkt, is de volgende stap het bouwen van een bijgewerkte werkstroomassembly met de bijgewerkte definities.

De bijgewerkte werkstroomassembly bouwen

Open een tweede exemplaar van Visual Studio 2012.
Kies Openen, Project/Oplossing in het menu Bestand .
Navigeer naar de map NumberGuessWorkflowActivities_du die u hebt gemaakt in Procedure: Meerdere versies van een werkstroom naast elkaar hosten, NumberGuessWorkflowActivities.csproj (of vbproj) selecteren en op Openen klikken.
Klik in Solution Explorer met de rechtermuisknop op SequentialNumberGuessWorkflow.xaml en kies Exclude From Project. Doe hetzelfde voor FlowchartNumberGuessWorkflow.xaml en StateMachineNumberGuessWorkflow.xaml. Met deze stap verwijdert u de vorige versies van de werkstroomdefinities uit het project.
Kies Bestaand item toevoegen in het menu Project .
Navigeer naar de map NumberGuessWorkflowActivities_du die u hebt gemaakt in Procedure: Meerdere versies van een werkstroom hosten naast elkaar.
Kies XAML-bestanden (*.xaml;*.xoml) in de vervolgkeuzelijst Bestanden van het type .
Selecteer SequentialNumberGuessWorkflow_du.xaml, FlowchartNumberGuessWorkflow_du.xaml en StateMachineNumberGuessWorkflow_du.xaml en klik op Toevoegen.

Notitie

Ctrl+Klik om meerdere items tegelijk te selecteren.

Met deze stap worden de bijgewerkte versies van de werkstroomdefinities toegevoegd aan het project.
Druk op Ctrl+Shift+B om het project te bouwen.
Kies Oplossing sluiten in het menu Bestand . Er is geen oplossingsbestand voor het project vereist. Klik dus op Nee om Visual Studio te sluiten zonder een oplossingsbestand op te slaan. Kies Afsluiten in het menu Bestand om Visual Studio te sluiten.
Open Windows Verkenner en navigeer naar de map NumberGuessWorkflowActivities_du\bin\Debug (of bin\Release , afhankelijk van uw projectinstellingen).
Wijzig de naam van NumberGuessWorkflowActivities.dll in NumberGuessWorkflowActivities_v15.dll en kopieer deze naar de map PreviousVersions die u hebt gemaakt in: Meerdere versies van een werkstroom hosten naast elkaar.

WorkflowVersionMap bijwerken met de nieuwe versies

Ga terug naar het eerste exemplaar van Visual Studio 2012.
Dubbelklik op WorkflowVersionMap.cs (of WorkflowVersionMap.vb) onder het project NumberGuessWorkflowHost om het te openen.

Voeg drie nieuwe werkstroomidentiteiten toe, net onder de zes bestaande declaraties van werkstroomidentiteiten. In deze zelfstudie 1.5.0.0 wordt deze gebruikt als de WorkflowIdentity.Version voor de dynamische update-identiteiten. Deze nieuwe v15 werkstroomidentiteiten worden gebruikt voor de juiste werkstroomdefinitie voor de dynamisch bijgewerkte persistente werkstroomexemplaren.

'Current version identities.
Public StateMachineNumberGuessIdentity As WorkflowIdentity
Public FlowchartNumberGuessIdentity As WorkflowIdentity
Public SequentialNumberGuessIdentity As WorkflowIdentity

'v1 identities.
Public StateMachineNumberGuessIdentity_v1 As WorkflowIdentity
Public FlowchartNumberGuessIdentity_v1 As WorkflowIdentity
Public SequentialNumberGuessIdentity_v1 As WorkflowIdentity

'v1.5 (Dynamic Update) identities.
Public StateMachineNumberGuessIdentity_v15 As WorkflowIdentity
Public FlowchartNumberGuessIdentity_v15 As WorkflowIdentity
Public SequentialNumberGuessIdentity_v15 As WorkflowIdentity

// Current version identities.
static public WorkflowIdentity StateMachineNumberGuessIdentity;
static public WorkflowIdentity FlowchartNumberGuessIdentity;
static public WorkflowIdentity SequentialNumberGuessIdentity;

// v1 identities.
static public WorkflowIdentity StateMachineNumberGuessIdentity_v1;
static public WorkflowIdentity FlowchartNumberGuessIdentity_v1;
static public WorkflowIdentity SequentialNumberGuessIdentity_v1;

// v1.5 (Dynamic Update) identities.
static public WorkflowIdentity StateMachineNumberGuessIdentity_v15;
static public WorkflowIdentity FlowchartNumberGuessIdentity_v15;
static public WorkflowIdentity SequentialNumberGuessIdentity_v15;

Voeg de volgende code toe aan het einde van de constructor. Met deze code worden de identiteiten van de werkstroom voor dynamische updates geïnitialiseerd, de bijbehorende werkstroomdefinities geladen en toegevoegd aan de woordenlijst van de werkstroomversie.

'Initialize the dynamic update workflow identities.
StateMachineNumberGuessIdentity_v15 = New WorkflowIdentity With
{
    .Name = "StateMachineNumberGuessWorkflow",
    .Version = New Version(1, 5, 0, 0)
}

FlowchartNumberGuessIdentity_v15 = New WorkflowIdentity With
{
    .Name = "FlowchartNumberGuessWorkflow",
    .Version = New Version(1, 5, 0, 0)
}

SequentialNumberGuessIdentity_v15 = New WorkflowIdentity With
{
    .Name = "SequentialNumberGuessWorkflow",
    .Version = New Version(1, 5, 0, 0)
}

'Add the dynamic update workflow identities to the dictionary along with
'the corresponding workflow definitions loaded from the v15 assembly.
'Assembly.LoadFile requires an absolute path so convert this relative path
'to an absolute path.
Dim v15AssemblyPath As String = "..\..\..\PreviousVersions\NumberGuessWorkflowActivities_v15.dll"
v15AssemblyPath = Path.GetFullPath(v15AssemblyPath)
Dim v15Assembly As Assembly = Assembly.LoadFile(v15AssemblyPath)

map.Add(StateMachineNumberGuessIdentity_v15,
    v15Assembly.CreateInstance("NumberGuessWorkflowActivities.StateMachineNumberGuessWorkflow"))

map.Add(SequentialNumberGuessIdentity_v15,
    v15Assembly.CreateInstance("NumberGuessWorkflowActivities.SequentialNumberGuessWorkflow"))

map.Add(FlowchartNumberGuessIdentity_v15,
    v15Assembly.CreateInstance("NumberGuessWorkflowActivities.FlowchartNumberGuessWorkflow"))

// Initialize the dynamic update workflow identities.
StateMachineNumberGuessIdentity_v15 = new WorkflowIdentity
{
    Name = "StateMachineNumberGuessWorkflow",
    Version = new Version(1, 5, 0, 0)
};

FlowchartNumberGuessIdentity_v15 = new WorkflowIdentity
{
    Name = "FlowchartNumberGuessWorkflow",
    Version = new Version(1, 5, 0, 0)
};

SequentialNumberGuessIdentity_v15 = new WorkflowIdentity
{
    Name = "SequentialNumberGuessWorkflow",
    Version = new Version(1, 5, 0, 0)
};

// Add the dynamic update workflow identities to the dictionary along with
// the corresponding workflow definitions loaded from the v15 assembly.
// Assembly.LoadFile requires an absolute path so convert this relative path
// to an absolute path.
string v15AssemblyPath = @"..\..\..\PreviousVersions\NumberGuessWorkflowActivities_v15.dll";
v15AssemblyPath = Path.GetFullPath(v15AssemblyPath);
Assembly v15Assembly = Assembly.LoadFile(v15AssemblyPath);

map.Add(StateMachineNumberGuessIdentity_v15,
    v15Assembly.CreateInstance("NumberGuessWorkflowActivities.StateMachineNumberGuessWorkflow") as Activity);

map.Add(SequentialNumberGuessIdentity_v15,
    v15Assembly.CreateInstance("NumberGuessWorkflowActivities.SequentialNumberGuessWorkflow") as Activity);

map.Add(FlowchartNumberGuessIdentity_v15,
    v15Assembly.CreateInstance("NumberGuessWorkflowActivities.FlowchartNumberGuessWorkflow") as Activity);

Het volgende voorbeeld is de voltooide WorkflowVersionMap klasse.

Public Module WorkflowVersionMap
    Dim map As Dictionary(Of WorkflowIdentity, Activity)

    'Current version identities.
    Public StateMachineNumberGuessIdentity As WorkflowIdentity
    Public FlowchartNumberGuessIdentity As WorkflowIdentity
    Public SequentialNumberGuessIdentity As WorkflowIdentity

    'v1 identities.
    Public StateMachineNumberGuessIdentity_v1 As WorkflowIdentity
    Public FlowchartNumberGuessIdentity_v1 As WorkflowIdentity
    Public SequentialNumberGuessIdentity_v1 As WorkflowIdentity

    'v1.5 (Dynamic Update) identities.
    Public StateMachineNumberGuessIdentity_v15 As WorkflowIdentity
    Public FlowchartNumberGuessIdentity_v15 As WorkflowIdentity
    Public SequentialNumberGuessIdentity_v15 As WorkflowIdentity

    Sub New()
        map = New Dictionary(Of WorkflowIdentity, Activity)

        'Add the current workflow version identities.
        StateMachineNumberGuessIdentity = New WorkflowIdentity With
        {
            .Name = "StateMachineNumberGuessWorkflow",
            .Version = New Version(2, 0, 0, 0)
        }

        FlowchartNumberGuessIdentity = New WorkflowIdentity With
        {
            .Name = "FlowchartNumberGuessWorkflow",
            .Version = New Version(2, 0, 0, 0)
        }

        SequentialNumberGuessIdentity = New WorkflowIdentity With
        {
            .Name = "SequentialNumberGuessWorkflow",
            .Version = New Version(2, 0, 0, 0)
        }

        map.Add(StateMachineNumberGuessIdentity, New StateMachineNumberGuessWorkflow())
        map.Add(FlowchartNumberGuessIdentity, New FlowchartNumberGuessWorkflow())
        map.Add(SequentialNumberGuessIdentity, New SequentialNumberGuessWorkflow())

        'Initialize the previous workflow version identities.
        StateMachineNumberGuessIdentity_v1 = New WorkflowIdentity With
        {
            .Name = "StateMachineNumberGuessWorkflow",
            .Version = New Version(1, 0, 0, 0)
        }

        FlowchartNumberGuessIdentity_v1 = New WorkflowIdentity With
        {
            .Name = "FlowchartNumberGuessWorkflow",
            .Version = New Version(1, 0, 0, 0)
        }

        SequentialNumberGuessIdentity_v1 = New WorkflowIdentity With
        {
            .Name = "SequentialNumberGuessWorkflow",
            .Version = New Version(1, 0, 0, 0)
        }

        'Add the previous version workflow identities to the dictionary along with
        'the corresponding workflow definitions loaded from the v1 assembly.
        'Assembly.LoadFile requires an absolute path so convert this relative path
        'to an absolute path.
        Dim v1AssemblyPath As String = "..\..\..\PreviousVersions\NumberGuessWorkflowActivities_v1.dll"
        v1AssemblyPath = Path.GetFullPath(v1AssemblyPath)
        Dim v1Assembly As Assembly = Assembly.LoadFile(v1AssemblyPath)

        map.Add(StateMachineNumberGuessIdentity_v1,
            v1Assembly.CreateInstance("NumberGuessWorkflowActivities.StateMachineNumberGuessWorkflow"))

        map.Add(SequentialNumberGuessIdentity_v1,
            v1Assembly.CreateInstance("NumberGuessWorkflowActivities.SequentialNumberGuessWorkflow"))

        map.Add(FlowchartNumberGuessIdentity_v1,
            v1Assembly.CreateInstance("NumberGuessWorkflowActivities.FlowchartNumberGuessWorkflow"))

        'Initialize the dynamic update workflow identities.
        StateMachineNumberGuessIdentity_v15 = New WorkflowIdentity With
        {
            .Name = "StateMachineNumberGuessWorkflow",
            .Version = New Version(1, 5, 0, 0)
        }

        FlowchartNumberGuessIdentity_v15 = New WorkflowIdentity With
        {
            .Name = "FlowchartNumberGuessWorkflow",
            .Version = New Version(1, 5, 0, 0)
        }

        SequentialNumberGuessIdentity_v15 = New WorkflowIdentity With
        {
            .Name = "SequentialNumberGuessWorkflow",
            .Version = New Version(1, 5, 0, 0)
        }

        'Add the dynamic update workflow identities to the dictionary along with
        'the corresponding workflow definitions loaded from the v15 assembly.
        'Assembly.LoadFile requires an absolute path so convert this relative path
        'to an absolute path.
        Dim v15AssemblyPath As String = "..\..\..\PreviousVersions\NumberGuessWorkflowActivities_v15.dll"
        v15AssemblyPath = Path.GetFullPath(v15AssemblyPath)
        Dim v15Assembly As Assembly = Assembly.LoadFile(v15AssemblyPath)

        map.Add(StateMachineNumberGuessIdentity_v15,
            v15Assembly.CreateInstance("NumberGuessWorkflowActivities.StateMachineNumberGuessWorkflow"))

        map.Add(SequentialNumberGuessIdentity_v15,
            v15Assembly.CreateInstance("NumberGuessWorkflowActivities.SequentialNumberGuessWorkflow"))

        map.Add(FlowchartNumberGuessIdentity_v15,
            v15Assembly.CreateInstance("NumberGuessWorkflowActivities.FlowchartNumberGuessWorkflow"))
    End Sub

    Public Function GetWorkflowDefinition(identity As WorkflowIdentity) As Activity
        Return map(identity)
    End Function

    Public Function GetIdentityDescription(identity As WorkflowIdentity) As String
        Return identity.ToString()
    End Function
End Module

public static class WorkflowVersionMap
{
    static Dictionary<WorkflowIdentity, Activity> map;

    // Current version identities.
    static public WorkflowIdentity StateMachineNumberGuessIdentity;
    static public WorkflowIdentity FlowchartNumberGuessIdentity;
    static public WorkflowIdentity SequentialNumberGuessIdentity;

    // v1 identities.
    static public WorkflowIdentity StateMachineNumberGuessIdentity_v1;
    static public WorkflowIdentity FlowchartNumberGuessIdentity_v1;
    static public WorkflowIdentity SequentialNumberGuessIdentity_v1;

    // v1.5 (Dynamic Update) identities.
    static public WorkflowIdentity StateMachineNumberGuessIdentity_v15;
    static public WorkflowIdentity FlowchartNumberGuessIdentity_v15;
    static public WorkflowIdentity SequentialNumberGuessIdentity_v15;

    static WorkflowVersionMap()
    {
        map = new Dictionary<WorkflowIdentity, Activity>();

        // Add the current workflow version identities.
        StateMachineNumberGuessIdentity = new WorkflowIdentity
        {
            Name = "StateMachineNumberGuessWorkflow",
            // Version = new Version(1, 0, 0, 0),
            Version = new Version(2, 0, 0, 0)
        };

        FlowchartNumberGuessIdentity = new WorkflowIdentity
        {
            Name = "FlowchartNumberGuessWorkflow",
            // Version = new Version(1, 0, 0, 0),
            Version = new Version(2, 0, 0, 0)
        };

        SequentialNumberGuessIdentity = new WorkflowIdentity
        {
            Name = "SequentialNumberGuessWorkflow",
            // Version = new Version(1, 0, 0, 0),
            Version = new Version(2, 0, 0, 0)
        };

        map.Add(StateMachineNumberGuessIdentity, new StateMachineNumberGuessWorkflow());
        map.Add(FlowchartNumberGuessIdentity, new FlowchartNumberGuessWorkflow());
        map.Add(SequentialNumberGuessIdentity, new SequentialNumberGuessWorkflow());

        // Initialize the previous workflow version identities.
        StateMachineNumberGuessIdentity_v1 = new WorkflowIdentity
        {
            Name = "StateMachineNumberGuessWorkflow",
            Version = new Version(1, 0, 0, 0)
        };

        FlowchartNumberGuessIdentity_v1 = new WorkflowIdentity
        {
            Name = "FlowchartNumberGuessWorkflow",
            Version = new Version(1, 0, 0, 0)
        };

        SequentialNumberGuessIdentity_v1 = new WorkflowIdentity
        {
            Name = "SequentialNumberGuessWorkflow",
            Version = new Version(1, 0, 0, 0)
        };

        // Add the previous version workflow identities to the dictionary along with
        // the corresponding workflow definitions loaded from the v1 assembly.
        // Assembly.LoadFile requires an absolute path so convert this relative path
        // to an absolute path.
        string v1AssemblyPath = @"..\..\..\PreviousVersions\NumberGuessWorkflowActivities_v1.dll";
        v1AssemblyPath = Path.GetFullPath(v1AssemblyPath);
        Assembly v1Assembly = Assembly.LoadFile(v1AssemblyPath);

        map.Add(StateMachineNumberGuessIdentity_v1,
            v1Assembly.CreateInstance("NumberGuessWorkflowActivities.StateMachineNumberGuessWorkflow") as Activity);

        map.Add(SequentialNumberGuessIdentity_v1,
            v1Assembly.CreateInstance("NumberGuessWorkflowActivities.SequentialNumberGuessWorkflow") as Activity);

        map.Add(FlowchartNumberGuessIdentity_v1,
            v1Assembly.CreateInstance("NumberGuessWorkflowActivities.FlowchartNumberGuessWorkflow") as Activity);

        // Initialize the dynamic update workflow identities.
        StateMachineNumberGuessIdentity_v15 = new WorkflowIdentity
        {
            Name = "StateMachineNumberGuessWorkflow",
            Version = new Version(1, 5, 0, 0)
        };

        FlowchartNumberGuessIdentity_v15 = new WorkflowIdentity
        {
            Name = "FlowchartNumberGuessWorkflow",
            Version = new Version(1, 5, 0, 0)
        };

        SequentialNumberGuessIdentity_v15 = new WorkflowIdentity
        {
            Name = "SequentialNumberGuessWorkflow",
            Version = new Version(1, 5, 0, 0)
        };

        // Add the dynamic update workflow identities to the dictionary along with
        // the corresponding workflow definitions loaded from the v15 assembly.
        // Assembly.LoadFile requires an absolute path so convert this relative path
        // to an absolute path.
        string v15AssemblyPath = @"..\..\..\PreviousVersions\NumberGuessWorkflowActivities_v15.dll";
        v15AssemblyPath = Path.GetFullPath(v15AssemblyPath);
        Assembly v15Assembly = Assembly.LoadFile(v15AssemblyPath);

        map.Add(StateMachineNumberGuessIdentity_v15,
            v15Assembly.CreateInstance("NumberGuessWorkflowActivities.StateMachineNumberGuessWorkflow") as Activity);

        map.Add(SequentialNumberGuessIdentity_v15,
            v15Assembly.CreateInstance("NumberGuessWorkflowActivities.SequentialNumberGuessWorkflow") as Activity);

        map.Add(FlowchartNumberGuessIdentity_v15,
            v15Assembly.CreateInstance("NumberGuessWorkflowActivities.FlowchartNumberGuessWorkflow") as Activity);
    }

    public static Activity GetWorkflowDefinition(WorkflowIdentity identity)
    {
        return map[identity];
    }

    public static string GetIdentityDescription(WorkflowIdentity identity)
    {
        return identity.ToString();
    }
}

Druk op Ctrl+Shift+B om het project te bouwen.

Dynamische updates toepassen

Klik met de rechtermuisknop op WF45GettingStartedTutorial in Solution Explorer en kies Toevoegen, Nieuw project.
Selecteer in het geïnstalleerde knooppunt Visual C#, Windows (of Visual Basic, Windows).

Notitie

Afhankelijk van de programmeertaal die is geconfigureerd als de primaire taal in Visual Studio, bevindt het knooppunt Visual C# of Visual Basic zich mogelijk onder het knooppunt Overige talen in het geïnstalleerde knooppunt.

Zorg ervoor dat .NET Framework 4.5 is geselecteerd in de vervolgkeuzelijst .NET Framework-versie. Selecteer Consoletoepassing in de Windows-lijst . Typ ApplyDynamicUpdate in het vak Naam en klik op OK.
Klik met de rechtermuisknop op ApplyDynamicUpdate in Solution Explorer en kies Verwijzing toevoegen.
Klik op Oplossing en schakel het selectievakje naast NumberGuessWorkflowHost in. Deze verwijzing is nodig, zodat ApplyDynamicUpdate de NumberGuessWorkflowHost.WorkflowVersionMap klasse kan worden gebruikt.
Selecteer Framework in het knooppunt Assembly's in de lijst Verwijzing toevoegen. Typ System.Activities in het vak Zoekassembly's . Hiermee worden de assembly's gefilterd en worden de gewenste verwijzingen gemakkelijker te selecteren.
Schakel het selectievakje naast System.Activities in de lijst met zoekresultaten in.
Typ serialisatie in het vak Zoekassembly's en schakel het selectievakje naast System.Runtime.Serialization in de lijst met zoekresultaten in.
Typ DurableInstancing in het vak Zoekassembly's en schakel het selectievakje naast System.Activities.DurableInstancing en System.Runtime.DurableInstancing in de lijst met zoekresultaten in.
Klik op OK om Reference Manager te sluiten en de verwijzingen toe te voegen.
Klik met de rechtermuisknop op ApplyDynamicUpdate in Solution Explorer en kies Toevoegen, Klasse. Typ DynamicUpdateInfo in het vak Naam en klik op Toevoegen.
Voeg de volgende twee leden toe aan de DynamicUpdateInfo klas. Het volgende voorbeeld is de voltooide DynamicUpdateInfo klasse. Deze klasse bevat informatie over de updatetoewijzing en de nieuwe werkstroomidentiteit die wordt gebruikt wanneer een werkstroomexemplaren worden bijgewerkt.
```
Public Class DynamicUpdateInfo
    Public updateMap As DynamicUpdateMap
    Public newIdentity As WorkflowIdentity
End Class
```
```
class DynamicUpdateInfo
{
    public DynamicUpdateMap updateMap;
    public WorkflowIdentity newIdentity;
}
```

Voeg de volgende using (of Imports) instructies toe boven aan het bestand met de andere using (of Imports) instructies.

Imports System.Activities
Imports System.Activities.DynamicUpdate

using System.Activities;
using System.Activities.DynamicUpdate;

Dubbelklik op Program.cs (of Module1.vb) in Solution Explorer.

Voeg de volgende using (of Imports) instructies toe boven aan het bestand met de andere using (of Imports) instructies.

Imports NumberGuessWorkflowHost
Imports System.Data.SqlClient
Imports System.Activities.DynamicUpdate
Imports System.IO
Imports System.Runtime.Serialization
Imports System.Activities
Imports System.Activities.DurableInstancing

using NumberGuessWorkflowHost;
using System.Data;
using System.Data.SqlClient;
using System.Activities;
using System.Activities.DynamicUpdate;
using System.IO;
using System.Runtime.Serialization;
using System.Activities.DurableInstancing;

Voeg het volgende verbindingsreeks lid toe aan de Program klasse (ofModule1).

Const connectionString = "Server=.\SQLEXPRESS;Initial Catalog=WF45GettingStartedTutorial;Integrated Security=SSPI"

const string connectionString = "Server=.\\SQLEXPRESS;Initial Catalog=WF45GettingStartedTutorial;Integrated Security=SSPI";

Notitie

Afhankelijk van uw editie van SQL Server kan de naam van de verbindingsreeks-server afwijken.

Voeg de volgende GetIDs methode toe aan de Program klasse (of Module1). Deze methode retourneert een lijst met persistente id's voor werkstroomexemplaren.

Function GetIds() As IList(Of Guid)
    Dim Ids As New List(Of Guid)
    Dim localCmd = _
        String.Format("Select [InstanceId] from [System.Activities.DurableInstancing].[Instances] Order By [CreationTime]")
    Using localCon = New SqlConnection(connectionString)
        Dim cmd As SqlCommand = localCon.CreateCommand()
        cmd.CommandText = localCmd
        localCon.Open()
        Using reader = cmd.ExecuteReader(CommandBehavior.CloseConnection)
            While reader.Read()
                'Get the InstanceId of the persisted Workflow
                Dim id As Guid = Guid.Parse(reader(0).ToString())

                'Add it to the list.
                Ids.Add(id)
            End While
        End Using
    End Using

    Return Ids
End Function

static IList<Guid> GetIds()
{
    List<Guid> Ids = new List<Guid>();
    string localCmd = string.Format("Select [InstanceId] from [System.Activities.DurableInstancing].[Instances] Order By [CreationTime]");
    using (SqlConnection localCon = new SqlConnection(connectionString))
    {
        SqlCommand cmd = localCon.CreateCommand();
        cmd.CommandText = localCmd;
        localCon.Open();
        using (SqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection))
        {
            while (reader.Read())
            {
                // Get the InstanceId of the persisted Workflow
                Guid id = Guid.Parse(reader[0].ToString());

                // Add it to the list.
                Ids.Add(id);
            }
        }
    }

    return Ids;
}

Voeg de volgende LoadMap methode toe aan de Program klasse (of Module1). Met deze methode maakt u een woordenlijst waarmee werkstroom-id's worden toegewezen v1 aan de updatetoewijzingen en nieuwe werkstroomidentiteiten die worden gebruikt om de bijbehorende persistente werkstroomexemplaren bij te werken.

Function LoadMap(mapName As String) As DynamicUpdateMap
    Dim mapPath As String = Path.Combine("..\..\..\PreviousVersions", mapName)

    Dim map As DynamicUpdateMap
    Using fs As FileStream = File.Open(mapPath, FileMode.Open)
        Dim serializer As DataContractSerializer = New DataContractSerializer(GetType(DynamicUpdateMap))
        Dim updateMap = serializer.ReadObject(fs)
        If updateMap Is Nothing Then
            Throw New ApplicationException("DynamicUpdateMap is null.")
        End If

        map = updateMap
    End Using

    Return map
End Function

static DynamicUpdateMap LoadMap(string mapName)
{
    string path = Path.Combine(@"..\..\..\PreviousVersions", mapName);

    DynamicUpdateMap map;
    using (FileStream fs = File.Open(path, FileMode.Open))
    {
        DataContractSerializer serializer = new DataContractSerializer(typeof(DynamicUpdateMap));
        object updateMap = serializer.ReadObject(fs);
        if (updateMap == null)
        {
            throw new ApplicationException("DynamicUpdateMap is null.");
        }

        map = updateMap as DynamicUpdateMap;
    }

    return map;
}

Voeg de volgende LoadMaps methode toe aan de Program klasse (of Module1). Met deze methode worden de drie updatekaarten geladen en wordt een woordenlijst gemaakt waarmee werkstroomidentiteiten worden toegewezen v1 aan de updatekaarten.

Function LoadMaps() As IDictionary(Of WorkflowIdentity, DynamicUpdateInfo)
    'There are 3 update maps to describe the changes to update v1 workflows,
    'one for reach of the 3 workflow types in the tutorial.
    Dim maps = New Dictionary(Of WorkflowIdentity, DynamicUpdateInfo)()

    Dim sequentialMap As DynamicUpdateMap = LoadMap("SequentialNumberGuessWorkflow.map")
    Dim sequentialInfo = New DynamicUpdateInfo With
    {
        .updateMap = sequentialMap,
        .newIdentity = WorkflowVersionMap.SequentialNumberGuessIdentity_v15
    }
    maps.Add(WorkflowVersionMap.SequentialNumberGuessIdentity_v1, sequentialInfo)

    Dim stateMap As DynamicUpdateMap = LoadMap("StateMachineNumberGuessWorkflow.map")
    Dim stateInfo = New DynamicUpdateInfo With
    {
        .updateMap = stateMap,
        .newIdentity = WorkflowVersionMap.StateMachineNumberGuessIdentity_v15
    }
    maps.Add(WorkflowVersionMap.StateMachineNumberGuessIdentity_v1, stateInfo)

    Dim flowchartMap As DynamicUpdateMap = LoadMap("FlowchartNumberGuessWorkflow.map")
    Dim flowchartInfo = New DynamicUpdateInfo With
    {
        .updateMap = flowchartMap,
        .newIdentity = WorkflowVersionMap.FlowchartNumberGuessIdentity_v15
    }
    maps.Add(WorkflowVersionMap.FlowchartNumberGuessIdentity_v1, flowchartInfo)

    Return maps
End Function

static IDictionary<WorkflowIdentity, DynamicUpdateInfo> LoadMaps()
{
    // There are 3 update maps to describe the changes to update v1 workflows,
    // one for reach of the 3 workflow types in the tutorial.
    Dictionary<WorkflowIdentity, DynamicUpdateInfo> maps =
        new Dictionary<WorkflowIdentity, DynamicUpdateInfo>();

    DynamicUpdateMap sequentialMap = LoadMap("SequentialNumberGuessWorkflow.map");
    DynamicUpdateInfo sequentialInfo = new DynamicUpdateInfo
    {
        updateMap = sequentialMap,
        newIdentity = WorkflowVersionMap.SequentialNumberGuessIdentity_v15
    };
    maps.Add(WorkflowVersionMap.SequentialNumberGuessIdentity_v1, sequentialInfo);

    DynamicUpdateMap stateMap = LoadMap("StateMachineNumberGuessWorkflow.map");
    DynamicUpdateInfo stateInfo = new DynamicUpdateInfo
    {
        updateMap = stateMap,
        newIdentity = WorkflowVersionMap.StateMachineNumberGuessIdentity_v15
    };
    maps.Add(WorkflowVersionMap.StateMachineNumberGuessIdentity_v1, stateInfo);

    DynamicUpdateMap flowchartMap = LoadMap("FlowchartNumberGuessWorkflow.map");
    DynamicUpdateInfo flowchartInfo = new DynamicUpdateInfo
    {
        updateMap = flowchartMap,
        newIdentity = WorkflowVersionMap.FlowchartNumberGuessIdentity_v15
    };
    maps.Add(WorkflowVersionMap.FlowchartNumberGuessIdentity_v1, flowchartInfo);

    return maps;
}

Voeg de volgende code toe aan Main. Met deze code worden de persistente werkstroomexemplaren herhaald en worden alle WorkflowIdentityexemplaren onderzocht. Als de WorkflowIdentity toewijzing wordt toegewezen aan een v1 werkstroomexemplaren, wordt een WorkflowApplication geconfigureerd met de bijgewerkte werkstroomdefinitie en een bijgewerkte werkstroomidentiteit. Vervolgens wordt WorkflowApplication.Load het aangeroepen met het exemplaar en de updatetoewijzing, waarmee de dynamische updatetoewijzing wordt toegepast. Zodra de update is toegepast, blijft het bijgewerkte exemplaar behouden met een aanroep naar Unload.

Dim store = New SqlWorkflowInstanceStore(connectionString)
WorkflowApplication.CreateDefaultInstanceOwner(store, Nothing, WorkflowIdentityFilter.Any)

Dim updateMaps As IDictionary(Of WorkflowIdentity, DynamicUpdateInfo) = LoadMaps()

For Each id As Guid In GetIds()
    'Get a proxy to the instance.
    Dim instance As WorkflowApplicationInstance = WorkflowApplication.GetInstance(id, store)

    Console.WriteLine("Inspecting: {0}", instance.DefinitionIdentity)

    'Only update v1 workflows.
    If Not instance.DefinitionIdentity Is Nothing AndAlso _
        instance.DefinitionIdentity.Version.Equals(New Version(1, 0, 0, 0)) Then

        Dim info As DynamicUpdateInfo = updateMaps(instance.DefinitionIdentity)

        'Associate the persisted WorkflowApplicationInstance with
        'a WorkflowApplication that is configured with the updated
        'definition and updated WorkflowIdentity.
        Dim wf As Activity = WorkflowVersionMap.GetWorkflowDefinition(info.newIdentity)
        Dim wfApp = New WorkflowApplication(wf, info.newIdentity)

        'Apply the Dynamic Update.
        wfApp.Load(instance, info.updateMap)

        'Persist the updated instance.
        wfApp.Unload()

        Console.WriteLine("Updated to: {0}", info.newIdentity)
    Else
        'Not updating this instance, so unload it.
        instance.Abandon()
    End If
Next

SqlWorkflowInstanceStore store = new SqlWorkflowInstanceStore(connectionString);
WorkflowApplication.CreateDefaultInstanceOwner(store, null, WorkflowIdentityFilter.Any);

IDictionary<WorkflowIdentity, DynamicUpdateInfo> updateMaps = LoadMaps();

foreach (Guid id in GetIds())
{
    // Get a proxy to the instance.
    WorkflowApplicationInstance instance =
        WorkflowApplication.GetInstance(id, store);

    Console.WriteLine("Inspecting: {0}", instance.DefinitionIdentity);

    // Only update v1 workflows.
    if (instance.DefinitionIdentity != null &&
        instance.DefinitionIdentity.Version.Equals(new Version(1, 0, 0, 0)))
    {
        DynamicUpdateInfo info = updateMaps[instance.DefinitionIdentity];

        // Associate the persisted WorkflowApplicationInstance with
        // a WorkflowApplication that is configured with the updated
        // definition and updated WorkflowIdentity.
        Activity wf = WorkflowVersionMap.GetWorkflowDefinition(info.newIdentity);
        WorkflowApplication wfApp =
            new WorkflowApplication(wf, info.newIdentity);

        // Apply the Dynamic Update.
        wfApp.Load(instance, info.updateMap);

        // Persist the updated instance.
        wfApp.Unload();

        Console.WriteLine("Updated to: {0}", info.newIdentity);
    }
    else
    {
        // Not updating this instance, so unload it.
        instance.Abandon();
    }
}

Klik met de rechtermuisknop op ApplyDynamicUpdate in Solution Explorer en kies Instellen als Opstartproject.
Druk op Ctrl+Shift+B om de oplossing te bouwen en druk vervolgens op Ctrl+F5 om de ApplyDynamicUpdate toepassing uit te voeren en de persistente werkstroomexemplaren bij te werken. De uitvoer ziet er als volgt uit. De werkstromen 1.0.0.0 worden bijgewerkt naar versie 1.5.0.0.0, terwijl de werkstromen van versie 2.0.0.0 niet worden bijgewerkt.

Inspecteren: StateMachineNumberGuessWorkflow; Versie=1.0.0.0
Bijgewerkt naar: StateMachineNumberGuessWorkflow; Versie=1.5.0.0
Inspecteren: StateMachineNumberGuessWorkflow; Versie=1.0.0.0
Bijgewerkt naar: StateMachineNumberGuessWorkflow; Versie=1.5.0.0
Inspecteren: FlowchartNumberGuessWorkflow; Versie=1.0.0.0
Bijgewerkt naar: FlowchartNumberGuessWorkflow; Versie=1.5.0.0
Inspecteren: FlowchartNumberGuessWorkflow; Versie=1.0.0.0
Bijgewerkt naar: FlowchartNumberGuessWorkflow; Versie=1.5.0.0
Inspecteren: SequentialNumberGuessWorkflow; Versie=1.0.0.0
Bijgewerkt naar: SequentialNumberGuessWorkflow; Versie=1.5.0.0
Inspecteren: SequentialNumberGuessWorkflow; Versie=1.0.0.0
Bijgewerkt naar: SequentialNumberGuessWorkflow; Versie=1.5.0.0
Inspecteren: SequentialNumberGuessWorkflow; Versie=1.0.0.0
Bijgewerkt naar: SequentialNumberGuessWorkflow; Versie=1.5.0.0
Inspecteren: StateMachineNumberGuessWorkflow; Versie=1.0.0.0
Bijgewerkt naar: StateMachineNumberGuessWorkflow; Versie=1.5.0.0
Inspecteren: FlowchartNumberGuessWorkflow; Versie=1.0.0.0
Bijgewerkt naar: FlowchartNumberGuessWorkflow; Versie=1.5.0.0
Inspecteren: StateMachineNumberGuessWorkflow; Versie=2.0.0.0
Inspecteren: StateMachineNumberGuessWorkflow; Versie=2.0.0.0
Inspecteren: FlowchartNumberGuessWorkflow; Versie=2.0.0.0
Inspecteren: FlowchartNumberGuessWorkflow; Versie=2.0.0.0
Inspecteren: SequentialNumberGuessWorkflow; Versie=2.0.0.0
Inspecteren: SequentialNumberGuessWorkflow; Versie=2.0.0.0
Druk op een willekeurige toets om door te gaan. . .

De toepassing uitvoeren met de bijgewerkte werkstromen

Klik met de rechtermuisknop op NumberGuessWorkflowHost in Solution Explorer en kies Instellen als Opstartproject.
Druk op CTRL + F5 om de toepassing uit te voeren.
Klik op New Game om een nieuwe werkstroom te starten en noteer de versie-informatie onder het statusvenster dat aangeeft dat de werkstroom een v2 werkstroom is.
Selecteer een van de v1 werkstromen die u aan het begin van het onderwerp Procedure hebt gestart: Meerdere versies van een werkstroom hosten naast elkaar . Houd er rekening mee dat de versie-informatie in het statusvenster aangeeft dat de werkstroom versie 1.5.0.0 is. Houd er rekening mee dat er geen informatie is aangegeven over eerdere schattingen dan of ze te hoog of te laag waren.

Geef een getal op tussen 1 en 10
Je schatting is te laag.
Noteer de InstanceId en voer vervolgens schattingen in totdat de werkstroom is voltooid. In het statusvenster wordt informatie weergegeven over de inhoud van de schatting, omdat de WriteLine activiteiten zijn bijgewerkt door de dynamische update.

Geef een getal op tussen 1 en 10
Je schatting is te laag.
Geef een getal op tussen 1 en 10
5 is te laag.
Geef een getal op tussen 1 en 10
7 is te hoog.
Geef een getal op tussen 1 en 10
Gefeliciteerd, u hebt het getal in 4 beurten geraden.
Open Windows Verkenner en navigeer naar de map NumberGuessWorkflowHost\bin\debug (of bin\release, afhankelijk van uw projectinstellingen) en open het traceringsbestand met behulp van Kladblok die overeenkomt met de voltooide werkstroom. Als u geen notitie hebt gemaakt van het InstanceId bestand, kunt u mogelijk het juiste traceringsbestand identificeren met behulp van de gewijzigde datumgegevens in Windows Verkenner. De laatste regel van de traceringsgegevens bevat de uitvoer van de zojuist toegevoegde WriteLine activiteit.

Geef een getal op tussen 1 en 10
Je schatting is te laag.
Geef een getal op tussen 1 en 10
5 is te laag.
Geef een getal op tussen 1 en 10
7 is te hoog.
Geef een getal op tussen 1 en 10
6 is juist. Je raadde het in 4 beurten.

Eerdere versies van de werkstromen inschakelen

Als u onvoldoende werkstromen hebt om bij te werken, kunt u de NumberGuessWorkflowHost toepassing wijzigen om eerdere versies van de werkstromen in te schakelen.

Dubbelklik op WorkflowHostForm in Solution Explorer en selecteer de keuzelijst met invoervak WorkflowType.
Selecteer in het venster Eigenschappen de eigenschap Items en klik op de knop met het beletselteken om de verzameling Items te bewerken.

Voeg de volgende drie items toe aan de verzameling.

StateMachineNumberGuessWorkflow v1
FlowchartNumberGuessWorkflow v1
SequentialNumberGuessWorkflow v1

De voltooide Items verzameling bevat zes items.

StateMachineNumberGuessWorkflow
FlowchartNumberGuessWorkflow
SequentialNumberGuessWorkflow
StateMachineNumberGuessWorkflow v1
FlowchartNumberGuessWorkflow v1
SequentialNumberGuessWorkflow v1

Dubbelklik op WorkflowHostForm in Solution Explorer en selecteer Code weergeven.

Voeg drie nieuwe cases toe aan de switch instructie (of Select Case) in de NewGame_Click handler om de nieuwe items in de keuzelijst met invoervak WorkflowType toe te wijzen aan de overeenkomende werkstroomidentiteiten.

Case "SequentialNumberGuessWorkflow v1"
    identity = WorkflowVersionMap.SequentialNumberGuessIdentity_v1

Case "StateMachineNumberGuessWorkflow v1"
    identity = WorkflowVersionMap.StateMachineNumberGuessIdentity_v1

Case "FlowchartNumberGuessWorkflow v1"
    identity = WorkflowVersionMap.FlowchartNumberGuessIdentity_v1

case "SequentialNumberGuessWorkflow v1":
    identity = WorkflowVersionMap.SequentialNumberGuessIdentity_v1;
    break;

case "StateMachineNumberGuessWorkflow v1":
    identity = WorkflowVersionMap.StateMachineNumberGuessIdentity_v1;
    break;

case "FlowchartNumberGuessWorkflow v1":
    identity = WorkflowVersionMap.FlowchartNumberGuessIdentity_v1;
    break;

Het volgende voorbeeld bevat de volledige switch (of Select Case) instructie.

Select Case WorkflowType.SelectedItem.ToString()
    Case "SequentialNumberGuessWorkflow"
        identity = WorkflowVersionMap.SequentialNumberGuessIdentity

    Case "StateMachineNumberGuessWorkflow"
        identity = WorkflowVersionMap.StateMachineNumberGuessIdentity

    Case "FlowchartNumberGuessWorkflow"
        identity = WorkflowVersionMap.FlowchartNumberGuessIdentity

    Case "SequentialNumberGuessWorkflow v1"
        identity = WorkflowVersionMap.SequentialNumberGuessIdentity_v1

    Case "StateMachineNumberGuessWorkflow v1"
        identity = WorkflowVersionMap.StateMachineNumberGuessIdentity_v1

    Case "FlowchartNumberGuessWorkflow v1"
        identity = WorkflowVersionMap.FlowchartNumberGuessIdentity_v1
End Select

switch (WorkflowType.SelectedItem.ToString())
{
    case "SequentialNumberGuessWorkflow":
        identity = WorkflowVersionMap.SequentialNumberGuessIdentity;
        break;

    case "StateMachineNumberGuessWorkflow":
        identity = WorkflowVersionMap.StateMachineNumberGuessIdentity;
        break;

    case "FlowchartNumberGuessWorkflow":
        identity = WorkflowVersionMap.FlowchartNumberGuessIdentity;
        break;

    case "SequentialNumberGuessWorkflow v1":
        identity = WorkflowVersionMap.SequentialNumberGuessIdentity_v1;
        break;

    case "StateMachineNumberGuessWorkflow v1":
        identity = WorkflowVersionMap.StateMachineNumberGuessIdentity_v1;
        break;

    case "FlowchartNumberGuessWorkflow v1":
        identity = WorkflowVersionMap.FlowchartNumberGuessIdentity_v1;
        break;
};

Druk op Ctrl+F5 om de toepassing te bouwen en uit te voeren. U kunt nu de v1 versies van de werkstroom en de huidige versies starten. Als u deze nieuwe exemplaren dynamisch wilt bijwerken, voert u de toepassing ApplyDynamicUpdate uit.

Delen via

Procedure: De definitie van een actief werkstroomexemplaren bijwerken

In dit onderwerp

Het project CreateUpdate Kaarten maken

StateMachineNumberGuessWorkflow bijwerken

FlowchartNumberGuessWorkflow bijwerken

SequentialNumberGuessWorkflow bijwerken

De CreateUpdate Kaarten-toepassing bouwen en uitvoeren

De bijgewerkte werkstroomassembly bouwen

WorkflowVersionMap bijwerken met de nieuwe versies

Dynamische updates toepassen

De toepassing uitvoeren met de bijgewerkte werkstromen

Eerdere versies van de werkstromen inschakelen

Feedback

Aanvullende resources