FRAMEWORK TO MODEL CROSS-CUTTING BEHAVIORAL CONCERNS IN THE
WORKFLOW DOMAIN
CROSS-REFERENCE TO RELATED APPLICATION
[0001] This application claims the benefit of U S provisional patent application No
60/615,537 filed 10/01/2004
TECHNICAL FIELD
[0002] Embodiments of the present mvention relate to the field of workflow modeling In
particular, embodiments of this invention relate to a componentized and extensible workflow
model
BACKGROUND OF THE INVENTION
[0003] Existing systems attempt to map business problems to high-level workflows by modeling the business problem However, real world workflows vary in a variety of dimensions such as (a) execution and modeling complexity, (b) knowledge of the structure of the flow at design time, (c) statically defined or ad-hoc/dynamic, (d) ease of authoring and editing the flow at various points in its hfecycle, and (e) weak or strong association of busmess logic with the core workflow process Existing models fail to accommodate all these factors [0004] Further, most existing workflow models are based on either language-based approaches (e g , BPEL4WS, XLANG/S, and WSFL) or application based approaches Language based approaches are high-level workflow languages with a closed set of pre-defined constructs help model the workflow process to the user/programmer The workflow languages carry all of the semantic information for the closed set of constructs to enable the user to build a workflow model However, the languages are not extensible by the developers and represent a closed set of primitives that constitute the workflow model The languages are tied to the language compiler shipped by the workflow system vendor Only the workflow system product vendor may extend the model by extendmg the language with a new set of constructs in a future version of the product This often requires upgrading the compiler associated with the language
[0005] Application based approaches are applications which have the workflow capabilities within the application to solve a domain specific problem These applications are not truly extensible nor do they have a programmable model
[0006] With the existing approaches, the issues of complexity, foreknowledge, dynamic workflows, authoring ease, and strength of associations with business logic and core workflows are not adequately addressed There are no extensible, customizable, and re-hostable workflow designer frameworks available to build visual workflow designers to model different classes of workflows Existing systems lack a rapid application development (RAD) style workflow design experience which allows users to graphically design the workflow process and associate the business logic m a programming language of developer's choice In addition, there are no ink-enabled workflow designers
[0007] In addition, existing systems fail to provide seamless ad-hoc or dynamic editing for executing workflows Workflow processes are dynamic and mobile m nature and their form cannot be entirely foreseen at design time The workflow processes start in a structured fashion and eventually evolve and change during the course of their execution lifetime There is a need for a workflow authoring framework that allows workflow builders to author various types of workflow models at design time as well as make ad-hoc or dynamic changes to running workflows in a seamless manner Even after a workflow process has been deployed and is running, changes in business requirements often force changing or editing the currently runnmg workflow process There is a need for a system that provides runtime authoring of a workflow process
[0008] In addition, workflow processes deal with cross cutting orthogonal and tangled concerns that span multiple steps of a workflow process model For example, while parts of the workflow process are designed to participate in long running transactions, other parts of the same process are designed for concurrent execution Still other portions of the same workflow process require tracking, while other portions handle business or application level exceptions There is a need to apply certain behaviors to one or more portions of a workflow process [0009] Some workflow modeling approaches are impractical as they require a complete flow-based description of an entire business process including all exceptions and human interventions Some of these approaches provide additional functionality as exceptions anse, while other approaches exclusively employ a constraint-based approach instead of a flow-based approach to modeling a business process Existing systems implement either the flow-based or
constraint-based approach Such systems are too inflexible to model many common business
situations
[0010] Accordingly, a componentized and extensible workflow model is desired to address
one or more of these and other disadvantages
SUMMARY OF THE INVENTION
[0011] Embodiments of the invention provide an extensible framework for building a componentized workflow model In particular, each step of a workflow process has an associated component model that describes design time aspects, compile time aspects, and runtime aspects of the workflow step Further, any developer may extend the core workflow model by authoring these components The invention includes a workflow engine that is flexible and powerful enough to coordinate the execution of vanous kinds of workflows including highly formal machine-to-machine processes, constraint-based ad-hoc human workflows, and workflows having a mixture of flow-based and constraint-based approaches The workflow engine permits activation, execution, query, and control capabilities against executing workflows For example, the invention permits ad-hoc and dynamic changes to executing workflows The workflow engine is rehostable or embeddable in a variety of host environments including both server and client environments Each specific host environment marries the workflow engine to a set of service providers The aggregate capabilities of the service providers determine the kinds of workflows that may be executed in the specific host environment
[0012] Other embodiments of the invention provide a declarative format such as an extensible orchestration markup language (XOML) for serializing a workflow model The declarative format enables a user to extend the workflow model by writing a set of components The semantics corresponding to the vanous steps of a workflow process are encapsulated in an activity validator component which validates and enforces the semantics for a given component at compile time Embodiments of the declarative format of the invention further enable the declaration and association of data with various elements of the workflow model The declarative format supports the transformation of the data through the workflow For example, the format represents external data sources such as databases or files, code snippets, and business rules within the workflow model declaratively
[0013] An embodiment of the invention provides an extensible, customizable, and re-hostable workflow designer framework to build graphical/visual workflow designers to model different classes of workflows Another embodiment of the invention supports a rapid application development style workflow design experience to allow users to graphically design a workflow process and associate business logic in any programming language Embodiments of the invention also provide ink support using pen and tablet technologies The invention provides a free form drawing surface in which a workflow drawn by a user is converted into an internal representation The invention supports creation and modification of the workflows via ink editing on the existing drawing surface (e g , add/delete activities), and ink annotation of existing workflows (e g, comments, suggestions, or reminders hand-drawn on the design surface)
[0014] Still other embodiments of the invention provide components for capturing cross cutting behaviors in a declarative way and applymg the behaviors to selected portions of a workflow model Other embodiments of the mvention execute the selected portions of the workflow model in the context of the behaviors associated therewith Embodiments of the invention provide a framework, reusable components, and a language to deal with cross cutting orthogonal and tangled concerns that span multiple steps of a workflow process model [0015] In accordance with one aspect of the invention, a computer-implemented method applies error and exception handling to one or more selected activities in a workflow The computer-implemented method includes selecting a pre-defined behavioral component The method also includes selecting one or more activities in a workflow The method also includes relating the selected behavioral component with the selected activities to enable the selected behavioral component to operate responsive to the selected activities
[0016] In accordance with another aspect of the invention, one or more computer-readable media have computer-executable modules for applymg error and exception handling to one or more selected activities m a workflow The modules mcludes a designer module for selecting a pre-defined behavioral component and for selecting one or more activities in a workflow The modules also include a context module for relating the behavioral component and the activities selected by the designer module to enable the selected behavioral component to operate responsive to the selected activities The modules also include a runtime engine module for executing the activities selected by the designer module as a function of the behavioral component related thereto by the context module
[0017] In accordance with yet another aspect of the invention, a system applies error and exception handling to one or more selected activities in a workflow The system includes a memory area stonng a plurality of activities each having a defined mterface The memory area further stores a plurality of behavioral components each conforming to the defined interface Each of the behavioral components is related to at least two of the activities The system also includes a processor configured to execute computer-executable instructions for receiving a selection from a user of one of the behavioral components stored in the memory area, receivmg a selection from the user of at least two of the activities stored in the memory area, creating a context associated with the selected behavioral component, and executing the selected activities within the created context
[0018] Alternatively, the invention may comprise various other methods and apparatuses [0019] Other features will be in part apparent and in part pointed out hereinafter
BRIEF DESCRIPTION OF THE DRAWINGS
[0020] FIG 1 is an exemplary workflow containing tasks and control flow composite
activities
[0021] FIG 2 illustrates an exemplary activity inheritance tree
[0022] FIG 3 illustrates an exemplary component model
[0023] FIG 4 illustrates an exemplary component model lifecycle
[0024] FIG 5 is a high-level application user interface for authoring workflows that relies
upon wizards for specification of the workflow
[0025] FIG 6 illustrates an exemplary workflow designer
[0026] FIG 7 illustrates an orchestration program including a receive activity followed by
a send activity
[0027] FIG 8 illustrates a schedule definition and the relationship between a visual
workflow, a serialized representation in XOML of the workflow, and the code beside of the
workflow
[0028] FIG 9 is a block diagram illustrating one example of a suitable computing system
environment in which the invention may be implemented
[0029] Appendix A describes exemplary activities
[0030] Corresponding reference characters indicate corresponding parts throughout the
drawings
DETAILED DESCRIPTION OF THE INVENTION
[0031] Embodiments of the invention model a workflow representing a process such as a business process Busmess processes are dependant and ordered tasks, activities, or the like that result in predictable and repeatable outcomes Including an organization's operating procedures, institutional working knowledge, and information resources, busmess processes are designed to satisfy defined business objectives in an efficient and timely manner In an efficient environment, the functional components of a process can be readily identified, adapted, and deployed to address ever-changing corporate requirements The workflow is an end user's experience interacting with the tasks in a business process Tasks are modeled as activities, components, or the like, each representing a unit of work that is performed by a person or machine In one embodiment, a plurality of activities is presented to a user The user selects and organizes the activities to create the workflow The created workflow is executed to model the business process Referring to FIG 1, an exemplary workflow 100 contains tasks and control flow composite activities
[0032] In one example, an orchestration engine workflow model supports modeling, authoring and executing different classes of workflows Examples include modeling a given problem in terms of a structured set of steps that occur m an ordered sequence or as a set of asynchronous events The orchestration engine coordinates the execution of schedules A schedule is an organized set of activities that is arranged hierarchically in a tree structure The execution context of, and the shared data visible to, an executing activity is provided by a scope Each activity represents a component that encapsulates metadata for the step m a workflow process The activity is the basic unit of execution in the workflow model and has associated properties, handlers, constraints and events Each activity may be configured by user code in any programming language For example, the user code may represent busmess or application logic or rules written in common language runtime (CLR) languages Each activity supports pre-interception hooks and post-interception hooks into execution m the user code Each activity has associated runtime execution semantics and behavior (e g , state management, transactions, event handlmg and exception handling) Activities may share state with other activities Activities may be primitive activities or grouped into a composite activity A primitive or basic activity has no substructure (e g , child activities), and thus is a leaf node m a tree structure A composite activity contains substructure (e g , it is the parent of one or more child activities)
[0034] In one embodiment, activities are of three types simple activity, container activity and root activity In this embodiment, there is one root activity in the model, and none or any quantity of simple activities or container activities inside the root activity A container activity may include simple or container activities The entire workflow process may be used as an activity to build higher-order workflow processes Further, an activity may be interruptible or non-interruptible A non-interruptible composite activity does not include interruptible activities A non-interruptible activity lacks services that would cause the activity to block [0035] The orchestration engine provides an exemplary set of activities Referring to FIG 2, an activity inheritance tree illustrates exemplary activities The exemplary activities listed in FIG 2 are described in detail in Appendix A In addition, any user may write one or more activities to extend the workflow model For example, the user may write activities for a specific business problem, domain, workflow standard (e g business process execution language), or a target platform The orchestration engine may provide a rich set of services to the user for writing activities which include, for example, services of analyzing code, type resolution and type system, services for serialization, and rendering [0036] In one embodiment, each activity has at least three parts metadata, mstance data, and execution logic The metadata of the activity defines data properties that may be configured For example, some activities may share a common set of metadata defined in an activity abstract base class Each activity declares its own additional metadata properties according to its needs by extending this class
[0037] The values of metadata properties will be shared by all instances of that activity across the instances of the schedule where the activity was configured For example, if a user creates a schedule A and adds a send activity to it, the send activity is given identification information (e g , "001") as part of its metadata A second send activity added to the schedule would receive its own unique identification information (e g, "002") Once multiple instances of schedule A are created and executed, all mstances of send "001" will share metadata values In contrast, the instance data of an activity defines a set of data which is specific to the instance of the activity in a running schedule instance For example, a delay activity may offer a readonly property on its instance data that is the date and time value representing the delay activity's timeout value This value is available once the delay activity has begun executmg, and it is most likely different for every single instance of the delay activity It is common to refer to
instances of schedules, and especially instances of activities and tasks, without qualifying the reference with "instance "
[0038] Composite activities have their set of child activities as another element Child activities are considered metadata in one embodiment The orchestration engine model explicitly permits manipulation of this metadata at runtime within an instance of the schedule It is possible to add new child activities to a composite activity that is part of an executing schedule instance such that only the metadata (activity tree) for that schedule instance is affected
[0039] Referring next to FIG 3, each activity has an associated set of components that forms the component model for the activity The associated set of components includes an activity executor, an activity designer, an activity senalizer, an activity validator (e g , semantic checker), and an activity code generator The activity executor is a stateless component that implements the execution semantics for the activity The activity executor works with the metadata of an activity to implement the activity A core scheduler acts as a service provider for the activity executor to provide services to the activity executor
[0040] The activity designer visually displays the design time visual representation of the activity The activity designer is a node m a designer hierarchy and may be themed or skinned The activity designer is hosted in a design environment (e g , an application program) and interacts with the host design environment via services The activity validator enforces the activity semantics at compile time as well as runtime The activity validator operates on the context of the workflow model and uses the services provided by the environment (e g , compiler, designer, or runtime) Validation occurs at various points in the lifecycle of a workflow Structural compliance checks are made when creatmg senahzed representations of the workflow, when compiling, and in response to the user's request The semantic checks may be stronger at runtime than those performed at compile-time to ensure the safety of a runtime operation such as the addition or replacement of an activity in the activity tree of a running instance The invention evaluates semantics associated with each of the activities for conformance or compliance with, for example, predefined interface requirements [0041] The activity senalizer is a component that senahzes the metadata of an activity The activity senalizer is called from the vanous model/format senalizers The entire workflow model is serialized based on an extensible schema into a declarative markup language which may be further translated into other workflow languages as desired
[0042] In one embodiment, the component model for an activity is stored as a data structure on a computer-readable medium In the data structure, the activity designer is represented by an image field storing data (e g , an icon) for visually representing the activity In addition, one or more author time fields store metadata defining properties, methods, and events associated with the activity The activity senahzer is represented by a senahzer field stonng data for transferring the metadata stored in the author time fields to a declarative representation of the activity The activity generator is represented by a business logic field stormg software code associated with the metadata stored m the author time fields The activity executor is represented by an executor field storing data for executing the software code stored in the business logic field
Scopes and Schedules
[0043] The execution context of, and the shared data visible to, an executing activity is provided by a scope A scope is one of the core activities A scope is a unifying construct for bringing together variables and the state of a long-running service with transactional semantics, error-handling semantics, compensation, event handlers, and data state management A scope may have associated exception and event handlers In one embodiment, a scope may be transactional, atomic, long running, or synchronized Concurrency control is provided for the user in cases of conflicting read-write or write-write access to user variables A scope is also a transaction boundary, an exception handlmg boundary, and a compensation boundary Smce scopes may be nested within a schedule, it is further possible to declare variables, messages, channels, and correlation sets with the same name in different scopes (even if the scopes are nested) without name collision
[0044] Scopes nested within a schedule are only executable within the context of that schedule A schedule may be compiled either as an application (e g, a standalone executable entity) or as a library (e g , for invocation from other schedules) Every schedule that is compiled as a library effectively constitutes a new activity type that may be invoked from withm other schedules A schedule's metadata includes the declaration of parameters [0045] Once a schedule is developed, instances of the developed schedule may be executed The process of activating and controlling a schedule instance is a function of the host environment in which the orchestration engine is embedded The orchestration engine provides a no-frills "simple host" that may be used to test schedules In addition, the orchestration
engine provides an activation service to promote standardization of a "service provider" model (e g , application programming interfaces) that is used alike by the engine and external applications for interacting with the service environment (1 e host) The activation service creates a schedule instance of a particular schedule type, optionally passmg parameters The schedule instance is essentially a proxy to the running schedule instance and includes an identifier that uniquely identifies the instance, a reference to the metadata (activity tree) for the schedule, and methods to suspend, resume, and terminate the instance The activation service also support finding a schedule instance based on a given schedule instance identifier
Code-Beside
[0046] A scope activity may have an associated code-beside class that includes business
logic for the scope activity Since a schedule is itself a scope, a schedule may also have a code-beside class Any scopes nested within a schedule may also have their own code-beside classes The activities that are nested within a scope share the scope's code-beside class which acts as a container for their shared data state and busmess logic For example, metadata for a code activity includes a reference to a method with a particular signature in the code-beside In another example, metadata for a send activity includes an optional reference to a code-beside method of a particular signature plus mandatory references to a message declaration and a channel declaration
[0047] Exemplary uses of code-beside include the following declaration of variables, messages, channels, and correlation sets, declaration of in/out/ref parameters, declaration of additional custom properties, preparation of a message to be sent, processing of a message that has been received, implementation of a rule expressed in code that returns a Boolean value, manipulation of locally defined variables, reading activity metadata and instance data, writing activity instance data (e g , setting a property on an activity about to be executed), raising an event, throwing an exception, enumerating and navigating the hierarchy of activities in the running schedule instance's activity tree, including across nested scopes and schedule invocation boundaries, adding new activities to a composite activity within the running schedule instance, changing the declarative rules associated with activities withm the running schedule instance, and obtaining references to, and manipulating, other running schedule instances
Behavioral Components
[0048] The orchestration engine of the invention allows developers to model cross-cutting orthogonal concerns in terms of behaviors that span across workflow activities Examples of cross-cutting or tangled concerns include transactions (e g , distributed transaction coordinator and long running), concurrency, tracking, persistence, error handling, logging, etc Applying behavioral components to workflow process modeling enables sophisticated process modularization and enables building reusable, extremely agile and reactive workflow processes Not only does it help externalize system level concerns (e g , process monitoring, tracking, persistence, transactions, and synchronization), but also business level concerns (e g , pick a web service dynamically based on the quality-of-service critena, and conditionally skip, replace, redo, add, or remove a set of execution steps in a running process to fulfill a business contract etcetera) based on an declarative criteria and/or the state of a running process [0049] Applying behavioral components provides better modularization model and helps separate the tangled concerns that crosscut any program or a component based system The cross cutting concern is captured within a modularity boundary referred to as a behavioral component A behavioral component provides the crosscut functionality In general, whenever two properties being programmed must compose differently and yet are coordmated, the properties crosscut each other Any implemented property is defined as a component if it may be cleanly encapsulated or otherwise well localized, easily accessed, and composed as necessary in a generalized procedure (e g, object, method, procedure, API) In one example, components are units of the system's functional decomposition such as image filters, bank accounts, graphical user interface widgets, or steps m a workflow model [0050] The cross-cutting concerns which span across workflow activities may be represented as workflow behavioral components Workflow behavioral components may be viewed as declarative modularity constructs These behavioral components are superimposed on a workflow application or portions of the application These are declarative in that they are schematized and described in a declarative manner
[0051] Transaction, synchronization, and exception handling are exemplary behavioral traits/concerns which are ill-suited for being modeled as composite activities These are orthogonal concerns that span and cross cut activities and business logic These are fundamentally as cross-cutting in nature as other concerns such as tracking, loggmg, and tracing Exemplary modeling rules include representing any execution logic as an activity if
the execution logic may be cleanly encapsulated as a component and representing a behavioral concern as a behavioral component if the semantics span a set of activities or components [0052] Behavioral components and activities share similarities with respect to their component models Like activities, each behavioral component declaratively describes its metadata in terms of properties, methods and events Additionally, each behavioral component has an associated designer, senahzer, and a runtime component However, the runtime component which actually implements the behavior/semantics is not the same as an activity executor in one embodiment For example, the interface contract between the scheduler and the behavioral component executor is different than an activity executor [0053] Exemplary behavioral components relate to one or more of the following error handling, exception handling, and messaging For example, the behavioral components may include a scope component and a process component The scope component relates to one or more of the following process analysis, state management, transaction, synchronization, and exception error handling The process component relates to one or more of the following transaction handling, synchronization, and exception error handlmg [0054] Behavioral components represent cross cutting concerns that span activity boundaries Activities reside in behavioral components and, by the virtue of this arrangement, inherit the behavior of a behavioral component For example, if an activity resides m an atomic transaction behavioral component, it inherits the ACID semantics during its execution In addition, the DTC transaction is also available in the context passed to it during its execution [0055] In one embodiment, an activity participates in multiple behavioral components Specifically, an activity lives in the union of a set of behavioral components referred to as a context The context is a region defined by the union of a set containing 1-n behavioral components Every behavioral component is asked to validate itself at compile time It receives the context from which it may get a list of all of the other sibling aspects, the activities contained in the context, etc The validation and error propagation is similar to that for an activity
[0056] At runtime, the scheduler gives a chance to each of the behavioral component executors of a context to mtercept and implement the behavior that behavioral component upports In one embodunent, the following operations occur durmg execution of the activities -Scheduler creates appropriate aspects on demand by readmg the object model
-Scheduler creates appropriate services by asking the behavioral Component (BehavioralComponentExecutor GetService() and pushing it in a Service Container)
-Scheduler calls BehavioralComponentExecutor Load() giving the behavioral component the chance to initialize itself
-Scheduler calls PreProcess() on every behavioral component of the context in which the Activity is placed and then calls ActivityExecutor Execute() passing the ContextService
-Scheduler calls BehavioralComponentExecutor PostProcess on each of the engulfing behavioral components
-Scheduler calls AspectExecutor Unload on each of the engulfing behavioral components
[0057] Referring to FIG 4, a block diagram illustrates an exemplary component model hfecycle A user interacts with computer-executable modules stored on one or more computer-readable media to apply error and exception handling to one or more selected activities in a workflow The computer-executable modules include a palette module 408, a designer module 402, a context module 404, and a runtime engine module 406 The user interacts with the palette module 408 to define a behavioral component The behavioral component includes user-editable metadata descnbing functionality of the behavioral component The user interacts with the designer module 402 (e g , a user interface) to select a pre-defined behavioral component and to select one or more activities in the workflow The user further interacts with the context module 404 to relate the behavioral component and the activities selected via the designer module 402 to enable the selected behavioral component to operate responsive to the selected activities That is, the designer module 402 enables the selected behavior component to perform operations responsive to execution of the selected activities For example, the selected behavioral component may catch an exception or error thrown by one of the selected activities In general, the selected behavioral component performs operations m response to output from the selected activities The user interacts with the runtime engine module 406 to execute the activities selected via the designer module 402 as a function of the behavioral component related thereto by the context module 404 The runtime engine module 406 executes the selected activities in coordination with the selected behavioral component For example, the runtime engine module 406 creates a context associated with the selected behavioral component and executes the selected activities within the created context In one
embodiment, the behavioral component includes one or more rules and the selected behavioral component applies the rules to the selected activities
[0058] The invention also supports customization of the activities to which the behavioral component applies In one example, the mvention includes receiving a user-defined activity from the user having one or more semantics associated therewith, evaluating the semantics for conformance to a predefined interface requirement, and executing the received, user-defined activity within the context created by the runtime engine module 406 as a function of the evaluation
[0059] In a system such as shown in FIG 4, a memory area stores a plurality of the activities each having a defined interface and a plurality of behavioral components each conforming to the defined interface Each of the behavioral components is related to one or more of the activities The memory area further comprises a data structure (e g , a component model) for each of the behavioral components An exemplary data structure mcludes properties, methods, events, a designer, a senalizer, and/or a runtime component Additionally, the system includes a processor configured to execute computer-executable instructions for receiving a selection from a user of one of the behavioral components stored in the memory area, receiving a selection from the user of at least two of the activities stored m the memory area, creating a context associated with the selected behavioral component, and executing the selected activities within the created context
[0060] One or more computer-readable media have computer-executable instructions for performing the methods described herein
Workflow Stencils
[0061] A workflow stencil (e g , a workflow template or an activity package) includes a root activity and a set of activities Stencils may be domain and or host specific Examples of the former include a structured workflow stencil, human workflow stencil, and an unstructured workflow stencil Some stencils may be "closed" as a set of activities including one or more roots designed to work together, possibly in a particular host environment Other stencils may be "open", to varying degrees A stencil defines its extensibility pomts For instance, a developer writes a CustomRoot and a new abstract CustomActivity and declares that the package is CustomRoot plus any activity that derives from CustomActivity [0062] An exemplary BPEL or XLANG/S stencil includes a root activity with the following characteristics participates in state management and transactions, has associated event and exception handlers, supports contract first model, may be analyzed, and has well-defined activation and termination behavior The exemplary stencil further includes a set of messaging specific activities (e g , Send and Receive and their variants) and other structured activities such as Scope, Loop, Condition, Listen, and Throw [0063] An exemplary Halifax Stencil includes a root activity with the following characteristics implicit state management, associated exception handlers (0-n), supports event based model, has well defined activation behavior, and has undefined termination The root activity contains 0-n EventDnven activities Each EventDnven Activity represents a Halifax Action Each EventDnven Activity has an associated state management protocol and executes in an atomic scope
Designer Framework (User Interface)
[0064] The orchestration engine provides a framework for designing various classes of workflow models in a WYSWYG fashion For example, referring to FIG 5, a high-level application user interface for authoring workflows relies upon wizards for specification of the workflow The framework includes a set of services and behaviors that enable developers to write visual workflow designers These services provide an efficient way of rendering a workflow process, support for Ink/Tablet for drawing the flows, and support for designer operations such as undo/redo, drag/drop, cut/copy/paste, zoom, pan, search /replace, bookmarks, adornments, smart tags for validation errors, valid drop-target indicators for activities, auto layout, view pagination, navigation markers, drag mdicators, print and preview
with headers/footers, etc Through such a user interface, simple workflows contaming tasks and control flow composite activities (e g , sequence, parallel, and conditional) may be constructed No input of code (or reliance upon existing compiled code) is required either for rule specification (e g , conditional branching logic, while looping logic) or dataflow specification (e g, the output of task A is input to task B) The serialized representation of a schedule (including rules and dataflow) is self-contained and complete in some scenarios where no code-beside is required
[0065] Using the designer framework of the invention, the orchestration engine of the invention includes a rapid application development (RAD) style visual workflow designer with support for associating software code with the workflow model in a visual way Each activity in the workflow ha# an associated activity designer Each activity designer is written in terms of framework services The framework of the invention also contains a visual designer model The visual designer model includes a set of activity designers linked with one another via relationships described in the workflow model FIG 6 illustrates an exemplary workflow designer The invention includes various modes of associating code with the workflow model including "Code-Beside", "Code-Within" and "Code-Only" which enables round-tnppmg of the user code to the workflow model in real time The invention also provides real-time emantic errors while the user is building the workflow
[0066] In one embodiment, the invention presents the user with a package identifying a plurality of activities in the designer framework user interface The mvention further receives from the user a selection and hierarchical organization of the presented activities The invention serializes the received activities to create a persistent representation of the workflow The invention further receives from the user software code representing busmess logic for association with one of the plurality of activities in the workflow The mvention may also receive a user-defined activity having one or more semantics associated therewith The invention includes a semantic checker or validator for evaluating the semantics for conformance to a predefined interface requirement If the semantics conform to the predefined interface requirement, the invention presents the user-defined activity as one of the plurality of activities The invention further compiles the software code to create one or more binary files For example, the invention compiles the serialized workflow representation and software code into a single assembly containing an executable representation of the workflow The invention
executes the created workflow In one embodiment, one or more computer-readable media have computer-executable instructions for performing the method
[0067] The orchestration engine designer allows the user to recursively compose higher order schedules by using other created schedule and usmg them The inline expansion of schedules allows the user to view the schedule contents inline and cut or copy the contents To enable the inline expansion of the schedule and to make the schedule read only, a separate design surface and designer host for the mime schedule is created Further, the composite schedule designer has its own hierarchy The invoked schedule is loaded and displayed when the designer is expanded by the user In one embodiment, the designer is collapsed when the activity is dropped or copied on the design surface A property chains the calling activity designer with the root designer of the hosted schedule The following functions prevent the adding and removing of activities from the designer
internal static bool AreAllComponentsInWntableContext(ICollection components) internal static bool IsContextReadOnly(IServiceProvider serviceProvider) [0068] These functions are called by the infrastructure to check if the context in which the activities are being inserted is writable For the hosted designer these functions return false In addition, properties are prevented from bemg modified Other functions fetch the activity designers from the appropriate components
internal static ServiceDesigner GetSafeRootDesigner(IServiceProvider serviceProvider) internal static ICompositeActivityDesigner GetSafeParentDesigner(object obj) internal static IActivityDesigner GetSafeDesigner(object obj) [0069] In one example, a user creates a schedule and compiles it as activity On successful compilation, the schedule appears on the toolbox The user opens or creates the schedule m which use of the compiled schedule is desired The user drags and drops the compiled schedule from the toolbox A collapsed schedule designer is shown on the design surface When the user wants to view the contents of the compiled schedule which was dropped, the user expands the schedule designer to show the contents of the invoked schedule inline in a read only state The miming of the called schedule enables the user to view the invoked schedule without switching between different schedule designers The feature is useful to developers composmg higher order schedules by reusing existing schedules
Support for Customization of the Designer Framework using Themes/Skins [0070] A workflow designer written using the designer framework may be customized using workflow themes These may be extensible markup language (XML) files which declaratively describe various aspects of the designer The workflow designer provides wizard support for partners to extend activities Exemplary user interface features supported by the workflow designer include, but are not limited to, undo/redo, drag/drop, cut/copy/paste, zoom, pan, search/replace, bookmarks, adornments, smart tags for validation errors, valid drop-target indicators for activities, auto layout, view pagination, navigation markers, drag mdicators, print and preview with headers/footers, and document outline integration The workflow designer supports custom designer themes/skins to enable customizing the look and feel of the designer using XML metadata The workflow designer supports background compilation In one example, smart tags and smart actions are provided for validation errors while designing the schedule The workflow designer may be hosted in any container (e g , application programs, shells, etc)
[0071] An exemplary orchestration engine program includes a receive activity followed by a send activity The process receives a message and sends it out The user creates a project called "Hello World" and adds an orchestration item to the project The user then drags and drops a scope activity onto the design surface Next, the user drops a receive activity followed by a send activity onto the scope FIG 7 illustrates the resultant workflow 700 in the designer Each activity designer provides a user mterface representation on an object model Developers are able to directly program the object model and set properties on activities or use the designer The orchestration engine designer allows a developer to select an activity from the toolbox and drag it onto the designer surface If the activity has already been placed into a schedule and needs to be moved, the developer is able to select it (by clicking on it) and drag it to the area of the schedule where it needs to go If a developer hold the control key while dragging and dropping, a copy of the selected activities selected are made [0072] Active placement provides possible drop points (targets) as visual mdicators on the design surface Auto scrolling also participates within the context of drag and drop When dealing with large schedules, navigation to areas of the designer currently not in the view port are accessible by dragging the activity towards the area of the schedule to be placed [0073] Drag and drop is supported across schedules in the same project and across schedules in other projects in the same solution After an activity has been placed onto the
design surface, the developer configures the activity Each activity has a set of properties that a developer configures in order for the schedule to be valid These properties are editable in the property browser Every activity controls what properties are viewable in the property browser To aide the developer in configuring vanous activities, the designer provides a variety of dialogs or "sub-designers" Each of the dialogs is mvoked for vanous properties of activities [0074] The orchestration engine is able to customize the activities presented in the toolbox When a developer creates a custom activity or schedule, the end result is an assembly Usmg a dialog, a developer is able to browse to the assembly location and select the assembly to make it appear as an orchestration engine activity Alternatively, a developer may place the assembly in the orchestration engine installation path and it will be present as an orchestration engine activity
Application Programming Interfaces (APIs)
[0075] In another embodiment, the invention provides application programming interfaces (APIs) for performing various workflow operations The invention includes a design application programming interface for authoring the workflow The design application programming interface comprises means for authoring a workflow and means for selecting one or more of the activities to create the workflow The mvention also mcludes a compilation application programming interface for compiling the workflow authored via the design application programming interface The compilation application programming interface comprises means for serializing the workflow, means for customizmg a visual appearance of the workflow, means for compiling the workflow authored via the design application programming interface, means for validating the workflow
[0076] The invention also includes a type provider application programming interface for associating a type with each of the activities in the workflow The type provider application programming interface comprises means for associatmg the type with each of the activities m the workflow and means for associating a type with each of the activities in the workflow [0077] One or more application programming interfaces constitute exemplary means for authoring the workflow, exemplary means for selectmg one or more of the activities to create the workflow, exemplary means for serializing the workflow, exemplary means for customizing a visual appearance of the workflow, exemplary means for validating the
workflow, exemplary means for compiling the workflow, and exemplary means for associatmg a type with each of the activities in the workflow
Activity Execution Framework
[0078] With the exception of schedule and scope, the engine views activities as abstract entities and simply coordinates the execution of activities without knowing the specific data or semantics of any particular activity In one embodiment, four entities interact during the execution of an activity the activity itself, a parent activity of the activity that is executing, the scope enclosing the activity that is executing, and the orchestration engine Each entity has a different function
[0079] If the execute method of an activity returns without having signaled completion to its activity coordinator, the activity is said to be in a logical waitmg state Such an activity may be cancelled by the orchestration engine, or continued (e g , once the item or event on which it is waiting becomes available or occurs, and the activity is notified of this by the engine) [0080] Some activities which never enter the logical waitmg state may never be cancelled Examples include the send activity and the code activity since they execute without any demands on external events or subscriptions Once handed a thread (I e once their execute method is called by the orchestration engine), these activities will do work until done The orchestration engine is never given an opportunity to cancel them since they do not return the thread until they signal completion
[0081] The orchestration engine runtime uses rules to trigger events on which orchestration engine activities are executed The orchestration engine designer provides the user ability to associated rules to be evaluated at runtime to trigger events The orchestration engine designer enables the user to use different types of rules technology by providing extensibility architecture The designer is agnostic to the type of rules technology used [0082] In one embodiment, the designer supports Boolean expression handlers as a way to associate a rule with an activity This means that in the user code file, the user wntes a method which returns a true or false value, based on which the rule is triggered Currently there are multiple technologies which may also be used to evaluate rules including Info Agent and Busmess Rules Engine (BRE) To achieve this, the designer includes an extensibility architecture which enables the rule technology developers to host custom user interfaces in the designer The designer provides a way to the custom user interface writers to serialize the rules
in the form of code statement collection The designer emits a Boolean handler m user code file with the code statement collections inserted mto it The orchestration engine mcludes a default user interface which may also be used by the rule writers A rule technology provider add rules to the orchestration engine designer by creatmg a custom rule declaration, writing a user interface type editor associated with the custom rule declaration, creating a custom user interface to host the rules user interface, and generating code statements on save [0083] In one example, a user selects the activity designer with which rule needs to be attached, locates the rule property in the property browser and selects the "RuleExpressionHandler" in the drop down (which makes the "Statements" property to appear underneath the Rule Property in the user interface), specifies the user code method name in the "Statements" property, invokes a user interface type editor to invoke a dialog which will host rules specific user interface, and defines rules m the dialog by creatmg new predicate rows and grouping them together The user interface emits a method in the user code file The method name will be same as the one specified by the user in the property browser The code statements equivalent to creating the rule will be inserted in the user code method for rule
Messaging During Execution
[0084] In a running workflow, messages sent to a schedule are mtended for a specific schedule instance For example, an invoice for purchase order #123 must be sent back to the same schedule instance that originated (e g , sent out) that purchase order To match an mbound message with the appropriate schedule instance, the message and the schedule instance share a correlation set The correlation set may be a single-valued correlation set in which means an identifier field in the message is matched against an identifier of the same type that is held by schedule instances Multi-property correlation sets are also possible and analogous to multi-column primary keys m a database table
[0085] The correlation set value held by a schedule instance is initialized when the schedule instance sends out a message (e g, the value may be taken from an identifier field of an outbound purchase order) or receives a message This correlation set value is then a part of that schedule instance's state When a subsequent inbound message arrives, the correlation set value held in the schedule instance state is matched against the identifier held by an inbound message of the expected type When a match is found, the correlation set is satisfied and the message is delivered to the schedule instance
[0086] Although the implementation of correlation sets is a function of the orchestration engine and host environment, the user in one embodiment declares the correlation sets to make the schedule instance work correctly In another embodiment, some activities (e g, SendRequest/ReceiveResponse activities and ReceiveRequest/SendResponse activities) set up the correlation sets independent of the user A wide range of validation checks are performed by the send and receive activities to ensure that correlation sets are initialized and followed properly
Dynamic Editing of Executing Workflows
[0087] The orchestration engine provides a framework for authoring (and subsequently visualizing and executing) various types of workflows Examples mclude event-condition-action (ECA) style workflows or structured flows or rules driven flows Further, regardless of the way the workflow was modeled, the framework allows the users to author or edit workflows in the same manner at design time or even when the workflow process is running without the need for recompiling the workflow process The framework allows the user to roundtnp between the runtime and the design time representation with hi-fidehty Ad hoc changes are the changes made at run time to the process model A user may ask a running instance for its schedule model and make changes to the model For example, the user may add, remove, or replace activities m a batch, then commit or rollback the batched changes In one embodiment, the model is validated after the updates In many workflow scenanos of the invention, there is a blurring of, or even an elimination of, the separation between "design-time authoring" and "runtime execution "
[0088] A schedule instance effectively shares with other instances the activity type (metadata) tree defined for those instances' schedule type But any schedule instance, once it begins executing, may be changed on the fly via the addition of new activities or the manipulation of declarative rules It is possible to take such a modified schedule instance and "save as" as a new schedule type or more generally, to simply recover the serialized representation from the instance That is, a running schedule instance may be serialized and then brought into any designer (e g, authoring environment) or runtime visualization tool [0089] Further, it is possible for an advanced developer to author a schedule entirely as software code To author a schedule type directly, the developer simply includes a static method called InitiahzeScheduleModel in the software code in the code-beside class for the
schedule and marks this method with a [ScheduleCreator] attribute In one embodiment, the static method takes no parameters and returns a Schedule object There is no companion serialized file, though the serialized representation of the schedule may be recovered from the Schedule object that is created Although this means that a schedule may be developed using a single software code file, validation checks may not be performed on the file The orchestration engine compilation ensures the structural and semantic validity of the activity tree that underlies the schedule type In another embodiment, compilation and validation run internally to produce the actual type that is executed, but no code input is required Schedule type compilation becomes a very light process since there is no translation from a compile-time object model to a runtime object model In essence, compilation simply combines the object model representation of a schedule with code-beside to produce a new type In one embodiment, there may be no fundamental need to provide any code-beside at all for a particular schedule if the compiled code-beside matches what is demanded by the activities in the object model or code-beside may already exist in compiled form (an assembly) [0090] When compiling a serialized schedule, it is possible to pomt to an existmg compiled type that effectively serves as the code-beside for the schedule A derivative of this compiled type is created and this new type serves as the code-beside to ensure that a unique type is created to represent the new schedule
Serialization Architecture
[0091] The serialization infrastructure provides a modular, format neutral and easily extensible mechanism to serialize the orchestration engine activity tree In particular, a caller (e g , an application program or a user) requests a senalizer for an object (or activity) A from the serialization manager The metadata attnbute of object A's type binds object A to a senalizer of the requested type The caller then asks the senalizer to serialize object A Object A's senalizer then serializes object A For each object encountered while senahzing, the senalizer requests additional senahzers from the serialization manager The result of the serialization is returned to the caller
[0092] Every activity in the orchestration engine component model may participate in serialization The senalizer component is not a part of activity class itself in one embodiment Instead the component is specified by annotating a senalizer attribute in a class associated with the activity The senalizer attnbute pomts to a class which is used to serialize objects of that
activity type In another embodiment, provider components for an activity type override the default senahzer provided by the activity
[0093] Designer serialization is based upon metadata, senalizers, and a senahzation manager Metadata attnbutes are used to relate a type with a senahzer A "bootstrapping" attribute may be used to install an object that provides senalizers for types that do not have them A senahzer is an object that knows how to senahze a particular type or a range of types There is a base class for each data format For example, there may be an XmlSenahzer base class that knows how to convert an object into XML The invention is a general architecture that is independent of any specific senahzation format The senahzation manager is an object that provides an information store for all the various senalizers that are used to senahze an object graph For example, a graph of fifty objects may have fifty different senalizers that all generate their own output The serialization manager may be used by these senalizers to communicate with each other when necessary
[0094] In one embodiment, the use of serialization providers coupled with senalizers that use generic object metadata provide a callback mechanism where an object is given the opportunity to provide a senahzer for a given type A senahzation manager may be given a serialization provider through a method such as AddSenahzationProvider A serialization provider may be automatically added to a serialization manager by adding an attnbute such as DefaultSenahzationProviderAttnbute to the senahzer
[0095] In one embodiment, the format is dictated by the following rules an object is serialized as an xml element, a property of an object is categonzed as simple property (e g , serialized as an xml attribute) or complex property (senahzed as child element), and a child object of an object is serialized as child element The definition of a child object may differ from an object to another object The example below is the serialization of a while activity, which has a Send activity as one of its child objects

