Procedimiento para actualizar la definición de una instancia de flujo de trabajo en ejecuciónHow to: Update the Definition of a Running Workflow Instance

La actualización dinámica proporciona un mecanismo para que los desarrolladores de aplicaciones de flujo de trabajo actualicen la definición de flujo de trabajo de una instancia de flujo de trabajo persistente.Dynamic update provides a mechanism for workflow application developers to update the workflow definition of a persisted workflow instance. El cambio necesario puede ser implementar una corrección de errores, nuevos requisitos o dar cabida a cambios inesperados.The required change can be to implement a bug fix, new requirements, or to accommodate unexpected changes. Este paso del tutorial muestra cómo usar la actualización dinámica para modificar las instancias conservadas de la v1 número adivinar el flujo de trabajo para que coincida con la nueva funcionalidad incluida en Cómo: Hospedar varias versiones de un flujo de trabajo Side-by-Side.This step in the tutorial demonstrates how to use dynamic update to modify persisted instances of the v1 number guessing workflow to match the new functionality introduced in How to: Host Multiple Versions of a Workflow Side-by-Side.

Nota

Para descargar una versión completada o ver un tutorial en vídeo del tutorial, vea Windows Workflow Foundation (WF45): Tutorial de introducción.To download a completed version or view a video walkthrough of the tutorial, see Windows Workflow Foundation (WF45) - Getting Started Tutorial.

En este temaIn this topic

Para crear el proyecto de CreateUpdateMapsTo create the CreateUpdateMaps project

  1. Haga clic en WF45GettingStartedTutorial en el Explorador de soluciones y elija agregar, nuevo proyecto.Right-click WF45GettingStartedTutorial in Solution Explorer and choose Add, New Project.

  2. En el instalado nodo, seleccione Visual C#, Windows (o Visual Basic, Windows).In the Installed node, select Visual C#, Windows (or Visual Basic, Windows).

    Nota

    En función del lenguaje de programación que se configure como lenguaje principal en Visual Studio, el nodo Visual C# o Visual Basic puede estar bajo el nodo Otros lenguajes en el nodo Instalado .Depending on which programming language is configured as the primary language in Visual Studio, the Visual C# or Visual Basic node may be under the Other Languages node in the Installed node.

    Asegúrese de que se haya seleccionado .NET Framework 4.5 en la lista desplegable correspondiente a la versión de .NET Framework.Ensure that .NET Framework 4.5 is selected in the .NET Framework version drop-down list. Seleccione aplicación de consola desde el Windows lista.Select Console Application from the Windows list. Tipo CreateUpdateMaps en el nombre y haga clic en Aceptar.Type CreateUpdateMaps into the Name box and click OK.

  3. Haga clic en CreateUpdateMaps en el Explorador de soluciones y elija Agregar referencia.Right-click CreateUpdateMaps in Solution Explorer and choose Add Reference.

  4. Seleccione Framework desde el ensamblados nodo en el Agregar referencia lista.Select Framework from the Assemblies node in the Add Reference list. Tipo System.Activities en el buscar ensamblados cuadro para filtrar los ensamblados y facilitar las referencias deseadas seleccionar.Type System.Activities into the Search Assemblies box to filter the assemblies and make the desired references easier to select.

  5. Active la casilla situada junto a System.Activities desde el los resultados de búsqueda lista.Check the checkbox beside System.Activities from the Search Results list.

  6. Tipo serialización en el buscar ensamblados cuadro y Active la casilla situada junto a System.Runtime.Serialization desde el los resultados de búsqueda lista.Type Serialization into the Search Assemblies box, and check the checkbox beside System.Runtime.Serialization from the Search Results list.

  7. Tipo System.Xaml en el buscar ensamblados cuadro y Active la casilla situada junto a System.Xaml desde el los resultados de búsqueda lista.Type System.Xaml into the Search Assemblies box, and check the checkbox beside System.Xaml from the Search Results list.

  8. Haga clic en Aceptar para cerrar Administrador de referencias y agregar las referencias.Click OK to close Reference Manager and add the references.

  9. Agregue las siguientes instrucciones using (o Imports) al principio del archivo con las demás instrucciones using (o Imports).Add the following using (or Imports) statements at the top of the file with the other using (or Imports) statements.

    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;
    
  10. Agregue los dos miembros de cadena siguientes a la clase Program (o Module1).Add the following two string members to the Program class (or Module1).

    Const mapPath = "..\..\..\PreviousVersions"
    Const definitionPath = "..\..\..\NumberGuessWorkflowActivities_du"
    
    const string mapPath = @"..\..\..\PreviousVersions";
    const string definitionPath = @"..\..\..\NumberGuessWorkflowActivities_du";
    
  11. Agregue el siguiente método StartUpdate a la clase Program (o Module1).Add the following StartUpdate method to the Program class (or Module1). Este método carga la definición de flujo de trabajo de xaml especificada en ActivityBuilder y, a continuación, llama a DynamicUpdate.PrepareForUpdate.This method loads up the specified xaml workflow definition into an ActivityBuilder, and then calls DynamicUpdate.PrepareForUpdate. PrepareForUpdate realiza una copia de la definición de flujo de trabajo dentro de ActivityBuilder.PrepareForUpdate makes a copy of the workflow definition inside the ActivityBuilder. Después de que se modifique la definición de flujo de trabajo, esta copia se usa junto con la definición de flujo de trabajo modificado para crear la asignación de actualización.After the workflow definition is modified, this copy is used along with the modified workflow definition to create the update map.

    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;
    }
    
  12. A continuación, agregue el siguiente CreateUpdateMethod a la clase Program (o Module1).Next, add the following CreateUpdateMethod to the Program class (or Module1). Esto crea una asignación de actualización dinámica al llamar a DynamicUpdateServices.CreateUpdateMap y, a continuación, guarda la asignación de actualización con el nombre especificado.This creates a dynamic update map by calling DynamicUpdateServices.CreateUpdateMap, and then saves the update map using the specified name. Esta asignación de actualización contiene la información que necesita el runtime de flujo de trabajo para actualizar una instancia de flujo de trabajo persistente que se inició mediante la definición de flujo de trabajo inicial incluida en ActivityBuilder, de modo que se completa con la definición de flujo de trabajo actualizada.This update map contains the information needed by the workflow runtime to update a persisted workflow instance that was started using the original workflow definition contained in the ActivityBuilder so that it completes using the updated workflow definition.

    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);
        }
    }
    
  13. Agregue el siguiente método SaveUpdatedDefinition a la clase Program (o Module1).Add the following SaveUpdatedDefinition method to the Program class (or Module1). Este método guarda la definición de flujo de trabajo actualizado una vez creada la asignación de actualización.This method saves the updated workflow definition once the update map is created.

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

