public PSWorkflowRuntime GetPSWorkflowRuntime()
{
PSWorkflowRuntime pSWorkflowRuntime;
if (this._runtime == null)
{
lock (this._syncObject)
{
if (this._runtime == null)
{
this._runtime = PSWorkflowRuntime.Instance;
return(this._runtime);
}
else
{
pSWorkflowRuntime = this._runtime;
}
}
return(pSWorkflowRuntime);
}
else
{
return(this._runtime);
}
}
static void Main(string[] args)
{
// Create a variable for the workflow path.
string workflowFileName = "SampleWorkflow.xaml";
// Read the XAML into the variable.
string xaml = File.ReadAllText(workflowFileName);
// Create a runtime to host the workflow, passing the custom configuration provider.
PSWorkflowRuntime runtime = new PSWorkflowRuntime(new SampleConfigurationProvider());
// Parameters to the workflow can be provided in this dictionary.
Dictionary<string, object> parameters = new Dictionary<string, object>();
// Pass the ID of the current process, which the sample workflow expects as an input parameter.
parameters.Add("ProcessId", (new List<int>() { Process.GetCurrentProcess().Id }).ToArray());
// Create the job, providing the XAML definition.
PSWorkflowJob job = runtime.JobManager.CreateJob(Guid.NewGuid(), xaml, "Get-CurrentProcess", "SampleWorkflow", parameters);
// Subscribe to the state change event before starting the job.
AutoResetEvent wfEvent = new AutoResetEvent(false);
job.StateChanged += delegate(object sender, JobStateEventArgs e)
{
switch (e.JobStateInfo.State)
{
case JobState.Failed:
case JobState.Completed:
{
wfEvent.Set();
}
break;
}
};
// Start the job.
job.StartJob();
// Wait for the state changes event.
wfEvent.WaitOne();
if (job.JobStateInfo.State == JobState.Completed)
{
Console.WriteLine("The job has completed successfully.");
Console.WriteLine("Total processes found: " + job.PSWorkflowInstance.Streams.OutputStream.Count);
}
else
Console.WriteLine("The job has Failed.");
Console.WriteLine("Press <Enter> to continue...");
Console.ReadLine();
}
internal PSOutOfProcessActivityController(PSWorkflowRuntime runtime)
: base(runtime)
{
if (runtime == null)
{
throw new ArgumentNullException("runtime");
}
Debug.Assert(runtime.Configuration != null, "For now only expecting PSWorkflowConfigurationProvider");
this._configuration = runtime.Configuration;
InitializeActivityHostProcesses();
}
static void Main(string[] args)
{
// Set the path to the XAML workflow.
string workflowFileName = "SampleWorkflow.xaml";
// Read the XAML from the workflow into the variable
string xaml = File.ReadAllText(workflowFileName);
// Create a runtime to host the workflow, passing the custom configuration provider to the constructor.
PSWorkflowRuntime runtime = new PSWorkflowRuntime(new SampleConfigurationProvider());
// Parameters for the workflow can be provided in this dictionary
Dictionary<string, object>parameters = new Dictionary<string, object>();
// Create the job. Because we are using the default file-based store, we need to provide the XAML worklfow definition.
PSWorkflowJob job = runtime.JobManager.CreateJob(Guid.NewGuid(), xaml, "Get-CurrentProcess", "SampleWorkflow", parameters);
// Subscribe to the state change event before starting the job.
AutoResetEvent wfEvent = new AutoResetEvent(false);
job.StateChanged += delegate(object sender, JobStateEventArgs e)
{
switch (e.JobStateInfo.State)
{
case JobState.Failed:
case JobState.Completed:
{
wfEvent.Set();
}
break;
}
};
// Start the job
job.StartJob();
// Wait for the state change event.
wfEvent.WaitOne();
if (job.JobStateInfo.State == JobState.Completed)
{
Console.WriteLine("The job has completed successfully.");
Console.WriteLine("Total Commands found: " + job.PSWorkflowInstance.Streams.OutputStream.Count);
}
else
Console.WriteLine("The job has Failed.");
Console.WriteLine("Press <Enter> to continue...");
Console.ReadLine();
}
internal PSOutOfProcessActivityController(PSWorkflowRuntime runtime) : base(runtime)
{
this._hostProcesses = new Collection <ActivityHostProcess>();
this._requests = new ConcurrentQueue <ActivityInvoker>();
this._structuredTracer = new Tracer();
this._failedRequests = new ConcurrentQueue <ActivityInvoker>();
if (runtime != null)
{
this._configuration = runtime.Configuration;
this.InitializeActivityHostProcesses();
return;
}
else
{
throw new ArgumentNullException("runtime");
}
}
internal PSOutOfProcessActivityController(PSWorkflowRuntime runtime) : base(runtime)
{
this._hostProcesses = new Collection<ActivityHostProcess>();
this._requests = new ConcurrentQueue<ActivityInvoker>();
this._structuredTracer = new Tracer();
this._failedRequests = new ConcurrentQueue<ActivityInvoker>();
if (runtime != null)
{
this._configuration = runtime.Configuration;
this.InitializeActivityHostProcesses();
return;
}
else
{
throw new ArgumentNullException("runtime");
}
}
/// <summary>
/// Begin for obtaining a runspace for the specified ConnectionInfo
/// </summary>
/// <param name="connectionInfo">connection info to be used for remote connections</param>
/// <param name="retryCount">number of times to retry</param>
/// <param name="callback">optional user defined callback</param>
/// <param name="state">optional user specified state</param>
/// <param name="retryInterval">time in milliseconds before the next retry has to be attempted</param>
/// <returns>async result</returns>
public override IAsyncResult BeginGetRunspace(WSManConnectionInfo connectionInfo, uint retryCount, uint retryInterval, AsyncCallback callback, object state)
{
if (connectionInfo != null)
{
throw new InvalidOperationException();
}
LocalRunspaceAsyncResult asyncResult = new LocalRunspaceAsyncResult(state, callback, Guid.Empty);
// Get the source language mode from the activity arguments if available and pass to runspace fetching.
PSLanguageMode? sourceLanguageMode = null;
RunCommandsArguments args = state as RunCommandsArguments;
if (args != null)
{
PSWorkflowRuntime wfRuntime = args.WorkflowHost as PSWorkflowRuntime;
if (wfRuntime != null)
{
PSWorkflowJob wfJob = wfRuntime.JobManager.GetJob(args.PSActivityContext.JobInstanceId);
if (wfJob != null)
{
sourceLanguageMode = wfJob.SourceLanguageMode;
}
}
}
Runspace runspace = AssignRunspaceIfPossible(sourceLanguageMode);
if (runspace != null)
{
asyncResult.Runspace = runspace;
asyncResult.CompletedSynchronously = true;
asyncResult.SetAsCompleted(null);
}
else
{
// queue the request
_requests.Enqueue(asyncResult);
CheckAndStartRequestServicingThread();
}
return(asyncResult);
}
/// <summary>
///
/// </summary>
/// <param name="runtime"></param>
/// <param name="command"></param>
/// <param name="name"></param>
/// <param name="instanceId"></param>
internal PSWorkflowJob(PSWorkflowRuntime runtime, string command, string name, Guid instanceId)
: base(command, name, instanceId)
{
Dbg.Assert(runtime != null, "runtime must not be null.");
_runtime = runtime;
CommonInit();
}
// Pass the PSWorkflowRuntime as the parameter.
// This resumes execution of the job.
public SampleActivityController(PSWorkflowRuntime runtime)
: base(runtime)
{
_runtime = runtime;
}
/// <summary>
/// Construct a PSWorkflowJob.
/// </summary>
/// <param name="runtime"></param>
/// <param name="specification">JobInvocationInfo representing the command this job will invoke.</param>
/// <param name="JobInstanceId"></param>
/// <param name="creationContext"></param>
internal PSWorkflowJob(PSWorkflowRuntime runtime, JobInvocationInfo specification, Guid JobInstanceId, Dictionary<string, object> creationContext)
: base(Validate(specification).Command, specification.Definition.Name, JobInstanceId)
{
Dbg.Assert(runtime != null, "runtime must not be null.");
// If specification is null, ArgumentNullException would be raised from
// the static validate method.
StartParameters = specification.Parameters;
_definition = WorkflowJobDefinition.AsWorkflowJobDefinition(specification.Definition);
_jobCreationContext = creationContext;
_runtime = runtime;
CommonInit();
}
/// <summary>
///
/// </summary>
/// <param name="runtime"></param>
/// <param name="command"></param>
/// <param name="name"></param>
/// <param name="token"></param>
internal PSWorkflowJob(PSWorkflowRuntime runtime, string command, string name, JobIdentifier token)
: base(command, name, token)
{
Dbg.Assert(runtime != null, "runtime must not be null.");
_runtime = runtime;
CommonInit();
}
internal PSWorkflowJob(PSWorkflowRuntime runtime, string command, string name, Guid instanceId) : base(command, name, instanceId)
{
this._tracer = PowerShellTraceSourceFactory.GetTraceSource();
this._syncObject = new object();
this._resumeErrorSyncObject = new object();
this._statusMessage = string.Empty;
this._location = string.Empty;
this._resumeErrors = new Dictionary<Guid, Exception>();
this._workflowParameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
this._psWorkflowCommonParameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
this._jobMetadata = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
this._privateMetadata = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
this.IsSuspendable = null;
this.listOfLabels = new List<string>();
this._runtime = runtime;
this.CommonInit();
}
internal PSWorkflowJob(PSWorkflowRuntime runtime, JobInvocationInfo specification, Guid JobInstanceId) : base(PSWorkflowJob.Validate(specification).Command, specification.Definition.Name, JobInstanceId)
{
this._tracer = PowerShellTraceSourceFactory.GetTraceSource();
this._syncObject = new object();
this._resumeErrorSyncObject = new object();
this._statusMessage = string.Empty;
this._location = string.Empty;
this._resumeErrors = new Dictionary<Guid, Exception>();
this._workflowParameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
this._psWorkflowCommonParameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
this._jobMetadata = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
this._privateMetadata = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
this.IsSuspendable = null;
this.listOfLabels = new List<string>();
base.StartParameters = specification.Parameters;
this._definition = WorkflowJobDefinition.AsWorkflowJobDefinition(specification.Definition);
this._runtime = runtime;
this.CommonInit();
}
private void InitializePSWorkflowApplicationInstance(PSWorkflowRuntime runtime)
{
if (runtime == null)
throw new ArgumentNullException("runtime");
this.PersistAfterNextPSActivity = false;
this.suspendAtNextCheckpoint = false;
Runtime = runtime;
this.asyncExecutionCollection = new Dictionary<string, PSActivityContext>();
this.ForceDisableStartOrEndPersistence = false;
if (Runtime.Configuration.PSWorkflowApplicationPersistUnloadTimeoutSec > 0)
{
PersistUnloadTimer = new Timer(Convert.ToDouble(Runtime.Configuration.PSWorkflowApplicationPersistUnloadTimeoutSec * 1000));
PersistUnloadTimer.Elapsed += new ElapsedEventHandler(PersistUnloadTimer_Elapsed);
PersistUnloadTimer.AutoReset = false;
}
this._debugger = new PSWorkflowDebugger(this);
}
/// <summary>
/// Workflow instance constructor.
/// </summary>
/// <param name="runtime"></param>
/// <param name="definition">The workflow definition.</param>
/// <param name="metadata">The metadata which includes parameters etc.</param>
/// <param name="pipelineInput">This is input coming from pipeline, which is added to the input stream.</param>
/// <param name="job"></param>
internal PSWorkflowApplicationInstance(
PSWorkflowRuntime runtime,
PSWorkflowDefinition definition,
PSWorkflowContext metadata,
PSDataCollection<PSObject> pipelineInput,
PSWorkflowJob job)
{
Tracer.WriteMessage("Creating Workflow instance.");
InitializePSWorkflowApplicationInstance(runtime);
this._definition = definition;
this._metadatas = metadata;
this._streams = new PowerShellStreams<PSObject, PSObject>(pipelineInput);
RegisterHandlersForDataAdding(_streams);
this._timers = new PSWorkflowTimer(this);
this.creationMode = WorkflowInstanceCreationMode.Normal;
_job = job;
_stores = Runtime.Configuration.CreatePSWorkflowInstanceStore(this);
this._remoteActivityState = new PSWorkflowRemoteActivityState(_stores);
}
protected PSResumableActivityHostController(PSWorkflowRuntime runtime) : base(runtime)
{
}
internal PSWorkflowApplicationInstance(PSWorkflowRuntime runtime, PSWorkflowId instanceId)
{
this.Tracer = PowerShellTraceSourceFactory.GetTraceSource();
this.wfAppNeverLoaded = true;
this.ReactivateSync = new object();
if (runtime != null)
{
this.Tracer.WriteMessage("Creating Workflow instance after crash and shutdown workflow.");
this._definition = null;
this._metadatas = null;
this._streams = null;
this._timers = null;
this.id = instanceId.Guid;
this.creationMode = WorkflowInstanceCreationMode.AfterCrashOrShutdown;
this.PersistAfterNextPSActivity = false;
this.suspendAtNextCheckpoint = false;
base.Runtime = runtime;
this._stores = base.Runtime.Configuration.CreatePSWorkflowInstanceStore(this);
this.asyncExecutionCollection = new Dictionary<string, PSActivityContext>();
base.ForceDisableStartOrEndPersistence = false;
return;
}
else
{
throw new ArgumentNullException("runtime");
}
}
internal PSWorkflowApplicationInstance(PSWorkflowRuntime runtime, PSWorkflowDefinition definition, PSWorkflowContext metadata, PSDataCollection<PSObject> pipelineInput, PSWorkflowJob job)
{
this.Tracer = PowerShellTraceSourceFactory.GetTraceSource();
this.wfAppNeverLoaded = true;
this.ReactivateSync = new object();
if (runtime != null)
{
this.Tracer.WriteMessage("Creating Workflow instance.");
this._definition = definition;
this._metadatas = metadata;
this._streams = new PowerShellStreams<PSObject, PSObject>(pipelineInput);
this.RegisterHandlersForDataAdding(this._streams);
this._timers = new PSWorkflowTimer(this);
this.creationMode = WorkflowInstanceCreationMode.Normal;
this.PersistAfterNextPSActivity = false;
this.suspendAtNextCheckpoint = false;
this._job = job;
base.Runtime = runtime;
this._stores = base.Runtime.Configuration.CreatePSWorkflowInstanceStore(this);
this.asyncExecutionCollection = new Dictionary<string, PSActivityContext>();
base.ForceDisableStartOrEndPersistence = false;
return;
}
else
{
throw new ArgumentNullException("runtime");
}
}
private Activity ValidateWorkflow(JobInvocationInfo invocationInfo, Activity activity, ref bool?isSuspendable)
{
bool flag = false;
PSWorkflowRuntime instance = PSWorkflowRuntime.Instance;
JobDefinition definition = invocationInfo.Definition;
WorkflowJobDefinition workflowJobDefinition = WorkflowJobDefinition.AsWorkflowJobDefinition(definition);
bool flag1 = true;
if (activity == null)
{
activity = DefinitionCache.Instance.GetActivityFromCache(workflowJobDefinition, out flag);
if (activity != null)
{
flag1 = false;
if (flag)
{
return(activity);
}
}
else
{
throw new InvalidOperationException();
}
}
if (instance.Configuration.EnableValidation)
{
if (!flag1 || DefinitionCache.Instance.AllowExternalActivity)
{
PSWorkflowValidationResults pSWorkflowValidationResult = this.GetWorkflowValidator().ValidateWorkflow(definition.InstanceId, activity, DefinitionCache.Instance.GetRuntimeAssemblyName(workflowJobDefinition));
if (pSWorkflowValidationResult.Results != null)
{
this.GetWorkflowValidator().ProcessValidationResults(pSWorkflowValidationResult.Results);
}
isSuspendable = new bool?(pSWorkflowValidationResult.IsWorkflowSuspendable);
return(activity);
}
else
{
if (Validation.CustomHandler != null)
{
if (!Validation.CustomHandler(activity))
{
string displayName = activity.DisplayName;
if (string.IsNullOrEmpty(displayName))
{
displayName = base.GetType().Name;
}
object[] objArray = new object[1];
objArray[0] = displayName;
string str = string.Format(CultureInfo.CurrentCulture, Resources.InvalidActivity, objArray);
throw new ValidationException(str);
}
else
{
return(activity);
}
}
else
{
throw new InvalidOperationException();
}
}
}
else
{
return(activity);
}
}
/// <summary>
/// Runtime should be provided for accessing the runtime activity mode
/// </summary>
protected PSActivityHostController(PSWorkflowRuntime runtime)
{
_runtime = runtime;
}
protected PSActivityHostController(PSWorkflowRuntime runtime)
{
this._inProcActivityLookup = new ConcurrentDictionary<string, bool>();
this._runtime = runtime;
}
static void Main(string[] args)
{
// Creat a variable for the workflow path.
string workflowFileName = "SampleWorkflow.xaml";
// Specify the database server name and instace before executing this command.
string dbServer = "ServerName\\InstanceName";
string database = "M3PExtendedStore";
// Read the XAML into the variable
string xaml = File.ReadAllText(workflowFileName);
string conString = GetConnectionString(dbServer, database);
// Create a runtime to host the application, passing the custom configuration provider.
PSWorkflowRuntime runtime = new PSWorkflowRuntime(new SampleConfigurationProvider(conString));
// Parameters to the workflow can be provided in this dictionary
Dictionary<string, object> parameters = new Dictionary<string, object>();
// Create the job, providing the XAML definition.
PSWorkflowJob job = runtime.JobManager.CreateJob(Guid.NewGuid(), xaml, "Get-CurrentProcess", "SampleWorkflow", parameters);
// Subscribe to the state change event before starting the job.
AutoResetEvent wfEvent = new AutoResetEvent(false);
job.StateChanged += delegate(object sender, JobStateEventArgs e)
{
switch (e.JobStateInfo.State)
{
case JobState.Failed:
case JobState.Completed:
case JobState.Suspended:
{
wfEvent.Set();
}
break;
}
};
// Start the job
job.StartJob();
// Wait for the state changes event
wfEvent.WaitOne();
// Check whether the workflow is in the suspended state.
if (job.JobStateInfo.State == JobState.Suspended)
{
Console.WriteLine("The job has suspended successfully.");
}
else
{
// If not, inform the user that the job was not suspended.
Console.WriteLine("The job has not reached a desired state.");
Console.ReadLine();
return;
}
Console.WriteLine("Resuming the job.");
// Resume
job.ResumeJob();
// Wait for the state changes event
wfEvent.WaitOne();
// The workfow should be completed
if (job.JobStateInfo.State == JobState.Completed)
{
Console.WriteLine("The job has completed successfully.");
Console.WriteLine("Total Process found: " + job.PSWorkflowInstance.Streams.OutputStream.Count);
}
else
Console.WriteLine("The job has Failed.");
Console.WriteLine("Press <Enter> to continue...");
Console.ReadLine();
}
/// <summary>
/// Workflow instance constructor for shutdown or crashed workflows.
/// </summary>
/// <param name="runtime"></param>
/// <param name="instanceId"></param>
internal PSWorkflowApplicationInstance(PSWorkflowRuntime runtime, PSWorkflowId instanceId)
{
Tracer.WriteMessage("Creating Workflow instance after crash and shutdown workflow.");
InitializePSWorkflowApplicationInstance(runtime);
this._definition = null;
this._metadatas = null;
this._streams = null;
this._timers = null;
this.id = instanceId.Guid;
this.creationMode = WorkflowInstanceCreationMode.AfterCrashOrShutdown;
_stores = Runtime.Configuration.CreatePSWorkflowInstanceStore(this);
this._remoteActivityState = null;
}
public PSWorkflowJobManager(PSWorkflowRuntime runtime, int throttleLimit)
{
this.lockObjects = new LockObjectsCollection();
this._pendingQueue = new ConcurrentQueue<Tuple<Action<object>, object, JobState>>();
this._servicingThreadSyncObject = new object();
this._needToStartServicingThread = true;
PSWorkflowJobManager lazy = this;
lazy._waitForJobs = new Lazy<AutoResetEvent>(() => new AutoResetEvent(false));
this._wfJobTable = new ConcurrentDictionary<Guid, PSWorkflowJob>();
if (runtime != null)
{
if (PSWorkflowJobManager.TestMode)
{
Interlocked.Increment(ref PSWorkflowJobManager.ObjectCounter);
}
this._runtime = runtime;
this._throttleLimit = throttleLimit;
return;
}
else
{
throw new ArgumentNullException("runtime");
}
}
private Activity ValidateWorkflow(JobInvocationInfo invocationInfo, Activity activity, ref bool?isSuspendable)
{
PSWorkflowRuntime runtime = PSWorkflowRuntime.Instance;
JobDefinition definition = invocationInfo.Definition;
WorkflowJobDefinition workflowJobDefinition = WorkflowJobDefinition.AsWorkflowJobDefinition(definition);
bool externalActivity = true;
if (activity == null)
{
bool windowsWorkflow;
activity = DefinitionCache.Instance.GetActivityFromCache(workflowJobDefinition, out windowsWorkflow);
// Debug.Assert(activity != null, "WorkflowManager failed validation for a null activity");
if (activity == null)
{
throw new InvalidOperationException();
}
externalActivity = false;
// skip validation if it is a windows workflow
if (windowsWorkflow)
{
return(activity);
}
}
// If validation is disabled, just return the activity as is...
if (!runtime.Configuration.EnableValidation)
{
return(activity);
}
if (externalActivity && !DefinitionCache.Instance.AllowExternalActivity)
{
// If there is a custom validator activity, then call it. If it returns true
// then just return the activity.
if (Validation.CustomHandler == null)
{
throw new InvalidOperationException();
}
if (Validation.CustomHandler.Invoke(activity))
{
return(activity);
}
string displayName = activity.DisplayName;
if (string.IsNullOrEmpty(displayName))
{
displayName = this.GetType().Name;
}
string message = string.Format(CultureInfo.CurrentCulture, Resources.InvalidActivity, displayName);
throw new ValidationException(message);
}
PSWorkflowValidationResults validationResults = GetWorkflowValidator().ValidateWorkflow(
definition.InstanceId, activity,
DefinitionCache.Instance.GetRuntimeAssemblyName(workflowJobDefinition));
if (validationResults.Results != null)
{
GetWorkflowValidator().ProcessValidationResults(validationResults.Results);
}
isSuspendable = validationResults.IsWorkflowSuspendable;
return(activity);
}
/// <summary>
/// Construct a workflow manager
/// </summary>
/// <param name="runtime"></param>
/// <param name="throttleLimit"></param>
public PSWorkflowJobManager(PSWorkflowRuntime runtime, int throttleLimit)
{
if (runtime == null)
{
throw new ArgumentNullException("runtime");
}
if (TestMode)
{
System.Threading.Interlocked.Increment(ref ObjectCounter);
}
_runtime = runtime;
_throttleLimit = throttleLimit;
if (PSWorkflowSessionConfiguration.IsWorkflowTypeEndpoint)
{
_shutdownTimer = new Timer(_runtime.Configuration.WSManPluginReportCompletionOnZeroActiveSessionsWaitIntervalMSec);
_shutdownTimer.Elapsed += ShutdownWaitTimerElapsed;
_shutdownTimer.AutoReset = false;
WSManServerChannelEvents.ActiveSessionsChanged += OnWSManServerActiveSessionsChangedEvent;
}
}
internal PSOutOfProcessActivityController(PSWorkflowRuntime runtime)
: base(runtime)
{
if (runtime == null)
throw new ArgumentNullException("runtime");
Debug.Assert(runtime.Configuration != null, "For now only expecting PSWorkflowConfigurationProvider");
this._configuration = runtime.Configuration;
InitializeActivityHostProcesses();
}
/// <summary>
/// Construct a PSWorkflowJob.
/// </summary>
/// <param name="runtime"></param>
/// <param name="specification">JobInvocationInfo representing the command this job
/// will invoke.</param>
internal PSWorkflowJob(PSWorkflowRuntime runtime, JobInvocationInfo specification)
: base(Validate(specification).Command)
{
Dbg.Assert(runtime != null, "runtime must not be null.");
// If specification is null, ArgumentNullException would be raised from
// the static validate method.
StartParameters = specification.Parameters;
_definition = WorkflowJobDefinition.AsWorkflowJobDefinition(specification.Definition);
_runtime = runtime;
CommonInit();
}