OnBeforeSend Name="onBeforeSendl" />

[0096] In an embodiment in which the language used for serialization is XOML, each XOML element is serialized to its respective object when the schedule is compiled Objects include both simple and complex types The mapping between the XOML representation of each activity and its mapping to the authonng object model is next described Senalization of XOML varies between Primitive and Composite activities
[0097] Simple types for primitive activities are senalized as attnbutes on the activity type Complex types for primitive activities are senalized as child elements As an example, here is the XOML representation of a Send activity
[0098] In a similar manner to pnrmtive type serialization, simple types for composite activities are serialized as attributes on the activity type However, by definition, composite activities encapsulate nested activities Each nested activity is senalized as another child element As an example, here is the XOML representation of a While activity [0099] A strong relationship between the process/workflow view and the senalized representation exists FIG 8 illustrates a schedule definition and the relationship between a visual workflow, a serialized (e g , XOML) representation of the workflow, and the code beside
of the workflow When authoring in either representation, the other will incur changes Thus, modifying the XOML for an activity (or its constituent parts in cases of composite activities) is directly reflected in the process/workflow view when a developer switches between the two The converse is also applicable Modifying the activity in the process/workflow view results in the appropriate modification within XOML As an example, the deletion of an activity in the process/workflow view results in the removal of the XML element in XOML for the same activity Round tripping also occurs between the process/workflow view and the code beside [0100] During creation of the XOML code, if the XOML definition does not conform to a pre-defined interface requirement, the offending XML element is underscored or otherwise visually identified to the developer If the developer switches to the process view, they will be alerted that there is an error within the XOML and the designer provide a link where the developer may click and will be navigated to the offending element This same error appears in the task pane and upon doubling clicking on the error, the developer will be navigated to the offending element in the XOML
Creating the Activity Tree from a XOML File (Deserialization)
[0101] In one embodiment, a CreateEditorInstance() function creates a DesignSurface object and then calls a BeginLoad() function onto the DesignSurface object passing the actual loader object into it, which eventually ends up in a BeginLoad() call to a DesignerLoader() function A PerformLoadO function reads the text buffer object and deserializes it to the orchestration engine component model hierarchy The mvention walks through the hierarchy and inserts the activities into the design surface to load the components in the visual studio [0102] The invention also listens to changes to the XOML file to track the hierarchy and item identification changes to update the values in the visual studio cache A secondary document data list includes a list of secondary documents, invisible to the user, on which orchestration engine designer works For example, it is possible that user has not opened the code beside file, but when the user makes changes in the orchestration engine designer, the changes are made to the code beside file As this file is not visible to the user, the file is maintained as a secondary document Whenever the XOML file is saved, the secondary documents are automatically saved If the name of one of these files changes or if the file is deleted, the invention updates the corresponding secondary document objects accordingly
[0103] Exemplary deserialization guidelines for an object tree are as follows An xml element is first treated as a property of parent object If the parent object does not have a property with the element's tag name then the element is treated as a child object of the parent object An xml attribute is treated as simple property on the parent object [0104] In an exemplary deserialization using the serialized code above, a element is treated as an object created using the xml namespace information A element is treated as a property of the While activity The element is treated an as object whose value will be applied to the ConditionRule property The element is first tried as a property of the While activity, but the 'While' activity does not have a property with the name 'Send', so the element is treated as an object and added as the children activity of the while activity The element is treated as a property of the Send activity Because the Message property on Send is read only, the contents of Message element are considered as the contents of Message object A similar rule applies to the deserialization of and elements [0105] Under the following conditions, XOML de-serialization will critically fail the XOML code is not well formed, the XomlDocument is not the first element in the XOML code, and the first activity in the XOML code cannot be de-serialized The developer will be presented with error message with which they may navigate to the offending XML element when switching from XOML view to process/workflow view
Hosting the Orchestration Engine Designer
[0106] The designer framework may be hosted in any application program This is a very useful feature for third party applications to render workflow in their respective environments It also will allow third parties to develop tools around the orchestration engine designer by rehosting and customizing the design surface The framework of the invention expects the hosting container application to provide a set of services such as editors and/or text buffers [0107] One step in rehosting the designer is to create a loader and a design surface The loader is responsible for loading a XOML file and constructing the designer host infrastructure which maintains the activities The design surface mamtains the designer host infrastructure within it and provides services to host and mteract with the design surface The design surface acts as a service container as well as a service provider In one example, the following code is
executed to load a XOML document and construct a designer host which maintains the activities in it
this loader XomlFile = filePath,
if (this surface IsLoaded == false)
this surface BeginLoad(this loader), [0108] The following services enable different functions in the designer An ISelectionService function maintains the selected objects An IToolboxService function manages interaction with the toolbox An IMenuCommandService function manages interaction with the menu An ITypeProvider function enables the type system In addition, there may be additional services provided by the designer hosting environment to enable advanced designer features
[0109] The type system is a component in the component model framework of the invention When a designer is hosted mside a project system, a TypeProvider object is created on a per project basis Assembly references in the project are pushed to the type provider Further, the user code files in the project are parsed and a single code compile unit is created and pushed to the type provider Also, the invention listens to the events in the project system which may cause the types to be changed in the type system and makes appropnate calls to the type provider to re-load types in response to the changes
Undo/Redo
[0110] After creating and correctly constructing a schedule, a developer may wish to rollback a series of performed operations Undo and redo functions of the invention provide visual feedback illustrating which activity has been directly affected For example, when a property change on an activity is undone, the activity which was affected becomes selected When the deletion of multiple objects is undone, all the objects involved become selected when they are restored to the schedule Undo/Redo is a common feature used throughout many applications in other fields and its meaning is well understood In the orchestration engine designer, undo/redo items are not purged on Save Further, undo/redo may be performed m the process/workflow view, XOML view, when a developer switches between views, and in the code beside
[0111] Undo/Redo is provided for the following actions in the process/workflow view activity drag and drop (e g , dragging an activity from the toolbox to the design surface, moving
an activity from one part of the schedule to another, and moving an activity from one designer to another), configuration of an activity (e g , specifying properties for an activity), and cut/copy/paste/delete
[0112] In one embodiment, the serialized view (e g , XOML view) is an XML editor which provides the standard undo/redo operations of a text editor The designer of the invention provides feedback to the developer indicating that changes made in the process/workflow view and then undone in serialized view will result in the loss of serialized code When the developer constructs a portion of the schedule in the process/workflow view, switches to the serialized view and then decides to perform an undo/redo operation, a warning will appear
Exemplary Operating Environment
[0113] FIG 9 shows one example of a general purpose computmg device in the form of a computer 130 In one embodiment of the invention, a computer such as the computer 130 is suitable for use in the other figures illustrated and described herem Computer 130 has one or more processors or processing units 132 and a system memory 134 In the illustrated embodiment, a system bus 136 couples various system components including the system memory 134 to the processors 132 The bus 136 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus also known as Mezzanine bus [0114] The computer 130 typically has at least some form of computer readable media Computer readable media, which include both volatile and nonvolatile media, removable and non-removable media, may be any available medium that may be accessed by computer 130 By way of example and not limitation, computer readable media comprise computer storage media and communication media Computer storage media include volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data For example, computer storage media include RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk
storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium that may be used to store the desired information and that may be accessed by computer 130 Communication media typically embody computer readable instructions, data structures, program modules, or other data in a modulated data signal such as a carrier wave or other transport mechanism and include any information delivery media Those skilled in the art are familiar with the modulated data signal, which has one or more of its characteristics set or changed in such a manner as to encode information in the signal Wired media, such as a wired network or direct-wired connection, and wireless media, such as acoustic, RF, infrared, and other wireless media, are examples of communication media Combinations of any of the above are also included within the scope of computer readable media
[0115] The system memory 134 includes computer storage media m the form of removable and/or non-removable, volatile and/or nonvolatile memory In the illustrated embodiment, system memory 134 includes read only memory (ROM) 138 and random access memory (RAM) 140 A basic input/output system 142 (BIOS), containing the basic routines that help to transfer information between elements within computer 130, such as during start-up, is typically stored in ROM 138 RAM 140 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit 132 By way of example, and not limitation, FIG 9 illustrates operating system 144, application programs 146, other program modules 148, and program data 150 [0116] The computer 130 may also include other removable/non-removable, volatile/nonvolatile computer storage media For example, FIG 9 illustrates a hard disk drive 154 that reads from or wntes to non-removable, nonvolatile magnetic media FIG 9 also shows a magnetic disk drive 156 that reads from or wntes to a removable, nonvolatile magnetic disk 158, and an optical disk drive 160 that reads from or writes to a removable, nonvolatile optical disk 162 such as a CD-ROM or other optical media Other removable/non-removable, volatile/nonvolatile computer storage media that may be used m the exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM, solid state ROM, and the like The hard disk dnve 154, and magnetic disk dnve 156 and optical disk drive 160 are typically connected to the system bus 136 by a non-volatile memory interface, such as interface 166
[0117] The drives or other mass storage devices and their associated computer storage media discussed above and illustrated m FIG 9, provide storage of computer readable instructions, data structures, program modules and other data for the computer 130 In FIG 9, for example, hard disk drive 154 is illustrated as storing operating system 170, application programs 172, other program modules 174, and program data 176 Note that these components may either be the same as or different from operating system 144, application programs 146, other program modules 148, and program data 150 Operating system 170, application programs 172, other program modules 174, and program data 176 are given different numbers here to illustrate that, at a mmimum, they are different copies
[0118] A user may enter commands and information into computer 130 through input devices or user interface selection devices such as a keyboard 180 and a pomting device 182 (e g, a mouse, trackball, pen, or touch pad) Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, or the like These and other input devices are connected to processing unit 132 through a user input mterface 184 that is coupled to system bus 136, but may be connected by other interface and bus structures, such as a parallel port, game port, or a Universal Serial Bus (USB) A momtor 188 or other type of display device is also connected to system bus 136 via an interface, such as a video mterface 190 In addition to the momtor 188, computers often mclude other peripheral output devices (not shown) such as a printer and speakers, which may be connected through an output peripheral interface (not shown)
[0119] The computer 130 may operate m a networked environment using logical connections to one or more remote computers, such as a remote computer 194 The remote computer 194 may be a personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to computer 130 The logical connections depicted in FIG 9 mclude a local area network (LAN) 196 and a wide area network (WAN) 198, but may also include other networks LAN 136 and/or WAN 138 may be a wired network, a wireless network, a combmation thereof, and so on Such networking environments are commonplace m offices, enterprise-wide computer networks, intranets, and global computer networks (e g , the Internet) [0120] When used m a local area networking environment, computer 130 is connected to the LAN 196 through a network interface or adapter 186 When used m a wide area networking environment, computer 130 typically includes a modem 178 or other means for establishing
communications over the WAN 198, such as the Internet The modem 178, which may be internal or external, is connected to system bus 136 via the user mput interface 184, or other appropriate mechanism In a networked environment, program modules depicted relative to computer 130, or portions thereof, may be stored in a remote memory storage device (not shown) By way of example, and not limitation, FIG 9 illustrates remote application programs 192 as residing on the memory device The network connections shown are exemplary and other means of establishing a communications link between the computers may be used [0121] Generally, the data processors of computer 130 are programmed by means of instructions stored at different times in the various computer-readable storage media of the computer Programs and operating systems are typically distributed, for example, on floppy disks or CD-ROMs From there, they are installed or loaded into the secondary memory of a computer At execution, they are loaded at least partially mto the computer's primary electronic memory The mvention described herein includes these and other various types of computer-readable storage media when such media contam instructions or programs for implementing the steps described below m conjunction with a microprocessor or other data processor The invention also includes the computer itself when programmed according to the methods and techniques described herein
[0122] For purposes of illustration, programs and other executable program components, such as the operating system, are illustrated herein as discrete blocks It is recognized, however, that such programs and components reside at various times in different storage components of the computer, and are executed by the data processor(s) of the computer [0123] Although described in connection with an exemplary computing system environment, including computer 130, the mvention is operational with numerous other general purpose or special purpose computing system environments or configurations The computing system environment is not intended to suggest any limitation as to the scope of use or functionality of the invention Moreover, the computing system environment should not be interpreted as having any dependency or requirement relating to any one or combmation of components illustrated in the exemplary operating environment Examples of well known computing systems, environments, and/or configurations that may be suitable for use with the mvention include, but are not limited to, personal computers, server computers, hand-held or laptop devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, mobile telephones, network PCs, minicomputers,
mainframe computers, distributed computing environments that include any of the above systems or devices, and the like
[0124] The invention may be described in the general context of computer-executable mstructions, such as program modules, executed by one or more computers or other devices Generally, program modules include, but are not limited to, routmes, programs, objects, components, and data structures that perform particular tasks or implement particular abstract data types The invention may also be practiced in distributed computmg environments where tasks are performed by remote processing devices that are linked through a communications network In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices [0125] An interface in the context of a software architecture includes a software module, component, code portion, or other sequence of computer-executable mstructions The interface includes, for example, a first module accessing a second module to perform computmg tasks on behalf of the first module The first and second modules include, m one example, application programming mterfaces (APIs) such as provided by operatmg systems, component object model (COM) mterfaces (e g , for peer-to-peer application communication), and extensible markup language metadata interchange format (XMI) interfaces (e g , for communication between web services)
[0126] The interface may be a tightly coupled, synchronous implementation such as in Java 2 Platform Enterprise Edition (J2EE), COM, or distributed COM (DCOM) examples Alternatively or in addition, the interface may be a loosely coupled, asynchronous implementation such as in a web service (e g, using the simple object access protocol) In general, the interface includes any combmation of the following characteristics tightly coupled, loosely coupled, synchronous, and asynchronous Further, the interface may conform to a standard protocol, a proprietary protocol, or any combmation of standard and proprietary protocols
[0127] The mterfaces described herein may all be part of a single interface or may be implemented as separate mterfaces or any combination therein The mterfaces may execute locally or remotely to provide functionality Further, the interfaces may include additional or less functionality than illustrated or described herem
[0128] The order of execution or performance of the methods illustrated and described herein is not essential, unless otherwise specified That is, elements of the methods may be performed
in any order, unless otherwise specified, and that the methods may include more or less
elements than those disclosed herein For example, it is contemplated that executing or
performing a particular element before, contemporaneously with, or after another element is
within the scope of the invention
[0129] When introducing elements of the present invention or the embodnnent(s) thereof, the
articles "a," "an," "the," and "said" are intended to mean that there are one or more of the
elements The terms "compnsing," "includmg," and "having" are intended to be mclusive and
mean that there may be additional elements other than the listed elements
[0130] In view of the above, it will be seen that the several objects of the invention are
achieved and other advantageous results attained
[0131] As various changes could be made in the above constructions, products, and methods
without departmg from the scope of the invention, it is intended that all matter contamed in the
above description and shown in the accompanying drawings shall be interpreted as illustrative
and not m a limiting sense
APPENDIX A
Exemplary Activities and Exemplary Implementation Thereof
[0132] Exemplary activities include the following Send, SendRequest, SendResponse,
Receive, ReceiveRequest, ReceiveResponse, Code, Delay, Fault, Suspend, Terminate,
InvokeSchedule, InvokeSchedules, InvokeWebService, DotNetEventSource, DotNetEventSink,
Sequence, Parallel, While, ConditionalBranch, Conditional, Constrained,
ConstrainedActivityGroup (CAG), EventDnven, Listen, EventHandlers, ExceptionHandler,
ExceptionHandlers, Compensate, CompensationHandler, Scope, and Schedule
[0133] Each of the exemplary activities have metadata associated therewith The metadata
is transferred to a declarative representation of the workflow by the senahzer associated with
the activity For example, the metadata may include an optional code-beside method and an
optional collection of correlation sets
Send Activities
[0134] The orchestration engine provides three activities (e g , Send, SendRequest, and SendResponse) for sending messages, each of which addresses a different use case Additionally, because the three activities share some metadata, an abstract base class is defined and used as the superclass of all three
Receive Activities
[0135] The orchestration engine provides three activities (e g, Receive, ReceiveRequest, and ReceiveResponse) for receiving messages, each of which addresses a different use case Additionally, because the three activities share some metadata, an abstract base class is defined and used as the superclass of all three
Code
[0136] The Code activity executes the code-beside method indicated in the metadata
Delay
[0137] The Delay activity executes its mandatory code-beside method to generate a
DateTime value It internally sets the TimeoutValue property on its instance data to this value
If the DateTime is in the past, the Delay completes immediately Otherwise, it sets up a tuner subscription so that the Delay will be notified when the timer fires When the timer fires, the Delay is notified and it completes
Fault
[0138] The Fault activity executes its mandatory code-beside method to generate a
Exception object It then throws this exception
Suspend
[0139] The Suspend activity suspends the current schedule instance
Terminate
[0140] The Terminate activity terminates the current schedule instance
Invoke Schedule
[0141] The InvokeSchedule activity invokes a schedule
Invoke Web Service
[0142] Invokes a web service via a proxy class, passing and receiving parameters as
specified
DotNetEvent Sink
[0143] Blocks awaiting notification that the specified event has been raised by a previously
invoked schedule instance
DotNetEvent Source
[0144] Raises the specified event, and immediately completes execution
Sequence
[0145] The Sequence activity coordinates the execution of a set of child activities in an
ordered fashion, one at a time
Parallel
[0146] The Parallel activity executes a set of child activities concurrently
While
[0147] Iteratively executes the child activity
ConditionalBranch
[0148] Executes the child activities, per Sequence semantics
Conditional
[0149] A Conditional activity contams an ordered set of ConditionalBranch activities
Constrained
[0150] When the Constrained activity is told by the CAG to execute, it simply executes the
activity that it wraps
CAG (Constrained Activity Group)
[0151] When the CAG executes, it executes (and re-executes) child activities based upon the
evaluation of their enable and disable constraints
Task
[0152] Model an external unit of work that is performed by one or more principals
Event Driven
[0153] Wrap an activity whose execution is triggered by an "event" activity
Listen
[0154] Conditionally execute one of n child EventDnven activities