Para actualizar StateMachineNumberGuessWorkflowTo update StateMachineNumberGuessWorkflow

  1. Agregue CreateStateMachineUpdateMap a la clase Program (o Module1).Add a CreateStateMachineUpdateMap to the Program class (or Module1).

    Private Sub CreateStateMachineUpdateMap()
    
    End Sub
    
    private static void CreateStateMachineUpdateMap()
    {
    }
    
  2. Realice una llamada a StartUpdate y, a continuación, obtenga una referencia a la actividad StateMachine raíz del flujo de trabajo.Make a call to StartUpdate and then get a reference to the root StateMachine activity of the workflow.

    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;
    
  3. A continuación, actualice las expresiones de los dos WriteLine las actividades que se muestran si el intento del usuario es demasiado alto o demasiado bajo para que coincidan las actualizaciones realizadas en Cómo: Hospedar varias versiones de un flujo de trabajo Side-by-Side.Next, update the expressions of the two WriteLine activities that display whether the user's guess is too high or too low so that they match the updates made in How to: Host Multiple Versions of a Workflow Side-by-Side.

    '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.\"");
    
  4. A continuación, agregue la nueva actividad WriteLine que muestra el mensaje de cierre.Next, add the new WriteLine activity that displays the closing message.

    '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;
    
  5. Una vez actualizado el flujo de trabajo, llame a CreateUpdateMaps y a SaveUpdatedDefinition.After the workflow is updated, call CreateUpdateMaps and SaveUpdatedDefinition. CreateUpdateMaps crea y guarda DynamicUpdateMap, y SaveUpdatedDefinition guarda la definición de flujo de trabajo actualizada.CreateUpdateMaps creates and saves the DynamicUpdateMap, and SaveUpdatedDefinition saves the updated workflow definition.

    '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");
    

    El siguiente ejemplo es el método CreateStateMachineUpdateMap completado.The following example is the completed CreateStateMachineUpdateMap method.

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

Para actualizar FlowchartNumberGuessWorkflowTo update FlowchartNumberGuessWorkflow

  1. Agregue el siguiente CreateFlowchartUpdateMethod a la clase Program (o Module1).Add the following CreateFlowchartUpdateMethod to the Program class (or Module1). Este método es parecido a CreateStateMachineUpdateMap.This method is similar to CreateStateMachineUpdateMap. Comienza con una llamada a StartUpdate, actualiza la definición de flujo de trabajo del diagrama de flujo y finaliza guardando la asignación de actualización y la definición de flujo de trabajo actualizada.It starts with a call to StartUpdate, updates the flowchart workflow definition, and finishes by saving the update map and the updated workflow definition.

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

