public CimActivityImplementationContext(ActivityImplementationContext activityImplementationContext, string computerName, PSCredential credential, string certificateThumbprint, AuthenticationMechanism? authenticationMechanism, bool useSsl, uint port, PSSessionOption sessionOption, CimSession session, CimSessionOptions cimSessionOptions, string moduleDefinition, Uri resourceUri)
		{
			if (activityImplementationContext != null)
			{
				base.PowerShellInstance = activityImplementationContext.PowerShellInstance;
				this.ResourceUri = resourceUri;
				this.ComputerName = computerName;
				base.PSCredential = credential;
				base.PSCertificateThumbprint = certificateThumbprint;
				base.PSAuthentication = authenticationMechanism;
				base.PSUseSsl = new bool?(useSsl);
				base.PSPort = new uint?(port);
				base.PSSessionOption = sessionOption;
				this.Session = session;
				this.SessionOptions = cimSessionOptions;
				if (moduleDefinition != null)
				{
					CimActivityImplementationContext._moduleScriptBlock = ScriptBlock.Create(moduleDefinition);
					this._moduleDefinition = moduleDefinition;
				}
				return;
			}
			else
			{
				throw new ArgumentNullException("activityImplementationContext");
			}
		}

 internal SessionStateFunctionEntry(string name, string definition, ScopedItemOptions options, SessionStateEntryVisibility visibility, System.Management.Automation.ScriptBlock scriptBlock, string helpFile) : base(name, visibility)
 {
     this._definition = definition;
     this._options = options;
     this._scriptBlock = scriptBlock;
     this._helpFile = helpFile;
 }

 private static object InvokeScript(string methodName, ScriptBlock script, object @this, object[] arguments)
 {
     object obj2;
     try
     {
         obj2 = script.DoInvokeReturnAsIs(true, ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe, AutomationNull.Value, AutomationNull.Value, @this, arguments);
     }
     catch (SessionStateOverflowException exception)
     {
         throw new MethodInvocationException("ScriptMethodSessionStateOverflowException", exception, ExtendedTypeSystem.MethodInvocationException, new object[] { methodName, arguments.Length, exception.Message });
     }
     catch (RuntimeException exception2)
     {
         throw new MethodInvocationException("ScriptMethodRuntimeException", exception2, ExtendedTypeSystem.MethodInvocationException, new object[] { methodName, arguments.Length, exception2.Message });
     }
     catch (TerminateException)
     {
         throw;
     }
     catch (FlowControlException exception3)
     {
         throw new MethodInvocationException("ScriptMethodFlowControlException", exception3, ExtendedTypeSystem.MethodInvocationException, new object[] { methodName, arguments.Length, exception3.Message });
     }
     catch (PSInvalidOperationException exception4)
     {
         throw new MethodInvocationException("ScriptMethodInvalidOperationException", exception4, ExtendedTypeSystem.MethodInvocationException, new object[] { methodName, arguments.Length, exception4.Message });
     }
     return obj2;
 }

 /// <summary>
 /// </summary>
 /// <param name="name">The name of the variable, without the preceeding $.</param>
 /// <param name="onGet">The get accessor for the variable. The return value will be used as the variable's value.</param>
 /// <param name="onSet">The set accessor for the variable. Use $Args[0] to access the new variable.</param>
 /// <param name="isCollection">True to wrap the value of the variable in a collection even if only a single value is returned.</param>
 public DynamicVariable(string name, ScriptBlock onGet, ScriptBlock onSet, bool isCollection)
     : base(name, null, ScopedItemOptions.AllScope)
 {
     OnGet = onGet;
     OnSet = onSet;
     IsCollection = isCollection;
 }

 private HelpCommentsParser(CommandInfo commandInfo, List<string> parameterDescriptions)
 {
     this._sections = new CommentHelpInfo();
     this._parameters = new Dictionary<string, string>();
     this._examples = new List<string>();
     this._inputs = new List<string>();
     this._outputs = new List<string>();
     this._links = new List<string>();
     FunctionInfo info = commandInfo as FunctionInfo;
     if (info != null)
     {
         this.scriptBlock = info.ScriptBlock;
         this.commandName = info.Name;
     }
     else
     {
         ExternalScriptInfo info2 = commandInfo as ExternalScriptInfo;
         if (info2 != null)
         {
             this.scriptBlock = info2.ScriptBlock;
             this.commandName = info2.Path;
         }
     }
     this.commandMetadata = commandInfo.CommandMetadata;
     this.parameterDescriptions = parameterDescriptions;
 }

 internal FunctionInfo(string name, ScriptBlock function, ScopedItemOptions options)
     : base(name, CommandTypes.Function)
 {
     ScriptBlock = function;
     Options = options;
     ScopeUsage = ScopeUsages.NewScope;
 }

 internal FunctionInfo(string verb, string noun, ScriptBlock function, IEnumerable<ParameterAst> explicitParams,
                       ScopedItemOptions options)
     : this(verb + "-" + noun, function, explicitParams, options)
 {
     Verb = verb;
     Noun = noun;
 }

 public void Set(string name, ScriptBlock function, string description = "")
 {
     var qualName = new SessionStateScope<FunctionInfo>.QualifiedName(name);
     var info = new FunctionInfo(qualName.UnqualifiedName, function);
     info.Description = description;
     _scope.Set(name, info, true, true);
 }

 protected ScriptCommandProcessorBase(ScriptBlock scriptBlock, ExecutionContext context, bool useLocalScope, CommandOrigin origin, SessionStateInternal sessionState)
 {
     this._dontUseScopeCommandOrigin = false;
     base.CommandInfo = new ScriptInfo(string.Empty, scriptBlock, context);
     base._fromScriptFile = false;
     this.CommonInitialization(scriptBlock, context, useLocalScope, sessionState);
     base.Command.CommandOriginInternal = origin;
 }

 public AsyncJob(ScriptBlock Script, Hashtable Parameters)
     : this(Script)
 {
     foreach(DictionaryEntry param in Parameters)
     {
         this.Pipeline.AddParameter((string)param.Key, param.Value);
     }
 }

 internal Breakpoint(string script, ScriptBlock action)
 {
     Enabled = true;
     Script = script;
     Id = s_lastID++;
     Action = action;
     HitCount = 0;
 }

 /// <summary>
 /// constructor
 /// </summary>
 /// <param name="scriptBlock"></param>
 /// <exception cref="ArgumentNullException"></exception>
 internal MshExpression(ScriptBlock scriptBlock)
 {
     if (scriptBlock == null)
     {
         throw PSTraceSource.NewArgumentNullException("scriptBlock");
     }
     Script = scriptBlock;
 }

 internal Breakpoint(string script, ScriptBlock action)
 {
     this.Enabled = true;
     this.Script = script;
     this.Id = _lastID++;
     this.Action = action;
     this.HitCount = 0;
 }

        public LogFile(string filename, StreamType streams = StreamType.All, ScriptBlock errorCallback = null)
        {
            fileName = System.IO.Path.GetFileName(filename);
            path = System.IO.Path.GetDirectoryName(filename);

            Streams = streams;
            ErrorCallback = errorCallback;
        }

 public PowerShellProcessInstance(Version powerShellVersion, PSCredential credential, ScriptBlock initializationScript, bool useWow64)
 {
     this._syncObject = new object();
     string pSExePath = PSExePath;
     if (useWow64)
     {
         string environmentVariable = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
         if (!string.IsNullOrEmpty(environmentVariable) && (environmentVariable.Equals("amd64", StringComparison.OrdinalIgnoreCase) || environmentVariable.Equals("ia64", StringComparison.OrdinalIgnoreCase)))
         {
             pSExePath = PSExePath.ToLowerInvariant().Replace(@"\system32\", @"\syswow64\");
             if (!System.IO.File.Exists(pSExePath))
             {
                 throw new PSInvalidOperationException(PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.IPCWowComponentNotPresent, new object[] { pSExePath }));
             }
         }
     }
     string str4 = string.Empty;
     Version version = powerShellVersion ?? PSVersionInfo.PSVersion;
     if (null == version)
     {
         version = new Version(3, 0);
     }
     str4 = string.Format(CultureInfo.InvariantCulture, "-Version {0}", new object[] { new Version(version.Major, version.Minor) });
     str4 = string.Format(CultureInfo.InvariantCulture, "{0} -s -NoLogo -NoProfile", new object[] { str4 });
     if (initializationScript != null)
     {
         string str5 = initializationScript.ToString();
         if (!string.IsNullOrEmpty(str5))
         {
             string str6 = Convert.ToBase64String(Encoding.Unicode.GetBytes(str5));
             str4 = string.Format(CultureInfo.InvariantCulture, "{0} -EncodedCommand {1}", new object[] { str4, str6 });
         }
     }
     ProcessStartInfo info = new ProcessStartInfo {
         FileName = useWow64 ? pSExePath : PSExePath,
         Arguments = str4,
         UseShellExecute = false,
         RedirectStandardInput = true,
         RedirectStandardOutput = true,
         RedirectStandardError = true,
         WindowStyle = ProcessWindowStyle.Hidden,
         CreateNoWindow = true,
         LoadUserProfile = true
     };
     this._startInfo = info;
     if (credential != null)
     {
         NetworkCredential networkCredential = credential.GetNetworkCredential();
         this._startInfo.UserName = networkCredential.UserName;
         this._startInfo.Domain = string.IsNullOrEmpty(networkCredential.Domain) ? "." : networkCredential.Domain;
         this._startInfo.Password = credential.Password;
     }
     System.Diagnostics.Process process = new System.Diagnostics.Process {
         StartInfo = this._startInfo,
         EnableRaisingEvents = true
     };
     this._process = process;
 }

        /// <summary>
        /// This constructor is used primarily via PowerShell scripts.
        /// </summary>
        /// <param name="scriptBlock"></param>
        public ArgumentCompleterAttribute(ScriptBlock scriptBlock)
        {
            if (scriptBlock == null)
            {
                throw PSTraceSource.NewArgumentNullException("scriptBlock");
            }

            ScriptBlock = scriptBlock;
        }

 public WorkflowInfo(
     string name,
     string definition,
     ScriptBlock workflow,
     string xamlDefinition,
     WorkflowInfo[] workflowsCalled)
     : base(name, workflow, null)
 {
 }

 public static void CreateWizard(string name, ScriptBlock[] sb)
 {
     UIAutomation.Commands.NewUIAWizardCommand cmdlet =
         new UIAutomation.Commands.NewUIAWizardCommand();
     cmdlet.Name = name;
     cmdlet.StartAction = sb;
     UIANewWizardCommand command =
         new UIANewWizardCommand(cmdlet);
     command.Execute();
 }

        /// <summary>
        /// Creates an instance of the ScriptInfo class with the specified name, and script.
        /// </summary>
        /// 
        /// <param name="name">
        /// The name of the script.
        /// </param>
        /// 
        /// <param name="script">
        /// The script definition
        /// </param>
        /// 
        /// <param name="context">
        /// The execution context for the script.
        /// </param>
        /// 
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="script"/> is null.
        /// </exception>
        /// 
        internal ScriptInfo(string name, ScriptBlock script, ExecutionContext context)
            : base(name, CommandTypes.Script, context)
        {
            if (script == null)
            {
                throw PSTraceSource.NewArgumentException("script");
            }

            this.ScriptBlock = script;
        } // ScriptInfo ctor

 public void BeginInvoke(ScriptBlock scriptblock, PSObject inputObject)
 {
     _percentComplete = 0;
     string command = $"param($_,$PSItem, $PSPArallelIndex,$PSParallelProgressId){scriptblock}";
     _powerShell.AddScript(command)
         .AddParameter("_", inputObject)
         .AddParameter("PSItem", inputObject)
         .AddParameter("PSParallelIndex", _index)
         .AddParameter("PSParallelProgressId", _index + 1000);
     _powerShell.BeginInvoke(_input, _output);
 }