Event Handlers
[0155] The EventHandlers activity simply holds a set of EventDnven activities, for use by
the associated Scope
Exception Handler
[0156] Wraps an activity with metadata that represents a catch block for a scope
Exception Handlers
[0157] Wrap an ordered set of ExceptionHandler activities
Compensate
[0158] Compensate a completed child scope
Compensation Handler
[0159] Wrap a child activity that is defined as the compensation handler for a scope
Scope
[0160] A scope is a transaction boundary, an exception handling boundary, a compensation boundary, an event handling boundary, and, a boundary for message, variable, correlation set, and channel declarations (l e shared data state) Execution of the activities within a Scope is sequential, and thus the contained activities are explicitly ordered when the scope is constructed, as in a Sequence
Schedule
[0161] A Schedule is the only top-level activity that the orchestration engine will execute
Composite Activities
[0162] The composite activity types that enable control flow are 'Sequence, Parallel,
Constrained Activity Group, Conditional, While, Listen Additionally, Scope and Schedule are
composite activity types that act as contamers with implied sequencmg of the activities within
them.

We Claims :-
1. A computer-implemented method for applying error and exception handling to one
or more selected activities in a workflow, said computer-implemented method comprising:
selecting a pre-defined behavioral component; selecting one or more activities in a workflow; and
relating the selected behavioral component with the selected activities to enable the selected behavioral component to operate responsive to the selected activities.
2. The computer-implemented method of claim 1, wherein the behavioral component includes one or more rules, and wherein the selected behavioral component applies the rules to the selected activities.
3. The computer-implemented method of claim 1, further comprising executing the selected activities in coordination with the selected behavioral component.
4. The computer-implemented method of claim 1, wherein executing the selected activities comprises:
creating a context associated with the selected behavioral component; executing the selected activities within the created context.
5. The computer-implemented method of claim 1, further comprising:
receiving a user-defined activity from the user, said user-defined activity having one or more semantics associated therewith;
evaluating the semantics for conformance to a predefined interface requirement;
executing the received, user-defined activity within the created context as a function of said evaluating.
6. The computer-implemented method of claim 1, wherein the behavioral component
includes metadata describing functionality of the behavioral component.
7. The computer-implemented method of claim 6, further comprising receiving an edit from the user to the metadata.
8. The computer-implemented method of claim 1, wherein one or more computer-readable media have computer-executable instructions for performing the computer-implemented method of claim 1.
9. The computer-implemented method of claim 1, further comprising defining the one or more activities.