Para actualizar SequentialNumberGuessWorkflowTo update SequentialNumberGuessWorkflow

  1. Agregue el siguiente CreateSequentialUpdateMethod a la clase Program (o Module1).Add the following CreateSequentialUpdateMethod to the Program class (or Module1). Este método es similar a los otros dos métodos.This method is similar to the other two methods. Comienza con una llamada a StartUpdate, actualiza la definición de flujo de trabajo secuencial y finaliza guardando la asignación de actualización y la definición de flujo de trabajo actualizada.It starts with a call to StartUpdate, updates the sequential workflow definition, and finishes by saving the update map and the updated workflow definition.

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

Para compilar y ejecutar la aplicación CreateUpdateMapsTo build and run the CreateUpdateMaps application

  1. Actualice el método Main y agregue las tres llamadas de método siguientes.Update the Main method and add the following three method calls. Estos métodos se agregan en las secciones siguientes.These methods are added in the following sections. Cada método actualiza el flujo de trabajo de acierto de números correspondiente y crea un elemento DynamicUpdateMap que describe las actualizaciones.Each method updates the corresponding number guess workflow and creates a DynamicUpdateMap that describes the updates.

    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();
    }
    
  2. Haga clic en CreateUpdateMaps en el Explorador de soluciones y elija establecer como proyecto de inicio.Right-click CreateUpdateMaps in Solution Explorer and choose Set as StartUp Project.

  3. Presione CTRL+MAYÚS+B para compilar la solución y, a continuación, CTRL+F5 para ejecutar la aplicación CreateUpdateMaps.Press CTRL+SHIFT+B to build the solution, and then CTRL+F5 to run the CreateUpdateMaps application.

    Nota

    El CreateUpdateMaps aplicación no muestra ninguna información de estado mientras se está ejecutando, pero si se examinan el NumberGuessWorkflowActivities_du carpeta y el PreviousVersions carpeta verá los archivos de definición de flujo de trabajo actualizada y las asignaciones de actualización.The CreateUpdateMaps application does not display any status information while running, but if you look in the NumberGuessWorkflowActivities_du folder and the PreviousVersions folder you will see the updated workflow definition files and the update maps.

    Una vez creadas las asignaciones de actualización y actualizadas las definiciones de flujo de trabajo, el siguiente paso es compilar un ensamblado de flujo de trabajo actualizado que contenga las definiciones actualizadas.Once the update maps are created and the workflow definitions updated, the next step is to build an updated workflow assembly containing the updated definitions.

Para compilar el ensamblado de flujo de trabajo actualizadaTo build the updated workflow assembly

  1. Abra una segunda instancia de Visual Studio 2012.Open a second instance of Visual Studio 2012.

  2. Elija abierto, proyecto/solución desde el archivo menú.Choose Open, Project/Solution from the File menu.

  3. Navegue hasta la NumberGuessWorkflowActivities_du carpeta que creó en Cómo: Hospedar varias versiones de un flujo de trabajo Side-by-Side, seleccione NumberGuessWorkflowActivities.csproj (o vbproj) y haga clic en abierto.Navigate to the NumberGuessWorkflowActivities_du folder you created in How to: Host Multiple Versions of a Workflow Side-by-Side, select NumberGuessWorkflowActivities.csproj (or vbproj), and click Open.

  4. En el Explorador de soluciones, haga clic en SequentialNumberGuessWorkflow.xaml y elija excluir del proyecto.In Solution Explorer, right click SequentialNumberGuessWorkflow.xaml and choose Exclude From Project. Lo mismo FlowchartNumberGuessWorkflow.xaml y StateMachineNumberGuessWorkflow.xaml.Do the same thing for FlowchartNumberGuessWorkflow.xaml and StateMachineNumberGuessWorkflow.xaml. Este paso quita las versiones anteriores de las definiciones de flujo de trabajo del proyecto.This step removes the previous versions of the workflow definitions from the project.

  5. Elija Agregar elemento existente desde el proyecto menú.Choose Add Existing Item from the Project menu.

  6. Navegue hasta la NumberGuessWorkflowActivities_du carpeta que creó en Cómo: Hospedar varias versiones de un flujo de trabajo Side-by-Side.Navigate to the NumberGuessWorkflowActivities_du folder you created in How to: Host Multiple Versions of a Workflow Side-by-Side.

  7. Elija archivos XAML (*.xaml;*. xoml) desde el archivos de tipo lista desplegable.Choose XAML Files (*.xaml;*.xoml) from the Files of type drop-down list.

  8. Seleccione SequentialNumberGuessWorkflow_du.xaml, FlowchartNumberGuessWorkflow_du.xaml, y StateMachineNumberGuessWorkflow_du.xaml y haga clic en Agregar.Select SequentialNumberGuessWorkflow_du.xaml, FlowchartNumberGuessWorkflow_du.xaml, and StateMachineNumberGuessWorkflow_du.xaml and click Add.

    Nota

    Presione CTRL y haga clic para seleccionar varios elementos a la vez.CTRL+Click to select multiple items at a time.

    Este paso agrega las versiones actualizadas de las definiciones de flujo de trabajo al proyecto.This step adds the updated versions of the workflow definitions to the project.

  9. Presione Ctrl+Mayús+B para compilar el proyecto.Press CTRL+SHIFT+B to build the project.

  10. Elija Cerrar solución desde el archivo menú.Choose Close Solution from the File menu. Un archivo de solución para el proyecto no es necesario, haga clic en No para cerrar Visual Studio sin guardar un archivo de solución.A solution file for the project is not required, so click No to close Visual Studio without saving a solution file. Elija Exit desde el archivo menú para cerrar Visual Studio.Choose Exit from the File menu to close Visual Studio.

  11. Abra el Explorador de Windows y navegue hasta la NumberGuessWorkflowActivities_du\bin\Debug carpeta (o bin\Release según la configuración del proyecto).Open Windows Explorer and navigate to the NumberGuessWorkflowActivities_du\bin\Debug folder (or bin\Release depending on your project settings).

  12. Cambiar el nombre de NumberGuessWorkflowActivities.dll a NumberGuessWorkflowActivities_v15.dlly cópielo en el PreviousVersions carpeta que creó en Cómo: Hospedar varias versiones de un flujo de trabajo Side-by-Side.Rename NumberGuessWorkflowActivities.dll to NumberGuessWorkflowActivities_v15.dll, and copy it to the PreviousVersions folder you created in How to: Host Multiple Versions of a Workflow Side-by-Side.

