2031 lines
69 KiB
C#
2031 lines
69 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.Activities
|
|
{
|
|
using System;
|
|
using System.Activities.DynamicUpdate;
|
|
using System.Activities.Expressions;
|
|
using System.Activities.Hosting;
|
|
using System.Activities.Runtime;
|
|
using System.Activities.Validation;
|
|
using System.Activities.XamlIntegration;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Runtime;
|
|
using System.Threading;
|
|
using System.Windows.Markup;
|
|
using System.Xaml;
|
|
|
|
[ContentProperty("Implementation")]
|
|
public abstract class Activity
|
|
{
|
|
const string generatedArgumentPrefix = "Argument";
|
|
static int nextCacheId;
|
|
|
|
static readonly IList<Activity> emptyChildren = new List<Activity>(0);
|
|
static readonly IList<Variable> emptyVariables = new List<Variable>(0);
|
|
static readonly IList<RuntimeArgument> emptyArguments = new List<RuntimeArgument>(0);
|
|
static readonly IList<ActivityDelegate> emptyDelegates = new List<ActivityDelegate>(0);
|
|
|
|
internal static readonly ReadOnlyCollection<Constraint> EmptyConstraints = new ReadOnlyCollection<Constraint>(new Constraint[0]);
|
|
|
|
string displayName;
|
|
bool isDisplayNameSet;
|
|
int id;
|
|
RootProperties rootProperties;
|
|
|
|
IList<RuntimeArgument> arguments;
|
|
|
|
IList<Activity> children;
|
|
IList<Activity> implementationChildren;
|
|
IList<Activity> importedChildren;
|
|
|
|
IList<ActivityDelegate> delegates;
|
|
IList<ActivityDelegate> implementationDelegates;
|
|
IList<ActivityDelegate> importedDelegates;
|
|
|
|
IList<Variable> variables;
|
|
IList<Variable> implementationVariables;
|
|
|
|
IList<ValidationError> tempValidationErrors;
|
|
IList<RuntimeArgument> tempAutoGeneratedArguments;
|
|
|
|
Collection<Constraint> constraints;
|
|
Activity runtimeImplementation;
|
|
|
|
Activity rootActivity;
|
|
object thisLock;
|
|
|
|
QualifiedId qualifiedId;
|
|
|
|
// For a given cacheId this tells us whether we've called InternalCacheMetadata yet or not
|
|
CacheStates isMetadataCached;
|
|
int cacheId;
|
|
|
|
RelationshipType relationshipToParent;
|
|
Nullable<bool> isSubtreeEmpty;
|
|
|
|
int symbolCount;
|
|
|
|
// alternatives are extended through DynamicActivity, CodeActivity, and NativeActivity
|
|
protected Activity()
|
|
{
|
|
this.thisLock = new object();
|
|
}
|
|
|
|
[TypeConverter(typeof(ImplementationVersionConverter))]
|
|
[DefaultValue(null)]
|
|
protected virtual internal Version ImplementationVersion
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
[XamlDeferLoad(typeof(FuncDeferringLoader), typeof(Activity))]
|
|
[DefaultValue(null)]
|
|
[Browsable(false)]
|
|
[Ambient]
|
|
protected virtual Func<Activity> Implementation
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
protected Collection<Constraint> Constraints
|
|
{
|
|
get
|
|
{
|
|
if (this.constraints == null)
|
|
{
|
|
this.constraints = new Collection<Constraint>();
|
|
}
|
|
return this.constraints;
|
|
}
|
|
}
|
|
|
|
protected internal int CacheId
|
|
{
|
|
get
|
|
{
|
|
return this.cacheId;
|
|
}
|
|
}
|
|
|
|
internal RelationshipType RelationshipToParent
|
|
{
|
|
get
|
|
{
|
|
return this.relationshipToParent;
|
|
}
|
|
}
|
|
|
|
internal bool HasNonEmptySubtree
|
|
{
|
|
get
|
|
{
|
|
if (this.isSubtreeEmpty.HasValue)
|
|
{
|
|
return !this.isSubtreeEmpty.Value;
|
|
}
|
|
else
|
|
{
|
|
if (this.Children.Count > 0 || this.ImplementationChildren.Count > 0 || this.ImportedChildren.Count > 0 ||
|
|
this.Delegates.Count > 0 || this.ImplementationDelegates.Count > 0 || this.ImportedDelegates.Count > 0 ||
|
|
this.RuntimeVariables.Count > 0 || this.ImplementationVariables.Count > 0 ||
|
|
this.RuntimeArguments.Count > 0)
|
|
{
|
|
this.isSubtreeEmpty = false;
|
|
}
|
|
else
|
|
{
|
|
this.isSubtreeEmpty = true;
|
|
}
|
|
return !this.isSubtreeEmpty.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal int SymbolCount
|
|
{
|
|
get
|
|
{
|
|
return this.symbolCount;
|
|
}
|
|
}
|
|
|
|
internal IdSpace MemberOf
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
internal IdSpace ParentOf
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
internal QualifiedId QualifiedId
|
|
{
|
|
get
|
|
{
|
|
if (this.qualifiedId == null)
|
|
{
|
|
this.qualifiedId = new QualifiedId(this);
|
|
}
|
|
|
|
return this.qualifiedId;
|
|
}
|
|
}
|
|
|
|
// This flag governs special behavior that we need to keep for back-compat on activities
|
|
// that implemented TryGetValue in 4.0.
|
|
internal bool UseOldFastPath
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
internal bool SkipArgumentResolution
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
internal bool IsFastPath
|
|
{
|
|
get
|
|
{
|
|
return this.SkipArgumentResolution && IsActivityWithResult;
|
|
}
|
|
}
|
|
|
|
internal virtual bool IsActivityWithResult
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal object Origin
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public string DisplayName
|
|
{
|
|
get
|
|
{
|
|
if (!this.isDisplayNameSet && string.IsNullOrEmpty(this.displayName))
|
|
{
|
|
this.displayName = ActivityUtilities.GetDisplayName(this);
|
|
}
|
|
|
|
return this.displayName;
|
|
}
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
this.displayName = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
this.displayName = value;
|
|
}
|
|
this.isDisplayNameSet = true;
|
|
}
|
|
}
|
|
|
|
public string Id
|
|
{
|
|
get
|
|
{
|
|
if (this.id == 0)
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
return this.QualifiedId.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
internal bool IsExpressionRoot
|
|
{
|
|
get
|
|
{
|
|
return this.relationshipToParent == RelationshipType.ArgumentExpression;
|
|
}
|
|
}
|
|
|
|
internal bool HasStartedCachingMetadata
|
|
{
|
|
get
|
|
{
|
|
return this.isMetadataCached != CacheStates.Uncached;
|
|
}
|
|
}
|
|
|
|
internal bool IsMetadataCached
|
|
{
|
|
get
|
|
{
|
|
return this.isMetadataCached != CacheStates.Uncached;
|
|
}
|
|
}
|
|
|
|
internal bool IsMetadataFullyCached
|
|
{
|
|
get
|
|
{
|
|
return (this.isMetadataCached & CacheStates.Full) == CacheStates.Full;
|
|
}
|
|
}
|
|
|
|
internal bool IsRuntimeReady
|
|
{
|
|
get
|
|
{
|
|
return (this.isMetadataCached & CacheStates.RuntimeReady) == CacheStates.RuntimeReady;
|
|
}
|
|
}
|
|
|
|
internal Activity RootActivity
|
|
{
|
|
get
|
|
{
|
|
return this.rootActivity;
|
|
}
|
|
}
|
|
|
|
internal int InternalId
|
|
{
|
|
get
|
|
{
|
|
return this.id;
|
|
}
|
|
set
|
|
{
|
|
Fx.Assert(value != 0, "0 is an invalid ID");
|
|
ClearIdInfo();
|
|
this.id = value;
|
|
}
|
|
}
|
|
|
|
internal ActivityDelegate HandlerOf
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
internal Activity Parent
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
internal LocationReferenceEnvironment HostEnvironment
|
|
{
|
|
get
|
|
{
|
|
if (this.RootActivity != null && this.RootActivity.rootProperties != null)
|
|
{
|
|
return this.RootActivity.rootProperties.HostEnvironment;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal IList<RuntimeArgument> RuntimeArguments
|
|
{
|
|
get
|
|
{
|
|
return this.arguments;
|
|
}
|
|
}
|
|
|
|
internal IList<Activity> Children
|
|
{
|
|
get
|
|
{
|
|
return this.children;
|
|
}
|
|
}
|
|
|
|
internal IList<Activity> ImplementationChildren
|
|
{
|
|
get
|
|
{
|
|
return this.implementationChildren;
|
|
}
|
|
}
|
|
|
|
internal IList<Activity> ImportedChildren
|
|
{
|
|
get
|
|
{
|
|
return this.importedChildren;
|
|
}
|
|
}
|
|
|
|
internal IList<ActivityDelegate> Delegates
|
|
{
|
|
get
|
|
{
|
|
return this.delegates;
|
|
}
|
|
}
|
|
|
|
internal IList<ActivityDelegate> ImplementationDelegates
|
|
{
|
|
get
|
|
{
|
|
return this.implementationDelegates;
|
|
}
|
|
}
|
|
|
|
internal IList<ActivityDelegate> ImportedDelegates
|
|
{
|
|
get
|
|
{
|
|
return this.importedDelegates;
|
|
}
|
|
}
|
|
|
|
internal bool HasBeenAssociatedWithAnInstance
|
|
{
|
|
get
|
|
{
|
|
if (this.rootProperties != null)
|
|
{
|
|
return this.rootProperties.HasBeenAssociatedWithAnInstance;
|
|
}
|
|
else if (this.IsMetadataCached && this.RootActivity != null && this.RootActivity.rootProperties != null)
|
|
{
|
|
return this.RootActivity.rootProperties.HasBeenAssociatedWithAnInstance;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
set
|
|
{
|
|
Fx.Assert(this.rootProperties != null, "This should only be called on the root and we should already be cached.");
|
|
Fx.Assert(value, "We really only let you set this to true.");
|
|
|
|
this.rootProperties.HasBeenAssociatedWithAnInstance = value;
|
|
}
|
|
}
|
|
|
|
internal Dictionary<string, List<RuntimeArgument>> OverloadGroups
|
|
{
|
|
get
|
|
{
|
|
Fx.Assert(this.rootProperties != null || System.Diagnostics.Debugger.IsAttached, "This should only be called on the root.");
|
|
return this.rootProperties.OverloadGroups;
|
|
}
|
|
set
|
|
{
|
|
Fx.Assert(this.rootProperties != null, "This should only be called on the root.");
|
|
this.rootProperties.OverloadGroups = value;
|
|
}
|
|
}
|
|
|
|
internal List<RuntimeArgument> RequiredArgumentsNotInOverloadGroups
|
|
{
|
|
get
|
|
{
|
|
Fx.Assert(this.rootProperties != null || System.Diagnostics.Debugger.IsAttached, "This should only be called on the root.");
|
|
return this.rootProperties.RequiredArgumentsNotInOverloadGroups;
|
|
}
|
|
set
|
|
{
|
|
Fx.Assert(this.rootProperties != null, "This should only be called on the root.");
|
|
this.rootProperties.RequiredArgumentsNotInOverloadGroups = value;
|
|
}
|
|
}
|
|
|
|
internal ValidationHelper.OverloadGroupEquivalenceInfo EquivalenceInfo
|
|
{
|
|
get
|
|
{
|
|
Fx.Assert(this.rootProperties != null || System.Diagnostics.Debugger.IsAttached, "This should only be called on the root.");
|
|
return this.rootProperties.EquivalenceInfo;
|
|
}
|
|
set
|
|
{
|
|
Fx.Assert(this.rootProperties != null, "This should only be called on the root.");
|
|
this.rootProperties.EquivalenceInfo = value;
|
|
}
|
|
}
|
|
|
|
internal IList<Variable> RuntimeVariables
|
|
{
|
|
get
|
|
{
|
|
return this.variables;
|
|
}
|
|
}
|
|
|
|
internal IList<Variable> ImplementationVariables
|
|
{
|
|
get
|
|
{
|
|
return this.implementationVariables;
|
|
}
|
|
}
|
|
|
|
internal IList<Constraint> RuntimeConstraints
|
|
{
|
|
get
|
|
{
|
|
return InternalGetConstraints();
|
|
}
|
|
}
|
|
|
|
internal LocationReferenceEnvironment PublicEnvironment
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
internal LocationReferenceEnvironment ImplementationEnvironment
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
internal virtual bool InternalCanInduceIdle
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal bool HasTempViolations
|
|
{
|
|
get
|
|
{
|
|
return (this.tempValidationErrors != null && this.tempValidationErrors.Count > 0);
|
|
}
|
|
}
|
|
|
|
internal object ThisLock
|
|
{
|
|
get
|
|
{
|
|
return this.thisLock;
|
|
}
|
|
}
|
|
|
|
internal int RequiredExtensionTypesCount
|
|
{
|
|
get
|
|
{
|
|
Fx.Assert(this.rootProperties != null || System.Diagnostics.Debugger.IsAttached, "only callable on the root");
|
|
return this.rootProperties.RequiredExtensionTypesCount;
|
|
}
|
|
}
|
|
|
|
internal int DefaultExtensionsCount
|
|
{
|
|
get
|
|
{
|
|
Fx.Assert(this.rootProperties != null || System.Diagnostics.Debugger.IsAttached, "only callable on the root");
|
|
return this.rootProperties.DefaultExtensionsCount;
|
|
}
|
|
}
|
|
|
|
internal bool GetActivityExtensionInformation(out Dictionary<Type, WorkflowInstanceExtensionProvider> activityExtensionProviders, out HashSet<Type> requiredActivityExtensionTypes)
|
|
{
|
|
Fx.Assert(this.rootProperties != null, "only callable on the root");
|
|
return this.rootProperties.GetActivityExtensionInformation(out activityExtensionProviders, out requiredActivityExtensionTypes);
|
|
}
|
|
|
|
internal virtual bool IsResultArgument(RuntimeArgument argument)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
internal bool CanBeScheduledBy(Activity parent)
|
|
{
|
|
// fast path if we're the sole (or first) child
|
|
if (object.ReferenceEquals(parent, this.Parent))
|
|
{
|
|
return this.relationshipToParent == RelationshipType.ImplementationChild || this.relationshipToParent == RelationshipType.Child;
|
|
}
|
|
else
|
|
{
|
|
return parent.Children.Contains(this) || parent.ImplementationChildren.Contains(this);
|
|
}
|
|
}
|
|
|
|
internal void ClearIdInfo()
|
|
{
|
|
if (this.ParentOf != null)
|
|
{
|
|
this.ParentOf.Dispose();
|
|
this.ParentOf = null;
|
|
}
|
|
|
|
this.id = 0;
|
|
this.qualifiedId = null;
|
|
}
|
|
|
|
// We use these Set methods rather than a setter on the property since
|
|
// we don't want to make it seem like setting these collections is the
|
|
// "normal" thing to do. Only OnInternalCacheMetadata implementations
|
|
// should call these methods.
|
|
internal void SetChildrenCollection(Collection<Activity> children)
|
|
{
|
|
this.children = children;
|
|
}
|
|
|
|
internal void AddChild(Activity child)
|
|
{
|
|
if (this.children == null)
|
|
{
|
|
this.children = new Collection<Activity>();
|
|
}
|
|
|
|
this.children.Add(child);
|
|
}
|
|
|
|
internal void SetImplementationChildrenCollection(Collection<Activity> implementationChildren)
|
|
{
|
|
this.implementationChildren = implementationChildren;
|
|
}
|
|
|
|
internal void AddImplementationChild(Activity implementationChild)
|
|
{
|
|
if (this.implementationChildren == null)
|
|
{
|
|
this.implementationChildren = new Collection<Activity>();
|
|
}
|
|
|
|
this.implementationChildren.Add(implementationChild);
|
|
}
|
|
|
|
internal void SetImportedChildrenCollection(Collection<Activity> importedChildren)
|
|
{
|
|
this.importedChildren = importedChildren;
|
|
}
|
|
|
|
internal void AddImportedChild(Activity importedChild)
|
|
{
|
|
if (this.importedChildren == null)
|
|
{
|
|
this.importedChildren = new Collection<Activity>();
|
|
}
|
|
|
|
this.importedChildren.Add(importedChild);
|
|
}
|
|
|
|
internal void SetDelegatesCollection(Collection<ActivityDelegate> delegates)
|
|
{
|
|
this.delegates = delegates;
|
|
}
|
|
|
|
internal void AddDelegate(ActivityDelegate activityDelegate)
|
|
{
|
|
if (this.delegates == null)
|
|
{
|
|
this.delegates = new Collection<ActivityDelegate>();
|
|
}
|
|
|
|
this.delegates.Add(activityDelegate);
|
|
}
|
|
|
|
internal void SetImplementationDelegatesCollection(Collection<ActivityDelegate> implementationDelegates)
|
|
{
|
|
this.implementationDelegates = implementationDelegates;
|
|
}
|
|
|
|
internal void AddImplementationDelegate(ActivityDelegate implementationDelegate)
|
|
{
|
|
if (this.implementationDelegates == null)
|
|
{
|
|
this.implementationDelegates = new Collection<ActivityDelegate>();
|
|
}
|
|
|
|
this.implementationDelegates.Add(implementationDelegate);
|
|
}
|
|
|
|
internal void SetImportedDelegatesCollection(Collection<ActivityDelegate> importedDelegates)
|
|
{
|
|
this.importedDelegates = importedDelegates;
|
|
}
|
|
|
|
internal void AddImportedDelegate(ActivityDelegate importedDelegate)
|
|
{
|
|
if (this.importedDelegates == null)
|
|
{
|
|
this.importedDelegates = new Collection<ActivityDelegate>();
|
|
}
|
|
|
|
this.importedDelegates.Add(importedDelegate);
|
|
}
|
|
|
|
internal void SetVariablesCollection(Collection<Variable> variables)
|
|
{
|
|
this.variables = variables;
|
|
}
|
|
|
|
internal void AddVariable(Variable variable)
|
|
{
|
|
if (this.variables == null)
|
|
{
|
|
this.variables = new Collection<Variable>();
|
|
}
|
|
|
|
this.variables.Add(variable);
|
|
}
|
|
|
|
internal void SetImplementationVariablesCollection(Collection<Variable> implementationVariables)
|
|
{
|
|
this.implementationVariables = implementationVariables;
|
|
}
|
|
|
|
internal void AddImplementationVariable(Variable implementationVariable)
|
|
{
|
|
if (this.implementationVariables == null)
|
|
{
|
|
this.implementationVariables = new Collection<Variable>();
|
|
}
|
|
|
|
this.implementationVariables.Add(implementationVariable);
|
|
}
|
|
|
|
internal void SetArgumentsCollection(Collection<RuntimeArgument> arguments, bool createEmptyBindings)
|
|
{
|
|
this.arguments = arguments;
|
|
|
|
// Arguments should always be "as bound as possible"
|
|
if (this.arguments != null && this.arguments.Count > 0)
|
|
{
|
|
for (int i = 0; i < this.arguments.Count; i++)
|
|
{
|
|
RuntimeArgument argument = this.arguments[i];
|
|
|
|
argument.SetupBinding(this, createEmptyBindings);
|
|
}
|
|
|
|
this.arguments.QuickSort(RuntimeArgument.EvaluationOrderComparer);
|
|
}
|
|
}
|
|
|
|
internal void AddArgument(RuntimeArgument argument, bool createEmptyBindings)
|
|
{
|
|
if (this.arguments == null)
|
|
{
|
|
this.arguments = new Collection<RuntimeArgument>();
|
|
}
|
|
|
|
argument.SetupBinding(this, createEmptyBindings);
|
|
|
|
int insertionIndex = this.arguments.BinarySearch(argument, RuntimeArgument.EvaluationOrderComparer);
|
|
if (insertionIndex < 0)
|
|
{
|
|
this.arguments.Insert(~insertionIndex, argument);
|
|
}
|
|
else
|
|
{
|
|
this.arguments.Insert(insertionIndex, argument);
|
|
}
|
|
}
|
|
|
|
internal void SetTempValidationErrorCollection(IList<ValidationError> validationErrors)
|
|
{
|
|
this.tempValidationErrors = validationErrors;
|
|
}
|
|
|
|
internal void TransferTempValidationErrors(ref IList<ValidationError> newList)
|
|
{
|
|
if (this.tempValidationErrors != null)
|
|
{
|
|
for (int i = 0; i < this.tempValidationErrors.Count; i++)
|
|
{
|
|
ActivityUtilities.Add(ref newList, this.tempValidationErrors[i]);
|
|
}
|
|
}
|
|
this.tempValidationErrors = null;
|
|
|
|
}
|
|
|
|
internal void AddTempValidationError(ValidationError validationError)
|
|
{
|
|
if (this.tempValidationErrors == null)
|
|
{
|
|
this.tempValidationErrors = new Collection<ValidationError>();
|
|
}
|
|
|
|
this.tempValidationErrors.Add(validationError);
|
|
}
|
|
|
|
internal RuntimeArgument AddTempAutoGeneratedArgument(Type argumentType, ArgumentDirection direction)
|
|
{
|
|
if (this.tempAutoGeneratedArguments == null)
|
|
{
|
|
this.tempAutoGeneratedArguments = new Collection<RuntimeArgument>();
|
|
}
|
|
|
|
string name = generatedArgumentPrefix + this.tempAutoGeneratedArguments.Count.ToString(CultureInfo.InvariantCulture);
|
|
RuntimeArgument argument = new RuntimeArgument(name, argumentType, direction);
|
|
this.tempAutoGeneratedArguments.Add(argument);
|
|
return argument;
|
|
}
|
|
|
|
internal void ResetTempAutoGeneratedArguments()
|
|
{
|
|
this.tempAutoGeneratedArguments = null;
|
|
}
|
|
|
|
internal virtual IList<Constraint> InternalGetConstraints()
|
|
{
|
|
if (this.constraints != null && this.constraints.Count > 0)
|
|
{
|
|
return this.constraints;
|
|
}
|
|
else
|
|
{
|
|
return Activity.EmptyConstraints;
|
|
}
|
|
}
|
|
|
|
internal static bool NullCheck<T>(T obj)
|
|
{
|
|
return (obj == null);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return string.Format(CultureInfo.CurrentCulture, "{0}: {1}", this.Id, this.DisplayName);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeDisplayName()
|
|
{
|
|
return this.isDisplayNameSet;
|
|
}
|
|
|
|
// subclasses are responsible for creating/disposing the necessary contexts
|
|
internal virtual void InternalAbort(ActivityInstance instance, ActivityExecutor executor, Exception terminationReason)
|
|
{
|
|
}
|
|
|
|
// subclasses are responsible for creating/disposing the necessary contexts
|
|
internal virtual void InternalExecute(ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
|
|
{
|
|
if (this.runtimeImplementation != null)
|
|
{
|
|
executor.ScheduleActivity(this.runtimeImplementation, instance, null, null, null);
|
|
}
|
|
}
|
|
|
|
// subclasses are responsible for creating/disposing the necessary contexts. This implementation
|
|
// covers Activity, Activity<T>, DynamicActivity, DynamicActivity<T>
|
|
internal virtual void InternalCancel(ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
|
|
{
|
|
NativeActivityContext context = executor.NativeActivityContextPool.Acquire();
|
|
try
|
|
{
|
|
context.Initialize(instance, executor, bookmarkManager);
|
|
context.Cancel();
|
|
}
|
|
finally
|
|
{
|
|
context.Dispose();
|
|
executor.NativeActivityContextPool.Release(context);
|
|
}
|
|
}
|
|
|
|
internal bool IsSingletonActivityDeclared(string name)
|
|
{
|
|
if (this.rootActivity == null || this.rootActivity.rootProperties == null)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return this.rootActivity.rootProperties.IsSingletonActivityDeclared(name);
|
|
}
|
|
}
|
|
|
|
internal void DeclareSingletonActivity(string name, Activity activity)
|
|
{
|
|
if (this.rootActivity != null && this.rootActivity.rootProperties != null)
|
|
{
|
|
this.rootActivity.rootProperties.DeclareSingletonActivity(name, activity);
|
|
}
|
|
}
|
|
|
|
internal Activity GetSingletonActivity(string name)
|
|
{
|
|
if (this.rootActivity != null && this.rootActivity.rootProperties != null)
|
|
{
|
|
return this.rootActivity.rootProperties.GetSingletonActivity(name);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
internal void ClearCachedInformation()
|
|
{
|
|
ClearCachedMetadata();
|
|
this.isMetadataCached = CacheStates.Uncached;
|
|
}
|
|
|
|
internal void InitializeAsRoot(LocationReferenceEnvironment hostEnvironment)
|
|
{
|
|
// We're being treated as the root of the workflow
|
|
this.Parent = null;
|
|
this.ParentOf = null;
|
|
|
|
Interlocked.CompareExchange(ref nextCacheId, 1, int.MaxValue);
|
|
this.cacheId = Interlocked.Increment(ref nextCacheId);
|
|
|
|
ClearCachedInformation();
|
|
|
|
this.MemberOf = new IdSpace();
|
|
this.rootProperties = new RootProperties();
|
|
this.rootProperties.HostEnvironment = hostEnvironment;
|
|
this.rootActivity = this;
|
|
}
|
|
|
|
internal LocationReferenceEnvironment GetParentEnvironment()
|
|
{
|
|
LocationReferenceEnvironment parentEnvironment = null;
|
|
|
|
if (this.Parent == null)
|
|
{
|
|
Fx.Assert(this.rootProperties != null, "Root properties must be available now.");
|
|
|
|
parentEnvironment = new ActivityLocationReferenceEnvironment(this.rootProperties.HostEnvironment) { InternalRoot = this };
|
|
}
|
|
else
|
|
{
|
|
switch (this.relationshipToParent)
|
|
{
|
|
case RelationshipType.ArgumentExpression:
|
|
parentEnvironment = this.Parent.PublicEnvironment.Parent;
|
|
|
|
if (parentEnvironment == null)
|
|
{
|
|
parentEnvironment = this.RootActivity.rootProperties.HostEnvironment;
|
|
}
|
|
break;
|
|
case RelationshipType.DelegateHandler:
|
|
Fx.Assert(this.HandlerOf != null, "Must have the parent delegate set");
|
|
|
|
parentEnvironment = this.HandlerOf.Environment;
|
|
break;
|
|
case RelationshipType.Child:
|
|
case RelationshipType.ImportedChild:
|
|
case RelationshipType.VariableDefault:
|
|
parentEnvironment = this.Parent.PublicEnvironment;
|
|
break;
|
|
case RelationshipType.ImplementationChild:
|
|
parentEnvironment = this.Parent.ImplementationEnvironment;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return parentEnvironment;
|
|
}
|
|
|
|
internal bool InitializeRelationship(ActivityDelegate activityDelegate, ActivityCollectionType collectionType, ref IList<ValidationError> validationErrors)
|
|
{
|
|
if (this.cacheId == activityDelegate.Owner.CacheId)
|
|
{
|
|
// This means that we already have a parent and a delegate is trying to initialize
|
|
// a relationship. Delegate handlers MUST be declared.
|
|
|
|
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityDelegateHandlersMustBeDeclarations(this.DisplayName, activityDelegate.Owner.DisplayName, this.Parent.DisplayName), false, activityDelegate.Owner));
|
|
|
|
return false;
|
|
}
|
|
|
|
if (InitializeRelationship(activityDelegate.Owner, collectionType != ActivityCollectionType.Implementation, RelationshipType.DelegateHandler, ref validationErrors))
|
|
{
|
|
this.HandlerOf = activityDelegate;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal bool InitializeRelationship(RuntimeArgument argument, ref IList<ValidationError> validationErrors)
|
|
{
|
|
return InitializeRelationship(argument.Owner, true, RelationshipType.ArgumentExpression, ref validationErrors);
|
|
}
|
|
|
|
internal bool InitializeRelationship(Variable variable, bool isPublic, ref IList<ValidationError> validationErrors)
|
|
{
|
|
return InitializeRelationship(variable.Owner, isPublic, RelationshipType.VariableDefault, ref validationErrors);
|
|
}
|
|
|
|
internal bool InitializeRelationship(Activity parent, ActivityCollectionType collectionType, ref IList<ValidationError> validationErrors)
|
|
{
|
|
RelationshipType relationshipType = RelationshipType.Child;
|
|
if (collectionType == ActivityCollectionType.Imports)
|
|
{
|
|
relationshipType = RelationshipType.ImportedChild;
|
|
}
|
|
else if (collectionType == ActivityCollectionType.Implementation)
|
|
{
|
|
relationshipType = RelationshipType.ImplementationChild;
|
|
}
|
|
|
|
return InitializeRelationship(parent, collectionType != ActivityCollectionType.Implementation, relationshipType, ref validationErrors);
|
|
}
|
|
|
|
bool InitializeRelationship(Activity parent, bool isPublic, RelationshipType relationship, ref IList<ValidationError> validationErrors)
|
|
{
|
|
if (this.cacheId == parent.cacheId)
|
|
{
|
|
// This means that we've already encountered a parent in the tree
|
|
|
|
// Validate that it is visible.
|
|
|
|
// In order to see the activity the new parent must be
|
|
// in the implementation IdSpace of an activity which has
|
|
// a public reference to it.
|
|
Activity referenceTarget = parent.MemberOf.Owner;
|
|
|
|
if (object.ReferenceEquals(this, parent))
|
|
{
|
|
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityCannotReferenceItself(this.DisplayName), parent));
|
|
|
|
return false;
|
|
}
|
|
else if (this.Parent == null)
|
|
{
|
|
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.RootActivityCannotBeReferenced(this.DisplayName, parent.DisplayName), parent));
|
|
|
|
return false;
|
|
}
|
|
else if (referenceTarget == null)
|
|
{
|
|
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityCannotBeReferencedWithoutTarget(this.DisplayName, parent.DisplayName, this.Parent.DisplayName), parent));
|
|
|
|
return false;
|
|
}
|
|
else if (!referenceTarget.Children.Contains(this) && !referenceTarget.ImportedChildren.Contains(this))
|
|
{
|
|
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityCannotBeReferenced(this.DisplayName, parent.DisplayName, referenceTarget.DisplayName, this.Parent.DisplayName), false, parent));
|
|
|
|
return false;
|
|
}
|
|
|
|
// This is a valid reference so we want to allow
|
|
// normal processing to proceed.
|
|
return true;
|
|
}
|
|
|
|
this.Parent = parent;
|
|
this.HandlerOf = null;
|
|
this.rootActivity = parent.RootActivity;
|
|
this.cacheId = parent.cacheId;
|
|
this.isMetadataCached = CacheStates.Uncached;
|
|
ClearCachedMetadata();
|
|
this.relationshipToParent = relationship;
|
|
|
|
if (isPublic)
|
|
{
|
|
this.MemberOf = parent.MemberOf;
|
|
}
|
|
else
|
|
{
|
|
if (parent.ParentOf == null)
|
|
{
|
|
parent.ParentOf = new IdSpace(parent.MemberOf, parent.InternalId);
|
|
}
|
|
|
|
this.MemberOf = parent.ParentOf;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ClearCachedMetadata()
|
|
{
|
|
this.symbolCount = 0;
|
|
|
|
this.arguments = null;
|
|
|
|
this.children = null;
|
|
this.implementationChildren = null;
|
|
this.importedChildren = null;
|
|
|
|
this.delegates = null;
|
|
this.implementationDelegates = null;
|
|
this.importedDelegates = null;
|
|
|
|
this.variables = null;
|
|
this.implementationVariables = null;
|
|
}
|
|
|
|
internal void InternalCacheMetadata(bool createEmptyBindings, ref IList<ValidationError> validationErrors)
|
|
{
|
|
OnInternalCacheMetadata(createEmptyBindings);
|
|
|
|
if (this.tempAutoGeneratedArguments != null)
|
|
{
|
|
Fx.Assert(this.tempAutoGeneratedArguments.Count > 0, "We should only have a non-null value here if we generated an argument");
|
|
if (!this.SkipArgumentResolution)
|
|
{
|
|
ActivityUtilities.Add(ref validationErrors, new ValidationError(
|
|
SR.PublicReferencesOnActivityRequiringArgumentResolution(this.DisplayName), false, this));
|
|
}
|
|
|
|
if (this.arguments == null)
|
|
{
|
|
this.arguments = this.tempAutoGeneratedArguments;
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < this.tempAutoGeneratedArguments.Count; i++)
|
|
{
|
|
this.arguments.Add(this.tempAutoGeneratedArguments[i]);
|
|
}
|
|
}
|
|
|
|
this.tempAutoGeneratedArguments = null;
|
|
}
|
|
|
|
if (this.arguments != null && this.arguments.Count > 1)
|
|
{
|
|
ActivityValidationServices.ValidateEvaluationOrder(this.arguments, this, ref this.tempValidationErrors);
|
|
}
|
|
|
|
if (this.tempValidationErrors != null)
|
|
{
|
|
if (validationErrors == null)
|
|
{
|
|
validationErrors = new List<ValidationError>();
|
|
}
|
|
|
|
for (int i = 0; i < this.tempValidationErrors.Count; i++)
|
|
{
|
|
ValidationError validationError = this.tempValidationErrors[i];
|
|
|
|
validationError.Source = this;
|
|
validationError.Id = this.Id;
|
|
|
|
validationErrors.Add(validationError);
|
|
}
|
|
|
|
this.tempValidationErrors = null;
|
|
}
|
|
|
|
if (this.arguments == null)
|
|
{
|
|
this.arguments = emptyArguments;
|
|
}
|
|
else
|
|
{
|
|
this.symbolCount += this.arguments.Count;
|
|
}
|
|
|
|
if (this.variables == null)
|
|
{
|
|
this.variables = emptyVariables;
|
|
}
|
|
else
|
|
{
|
|
this.symbolCount += this.variables.Count;
|
|
}
|
|
|
|
if (this.implementationVariables == null)
|
|
{
|
|
this.implementationVariables = emptyVariables;
|
|
}
|
|
else
|
|
{
|
|
this.symbolCount += this.implementationVariables.Count;
|
|
}
|
|
|
|
if (this.children == null)
|
|
{
|
|
this.children = emptyChildren;
|
|
}
|
|
|
|
if (this.importedChildren == null)
|
|
{
|
|
this.importedChildren = emptyChildren;
|
|
}
|
|
|
|
if (this.implementationChildren == null)
|
|
{
|
|
this.implementationChildren = emptyChildren;
|
|
}
|
|
|
|
if (this.delegates == null)
|
|
{
|
|
this.delegates = emptyDelegates;
|
|
}
|
|
|
|
if (this.importedDelegates == null)
|
|
{
|
|
this.importedDelegates = emptyDelegates;
|
|
}
|
|
|
|
if (this.implementationDelegates == null)
|
|
{
|
|
this.implementationDelegates = emptyDelegates;
|
|
}
|
|
|
|
this.isMetadataCached = CacheStates.Partial;
|
|
}
|
|
|
|
// Note that this is relative to the type of walk we've done. If we
|
|
// skipped implementation then we can still be "Cached" even though
|
|
// we never ignored the implementation.
|
|
internal void SetCached(bool isSkippingPrivateChildren)
|
|
{
|
|
if (isSkippingPrivateChildren)
|
|
{
|
|
this.isMetadataCached = CacheStates.Partial;
|
|
}
|
|
else
|
|
{
|
|
this.isMetadataCached = CacheStates.Full;
|
|
}
|
|
}
|
|
|
|
internal void SetRuntimeReady()
|
|
{
|
|
this.isMetadataCached |= CacheStates.RuntimeReady;
|
|
}
|
|
|
|
internal virtual void OnInternalCacheMetadata(bool createEmptyBindings)
|
|
{
|
|
// By running CacheMetadata first we allow the user
|
|
// to set their Implementation during CacheMetadata.
|
|
ActivityMetadata metadata = new ActivityMetadata(this, GetParentEnvironment(), createEmptyBindings);
|
|
CacheMetadata(metadata);
|
|
metadata.Dispose();
|
|
|
|
if (this.Implementation != null)
|
|
{
|
|
this.runtimeImplementation = this.Implementation();
|
|
}
|
|
else
|
|
{
|
|
this.runtimeImplementation = null;
|
|
}
|
|
|
|
if (this.runtimeImplementation != null)
|
|
{
|
|
SetImplementationChildrenCollection(new Collection<Activity>
|
|
{
|
|
this.runtimeImplementation
|
|
});
|
|
}
|
|
}
|
|
|
|
protected virtual void CacheMetadata(ActivityMetadata metadata)
|
|
{
|
|
ReflectedInformation information = new ReflectedInformation(this);
|
|
|
|
SetImportedChildrenCollection(information.GetChildren());
|
|
SetVariablesCollection(information.GetVariables());
|
|
SetImportedDelegatesCollection(information.GetDelegates());
|
|
SetArgumentsCollection(information.GetArguments(), metadata.CreateEmptyBindings);
|
|
}
|
|
|
|
internal virtual void OnInternalCreateDynamicUpdateMap(DynamicUpdateMapBuilder.Finalizer finalizer,
|
|
DynamicUpdateMapBuilder.IDefinitionMatcher matcher, Activity originalActivity)
|
|
{
|
|
UpdateMapMetadata metadata = new UpdateMapMetadata(finalizer, matcher, this);
|
|
try
|
|
{
|
|
OnCreateDynamicUpdateMap(metadata, originalActivity);
|
|
}
|
|
finally
|
|
{
|
|
metadata.Dispose();
|
|
}
|
|
}
|
|
|
|
protected virtual void OnCreateDynamicUpdateMap(UpdateMapMetadata metadata, Activity originalActivity)
|
|
{
|
|
}
|
|
|
|
internal void AddDefaultExtensionProvider<T>(Func<T> extensionProvider)
|
|
where T : class
|
|
{
|
|
Fx.Assert(extensionProvider != null, "caller must verify");
|
|
Fx.Assert(this.rootActivity != null && this.rootActivity.rootProperties != null, "need a valid root");
|
|
this.rootActivity.rootProperties.AddDefaultExtensionProvider(extensionProvider);
|
|
}
|
|
|
|
internal void RequireExtension(Type extensionType)
|
|
{
|
|
Fx.Assert(extensionType != null && !extensionType.IsValueType, "caller should verify we have a valid reference type");
|
|
Fx.Assert(this.rootActivity != null && this.rootActivity.rootProperties != null, "need a valid root");
|
|
this.rootActivity.rootProperties.RequireExtension(extensionType);
|
|
}
|
|
|
|
// information used by root activities
|
|
class RootProperties
|
|
{
|
|
Dictionary<string, Activity> singletonActivityNames;
|
|
Dictionary<Type, WorkflowInstanceExtensionProvider> activityExtensionProviders;
|
|
HashSet<Type> requiredExtensionTypes;
|
|
|
|
public RootProperties()
|
|
{
|
|
}
|
|
|
|
public bool HasBeenAssociatedWithAnInstance
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public LocationReferenceEnvironment HostEnvironment
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Dictionary<string, List<RuntimeArgument>> OverloadGroups
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public List<RuntimeArgument> RequiredArgumentsNotInOverloadGroups
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public ValidationHelper.OverloadGroupEquivalenceInfo EquivalenceInfo
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public int DefaultExtensionsCount
|
|
{
|
|
get
|
|
{
|
|
if (this.activityExtensionProviders != null)
|
|
{
|
|
return this.activityExtensionProviders.Count;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
public int RequiredExtensionTypesCount
|
|
{
|
|
get
|
|
{
|
|
if (this.requiredExtensionTypes != null)
|
|
{
|
|
return this.requiredExtensionTypes.Count;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool GetActivityExtensionInformation(out Dictionary<Type, WorkflowInstanceExtensionProvider> activityExtensionProviders, out HashSet<Type> requiredActivityExtensionTypes)
|
|
{
|
|
activityExtensionProviders = this.activityExtensionProviders;
|
|
requiredActivityExtensionTypes = this.requiredExtensionTypes;
|
|
return activityExtensionProviders != null || (requiredExtensionTypes != null && requiredExtensionTypes.Count > 0);
|
|
}
|
|
|
|
public void AddDefaultExtensionProvider<T>(Func<T> extensionProvider)
|
|
where T : class
|
|
{
|
|
Type key = typeof(T);
|
|
if (this.activityExtensionProviders == null)
|
|
{
|
|
this.activityExtensionProviders = new Dictionary<Type, WorkflowInstanceExtensionProvider>();
|
|
}
|
|
else
|
|
{
|
|
if (this.activityExtensionProviders.ContainsKey(key))
|
|
{
|
|
return; // already have a provider of this type
|
|
}
|
|
}
|
|
|
|
this.activityExtensionProviders.Add(key, new WorkflowInstanceExtensionProvider<T>(extensionProvider));
|
|
|
|
// if we're providing an extension that exactly matches a required type, simplify further bookkeeping
|
|
if (this.requiredExtensionTypes != null)
|
|
{
|
|
this.requiredExtensionTypes.Remove(key);
|
|
}
|
|
}
|
|
|
|
public void RequireExtension(Type extensionType)
|
|
{
|
|
// if we're providing an extension that exactly matches a required type, don't bother with further bookkeeping
|
|
if (this.activityExtensionProviders != null && this.activityExtensionProviders.ContainsKey(extensionType))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (this.requiredExtensionTypes == null)
|
|
{
|
|
this.requiredExtensionTypes = new HashSet<Type>();
|
|
}
|
|
this.requiredExtensionTypes.Add(extensionType);
|
|
}
|
|
|
|
public bool IsSingletonActivityDeclared(string name)
|
|
{
|
|
if (this.singletonActivityNames == null)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return this.singletonActivityNames.ContainsKey(name);
|
|
}
|
|
}
|
|
|
|
public void DeclareSingletonActivity(string name, Activity activity)
|
|
{
|
|
if (this.singletonActivityNames == null)
|
|
{
|
|
this.singletonActivityNames = new Dictionary<string, Activity>(1);
|
|
}
|
|
|
|
this.singletonActivityNames.Add(name, activity);
|
|
}
|
|
|
|
public Activity GetSingletonActivity(string name)
|
|
{
|
|
Activity result = null;
|
|
if (this.singletonActivityNames != null)
|
|
{
|
|
this.singletonActivityNames.TryGetValue(name, out result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
internal class ReflectedInformation
|
|
{
|
|
Activity parent;
|
|
|
|
Collection<RuntimeArgument> arguments;
|
|
Collection<Variable> variables;
|
|
Collection<Activity> children;
|
|
Collection<ActivityDelegate> delegates;
|
|
|
|
static Type DictionaryArgumentHelperType = typeof(DictionaryArgumentHelper<>);
|
|
static Type OverloadGroupAttributeType = typeof(OverloadGroupAttribute);
|
|
|
|
public ReflectedInformation(Activity owner)
|
|
: this(owner, ReflectedType.All)
|
|
{
|
|
}
|
|
|
|
ReflectedInformation(Activity activity, ReflectedType reflectType)
|
|
{
|
|
this.parent = activity;
|
|
|
|
// reflect over our activity and gather relevant pieces of the system so that the developer
|
|
// doesn't need to worry about "zipping up" his model to the constructs necessary for the
|
|
// runtime to function correctly
|
|
foreach (PropertyDescriptor propertyDescriptor in TypeDescriptor.GetProperties(activity))
|
|
{
|
|
ArgumentDirection direction;
|
|
Type argumentType;
|
|
if ((reflectType & ReflectedType.Argument) == ReflectedType.Argument &&
|
|
ActivityUtilities.TryGetArgumentDirectionAndType(propertyDescriptor.PropertyType, out direction, out argumentType))
|
|
{
|
|
// We only do our magic for generic argument types. If the property is a non-generic
|
|
// argument type then that means the type of the RuntimeArgument should be based on
|
|
// the type of the argument bound to it. The activity author is responsible for dealing
|
|
// with these dynamic typing cases.
|
|
if (propertyDescriptor.PropertyType.IsGenericType)
|
|
{
|
|
bool isRequired = GetIsArgumentRequired(propertyDescriptor);
|
|
List<string> overloadGroupNames = GetOverloadGroupNames(propertyDescriptor);
|
|
RuntimeArgument argument = new RuntimeArgument(propertyDescriptor.Name, argumentType, direction, isRequired, overloadGroupNames, propertyDescriptor, activity);
|
|
Add<RuntimeArgument>(ref this.arguments, argument);
|
|
}
|
|
}
|
|
else if ((reflectType & ReflectedType.Variable) == ReflectedType.Variable &&
|
|
ActivityUtilities.IsVariableType(propertyDescriptor.PropertyType))
|
|
{
|
|
Variable variable = propertyDescriptor.GetValue(activity) as Variable;
|
|
if (variable != null)
|
|
{
|
|
Add<Variable>(ref this.variables, variable);
|
|
}
|
|
}
|
|
else if ((reflectType & ReflectedType.Child) == ReflectedType.Child &&
|
|
ActivityUtilities.IsActivityType(propertyDescriptor.PropertyType))
|
|
{
|
|
Activity workflowElement = propertyDescriptor.GetValue(activity) as Activity;
|
|
Add<Activity>(ref this.children, workflowElement);
|
|
}
|
|
else if ((reflectType & ReflectedType.ActivityDelegate) == ReflectedType.ActivityDelegate &&
|
|
ActivityUtilities.IsActivityDelegateType(propertyDescriptor.PropertyType))
|
|
{
|
|
ActivityDelegate activityDelegate = propertyDescriptor.GetValue(activity) as ActivityDelegate;
|
|
Add<ActivityDelegate>(ref this.delegates, activityDelegate);
|
|
}
|
|
else
|
|
{
|
|
Type innerType;
|
|
bool foundMatch = false;
|
|
if ((reflectType & ReflectedType.Argument) == ReflectedType.Argument)
|
|
{
|
|
object property = propertyDescriptor.GetValue(activity);
|
|
if (property != null)
|
|
{
|
|
IList<RuntimeArgument> runtimeArguments = DictionaryArgumentHelper.TryGetRuntimeArguments(property, propertyDescriptor.Name);
|
|
if (runtimeArguments != null)
|
|
{
|
|
this.AddCollection(ref this.arguments, runtimeArguments);
|
|
foundMatch = true;
|
|
}
|
|
else if (ActivityUtilities.IsArgumentDictionaryType(propertyDescriptor.PropertyType, out innerType))
|
|
{
|
|
Type concreteHelperType = DictionaryArgumentHelperType.MakeGenericType(innerType);
|
|
DictionaryArgumentHelper helper = Activator.CreateInstance(concreteHelperType, new object[] { property, propertyDescriptor.Name }) as DictionaryArgumentHelper;
|
|
this.AddCollection(ref this.arguments, helper.RuntimeArguments);
|
|
foundMatch = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!foundMatch && ActivityUtilities.IsKnownCollectionType(propertyDescriptor.PropertyType, out innerType))
|
|
{
|
|
if ((reflectType & ReflectedType.Variable) == ReflectedType.Variable &&
|
|
ActivityUtilities.IsVariableType(innerType))
|
|
{
|
|
IEnumerable enumerable = propertyDescriptor.GetValue(activity) as IEnumerable;
|
|
|
|
AddCollection(ref this.variables, enumerable);
|
|
}
|
|
else if ((reflectType & ReflectedType.Child) == ReflectedType.Child &&
|
|
ActivityUtilities.IsActivityType(innerType, false))
|
|
{
|
|
IEnumerable enumerable = propertyDescriptor.GetValue(activity) as IEnumerable;
|
|
|
|
AddCollection(ref this.children, enumerable);
|
|
}
|
|
else if ((reflectType & ReflectedType.ActivityDelegate) == ReflectedType.ActivityDelegate &&
|
|
ActivityUtilities.IsActivityDelegateType(innerType))
|
|
{
|
|
IEnumerable enumerable = propertyDescriptor.GetValue(activity) as IEnumerable;
|
|
|
|
AddCollection(ref this.delegates, enumerable);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Collection<RuntimeArgument> GetArguments(Activity parent)
|
|
{
|
|
Collection<RuntimeArgument> arguments = null;
|
|
|
|
if (parent != null)
|
|
{
|
|
arguments = new ReflectedInformation(parent, ReflectedType.Argument).GetArguments();
|
|
}
|
|
|
|
if (arguments == null)
|
|
{
|
|
arguments = new Collection<RuntimeArgument>();
|
|
}
|
|
|
|
return arguments;
|
|
}
|
|
|
|
public static Collection<Variable> GetVariables(Activity parent)
|
|
{
|
|
Collection<Variable> variables = null;
|
|
|
|
if (parent != null)
|
|
{
|
|
variables = new ReflectedInformation(parent, ReflectedType.Variable).GetVariables();
|
|
}
|
|
|
|
if (variables == null)
|
|
{
|
|
variables = new Collection<Variable>();
|
|
}
|
|
|
|
return variables;
|
|
}
|
|
|
|
public static Collection<Activity> GetChildren(Activity parent)
|
|
{
|
|
Collection<Activity> children = null;
|
|
|
|
if (parent != null)
|
|
{
|
|
children = new ReflectedInformation(parent, ReflectedType.Child).GetChildren();
|
|
}
|
|
|
|
if (children == null)
|
|
{
|
|
children = new Collection<Activity>();
|
|
}
|
|
|
|
return children;
|
|
}
|
|
|
|
public static Collection<ActivityDelegate> GetDelegates(Activity parent)
|
|
{
|
|
Collection<ActivityDelegate> delegates = null;
|
|
|
|
if (parent != null)
|
|
{
|
|
delegates = new ReflectedInformation(parent, ReflectedType.ActivityDelegate).GetDelegates();
|
|
}
|
|
|
|
if (delegates == null)
|
|
{
|
|
delegates = new Collection<ActivityDelegate>();
|
|
}
|
|
|
|
return delegates;
|
|
}
|
|
|
|
public Collection<RuntimeArgument> GetArguments()
|
|
{
|
|
return this.arguments;
|
|
}
|
|
|
|
public Collection<Variable> GetVariables()
|
|
{
|
|
return this.variables;
|
|
}
|
|
|
|
public Collection<Activity> GetChildren()
|
|
{
|
|
return this.children;
|
|
}
|
|
|
|
public Collection<ActivityDelegate> GetDelegates()
|
|
{
|
|
return this.delegates;
|
|
}
|
|
|
|
void AddCollection<T>(ref Collection<T> list, IEnumerable enumerable)
|
|
where T : class
|
|
{
|
|
if (enumerable != null)
|
|
{
|
|
foreach (object obj in enumerable)
|
|
{
|
|
if (obj != null && obj is T)
|
|
{
|
|
Add<T>(ref list, (T)obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Add<T>(ref Collection<T> list, T data)
|
|
{
|
|
if (data != null)
|
|
{
|
|
if (list == null)
|
|
{
|
|
list = new Collection<T>();
|
|
}
|
|
list.Add(data);
|
|
}
|
|
}
|
|
|
|
bool GetIsArgumentRequired(PropertyDescriptor propertyDescriptor)
|
|
{
|
|
return propertyDescriptor.Attributes[typeof(RequiredArgumentAttribute)] != null;
|
|
}
|
|
|
|
List<string> GetOverloadGroupNames(PropertyDescriptor propertyDescriptor)
|
|
{
|
|
List<string> overloadGroupNames = new List<string>(0);
|
|
AttributeCollection propertyAttributes = propertyDescriptor.Attributes;
|
|
for (int i = 0; i < propertyAttributes.Count; i++)
|
|
{
|
|
Attribute attribute = propertyAttributes[i];
|
|
if (ReflectedInformation.OverloadGroupAttributeType.IsAssignableFrom(attribute.GetType()))
|
|
{
|
|
overloadGroupNames.Add(((OverloadGroupAttribute)attribute).GroupName);
|
|
}
|
|
}
|
|
return overloadGroupNames;
|
|
}
|
|
|
|
[Flags]
|
|
enum ReflectedType
|
|
{
|
|
Argument = 0X1,
|
|
Variable = 0X2,
|
|
Child = 0X4,
|
|
ActivityDelegate = 0X8,
|
|
All = 0XF
|
|
}
|
|
|
|
class DictionaryArgumentHelper
|
|
{
|
|
protected DictionaryArgumentHelper()
|
|
{
|
|
}
|
|
|
|
public IList<RuntimeArgument> RuntimeArguments
|
|
{
|
|
get;
|
|
protected set;
|
|
}
|
|
|
|
public static IList<RuntimeArgument> TryGetRuntimeArguments(object propertyValue, string propertyName)
|
|
{
|
|
// special case each of the non-generic argument types to avoid reflection costs
|
|
|
|
IEnumerable<KeyValuePair<string, Argument>> argumentEnumerable = propertyValue as IEnumerable<KeyValuePair<string, Argument>>;
|
|
if (argumentEnumerable != null)
|
|
{
|
|
return GetRuntimeArguments(argumentEnumerable, propertyName);
|
|
}
|
|
|
|
IEnumerable<KeyValuePair<string, InArgument>> inArgumentEnumerable = propertyValue as IEnumerable<KeyValuePair<string, InArgument>>;
|
|
if (inArgumentEnumerable != null)
|
|
{
|
|
return GetRuntimeArguments(inArgumentEnumerable, propertyName);
|
|
}
|
|
|
|
IEnumerable<KeyValuePair<string, OutArgument>> outArgumentEnumerable = propertyValue as IEnumerable<KeyValuePair<string, OutArgument>>;
|
|
if (outArgumentEnumerable != null)
|
|
{
|
|
return GetRuntimeArguments(outArgumentEnumerable, propertyName);
|
|
}
|
|
|
|
IEnumerable<KeyValuePair<string, InOutArgument>> inOutArgumentEnumerable = propertyValue as IEnumerable<KeyValuePair<string, InOutArgument>>;
|
|
if (inOutArgumentEnumerable != null)
|
|
{
|
|
return GetRuntimeArguments(inOutArgumentEnumerable, propertyName);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected static IList<RuntimeArgument> GetRuntimeArguments<T>(IEnumerable<KeyValuePair<string, T>> argumentDictionary, string propertyName) where T : Argument
|
|
{
|
|
IList<RuntimeArgument> runtimeArguments = new List<RuntimeArgument>();
|
|
|
|
foreach (KeyValuePair<string, T> pair in argumentDictionary)
|
|
{
|
|
string key = pair.Key;
|
|
Argument value = pair.Value;
|
|
|
|
if (value == null)
|
|
{
|
|
string argName = (key == null) ? "<null>" : key;
|
|
throw FxTrace.Exception.AsError(new ValidationException(SR.MissingArgument(argName, propertyName)));
|
|
}
|
|
if (string.IsNullOrEmpty(key))
|
|
{
|
|
throw FxTrace.Exception.AsError(new ValidationException(SR.MissingNameProperty(value.ArgumentType)));
|
|
}
|
|
|
|
RuntimeArgument runtimeArgument = new RuntimeArgument(key, value.ArgumentType, value.Direction, false, null, value);
|
|
runtimeArguments.Add(runtimeArgument);
|
|
}
|
|
|
|
return runtimeArguments;
|
|
}
|
|
}
|
|
|
|
class DictionaryArgumentHelper<T> : DictionaryArgumentHelper where T : Argument
|
|
{
|
|
public DictionaryArgumentHelper(object propertyValue, string propertyName)
|
|
: base()
|
|
{
|
|
IEnumerable<KeyValuePair<string, T>> argumentDictionary = propertyValue as IEnumerable<KeyValuePair<string, T>>;
|
|
|
|
this.RuntimeArguments = GetRuntimeArguments(argumentDictionary, propertyName);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
internal enum RelationshipType : byte
|
|
{
|
|
Child = 0x00,
|
|
ImportedChild = 0x01,
|
|
ImplementationChild = 0x02,
|
|
DelegateHandler = 0x03,
|
|
ArgumentExpression = 0x04,
|
|
VariableDefault = 0x05
|
|
}
|
|
|
|
enum CacheStates : byte
|
|
{
|
|
// We don't have valid cached data
|
|
Uncached = 0x00,
|
|
|
|
// The next two states are mutually exclusive:
|
|
|
|
// The activity has its own metadata cached, or private implementation are skipped
|
|
Partial = 0x01,
|
|
|
|
// The activity has its own metadata and its private implementation cached
|
|
// We can make use of the roll-up metadata (like
|
|
// SubtreeHasConstraints).
|
|
Full = 0x02,
|
|
|
|
// The next state can be ORed with the last two:
|
|
|
|
// The cached data is ready for runtime use
|
|
RuntimeReady = 0x04
|
|
}
|
|
}
|
|
|
|
[TypeConverter(typeof(ActivityWithResultConverter))]
|
|
[ValueSerializer(typeof(ActivityWithResultValueSerializer))]
|
|
public abstract class Activity<TResult> : ActivityWithResult
|
|
{
|
|
// alternatives are extended through DynamicActivity<TResult>, CodeActivity<TResult>, and NativeActivity<TResult>
|
|
protected Activity()
|
|
: base()
|
|
{
|
|
}
|
|
|
|
[DefaultValue(null)]
|
|
public new OutArgument<TResult> Result
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
internal override Type InternalResultType
|
|
{
|
|
get
|
|
{
|
|
return typeof(TResult);
|
|
}
|
|
}
|
|
|
|
internal override OutArgument ResultCore
|
|
{
|
|
get
|
|
{
|
|
return this.Result;
|
|
}
|
|
set
|
|
{
|
|
this.Result = value as OutArgument<TResult>;
|
|
|
|
if (this.Result == null && value != null)
|
|
{
|
|
throw FxTrace.Exception.Argument("value", SR.ResultArgumentMustBeSpecificType(typeof(TResult)));
|
|
}
|
|
}
|
|
}
|
|
|
|
public static implicit operator Activity<TResult>(TResult constValue)
|
|
{
|
|
return FromValue(constValue);
|
|
}
|
|
|
|
public static implicit operator Activity<TResult>(Variable variable)
|
|
{
|
|
return FromVariable(variable);
|
|
}
|
|
|
|
public static implicit operator Activity<TResult>(Variable<TResult> variable)
|
|
{
|
|
return FromVariable(variable);
|
|
}
|
|
|
|
public static Activity<TResult> FromValue(TResult constValue)
|
|
{
|
|
return new Literal<TResult> { Value = constValue };
|
|
}
|
|
|
|
public static Activity<TResult> FromVariable(Variable variable)
|
|
{
|
|
if (variable == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("variable");
|
|
}
|
|
|
|
if (TypeHelper.AreTypesCompatible(variable.Type, typeof(TResult)))
|
|
{
|
|
return new VariableValue<TResult> { Variable = variable };
|
|
}
|
|
else
|
|
{
|
|
Type locationGenericType;
|
|
if (ActivityUtilities.IsLocationGenericType(typeof(TResult), out locationGenericType))
|
|
{
|
|
if (locationGenericType == variable.Type)
|
|
{
|
|
return (Activity<TResult>)ActivityUtilities.CreateVariableReference(variable);
|
|
}
|
|
}
|
|
}
|
|
|
|
throw FxTrace.Exception.Argument("variable", SR.ConvertVariableToValueExpressionFailed(variable.GetType().FullName, typeof(Activity<TResult>).FullName));
|
|
}
|
|
|
|
[SuppressMessage(FxCop.Category.Design, FxCop.Rule.ConsiderPassingBaseTypesAsParameters,
|
|
Justification = "Generic needed for type inference")]
|
|
public static Activity<TResult> FromVariable(Variable<TResult> variable)
|
|
{
|
|
if (variable == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("variable");
|
|
}
|
|
|
|
return new VariableValue<TResult>(variable);
|
|
}
|
|
|
|
internal override bool IsResultArgument(RuntimeArgument argument)
|
|
{
|
|
return object.ReferenceEquals(argument, this.ResultRuntimeArgument);
|
|
}
|
|
|
|
internal sealed override void OnInternalCacheMetadata(bool createEmptyBindings)
|
|
{
|
|
OnInternalCacheMetadataExceptResult(createEmptyBindings);
|
|
|
|
bool foundResult = false;
|
|
|
|
// This could be null at this point
|
|
IList<RuntimeArgument> runtimeArguments = this.RuntimeArguments;
|
|
|
|
int runtimeArgumentCount = 0;
|
|
|
|
if (runtimeArguments != null)
|
|
{
|
|
runtimeArgumentCount = runtimeArguments.Count;
|
|
|
|
for (int i = 0; i < runtimeArgumentCount; i++)
|
|
{
|
|
RuntimeArgument argument = runtimeArguments[i];
|
|
|
|
if (argument.Name == "Result")
|
|
{
|
|
foundResult = true;
|
|
|
|
if (argument.Type != typeof(TResult) || argument.Direction != ArgumentDirection.Out)
|
|
{
|
|
// The user supplied "Result" is incorrect so we
|
|
// log a violation.
|
|
AddTempValidationError(new ValidationError(SR.ResultArgumentHasRequiredTypeAndDirection(typeof(TResult), argument.Direction, argument.Type)));
|
|
}
|
|
else if (!IsBoundArgumentCorrect(argument, createEmptyBindings))
|
|
{
|
|
// The user supplied "Result" is not bound to the correct
|
|
// argument object.
|
|
AddTempValidationError(new ValidationError(SR.ResultArgumentMustBeBoundToResultProperty));
|
|
}
|
|
else
|
|
{
|
|
// The user supplied "Result" is correct so we
|
|
// cache it.
|
|
this.ResultRuntimeArgument = argument;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!foundResult)
|
|
{
|
|
this.ResultRuntimeArgument = new RuntimeArgument("Result", typeof(TResult), ArgumentDirection.Out);
|
|
|
|
if (this.Result == null)
|
|
{
|
|
if (createEmptyBindings)
|
|
{
|
|
this.Result = new OutArgument<TResult>();
|
|
Argument.Bind(this.Result, this.ResultRuntimeArgument);
|
|
}
|
|
else
|
|
{
|
|
OutArgument<TResult> tempArgument = new OutArgument<TResult>();
|
|
Argument.Bind(tempArgument, this.ResultRuntimeArgument);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Argument.Bind(this.Result, this.ResultRuntimeArgument);
|
|
}
|
|
|
|
|
|
AddArgument(this.ResultRuntimeArgument, createEmptyBindings);
|
|
}
|
|
}
|
|
|
|
bool IsBoundArgumentCorrect(RuntimeArgument argument, bool createEmptyBindings)
|
|
{
|
|
if (createEmptyBindings)
|
|
{
|
|
// We must match if we've gone through
|
|
// RuntimeArgument.SetupBinding with
|
|
// createEmptyBindings == true.
|
|
return object.ReferenceEquals(argument.BoundArgument, this.Result);
|
|
}
|
|
else
|
|
{
|
|
// Otherwise, if the Result is null then
|
|
// SetupBinding has created a default
|
|
// BoundArgument which is fine. If it
|
|
// is non-null then it had better match.
|
|
return this.Result == null || object.ReferenceEquals(argument.BoundArgument, this.Result);
|
|
}
|
|
}
|
|
|
|
internal virtual void OnInternalCacheMetadataExceptResult(bool createEmptyBindings)
|
|
{
|
|
// default to Activity's behavior
|
|
base.OnInternalCacheMetadata(createEmptyBindings);
|
|
}
|
|
|
|
internal override object InternalExecuteInResolutionContextUntyped(CodeActivityContext resolutionContext)
|
|
{
|
|
return InternalExecuteInResolutionContext(resolutionContext);
|
|
}
|
|
|
|
internal virtual TResult InternalExecuteInResolutionContext(CodeActivityContext resolutionContext)
|
|
{
|
|
throw Fx.AssertAndThrow("This should only be called on CodeActivity<T>");
|
|
}
|
|
}
|
|
}
|
|
|
|
|