C# Runspace.Open方法代码示例

        public PSTestScope(bool connect = true)
        {
            SiteUrl = ConfigurationManager.AppSettings["SPODevSiteUrl"];
            CredentialManagerEntry = ConfigurationManager.AppSettings["SPOCredentialManagerLabel"];

            var iss = InitialSessionState.CreateDefault();
            if (connect)
            {
                SessionStateCmdletEntry ssce = new SessionStateCmdletEntry("Connect-SPOnline", typeof(ConnectSPOnline), null);

                iss.Commands.Add(ssce);
            }
            _runSpace = RunspaceFactory.CreateRunspace(iss);

            _runSpace.Open();

            if (connect)
            {
                var pipeLine = _runSpace.CreatePipeline();
                Command cmd = new Command("connect-sponline");
                cmd.Parameters.Add("Url", SiteUrl);
                if (!string.IsNullOrEmpty(CredentialManagerEntry))
                {
                    cmd.Parameters.Add("Credentials", CredentialManagerEntry);
                }
                pipeLine.Commands.Add(cmd);
                pipeLine.Invoke();
            }
        }

 public WishModel()
 {
     _runspace = RunspaceFactory.CreateRunspace();
     _runspace.Open();
     _runner = new Powershell(_runspace);
     _repl = new Repl(_runner);
 }

        public HookInjection(
            RemoteHooking.IContext InContext,
            String InChannelName,
            String entryPoint,
            String dll,
            String returnType,
            String scriptBlock,
            String modulePath,
            String additionalCode,
            bool eventLog)
        {
            Log("Opening hook interface channel...", eventLog);
            Interface = RemoteHooking.IpcConnectClient<HookInterface>(InChannelName);
            try
            {
                Runspace = RunspaceFactory.CreateRunspace();
                Runspace.Open();

                //Runspace.SessionStateProxy.SetVariable("HookInterface", Interface);
            }
            catch (Exception ex)
            {
                Log("Failed to open PowerShell runspace." + ex.Message, eventLog);
                Interface.ReportError(RemoteHooking.GetCurrentProcessId(), ex);
            }
        }

        public ScriptDebugger(bool overrideExecutionPolicy, DTE2 dte2)
        {
            HostUi = new HostUi(this);

            InitialSessionState iss = InitialSessionState.CreateDefault();
            iss.ApartmentState = ApartmentState.STA;
            iss.ThreadOptions = PSThreadOptions.ReuseThread;


            _runspace = RunspaceFactory.CreateRunspace(this, iss);
            _runspace.Open();

            _runspaceRef = new RunspaceRef(_runspace);
            //TODO: I think this is a v4 thing. Probably need to look into it.
            //_runspaceRef.Runspace.Debugger.SetDebugMode(DebugModes.LocalScript | DebugModes.RemoteScript);
            
            //Provide access to the DTE via PowerShell. 
            //This also allows PoshTools to support StudioShell.
            _runspace.SessionStateProxy.PSVariable.Set("dte", dte2);
            ImportPoshToolsModule();
            LoadProfile();

            if (overrideExecutionPolicy)
            {
                SetupExecutionPolicy();
            }

            SetRunspace(Runspace);
        }

 public static Collection<PSObject> RawExecute(string[] commands)
 {
     LastRawResults = null;
     LastUsedRunspace = InitialSessionState == null ?
         RunspaceFactory.CreateRunspace() : RunspaceFactory.CreateRunspace(InitialSessionState);
     LastUsedRunspace.Open();
     foreach (var command in commands)
     {
         using (var pipeline = LastUsedRunspace.CreatePipeline())
         {
             pipeline.Commands.AddScript(command, true);
             try
             {
                 LastRawResults = pipeline.Invoke();
             }
             catch (Exception)
             {
                 LastRawResults = pipeline.Output.ReadToEnd();
                 throw;
             }
             if (pipeline.Error.Count > 0)
             {
                 throw new MethodInvocationException(String.Join(Environment.NewLine, pipeline.Error.ReadToEnd()));
             }
         }
     }
     return LastRawResults;
 }

        public void InitializeTests()
        {

            RunspaceConfiguration config = RunspaceConfiguration.Create();
            
            PSSnapInException warning;

            config.AddPSSnapIn("ShareFile", out warning);

            runspace = RunspaceFactory.CreateRunspace(config);
            runspace.Open();

            // do login first to start tests
            using (Pipeline pipeline = runspace.CreatePipeline())
            {

                Command command = new Command("Get-SfClient");
                command.Parameters.Add(new CommandParameter("Name", Utils.LoginFilePath));

                pipeline.Commands.Add(command);

                Collection<PSObject> objs = pipeline.Invoke();
                Assert.AreEqual<int>(1, objs.Count);
                sfLogin = objs[0];
            }
        }

        private bool createRunspace(string command)
        {
            bool result = false;
            
            // 20131210
            // UIAutomation.Preferences.FromCache = false;
            
            try {
                testRunSpace = null;
                testRunSpace = RunspaceFactory.CreateRunspace();
                testRunSpace.Open();
                Pipeline cmd =
                    testRunSpace.CreatePipeline(command);
                cmd.Invoke();
                result = true;
            }
            catch (Exception eInitRunspace) {

                richResults.Text += eInitRunspace.Message;
                richResults.Text += "\r\n";
                result = false;
            }
            return result;
            //Screen.PrimaryScreen.Bounds.Width
        }

        /// <summary>
        /// Creates a new class and stores the passed values containing connection information
        /// </summary>
        /// <param name="uri">The URI to the Exchange powershell virtual directory</param>
        /// <param name="username">DOMAIN\Username to authenticate with</param>
        /// <param name="password">Password for the domain user</param>
        /// <param name="isKerberos">True if using kerberos authentication, False if using basic authentication</param>
        /// <param name="domainController">The domain controller to communicate with</param>
        public ExchPowershell()
        {
            try
            {
                // Retrieve the settings from the database
                SchedulerRetrieve.GetSettings();

                // Set our domain controller to communicate with
                this.domainController = Config.PrimaryDC;

                // Get the type of Exchange connection
                bool isKerberos = false;
                if (Config.ExchangeConnectionType == Enumerations.ConnectionType.Kerberos)
                    isKerberos = true;

                // Create our connection
                this.wsConn = GetConnection(Config.ExchangeURI, Config.Username, Config.Password, isKerberos);

                // Create our runspace
                runspace = RunspaceFactory.CreateRunspace(wsConn);

                // Open our connection
                runspace.Open();
            }
            catch (Exception ex)
            {
                // ERROR
                logger.Fatal("Unable to establish connection to Exchange.", ex);
            }
        }

 public AppFabricPowershellCommandRunner()
 {
     _state = InitialSessionState.CreateDefault();
     _state.ImportPSModule(new string[] { "DistributedCacheAdministration", "DistributedCacheConfiguration" });
     _state.ThrowOnRunspaceOpenError = true;
     _runspace = RunspaceFactory.CreateRunspace(_state);
     _runspace.Open();
 }

        public PipelineFixture()
        {
            var runspaceConfiguration = RunspaceConfiguration.Create();
            runspaceConfiguration.Providers.Append(new ProviderConfigurationEntry(CloudProvider.PROVIDER_NAME, typeof(CloudProvider), null));

            runspace = RunspaceFactory.CreateRunspace(runspaceConfiguration);
            runspace.Open();
        }

 private void ImportModule()
 {
     InitialSessionState initial = InitialSessionState.CreateDefault();
     string assemblyPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\src\PackageManagement.PowerShellCmdlets\bin\debug\NuGet.PackageManagement.PowerShellCmdlets.dll");
     initial.ImportPSModule(new string[] { assemblyPath });
     _runSpace = RunspaceFactory.CreateRunspace(initial);
     _runSpace.Open();
 }

 /// <summary>
 /// Create this instance of the console listener.
 /// </summary>
 PSListenerConsoleSample()
 {
     // Create the host and runspace instances for this interpreter. Note that
     // this application doesn't support console files so only the default snapins
     // will be available.
     myHost = new MyHost(this);
     myRunSpace = RunspaceFactory.CreateRunspace(myHost);
     myRunSpace.Open();
 }

        public CompletionProvider(IBackendContext backendContext, LanguageContext languageContext)
        {
            _languageContext = languageContext;
            _backendContext = backendContext;
            _snippetsCollection = AppContext.Resolve<ISnippetsCollection>();

            _runspace = RunspaceFactory.CreateRunspace();
            _runspace.Open();
        }

 public AsyncPowershellRunnerForm()
 {
     InitializeComponent();
     InitializeComboBox();
     // create Powershell runspace
     runSpace = RunspaceFactory.CreateRunspace();
     // open it
     runSpace.Open();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="PowerShellScriptingContext"/> class.
 /// </summary>
 public PowerShellScriptingContext()
     : base("PS> ")
 {
     _host = new PowerShellHost(Output);
     _runspace = RunspaceFactory.CreateRunspace(_host);
     Runspace.DefaultRunspace = _runspace;
     _runspace.Open();
     UpdatePrompt();
 }