Serializar flujos de trabajo y actividades a y de XAML

Este tema es aplicable a Windows Workflow Foundation 4.

Además de compilarse en tipos incluidos en ensamblados, las definiciones de flujo de trabajo también se pueden serializar en XAML. Estas definiciones serializadas se pueden recargar para edición o inspección, pasar a un sistema de compilación para compilación, o bien cargar e invocar. En este tema se proporciona información general sobre la serialización de definiciones de flujo de trabajo y el trabajo con definiciones de flujo de trabajo de XAML.

Trabajar con definiciones de flujo de trabajo de XAML

Para crear una definición de flujo de trabajo para la serialización, se utiliza la clase ActivityBuilder. La creación de una clase ActivityBuilder es muy similar a la creación de una clase DynamicActivity. Se especifican los argumento deseados y se configuran las actividades que constituyen el comportamiento. En el siguiente ejemplo, se crea una actividad Add que toma dos argumentos de entrada, los suma y devuelve el resultado. Dado que esta actividad devuelve un resultado, se utiliza la clase ActivityBuilder la genérica.

ActivityBuilder<int> ab = new ActivityBuilder<int>();
ab.Name = "Add";
ab.Properties.Add(new DynamicActivityProperty { Name = "Operand1", Type = typeof(InArgument<int>) });
ab.Properties.Add(new DynamicActivityProperty { Name = "Operand2", Type = typeof(InArgument<int>) });
ab.Implementation = new Sequence
{
    Activities = 
    {
        new WriteLine
        {
            Text = new VisualBasicValue<string> 
            {
                ExpressionText= "Operand1.ToString() + \" + \" + Operand2.ToString()"
            },
        },
        new Assign<int>
        {
            To = new ArgumentReference<int> { ArgumentName = "Result" },
            Value = new VisualBasicValue<int>
            {
                ExpressionText = "Operand1 + Operand2"
            }
        }
    }
};

Cada una de las instancias de DynamicActivityProperty representa uno de los argumentos de entrada al flujo de trabajo y la propiedad Implementation contiene las actividades que constituyen la lógica del flujo de trabajo.

Para serializar la definición de flujo de trabajo representada por la instancia ActivityBuilder en XAML, utilice ActivityXamlServices para crear XamlWriter y, a continuación, utilice XamlServices para serializar la definición de flujo de trabajo utilizando XamlWriter. ActivityXamlServices dispone de métodos para asignar las instancias de ActivityBuilder a y de XAML, y para cargar los flujos de trabajo de XAML y devolver una clase DynamicActivity que se pueda invocar. En el siguiente ejemplo, la instancia de ActivityBuilder del ejemplo anterior se serializa en una cadena y también se guarda en un archivo.

// Serialize the workflow to XAML and store it in a string.
StringBuilder sb = new StringBuilder();
StringWriter tw = new StringWriter(sb);
XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(new XamlXmlWriter(tw, new XamlSchemaContext()));
XamlServices.Save(xw , ab);
string serializedAB = sb.ToString();

// Display the XAML to the console.
Console.WriteLine(serializedAB);

// Serialize the workflow to XAML and save it to a file.
StreamWriter sw = File.CreateText(@"C:\Workflows\add.xaml");
XamlWriter xw2 = ActivityXamlServices.CreateBuilderWriter(new XamlXmlWriter(sw, new XamlSchemaContext()));
XamlServices.Save(xw2, ab);
sw.Close();

En el siguiente ejemplo se representa el flujo de trabajo serializado.

<Activity 
  x:TypeArguments="x:Int32" 
  x:Class="Add" 
  xmlns="https://schemas.microsoft.com/netfx/2009/xaml/activities" 
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml">
  <x:Members>
    <x:Property Name="Operand1" Type="InArgument(x:Int32)" />
    <x:Property Name="Operand2" Type="InArgument(x:Int32)" />
  </x:Members>
  <Sequence>
    <WriteLine Text="[Operand1.ToString() + &quot; + &quot; + Operand2.ToString()]" />
    <Assign x:TypeArguments="x:Int32" Value="[Operand1 + Operand2]">
      <Assign.To>
        <OutArgument x:TypeArguments="x:Int32">
          <ArgumentReference x:TypeArguments="x:Int32" ArgumentName="Result" />
          </OutArgument>
      </Assign.To>
      </Assign>
  </Sequence>
</Activity>

Para cargar un flujo de trabajo serializado, se utiliza el método ActivityXamlServicesLoad. Este método toma la definición de flujo de trabajo serializada y devuelve una clase DynamicActivity que representa la definición de flujo de trabajo. Observe que el XAML no se deserializa hasta que se llama al método CacheMetadata en el cuerpo de la clase DynamicActivity durante el proceso de validación. Si no se llama a la validación explícitamente, se realiza cuando se invoca el flujo de trabajo. Si la definición de flujo de trabajo de XAML no es válida, se produce una excepción Argument. Las excepciones que se producen desde el método CacheMetadata escapan de la llamada al método Validate y deben ser administradas por el autor de la llamada. En el siguiente ejemplo, el flujo de trabajo serializado del ejemplo anterior se carga y se invoca utilizando WorkflowInvoker.

// Load the workflow definition from XAML and invoke it.
DynamicActivity<int> wf = ActivityXamlServices.Load(new StringReader(serializedAB)) as DynamicActivity<int>;
Dictionary<string, object> wfParams = new Dictionary<string, object>
{
    { "Operand1", 25 },
    { "Operand2", 15 }
};

int result = WorkflowInvoker.Invoke(wf, wfParams);
Console.WriteLine(result);

Cuando se invoca este flujo de trabajo, en la consola se muestra el siguiente resultado.

25 + 15
40

Nota:
Para obtener más información sobre cómo invocar flujos de trabajo con argumentos de entrada y salida, vea Usar WorkflowInvoker y WorkflowApplication y Invoke.

Una definición de flujo de trabajo serializada también se puede cargar en una instancia de ActivityBuilder utilizando el método ActivityXamlServicesCreateBuilderReader. Una vez cargado un flujo de trabajo serializado en una instancia de ActivityBuilder, se puede inspeccionar y modificar. Esto resulta útil para los autores de diseñadores de flujo de trabajo personalizados y proporciona un mecanismo para guardar y recargar las definiciones de flujo de trabajo durante el proceso del diseño. En el siguiente ejemplo, se carga la definición de flujo de trabajo serializada del ejemplo anterior y se inspeccionan sus propiedades.

// Create a new ActivityBuilder and initialize it using the serialized
// workflow definition.
ActivityBuilder<int> ab2 = XamlServices.Load(
    ActivityXamlServices.CreateBuilderReader(
    new XamlXmlReader(new StringReader(serializedAB)))) as ActivityBuilder<int>;

// Now you can continue working with the ActivityBuilder, inspect
// properties, etc...
Console.WriteLine("There are {0} arguments in the activity builder.", ab2.Properties.Count);