10. The computer-implemented method of claim 1, further comprising defining the behavioral component.
11. One or more computer-readable media have computer-executable modules for applying error and exception handling to one or more selected activities in a workflow, said modules comprising:
a designer module for selecting a pre-defined behavioral component and for selecting one or more activities in a workflow;
a context module for relating the behavioral component and the activities selected by the designer module to enable the selected behavioral component to operate responsive to the selected activities; and
a runtime engine module for executing the activities selected by the designer module as a function of the behavioral component related thereto by the context module.
12. The computer-readable media of claim 11, further comprising a palette module for defining the behavioral component.
13. The computer-readable media of claim 11, wherein the context module further creates a context associated with the defined behavioral component.
14. The computer-readable media of claim 11, wherein the designer module comprises a user interface.
15. A system for applying error and exception handling to one or more selected activities in a workflow, said system comprising:
a memory area storing a plurality of activities each having a defined interface, said memory area further storing a plurality of behavioral components each conforming to the defined interface, each of the behavioral components being related to at least two of the activities; and
a processor configured to execute computer-executable instructions for:
receiving a selection from a user of one of the behavioral components stored in the memory area;
receiving a selection from the user of at least two of the activities stored in the memory area;
creating a context associated with the selected behavioral component; and executing the selected activities within the created context.
16. The system of claim 15, wherein the behavioral components stored in the memory area relate to one or more of the following: error handling, exception handling, and messaging.
17. The system of claim 15, wherein each of the behavioral components stored in the memory area include a scope component and a process component.
18. The system of claim 17, wherein the scope component relates to one or more of the following: process analysis, state management, transaction, synchronization, and exception error handling.
19. The system of claim 17, wherein the process component relates to one or more of the following: transaction handling, synchronization, and exception error handling.
20. The system of claim 15, wherein the memory area further comprises a data structure for each of the behavioral components, said data structure comprising one or more of the following: properties, methods, events, a designer, a serializer, and a runtime component.