<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Allegro.TaskExecution</name>
    </assembly>
    <members>
        <member name="T:Allegro.TaskExecution.TaskActivity">
            <summary>
            Activity
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.PersistentItem">
            <summary>
            Persistent item
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.IXmlPersist">
            <summary>
            XML Persistence interface
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.IXmlPersist.Save(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            Save to XML
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.IXmlPersist.Load(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            Load from XML
            </summary>
            <param name="navigator"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.Save(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            Save to XML
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.Load(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            Load from XML
            </summary>
            <param name="navigator"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.LoadAttributes(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            Override in order to load class specific attributes
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.SaveAttributes(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            Override in order to save class specific attributes
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            Override in order to load class specific content
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            Override in order to save class specific content
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.GetSchema">
            <summary>
            This method is reserved and should not be used. When implementing the IXmlSerializable interface, you should return null (Nothing in Visual Basic) from this method, and instead, if specifying a custom schema is required, apply the <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> to the class.
            </summary>
            <returns>
            An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
            </returns>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.ReadXml(System.Xml.XmlReader)">
            <summary>
            Generates an object from its XML representation.
            </summary>
            <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. 
                            </param>
        </member>
        <member name="M:Allegro.TaskExecution.PersistentItem.WriteXml(System.Xml.XmlWriter)">
            <summary>
            Converts an object into its XML representation.
            </summary>
            <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized. 
                            </param>
        </member>
        <member name="P:Allegro.TaskExecution.PersistentItem.Oid">
            <summary>
            Object id
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.PersistentItem.Name">
            <summary>
            Name
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.PersistentItem.XmlElementName">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.PersistentItem.XmlNamespace">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.TaskActivity.CheckIfSuspendedOrAborted(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            method to check if task execution has been suspended or aborted
            </summary>
            <param name="context"></param>
        </member>
        <member name="T:Allegro.TaskExecution.AtomicTaskActivity">
            <summary>
            Atomic task activity
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.AtomicTaskActivity.CanExecute(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Return true if the task can execute. Default is true
            </summary>
            <param name="context"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.AtomicTaskActivity.Execute(Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Execute activity
            </summary>
            <param name="spawningTask"></param>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.AtomicTaskActivity.ExecuteActivity(Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Overridable method to execute the activity
            </summary>
            <param name="spawningTask"></param>
            <param name="context"></param>
        </member>
        <member name="T:Allegro.TaskExecution.CompositeActivity">
            <summary>
            Composite task activity
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeActivity.BeforeExecute(Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Called before a composite task is executed
            </summary>
            <param name="spawningTask"></param>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeActivity.AfterExecute(Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Called after a composite task is executed
            </summary>
            <param name="spawningTask"></param>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeActivity.PreProcessChildTask(Allegro.TaskExecution.ITask,Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Overridable method for pre processing child task of a composite task
            </summary>
            <param name="spawningTask"></param>
            <param name="childTask"></param>
            <param name="currentActivityContext"></param>
            <param name="childActivityContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeActivity.PostProcessChildTask(Allegro.TaskExecution.ITask,Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Overridable method for post processing child task of a composite task
            </summary>
            <param name="spawningTask"></param>
            <param name="childTask"></param>
            <param name="currentActivityContext"></param>
            <param name="childActivityContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeActivity.PreExecute(Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Called before the first child task is invoked
            </summary>
            <param name="spawningTask"></param>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeActivity.PostExecute(Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Called after the last child task has completed
            </summary>
            <param name="spawningTask"></param>
            <param name="context"></param>
        </member>
        <member name="T:Allegro.TaskExecution.Constants">
            <summary>
            Task execution constants
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.Constants.Namespace">
            <summary>
            Namespace
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.Constants.XmlNamespace">
            <summary>
            Default namespace
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.Constants.XmlDefaultNamespacePrefix">
            <summary>
            Default namespace prefix
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.AbortedTaskExecutionException">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.AbortedTaskExecutionException.#ctor(System.String)">
            <summary>
            
            </summary>
            <param name="msg"></param>
        </member>
        <member name="M:Allegro.TaskExecution.AbortedTaskExecutionException.#ctor(System.String,Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="msg"></param>
            <param name="abortedTask"></param>
        </member>
        <member name="M:Allegro.TaskExecution.AbortedTaskExecutionException.#ctor(System.String,Allegro.TaskExecution.ITask,System.Exception)">
            <summary>
            
            </summary>
            <param name="msg"></param>
            <param name="abortedTask"></param>
            <param name="innerException"></param>
        </member>
        <member name="P:Allegro.TaskExecution.AbortedTaskExecutionException.AbortedTask">
            <summary>
            Task aborted
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.ContextVariable">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.ContextVariable.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.ContextVariable.#ctor(System.String,System.Object)">
            <summary>
            
            </summary>
            <param name="varName"></param>
            <param name="value"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ContextVariable.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ContextVariable.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="P:Allegro.TaskExecution.ContextVariable.Value">
            <summary>
            
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.ProgressAggregator">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.ProgressAggregator.#ctor">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.ProgressAggregator.Reset">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.ProgressAggregator.UpdateProgress(System.Object,System.Double,System.String)">
            <summary>
            
            </summary>
            <param name="item"></param>
            <param name="progress"></param>
            <param name="message"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ProgressAggregator.UpdateProgress(System.Object,System.Double)">
            <summary>
            Update object progress
            </summary>
            <param name="item"></param>
            <param name="progress"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ProgressAggregator.UpdateStatus(System.Object,System.String)">
            <summary>
            Update object status
            </summary>
            <param name="item"></param>
            <param name="status"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ProgressAggregator.GetProgress(System.Object)">
            <summary>
            
            </summary>
            <param name="item"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.ProgressAggregator.GetStatus(System.Object)">
            <summary>
            Get execution status for an object
            </summary>
            <param name="item"></param>
            <returns></returns>
        </member>
        <member name="P:Allegro.TaskExecution.ProgressAggregator.ProgressMessage">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.ProgressAggregator.LastUpdatedItem">
            <summary>
            
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.BasicTaskExecutionContext">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.#ctor">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.GetValue(System.String)">
            <summary>
            
            </summary>
            <param name="varName"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.TryGetValue(System.String,System.Object@)">
            <summary>
            Try to get a variable name. Return true if the value was found, false otherwise
            </summary>
            <param name="varName"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.SetValue(System.String,System.Object)">
            <summary>
            
            </summary>
            <param name="varName"></param>
            <param name="value"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.SetValueIfDefined(System.String,System.Object)">
            <summary>
            Set the value if defined in this or nested contexts and return true if
            the value could be set. If not set, return false
            </summary>
            <param name="varName"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.HasVariable(System.String)">
            <summary>
            
            </summary>
            <param name="varName"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.SetProgressAndCompute(Allegro.TaskExecution.ITask,System.Double,System.String)">
            <summary>
            
            </summary>
            <param name="task"></param>
            <param name="progress"></param>
            <param name="msg"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.CheckIfSuspendOrAbort">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.RegisterTaskInContext(Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="task"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.WaitOnTaskCompletion(Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="task"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.Complete(Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="task"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.CompletionEvent(Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="task"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.WaitIfJobIsSuspended">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.ExitIfJobIsAborted">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.SuspendTaskExecution">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.ResumeTaskExecution">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.AbortTaskExecution">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.AddBreakpoint(System.String,System.String)">
            <summary>
            Add breakpoint
            </summary>
            <param name="taskId"></param>
            <param name="breakpointName"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.RemoveBreakpoint(System.String,System.String)">
            <summary>
            Remove breakpoint
            </summary>
            <param name="taskId"></param>
            <param name="breakpointName"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.BreakpointIsSet(System.String,System.String)">
            <summary>
            Return true if the breakpoint is set
            </summary>
            <param name="taskId"></param>
            <param name="breakPointName"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.HasLocalVariable(System.String)">
            <summary>
            True if the variable is defined locally (not in a nested context)
            </summary>
            <param name="varName"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.GetLocalVar(System.String)">
            <summary>
            Get local variable, return null if not defined
            </summary>
            <param name="varName"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.SetLocalVar(System.String,System.Object)">
            <summary>
            Set local variable.
            </summary>
            <param name="varName"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTaskExecutionContext.GetSchema">
            <summary>
            This method is reserved and should not be used. When implementing the IXmlSerializable interface, you should return null (Nothing in Visual Basic) from this method, and instead, if specifying a custom schema is required, apply the <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> to the class.
            </summary>
            <returns>
            An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
            </returns>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.IsExecuting">
            <summary>
            True if a task is executing in this context
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.Item(System.String)">
            <summary>
            
            </summary>
            <param name="varName"></param>
            <returns></returns>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.Variables">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.ProgressAggregator">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.This">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.OuterContext">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.RootContext">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.IsAborted">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.Breakpoints">
            <summary>
            List of breakpoints
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTaskExecutionContext.ContextVariables">
            <summary>
            
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.ParallelTaskExecutionContext">
            <summary>
            Task execution context for parallel execution. Supports context derivation
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.#ctor(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="nestedContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.Fork">
            <summary>
            Fork a context
            </summary>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.New(System.Object)">
            <summary>
            Create new context
            </summary>
            <param name="self"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.New(System.Object,System.Object)">
            <summary>
            Create new context
            </summary>
            <param name="index"></param>
            <param name="self"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.New(System.Object,System.Object,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Create new context
            </summary>
            <param name="index"></param>
            <param name="self"></param>
            <param name="nestedContext"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.ConnectDerivedContext(Allegro.TaskExecution.ParallelTaskExecutionContext,System.Object,System.Object)">
            <summary>
            Connect derived context
            </summary>
            <param name="newContext"></param>
            <param name="self"></param>
            <param name="index"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.FindTaskExecutionContext(System.Object)">
            <summary>
            Search for the context in the derived context tree below the current context. If no associated 
            context is found, return null.
            </summary>
            <param name="contextKey"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.HasVariable(System.String)">
            <summary>
            
            </summary>
            <param name="varName"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.GetValue(System.String)">
            <summary>
            
            </summary>
            <param name="varName"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.TryGetValue(System.String,System.Object@)">
            <summary>
            Try to get a variable name. Return true if the value was found, false otherwise
            </summary>
            <param name="varName"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.SetValue(System.String,System.Object)">
            <summary>
            
            </summary>
            <param name="varName"></param>
            <param name="value"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ParallelTaskExecutionContext.SetValueIfDefined(System.String,System.Object)">
            <summary>
            Set the value if defined in this or nested contexts and return true if
            the value could be set. If not set, return false
            </summary>
            <param name="varName"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="P:Allegro.TaskExecution.ParallelTaskExecutionContext.OuterContext">
            <summary>
            Outer context
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.ParallelTaskExecutionContext.RootContext">
            <summary>
            Root context. Null if this is a root context
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.ParallelTaskExecutionContext.DerivedTaskContexts">
            <summary>
            Derived contexts
            </summary>
        </member>
        <member name="T:Allegro.Interception.IInterceptorAttribute">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.Interception.IInterceptorAttribute.PreInvoke(System.Object,System.String,System.Object[])">
            <summary>
            
            </summary>
            <param name="o"></param>
            <param name="member"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="T:Allegro.Interception.ClassFactory`1">
            <summary>
            </summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="M:Allegro.Interception.ClassFactory`1.New">
            <summary>
            </summary>
            <returns></returns>
        </member>
        <member name="T:Allegro.Interception.InterceptingProxyFactory`1">
            <summary>
            </summary>
            <typeparam name="I"></typeparam>
        </member>
        <member name="M:Allegro.Interception.InterceptingProxyFactory`1.CreateProxy(`0)">
            <summary>
            </summary>
            <param name="realObject"></param>
            <returns></returns>
            <exception cref="T:System.ApplicationException"></exception>
        </member>
        <member name="T:Allegro.Interception.I1">
            <summary>
            </summary>
        </member>
        <member name="P:Allegro.Interception.I1.Name">
            <summary>
            </summary>
        </member>
        <member name="P:Allegro.Interception.I1.InnerInterface">
            <summary>
            </summary>
        </member>
        <member name="T:Allegro.Interception.I2">
            <summary>
            </summary>
        </member>
        <member name="P:Allegro.Interception.I2.Name">
            <summary>
            </summary>
        </member>
        <member name="T:Allegro.Interception.InterceptingProxy">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.Interception.InterceptingProxy.#ctor(System.Object)">
            <summary>
            
            </summary>
            <param name="realObject"></param>
        </member>
        <member name="M:Allegro.Interception.InterceptingProxy.Equals(System.Object)">
            <summary>
            
            </summary>
            <param name="obj"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.Interception.InterceptingProxy.PreInvoke(System.Reflection.MethodBase,System.Object[])">
            <summary>
            
            </summary>
            <param name="currentMethod"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="P:Allegro.Interception.InterceptingProxy.RealObject">
            <summary>
            
            </summary>
        </member>
        <member name="T:Allegro.Interception.ProxyI1">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.Interception.ProxyI1.#ctor(Allegro.Interception.I1)">
            <summary>
            </summary>
            <param name="realObject"></param>
        </member>
        <member name="P:Allegro.Interception.ProxyI1.Name">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.Interception.ProxyI1.InnerInterface">
            <summary>
            
            </summary>
        </member>
        <member name="T:Allegro.Interception.ProxyI2">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.Interception.ProxyI2.#ctor(Allegro.Interception.I2)">
            <summary>
            </summary>
            <param name="realObject"></param>
        </member>
        <member name="P:Allegro.Interception.ProxyI2.Name">
            <summary>
            
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.IContextExpression">
            <summary>
            An interface that allows application objects unknown to Task Execution to be resolved in the 
            execution context and plugged into the task execution.
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.IContextExpression.Evaluate(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Execute the task. Before the task can be executed, a context must be registered for the task
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.IExecutionCondition">
            <summary>
            Condition to be used as execution condition for tasks
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.IExecutionCondition.IsTrue(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Return true if the coniditon is met
            </summary>
            <param name="context"></param>
            <returns></returns>
        </member>
        <member name="T:Allegro.TaskExecution.IXmlPersistenceContext">
            <summary>
            XML Persistence context
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.IXmlPersistenceContext.NamespaceManager">
            <summary>
            Xml namespace manager used for loading XML
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.ExecuteInContext">
            <summary>
            Delegate for execution in a task execution context
            </summary>
            <param name="context"></param>
            <returns></returns>
        </member>
        <member name="T:Allegro.TaskExecution.ExecuteInContext`2">
            <summary>
            Delegate for execution in a task execution context
            </summary>
            <typeparam name="T"></typeparam>
            <typeparam name="C"></typeparam>
            <param name="context"></param>
            <returns></returns>
        </member>
        <member name="T:Allegro.TaskExecution.ExecuteInTaskContext`2">
            <summary>
            Delegate for execution in a task execution context
            </summary>
            <typeparam name="T"></typeparam>
            <typeparam name="C"></typeparam>
            <param name="task"></param>
            <param name="context"></param>
            <returns></returns>
        </member>
        <member name="T:Allegro.TaskExecution.BasicTask`2">
            <summary>
            
            </summary>
            <typeparam name="T"></typeparam>
            <typeparam name="C"></typeparam>
        </member>
        <member name="T:Allegro.TaskExecution.Task">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Task.Run">
            <summary>
            </summary>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.Run(System.String)">
            <summary>
            </summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.RunInSequence">
            <summary>
            </summary>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.RunInSequence(System.String)">
            <summary>
            </summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.RunActivity">
            <summary>
            </summary>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.RunActivity(Allegro.TaskExecution.ITaskActivity)">
            <summary>
            </summary>
            <param name="activity"></param>
            <returns></returns>
        </member>
        <member name="F:Allegro.TaskExecution.Task.ProgressCallbacks">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Task.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Task.#ctor(System.String)">
            <summary>
            
            </summary>
            <param name="name"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.CanExecute(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.Execute(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.GetTaskInformation">
            <summary>
            Get task information
            </summary>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.PostEvent(Allegro.TaskExecution.IExecutionContext,Allegro.TaskExecution.ProgressEventType,System.Double,System.String)">
            <summary>
            
            </summary>
            <param name="context"></param>
            <param name="eventType"></param>
            <param name="progress"></param>
            <param name="message"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.PostEvent(Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext,Allegro.TaskExecution.ProgressEventType,System.Double,System.String)">
            <summary>
            
            </summary>
            <param name="originatingTask"></param>
            <param name="context"></param>
            <param name="eventType"></param>
            <param name="progress"></param>
            <param name="message"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.DependsOn(Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="task"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.NotifyProgress(Allegro.TaskExecution.TaskExecutionProgressNotification,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="callback"></param>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.HasTaskVariable(System.String)">
            <summary>
            Return true if the task has a named variable
            </summary>
            <param name="varName"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.GetTaskVariable(System.String)">
            <summary>
            Return the variable value. Return null if the variable is not found
            </summary>
            <param name="varName"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.SetTaskVariable(System.String,System.Object)">
            <summary>
            Set variable value. 
            </summary>
            <param name="varName"></param>
            <param name="value"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.CompletionEvent(Allegro.TaskExecution.ITaskContextCoordination)">
            <summary>
            Get the completion event for the task
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Task.PreExecute(Allegro.TaskExecution.ITaskContextCoordination)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.PostExecute(Allegro.TaskExecution.ITaskContextCoordination)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.ComputeProgress(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Compute progress
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.RunTask(System.Object)">
            <summary>
            
            </summary>
            <param name="input"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.RunTaskBatch(System.Object)">
            <summary>
            
            </summary>
            <param name="input"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.CheckIfSuspendOrAbort(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.BreakIfBreakpointSet(System.String,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Check if 
            </summary>
            <param name="breakpointName"></param>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.CheckForBreakpoint(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task.GetTaskExecutionContext(System.Object,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            If the current context has a derived context, return the derived context.
            Otherwise, return the current context 
            </summary>
            <param name="contextKey"></param>
            <param name="currentContext"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.Task.FindTaskExecutionContext(System.Object,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Search for the context in the derived context tree below the current task. If no associated 
            context is found, return the current context.
            </summary>
            <param name="contextKey"></param>
            <param name="currentContext"></param>
            <returns></returns>
        </member>
        <member name="P:Allegro.TaskExecution.Task.Activity">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.Task.RootTask">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.Task.ParentTask">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.Task.ClearChildContextsWhenComplete">
            <summary>
            If true, the child contexts will be cleared after task completion. Default is true
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.Task.BreakPoints">
            <summary>
            Breakpoints
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.BasicTask`2.Executor">
            <summary>
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.BasicTask`2.TaskExecutor">
            <summary>
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.BasicTask`2.GeneralExecutor">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask`2.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask`2.#ctor(Allegro.TaskExecution.ExecuteInContext)">
            <summary>
            
            </summary>
            <param name="executor"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask`2.#ctor(Allegro.TaskExecution.ExecuteInContext{`0,`1})">
            <summary>
            
            </summary>
            <param name="executor"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask`2.#ctor(Allegro.TaskExecution.ExecuteInTaskContext{`0,`1})">
            <summary>
            
            </summary>
            <param name="executor"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask`2.#ctor(Allegro.TaskExecution.ITaskActivity)">
            <summary>
            
            </summary>
            <param name="activity"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask`2.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="T:Allegro.TaskExecution.BasicTask`1">
            <summary>
            
            </summary>
            <typeparam name="C"></typeparam>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask`1.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask`1.#ctor(Allegro.TaskExecution.ITaskActivity)">
            <summary>
            
            </summary>
            <param name="activity"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask`1.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="T:Allegro.TaskExecution.BasicTask">
            <summary>
            
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.BasicTask.Executor">
            <summary>
            
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.BasicTask.TaskExecutor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask.#ctor(Allegro.TaskExecution.ITaskActivity)">
            <summary>
            
            </summary>
            <param name="activity"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask.#ctor(Allegro.TaskExecution.ExecuteInContext{System.Object,Allegro.TaskExecution.IExecutionContext})">
            <summary>
            
            </summary>
            <param name="executor"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask.#ctor(Allegro.TaskExecution.ExecuteInTaskContext{System.Object,Allegro.TaskExecution.IExecutionContext})">
            <summary>
            
            </summary>
            <param name="executor"></param>
        </member>
        <member name="M:Allegro.TaskExecution.BasicTask.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="P:Allegro.TaskExecution.BasicTask.If">
            <summary>
            Predicate. If not set or evaluates to true, the task will run, otherwise not
            </summary>
        </member>
        <member name="T:Allegro.Framework.CompleteDependentTask">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.Framework.CompleteDependentTask.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.Framework.CompleteDependentTask.#ctor(Allegro.TaskExecution.CompletionType)">
            <summary>
            
            </summary>
            <param name="completionType"></param>
        </member>
        <member name="M:Allegro.Framework.CompleteDependentTask.DependsOn(System.Collections.Generic.IEnumerable{Allegro.TaskExecution.ITask},Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="tasks"></param>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.Framework.CompleteDependentTask.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="P:Allegro.Framework.CompleteDependentTask.Type">
            <summary>
            
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.PreProcessChildActivity">
            <summary>
            </summary>
            <param name="childTask"></param>
            <param name="currentActivityContext"></param>
            <param name="childActivityContext"></param>
        </member>
        <member name="T:Allegro.TaskExecution.PostProcessChildActivity">
            <summary>
            </summary>
            <param name="childTask"></param>
            <param name="currentActivityContext"></param>
            <param name="childActivityContext"></param>
        </member>
        <member name="T:Allegro.TaskExecution.CompositeTask">
            <summary>
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.CompositeTask.NumberOfCompletedChildTasks">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.#ctor(System.String)">
            <summary>
            
            </summary>
            <param name="name"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.#ctor(Allegro.TaskExecution.PreProcessChildActivity,Allegro.TaskExecution.PostProcessChildActivity)">
            <summary>
            
            </summary>
            <param name="preProcessChildActivityDelegate"></param>
            <param name="postProcessChildActivityDelegate"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.Add(Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="item"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.AddTask(Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="item"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.AddTask(Allegro.TaskExecution.ITask,System.Double)">
            <summary>
            
            </summary>
            <param name="item"></param>
            <param name="elapsedTimeEstimateInSeconds"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.GetEstimatedDuration(Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="childTask"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.Remove(Allegro.TaskExecution.ITask)">
            <summary>
            
            </summary>
            <param name="item"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.Remove(System.String)">
            <summary>
            
            </summary>
            <param name="name"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.CompositeTask.NotifyProgress(Allegro.TaskExecution.TaskExecutionProgressNotification,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="callback"></param>
            <param name="context"></param>
        </member>
        <member name="P:Allegro.TaskExecution.CompositeTask.PreProcessChildActivityDelegate">
            <summary>
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.CompositeTask.PostProcessChildActivityDelegate">
            <summary>
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.CompositeTask.Allegro#TaskExecution#ICompositeItem{Allegro#TaskExecution#ITask}#Item(System.String)">
            <summary>
            
            </summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="P:Allegro.TaskExecution.CompositeTask.Allegro#TaskExecution#ICompositeItem{Allegro#TaskExecution#ITask}#Item(System.Guid)">
            <summary>
            
            </summary>
            <param name="oid"></param>
            <returns></returns>
        </member>
        <member name="P:Allegro.TaskExecution.CompositeTask.Items">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.CompositeTask.Tasks">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.CompositeTask.TaskWeights">
            <summary>
            
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.Conditional">
            <summary>
            Conditional task
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Conditional.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Overridable method for executing a task
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Conditional.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Conditional.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Conditional.NotifyProgress(Allegro.TaskExecution.TaskExecutionProgressNotification,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="callback"></param>
            <param name="context"></param>
        </member>
        <member name="P:Allegro.TaskExecution.Conditional.If">
            <summary>
            Predicate. If not set or evaluates to true, the task will run, otherwise not.
            An exception is thrown if the condition is not set when the task is executed
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.Conditional.Condition">
            <summary>
            Alternatively, the condition of the conditional can be specified by a Predicate.
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.Conditional.Then">
            <summary>
            If the If predicate evaluates to true, the Then task will be executed.
            An exception is thrown if the Then task is not set when the task is executed
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.Conditional.Else">
            <summary>
            If the If predicate evaluates to false, the Else task will be executed
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.ForEach">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.ForEach.#ctor">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.ForEach.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="outerContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ForEach.SaveAttributes(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ForEach.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ForEach.LoadAttributes(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ForEach.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.ForEach.NotifyProgress(Allegro.TaskExecution.TaskExecutionProgressNotification,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="callback"></param>
            <param name="context"></param>
        </member>
        <member name="P:Allegro.TaskExecution.ForEach.InSequence">
            <summary>
             If true, the child tasks will be executed in sequence. If false, 
             the tasks will be executed in parallel. Default is true
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.ForEach.Var">
            <summary>
             Name of iteration variable
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.ForEach.In">
            <summary>
             Must be assigned an object of type IEnumerable
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.ForEach.Do">
            <summary>
            Task to execute
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.ForEach.OptimizeWorkload">
            <summary>
            True if the workload should be optimized during parallel execution. 
            Default is false
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.ForEach.NumberOfThreadsScheduledPerCore">
            <summary>
            Number of processing threads scheduled per available processor core.
            Used only if OptimizeWorkload = true.
            Default is 4.
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.Tasks.PredicateAsCondition">
            <summary>
            Cast a predicate as a condition in a task
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Tasks.PredicateAsCondition.#ctor(System.Predicate{Allegro.TaskExecution.IExecutionContext})">
            <summary>
            </summary>
            <param name="predicate"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Tasks.PredicateAsCondition.IsTrue(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
            <returns></returns>
        </member>
        <member name="P:Allegro.TaskExecution.Tasks.PredicateAsCondition.Predicate">
            <summary>
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.Run">
            <summary>
             Composite task. Each child task will be executed once, either in sequence or in parallel, depending 
             on the setting of InSequence
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Run.#ctor">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Run.#ctor(System.String)">
            <summary>
            </summary>
            <param name="name"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Run.#ctor(Allegro.TaskExecution.ITask[])">
            <summary>
            </summary>
            <param name="children"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Run.#ctor(Allegro.TaskExecution.PreProcessChildActivity,Allegro.TaskExecution.PostProcessChildActivity)">
            <summary>
            </summary>
            <param name="preProcessChildActivityDelegate"></param>
            <param name="postProcessChildActivityDelegate"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Run.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="outerContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Run.SaveAttributes(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Run.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Run.LoadAttributes(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Run.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="P:Allegro.TaskExecution.Run.InSequence">
            <summary>
            True if the child tasks must be run in sequence, false if not
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.Run.If">
            <summary>
            Predicate. If not set or evaluates to true, the task will run, otherwise not
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.RunActivity">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.RunActivity.#ctor">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.RunActivity.#ctor(Allegro.TaskExecution.ITaskActivity)">
            <summary>
            </summary>
            <param name="activity"></param>
        </member>
        <member name="M:Allegro.TaskExecution.RunActivity.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.RunActivity.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.RunActivity.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="P:Allegro.TaskExecution.RunActivity.If">
            <summary>
            Predicate. If not set or evaluates to true, the task will run, otherwise not
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.RunInContext">
            <summary>
            Delegate for execution in context
            </summary>
            <param name="context"></param>
        </member>
        <member name="T:Allegro.TaskExecution.EnumerateInContext">
            <summary>
            Delegate for late-bound enumeration in context
            </summary>
            <param name="context"></param>
            <returns></returns>
        </member>
        <member name="T:Allegro.TaskExecution.ContextEvaluation">
            <summary>
            Delegate for late-bound evaluation in context
            </summary>
            <param name="c"></param>
            <returns></returns>
        </member>
        <member name="T:Allegro.TaskExecution.RunDelegate">
            <summary>
            Task for running a delegate
            </summary>
        </member>
        <member name="F:Allegro.TaskExecution.RunDelegate.Execute">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.RunDelegate.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.RunDelegate.#ctor(Allegro.TaskExecution.RunInContext)">
            <summary>
            
            </summary>
            <param name="exec"></param>
        </member>
        <member name="M:Allegro.TaskExecution.RunDelegate.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="T:Allegro.TaskExecution.RunAction">
            <summary>
            Task for running an action delegate
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.RunAction.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.RunAction.#ctor(System.Action,System.Boolean)">
            <summary>
            
            </summary>
            <param name="exec"></param>
            <param name="invokeActionOnCurrentThread"></param>
        </member>
        <member name="M:Allegro.TaskExecution.RunAction.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="P:Allegro.TaskExecution.RunAction.ExecuteAction">
            <summary>
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.RunAction.InvokeActionOnCurrentThread">
            <summary>
            If true, the action will be invoked on the thread from
            which the action was created
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.RunAction`1">
            <summary>
            Task for running an action delegate
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.Task`1">
            <summary>
            Task base class with typed data
            </summary>
            <typeparam name="TData"></typeparam>
        </member>
        <member name="M:Allegro.TaskExecution.Task`1.Execute(`0)">
            <summary>
            
            </summary>
            <param name="data"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Task`1.ExecuteTask(`0)">
            <summary>
            Overridable task execution method
            </summary>
            <param name="data"></param>
        </member>
        <member name="M:Allegro.TaskExecution.RunAction`1.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.RunAction`1.#ctor(System.Action{`0},System.Boolean)">
            <summary>
            Create the task, specifying whether or not the action should be called on the thread on which
            the task was created
            </summary>
            <param name="exec"></param>
            <param name="invokeActionOnCurrentThread">Whether or not to invoke the action on the current thread</param>
        </member>
        <member name="M:Allegro.TaskExecution.RunAction`1.ExecuteTask(`0)">
            <summary>
            
            </summary>
            <param name="context"></param>
        </member>
        <member name="P:Allegro.TaskExecution.RunAction`1.ExecuteAction">
            <summary>
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.RunAction`1.InvokeActionOnCurrentThread">
            <summary>
            If true, the action will be invoked on the thread from
            which the action was created
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.TaskExecutionRecord">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.TaskExecutionRecord.Context">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.TaskExecutionRecord.Task">
            <summary>
            
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.TaskExecutionBatch">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.TaskExecutionBatch.Context">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.TaskExecutionBatch.Task">
            <summary>
            
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.TaskExecutionBatch.Items">
            <summary>
            Items in the batch
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.TaskExecutionBatch.ItemVarName">
            <summary>
            Context variable name in which the item will be bound
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.While">
            <summary>
            While task
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.While.ExecuteTask(Allegro.TaskExecution.IExecutionContext)">
            <summary>
            Overridable method for executing a task
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Allegro.TaskExecution.While.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.While.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.While.NotifyProgress(Allegro.TaskExecution.TaskExecutionProgressNotification,Allegro.TaskExecution.IExecutionContext)">
            <summary>
            
            </summary>
            <param name="callback"></param>
            <param name="context"></param>
        </member>
        <member name="P:Allegro.TaskExecution.While.If">
            <summary>
            Predicate. If not set or evaluates to true, the task will run, otherwise not.
            An exception is thrown if the condition is not set when the task is executed
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.While.Condition">
            <summary>
            Alternatively, the condition of the conditional can be specified by a Predicate.
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.While.Do">
            <summary>
            If the If predicate evaluates to true, the Then task will be executed.
            An exception is thrown if the Then task is not set when the task is executed
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.Blob">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Blob.#ctor">
            <summary>
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.Blob.#ctor(System.Byte[])">
            <summary>
            </summary>
            <param name="content"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Blob.SaveContent(System.Xml.XmlWriter,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.Blob.LoadContent(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="itemNode"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="P:Allegro.TaskExecution.Blob.ByteArray">
            <summary>
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.TaskException">
            <summary>
            Exception thrown during task execution
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.TaskException.#ctor(Allegro.TaskExecution.ITask,Allegro.TaskExecution.IExecutionContext,System.String,System.Exception)">
            <summary>
            
            </summary>
            <param name="task"></param>
            <param name="context"></param>
            <param name="msg"></param>
            <param name="innerException"></param>
        </member>
        <member name="P:Allegro.TaskExecution.TaskException.Task">
            <summary>
            Task
            </summary>
        </member>
        <member name="P:Allegro.TaskExecution.TaskException.Context">
            <summary>
            Scope
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.XmlPersistenceContext">
            <summary>
             Persistence context
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersistenceContext.#ctor">
            <summary>
            Create an empty persistence context. This can not be used for loading XML until a namespace manager has been assigned
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersistenceContext.#ctor(System.Xml.XmlNamespaceManager)">
            <summary>
            </summary>
            <param name="nsMgr"></param>
        </member>
        <member name="P:Allegro.TaskExecution.XmlPersistenceContext.NamespaceManager">
            <summary>
            Xml namespace manager used for loading XML
            </summary>
        </member>
        <member name="T:Allegro.TaskExecution.XmlPersist">
            <summary>
             Persistence class
            </summary>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersist.LoadObject``1(System.Xml.XPath.XPathNavigator)">
            <summary>
             Load object from XML
            </summary>
            <param name="navigator"></param>
            <typeparam name="T"></typeparam>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersist.LoadObject``1(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            Load obejct from XML
            </summary>
            <typeparam name="T"></typeparam>
            <param name="navigator"></param>
            <param name="persistenceContext"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersist.LoadObject(System.Xml.XPath.XPathNavigator)">
            <summary>
            </summary>
            <param name="navigator"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersist.LoadObject(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            </summary>
            <param name="navigator"></param>
            <param name="persistenceContext"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersist.LoadCollection(System.Xml.XPath.XPathNavigator,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            </summary>
            <param name="navigator"></param>
            <param name="persistenceContext"></param>
            <returns></returns>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersist.SaveObject(System.Xml.XmlWriter,System.Object,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            </summary>
            <param name="writer"></param>
            <param name="o"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersist.SaveCollection(System.Xml.XmlWriter,System.Object,Allegro.TaskExecution.IXmlPersistenceContext)">
            <summary>
            
            </summary>
            <param name="writer"></param>
            <param name="o"></param>
            <param name="persistenceContext"></param>
        </member>
        <member name="M:Allegro.TaskExecution.XmlPersist.GetNamespaceManager(System.Xml.XPath.XPathNavigator)">
            <summary>
            Get a namespace resolver
            </summary>
            <param name="navigator"></param>
            <returns></returns>
        </member>
    </members>
</doc>
