Il blog di Giuseppe Marchi - SharePoint MVP
NAVIGATION - SEARCH

Hello Workflow

Hello Workflow
Data: 07/09/2006
Categoria: Workflow Foundation
Codice d'esempio


E' notizia di pochi giorni l'uscita del .NET Framework 3.0 in RC1. Questa nuova versione, che fin'ora prendeva il nome di WinFx, contiene al suo interno 4 sotto-framework:
  • Windows Comunication Foundation – per la realizzazione di robuste applicazioni distribuite.
  • Windows Presentation Foundation – per la costruzione di rich windows smart client.
  • Windows Workflow Foundation – per la costruzione di workflow.
  • Windows CardSpace – per la gestione di identità utente in digitale.
In questo articolo, andremo ad introdurre il framework Microsoft per la costruzione di workflow: Windows Workflow Foundation.

Nota: Questo articolo è stato scritto nel periodo in cui il framework Workflow Foundation era in Beta 2.2

Innanzitutto … Cos'è un Workflow ?
Ecco, un workflow è un modello di processi umani o di sistema, definito da un'insieme di attività; queste attività rappresentano i passi del workflow e nel loro insieme possono definire delle regole, delle azioni o degli stati e tutte quante le relazioni che le legano fra loro.
Il framework Microsoft supporta due tipi di workflow: il sequential workflow e lo state machine workflow.
Un sequential workflow è rappresentato come un insieme di passi che vengono eseguiti uno dopo l'altro e fin quando questi passi non sono stati completati, il workflow non può considerarsi finito. Questi step non sono sempre eseguiti in sequenza, in quanto possono essere inseriti in rami di esecuzione paralleli dello stesso workflow.
Uno state machine workflow, invece, è composto da un insieme di stati, azioni e transizioni. Dato quindi uno stato iniziale, varie transazioni possono portare lo stato iniziale da uno stato all'altro, in base allo scatenarsi di eventi; un workflow di questo tipo termina quando si raggiunge uno stato che è stato dichiarato come stato di fine.

Windows Workflow Foundation è un framework estendibile che fornisce allo sviluppatore sia delle API .NET, che dei servizi runtime, che un designer visuale integrato con Visual Studio .NET 2005 per la creazione e il debugging dei nostri workflow.
Il grado di estensione del framework è dato dalla possibilità di creare delle proprie attività custom da inserire nei propri workflow.
Un'altra particolarità sta nel fatto che, attraverso il designer integrato in Visual Studio 2005, la costruzione "logica" del workflow può essere fatta in maniera visiva anche da una figura diversa da quella dello sviluppatore.
Una volta, però, che è stato creato un workflow, questo ha bisogno di un’applicazione "host" che lo "consumi" (ed è qui che entriamo in gioco noi sviluppatori).

N.B.: Possono fare da host sia applicazioni Windows Form che applicazioni web ASP.NET, che Console Application.

Il primo Workflow

Una volta installato il runtime, Workflow Foundation aggiunge 6 nuovi template di progetto in Visual Studio 2005, sia per C# che VB.NET:
  • Sequential Workflow Console Application – Consente di creare un sequential workflow e testarne il funzionamento in una Console Application.
  • Sequential Workflow Library – Consente di creare una libreria di sequential workflow.
  • Workflow Activity Library – Consente di creare una libreria personalizzata di attività.
  • State Machine Console Application – Consente di creare uno state machine workflow e testarne il funzionamento in una Console Application.
  • State Machine Workflow Library – Consente di creare una libreria di state machine workflow.
  • Empty Workflow – Consente di creare una libreria personalizzata di workflow e attività.
In questo primo esempio, scegliamo di creare un semplice sequential workflow e di testarne le funzionalità in una Console Application, che, come detto, farà da host per il nostro workflow.
Nella sequenza abbiamo un'unica attività, di tipo CodeActivity (attività che consente di eseguire delle linee di codice .NET all'interno del workflow), che stamperà nella console un bel "Hello Workflow".