Para actualizar WorkflowVersionMap con las nuevas versionesTo update WorkflowVersionMap with the new versions

  1. Cambie a la instancia inicial de Visual Studio 2012.Switch back to the initial instance of Visual Studio 2012.

  2. Haga doble clic en WorkflowVersionMap.cs (o WorkflowVersionMap.vb) en el NumberGuessWorkflowHost proyecto para abrirlo.Double-click WorkflowVersionMap.cs (or WorkflowVersionMap.vb) under the NumberGuessWorkflowHost project to open it.

  3. Agregue tres nuevas identidades de flujo de trabajo justo debajo de las seis declaraciones de identidad de flujo de trabajo existentes.Add three new workflow identities just below the six existing workflow identity declarations. En este tutorial, 1.5.0.0 se usa como WorkflowIdentity.Version para las identidades de actualización dinámica.In this tutorial, 1.5.0.0 is used as the WorkflowIdentity.Version for the dynamic update identities. Estas nuevas identidades de flujo de trabajo de v15 se usarán para proporcionar la definición de flujo de trabajo correcta para las instancias de flujo de trabajo persistentes y actualizadas dinámicamente.These new v15 workflow identities will be used provide the correct workflow definition for the dynamically updated persisted workflow instances.

    '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;
    
  4. Al final del constructor agregue el siguiente código.Add the following code at the end of the constructor. Este código inicializa las identidades de flujo de trabajo de actualización dinámica, carga las definiciones de flujo de trabajo correspondientes y las agrega al diccionario de versiones de flujo de trabajo.This code initializes the dynamic update workflow identities, loads the corresponding workflow definitions, and adds them to the workflow version dictionary.

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

    El ejemplo siguiente es la clase WorkflowVersionMap completada.The following example is the completed WorkflowVersionMap class.

    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();
        }
    }
    
  5. Presione Ctrl+Mayús+B para compilar el proyecto.Press CTRL+SHIFT+B to build the project.