Workflow designer
Figura 1 - Il primo workflow


Come possiamo vedere, Visual Studio 2005, ha inserito all'interno del progetto 3 files: workflow1.cs, workflow1.designer.cs e program.cs; vediamone il codice:

workflow1.cs
namespace HelloWorkflow

{
public sealed partial class Workflow1 : SequentialWorkflowActivity
{
public Workflow1()
{
InitializeComponent();
}

private void helloWorldCodeActivity_ExecuteCode(object sender, EventArgs e)
{
Console.WriteLine("Hello WORKFLOW !");
}
}
}

Questa è la classe che rappresenta il nostro workflow. E' una classe partial che eredita dalla classe SequentialWorkflowActivity con all'interno l'event handler proprio della CodeActivity che abbiamo inserito nella sequenza.
Il resto del codice utile all'inzializzazione dei componenti utilizzati nel workflow sta nella classe workflow1.designer.cs:

workflow1.designer.cs
namespace HelloWorkflow

{
partial class Workflow1
{
#region Designer generated code
[System.Diagnostics.DebuggerNonUserCode]
private void InitializeComponent()
{
this.CanModifyActivities = true;
this.helloWorldCodeActivity =
new System.Workflow.Activities.CodeActivity();
// // helloWorldCodeActivity // this.helloWorldCodeActivity.Name = "helloWorldCodeActivity";
this.helloWorldCodeActivity.ExecuteCode +=
new System.EventHandler(this.helloWorldCodeActivity_ExecuteCode);
// // Workflow1 // this.Activities.Add(this.helloWorldCodeActivity);
this.Name = "Workflow1";
this.CanModifyActivities = false;
}
#endregion
private CodeActivity helloWorldCodeActivity;
}
}

Infine, il file program.cs. Questa classe è la console application di test che fa da host al nostro workflow.

program.cs
namespace HelloWorkflow

{
class Program
{
static void Main(string[] args)
{
using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
AutoResetEvent waitHandle = new AutoResetEvent(false);
workflowRuntime.WorkflowCompleted +=
delegate(object sender, WorkflowCompletedEventArgs e) {waitHandle.Set();};
workflowRuntime.WorkflowTerminated +=
delegate(object sender, WorkflowTerminatedEventArgs e)
{
Console.WriteLine(e.Exception.Message);
waitHandle.Set();
};

WorkflowInstance instance =
workflowRuntime.CreateWorkflow(typeof(HelloWorkflow.Workflow1));
instance.Start();

waitHandle.WaitOne();

Console.WriteLine("\n\n############################");
Console.WriteLine("Press any key to exit ...");
Console.WriteLine("############################");
Console.Read();
}
}
}
}

In questa classe è interessante notare un paio di cose: innanzitutto viene creato il runtime (attraverso la creazione di una nuova istanza della classe WorkflowRuntime), senza il quale il nostro sequential workflow non riuscirebbe ad essere eseguito. Poi vengono gestiti gli eventi WorkflowCompleted e WorkflowTerminated propri del runtime. Ed infine viene creata l'istanza propria del nostro sequential workflow e viene lanciata (attraverso la chiamata del suo metodo Start).
Tutto ciò permette all’applicazione di fungere da host per il workflow creato.

Hello Workflow: esecuzione del programma
Immagine 2: esecuzione del programma


L'esecuzione del programma, per quanto stupido, finisce con la stampa a video della frase "Hello WORKFLOW", data dall'esecuzione dell'unica attività presente all'interno del workflow.

Quello appena visto è un esempio base per la costruzione di un sequential workflow. Nei prossimi articoli andremo a scoprire le varie attività gia presenti nel framework e vedremo esempi su come implementare degli state machine workflow o su come estendere il sistema creando delle attività personalizzate.

Link utili:
WF home page
WF on msdn
Introduzione a Windows Workflow Foundation di Cristian Civera, ASP.NET MVP