Para aplicar las actualizaciones dinámicasTo apply the dynamic updates

  1. Haga clic en WF45GettingStartedTutorial en el Explorador de soluciones y elija agregar, nuevo proyecto.Right-click WF45GettingStartedTutorial in Solution Explorer and choose Add, New Project.

  2. En el instalado nodo, seleccione Visual C#, Windows (o Visual Basic, Windows).In the Installed node, select Visual C#, Windows (or Visual Basic, Windows).

    Nota

    En función del lenguaje de programación que se configure como lenguaje principal en Visual Studio, el nodo Visual C# o Visual Basic puede estar bajo el nodo Otros lenguajes en el nodo Instalado .Depending on which programming language is configured as the primary language in Visual Studio, the Visual C# or Visual Basic node may be under the Other Languages node in the Installed node.

    Asegúrese de que se haya seleccionado .NET Framework 4.5 en la lista desplegable correspondiente a la versión de .NET Framework.Ensure that .NET Framework 4.5 is selected in the .NET Framework version drop-down list. Seleccione aplicación de consola desde el Windows lista.Select Console Application from the Windows list. Tipo ApplyDynamicUpdate en el nombre y haga clic en Aceptar.Type ApplyDynamicUpdate into the Name box and click OK.

  3. Haga clic en ApplyDynamicUpdate en el Explorador de soluciones y elija Agregar referencia.Right-click ApplyDynamicUpdate in Solution Explorer and choose Add Reference.

  4. Haga clic en solución y Active la casilla junto a NumberGuessWorkflowHost.Click Solution and check the box next to NumberGuessWorkflowHost. Esta referencia es necesaria para que ApplyDynamicUpdate pueda usar la clase NumberGuessWorkflowHost.WorkflowVersionMap.This reference is needed so that ApplyDynamicUpdate can use the NumberGuessWorkflowHost.WorkflowVersionMap class.

  5. Seleccione Framework desde el ensamblados nodo en el Agregar referencia lista.Select Framework from the Assemblies node in the Add Reference list. Tipo System.Activities en el buscar ensamblados cuadro.Type System.Activities into the Search Assemblies box. Esto filtrará los ensamblados y simplificará la selección de las referencias deseadas.This will filter the assemblies and make the desired references easier to select.

  6. Active la casilla situada junto a System.Activities desde el los resultados de búsqueda lista.Check the checkbox beside System.Activities from the Search Results list.

  7. Tipo serialización en el buscar ensamblados cuadro y Active la casilla situada junto a System.Runtime.Serialization desde el los resultados de búsqueda lista.Type Serialization into the Search Assemblies box, and check the checkbox beside System.Runtime.Serialization from the Search Results list.

  8. Tipo DurableInstancing en el buscar ensamblados cuadro y Active la casilla situada junto a System.Activities.DurableInstancing y System.Runtime.DurableInstancing desde el los resultados de búsqueda lista.Type DurableInstancing into the Search Assemblies box, and check the checkbox beside System.Activities.DurableInstancing and System.Runtime.DurableInstancing from the Search Results list.

  9. Haga clic en Aceptar para cerrar Administrador de referencias y agregar las referencias.Click OK to close Reference Manager and add the references.

  10. Haga clic en ApplyDynamicUpdate en el Explorador de soluciones y elija agregar, clase.Right-click ApplyDynamicUpdate in Solution Explorer and choose Add, Class. Tipo DynamicUpdateInfo en el nombre y haga clic en agregar.Type DynamicUpdateInfo into the Name box and click Add.

  11. Agregue los dos miembros siguientes a la clase DynamicUpdateInfo.Add the following two members to the DynamicUpdateInfo class. El ejemplo siguiente es la clase DynamicUpdateInfo completada.The following example is the completed DynamicUpdateInfo class. Esta clase contiene información sobre la asignación de actualización y la nueva identidad de flujo de trabajo usada cuando se actualiza una instancia de flujo de trabajo.This class contains information on the update map and new workflow identity used when a workflow instance is updated.

    Public Class DynamicUpdateInfo
        Public updateMap As DynamicUpdateMap
        Public newIdentity As WorkflowIdentity
    End Class
    
    class DynamicUpdateInfo
    {
        public DynamicUpdateMap updateMap;
        public WorkflowIdentity newIdentity;
    }
    
  12. Agregue las siguientes instrucciones using (o Imports) al principio del archivo con las demás instrucciones using (o Imports).Add the following using (or Imports) statements at the top of the file with the other using (or Imports) statements.

    Imports System.Activities
    Imports System.Activities.DynamicUpdate
    
    using System.Activities;
    using System.Activities.DynamicUpdate;
    
  13. Haga doble clic en Program.cs (o Module1.vb) en el Explorador de soluciones.Double-click Program.cs (or Module1.vb) in Solution Explorer.

  14. Agregue las siguientes instrucciones using (o Imports) al principio del archivo con las demás instrucciones using (o Imports).Add the following using (or Imports) statements at the top of the file with the other using (or Imports) statements.

    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;
    
  15. Agregue el siguiente miembro de cadena de conexión a la clase Program (o Module1).Add the following connection string member to the Program class (or Module1).

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

    Nota

    Según la edición de SQL Server, el nombre de servidor de cadena de conexión puede ser diferente.Depending on your edition of SQL Server, the connection string server name may be different.

  16. Agregue el siguiente método GetIDs a la clase Program (o Module1).Add the following GetIDs method to the Program class (or Module1). Este método devuelve una lista de identificadores de instancia de flujo de trabajo persistente.This method returns a list of persisted workflow instance ids.

    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;
    }
    
  17. Agregue el siguiente método LoadMap a la clase Program (o Module1).Add the following LoadMap method to the Program class (or Module1). Este método crea un diccionario que asigna las identidades de flujo de trabajo de v1 a las asignaciones de actualización y a las nuevas identidades de flujo de trabajo usadas para actualizar las instancias de flujo de trabajo persistentes correspondientes.This method creates a dictionary that maps v1 workflow identities to the update maps and new workflow identities used to update the corresponding persisted workflow instances.

    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;
    }
    
  18. Agregue el siguiente método LoadMaps a la clase Program (o Module1).Add the following LoadMaps method to the Program class (or Module1). Este método carga las tres asignaciones de actualización y crea un diccionario que asigna las identidades de flujo de trabajo de v1 a las asignaciones de actualización.This method loads the three update maps and creates a dictionary that maps v1 workflow identities to the update maps.

    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;
    }
    
  19. Agregue el código siguiente a Main.Add the following code to Main. Este código repite las instancias de flujo de trabajo persistentes y examina cada WorkflowIdentity.This code iterates the persisted workflow instances and examines each WorkflowIdentity. Si WorkflowIdentity se asigna a una instancia de flujo de trabajo de v1, se configura un WorkflowApplication con la definición de flujo de trabajo actualizada y una identidad de flujo de trabajo actualizada.If the WorkflowIdentity maps to a v1 workflow instance, a WorkflowApplication is configured with the updated workflow definition and an updated workflow identity. A continuación, se llama a WorkflowApplication.Load con la instancia y la asignación de actualización, que aplica la asignación de actualización dinámica.Next, WorkflowApplication.Load is called with the instance and the update map, which applies the dynamic update map. Una vez aplicada la actualización, la instancia actualizada es persistente con una llamada a Unload.Once the update is applied, the updated instance is persisted with a call to 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();
        }
    }
    
  20. Haga clic en ApplyDynamicUpdate en el Explorador de soluciones y elija establecer como proyecto de inicio.Right-click ApplyDynamicUpdate in Solution Explorer and choose Set as StartUp Project.

  21. Presione CTRL+MAYÚS+B para compilar la solución y, a continuación, presione CTRL+F5 para ejecutar la aplicación ApplyDynamicUpdate y actualizar las instancias de flujo de trabajo persistentes.Press CTRL+SHIFT+B to build the solution, and then press CTRL+F5 to run the ApplyDynamicUpdate application and update the persisted workflow instances. Debería ver un resultado parecido al siguiente.You should see output similar to the following. Los flujos de trabajo de la versión 1.0.0.0 se actualizan a la versión 1.5.0.0, mientras que los flujos de trabajo de la versión 2.0.0.0 no se actualizan.The version 1.0.0.0 workflows are updated to version 1.5.0.0, while the version 2.0.0.0 workflows are not updated.

    Inspeccionando: StateMachineNumberGuessWorkflow; Version=1.0.0.0\Inspecting: StateMachineNumberGuessWorkflow; Version=1.0.0.0\ Actualizado para: StateMachineNumberGuessWorkflow; Version=1.5.0.0\Updated to: StateMachineNumberGuessWorkflow; Version=1.5.0.0\ Inspeccionando: StateMachineNumberGuessWorkflow; Version=1.0.0.0\Inspecting: StateMachineNumberGuessWorkflow; Version=1.0.0.0\ Actualizado para: StateMachineNumberGuessWorkflow; Version=1.5.0.0\Updated to: StateMachineNumberGuessWorkflow; Version=1.5.0.0\ Inspeccionando: FlowchartNumberGuessWorkflow; Versión = 1.0.0.0\Inspecting: FlowchartNumberGuessWorkflow; Version=1.0.0.0\ Actualizado para: FlowchartNumberGuessWorkflow; Versión = 1.5.0.0\Updated to: FlowchartNumberGuessWorkflow; Version=1.5.0.0\ Inspeccionando: FlowchartNumberGuessWorkflow; Versión = 1.0.0.0\Inspecting: FlowchartNumberGuessWorkflow; Version=1.0.0.0\ Actualizado para: FlowchartNumberGuessWorkflow; Versión = 1.5.0.0\Updated to: FlowchartNumberGuessWorkflow; Version=1.5.0.0\ Inspeccionando: SequentialNumberGuessWorkflow; Versión = 1.0.0.0\Inspecting: SequentialNumberGuessWorkflow; Version=1.0.0.0\ Actualizado para: SequentialNumberGuessWorkflow; Versión = 1.5.0.0\Updated to: SequentialNumberGuessWorkflow; Version=1.5.0.0\ Inspeccionando: SequentialNumberGuessWorkflow; Versión = 1.0.0.0\Inspecting: SequentialNumberGuessWorkflow; Version=1.0.0.0\ Actualizado para: SequentialNumberGuessWorkflow; Versión = 1.5.0.0\Updated to: SequentialNumberGuessWorkflow; Version=1.5.0.0\ Inspeccionando: SequentialNumberGuessWorkflow; Versión = 1.0.0.0\Inspecting: SequentialNumberGuessWorkflow; Version=1.0.0.0\ Actualizado para: SequentialNumberGuessWorkflow; Versión = 1.5.0.0\Updated to: SequentialNumberGuessWorkflow; Version=1.5.0.0\ Inspeccionando: StateMachineNumberGuessWorkflow; Version=1.0.0.0\Inspecting: StateMachineNumberGuessWorkflow; Version=1.0.0.0\ Actualizado para: StateMachineNumberGuessWorkflow; Version=1.5.0.0\Updated to: StateMachineNumberGuessWorkflow; Version=1.5.0.0\ Inspeccionando: FlowchartNumberGuessWorkflow; Versión = 1.0.0.0\Inspecting: FlowchartNumberGuessWorkflow; Version=1.0.0.0\ Actualizado para: FlowchartNumberGuessWorkflow; Versión = 1.5.0.0\Updated to: FlowchartNumberGuessWorkflow; Version=1.5.0.0\ Inspeccionando: StateMachineNumberGuessWorkflow; Version=2.0.0.0\Inspecting: StateMachineNumberGuessWorkflow; Version=2.0.0.0\ Inspeccionando: StateMachineNumberGuessWorkflow; Version=2.0.0.0\Inspecting: StateMachineNumberGuessWorkflow; Version=2.0.0.0\ Inspeccionando: FlowchartNumberGuessWorkflow; Versión = 2.0.0.0\Inspecting: FlowchartNumberGuessWorkflow; Version=2.0.0.0\ Inspeccionando: FlowchartNumberGuessWorkflow; Versión = 2.0.0.0\Inspecting: FlowchartNumberGuessWorkflow; Version=2.0.0.0\ Inspeccionando: SequentialNumberGuessWorkflow; Versión = 2.0.0.0\Inspecting: SequentialNumberGuessWorkflow; Version=2.0.0.0\ Inspeccionando: SequentialNumberGuessWorkflow; Versión = 2.0.0.0\Inspecting: SequentialNumberGuessWorkflow; Version=2.0.0.0\ Presione cualquier tecla para continuar...Press any key to continue . . .

Para ejecutar la aplicación con los flujos de trabajo actualizadasTo run the application with the updated workflows

  1. Haga clic en NumberGuessWorkflowHost en el Explorador de soluciones y elija establecer como proyecto de inicio.Right-click NumberGuessWorkflowHost in Solution Explorer and choose Set as StartUp Project.

  2. Presione CTRL+F5 para ejecutar la aplicación.Press CTRL+F5 to run the application.

  3. Haga clic en nuevo juego para iniciar un nuevo flujo de trabajo y tenga en cuenta la siguiente información de versión es la ventana de estado que indica el flujo de trabajo un v2 flujo de trabajo.Click New Game to start a new workflow and note the version information below the status window that indicates the workflow is a v2 workflow.

  4. Seleccione uno de los v1 flujos de trabajo se inició al principio de la Cómo: Hospedar varias versiones de un flujo de trabajo Side-by-Side tema.Select one of the v1 workflows you started at the beginning of the How to: Host Multiple Versions of a Workflow Side-by-Side topic. Tenga en cuenta que la información de versión en la ventana de estado indica que el flujo de trabajo es una versión 1.5.0.0 flujo de trabajo.Note that the version information under the status window indicates that the workflow is a version 1.5.0.0 workflow. Observe que no hay información indicada sobre intentos anteriores aparte de si eran demasiado altos o demasiado bajos.Note that there is no information indicated about previous guesses other than whether they were too high or too low.

    Escriba un número entre 1 y 10\Please enter a number between 1 and 10\ Su intento es demasiado bajo.Your guess is too low.

  5. Anote InstanceId y, a continuación, escriba números hasta que se complete el flujo de trabajo.Make a note of the InstanceId and then enter guesses until the workflow completes. La ventana de estado muestra información sobre el contenido del intento porque la actualización dinámica ha actualizado las actividades WriteLine.The status window displays information about the content of the guess because the WriteLine activities were updated by the dynamic update.

    Escriba un número entre 1 y 10\Please enter a number between 1 and 10\ Su intento es demasiado bajo.\Your guess is too low.\ Escriba un número entre 1 y 10\Please enter a number between 1 and 10\ 5 es demasiado bajo.\5 is too low.\ Escriba un número entre 1 y 10\Please enter a number between 1 and 10\ 7 es demasiado alto.\7 is too high.\ Escriba un número entre 1 y 10\Please enter a number between 1 and 10\ Enhorabuena, acertó el número en 4 intentos.Congratulations, you guessed the number in 4 turns.

  6. Abra el Explorador de Windows y navegue hasta la NumberGuessWorkflowHost\bin\debug carpeta (o bin\release según la configuración del proyecto) y abra el archivo de seguimiento con el Bloc de notas que corresponde en el flujo de trabajo completado.Open Windows Explorer and navigate to the NumberGuessWorkflowHost\bin\debug folder (or bin\release depending on your project settings) and open the tracking file using Notepad that corresponds to the completed workflow. Si no ha realizado una nota de la InstanceId es posible que pueda identificar el archivo correcto de seguimiento mediante la fecha de modificación información en el Explorador de Windows.If you did not make a note of the InstanceId you may be able to identify the correct tracking file by using the Date modified information in Windows Explorer. La última línea de la información de seguimiento contiene el resultado de la actividad WriteLine agregada recientemente.The last line of the tracking information contains the output of the newly added WriteLine activity.

    Escriba un número entre 1 y 10\Please enter a number between 1 and 10\ Su intento es demasiado bajo.\Your guess is too low.\ Escriba un número entre 1 y 10\Please enter a number between 1 and 10\ 5 es demasiado bajo.\5 is too low.\ Escriba un número entre 1 y 10\Please enter a number between 1 and 10\ 7 es demasiado alto.\7 is too high.\ Escriba un número entre 1 y 10\Please enter a number between 1 and 10\ 6 es correcto. Lo acertó en 4 intentos.6 is correct. You guessed it in 4 turns.

Para habilitar el inicio de las versiones anteriores de los flujos de trabajoTo enable starting previous versions of the workflows

Si ya no le quedan flujos de trabajo que actualizar, puede modificar la aplicación NumberGuessWorkflowHost para habilitar el inicio de versiones anteriores de los flujos de trabajo.If you run out of workflows to update, you can modify the NumberGuessWorkflowHost application to enable starting previous versions of the workflows.

  1. Haga doble clic en WorkflowHostForm en el Explorador de solucionesy seleccione el WorkflowType cuadro combinado.Double-click WorkflowHostForm in Solution Explorer, and select the WorkflowType combo box.

  2. En el propiedades ventana, seleccione el elementos propiedad y haga clic en botón de puntos suspensivos para editar el elementos colección.In the Properties window, select the Items property and click the ellipsis button to edit the Items collection.

  3. Agregue los siguientes tres elementos a la colección.Add the following three items to the collection.

    StateMachineNumberGuessWorkflow v1
    FlowchartNumberGuessWorkflow v1
    SequentialNumberGuessWorkflow v1
    

    La colección Items completa tendrá seis elementos.The completed Items collection will have six items.

    StateMachineNumberGuessWorkflow
    FlowchartNumberGuessWorkflow
    SequentialNumberGuessWorkflow
    StateMachineNumberGuessWorkflow v1
    FlowchartNumberGuessWorkflow v1
    SequentialNumberGuessWorkflow v1
    
  4. Haga doble clic en WorkflowHostForm en el Explorador de solucionesy seleccione ver código.Double-click WorkflowHostForm in Solution Explorer, and select View Code.

  5. Agregue tres nuevos casos a la switch (o Select Case) instrucción en el NewGame_Click controlador para asignar los nuevos elementos en el WorkflowType cuadro combinado para las identidades de flujo de trabajo coincidente.Add three new cases to the switch (or Select Case) statement in the NewGame_Click handler to map the new items in the WorkflowType combo box to the matching workflow identities.

    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;
    

    El ejemplo siguiente incluye la instrucción switch (o Select Case) completa.The following example contains the complete switch (or Select Case) statement.

    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;
    };
    
  6. Presione CTRL+F5 para compilar y ejecutar la aplicación.Press CTRL+F5 to build and run the application. Ahora puede iniciar las versiones v1 del flujo de trabajo así como las versiones actuales.You can now start the v1 versions of the workflow as well as the current versions. Para actualizar dinámicamente estas nuevas instancias, ejecute el ApplyDynamicUpdate aplicación.To dynamically update these new instances, run the ApplyDynamicUpdate application.