C# ScriptEngine.SetSearchPaths方法代码示例

        private void initRuby()
        {
            ScriptRuntimeSetup runtimeSetup = ScriptRuntimeSetup.ReadConfiguration();
            var languageSetup = IronRuby.RubyHostingExtensions.AddRubySetup(runtimeSetup);

            runtimeSetup.DebugMode = false;
            runtimeSetup.PrivateBinding = false;
            runtimeSetup.HostType = typeof(RhoHost);

            languageSetup.Options["NoAdaptiveCompilation"] = false;
            languageSetup.Options["CompilationThreshold"] = 0;
            languageSetup.Options["Verbosity"] = 2;

            m_runtime = IronRuby.Ruby.CreateRuntime(runtimeSetup);
            m_engine = IronRuby.Ruby.GetEngine(m_runtime);
            m_context = (RubyContext)Microsoft.Scripting.Hosting.Providers.HostingHelpers.GetLanguageContext(m_engine);

            m_context.ObjectClass.SetConstant("RHO_WP7", 1);
            m_context.ObjectClass.AddMethod(m_context, "__rhoGetCallbackObject", new RubyLibraryMethodInfo(
                new[] { LibraryOverload.Create(new Func<System.Object, System.Int32, System.Object>(RhoKernelOps.__rhoGetCallbackObject), false, 0, 0) },
                RubyMethodVisibility.Public,
                m_context.ObjectClass
            ));
            m_context.Loader.LoadAssembly("RhoRubyLib", "rho.rubyext.rubyextLibraryInitializer", true, true);

            System.Collections.ObjectModel.Collection<string> paths = new System.Collections.ObjectModel.Collection<string>();
            paths.Add("lib");
            paths.Add("apps/app");
            m_engine.SetSearchPaths(paths);
        }

        public override IEnumerable<Kbtter4Plugin> Load(Kbtter instance, IList<string> filenames)
        {
            var files = filenames.Where(p => p.EndsWith(".py"));
            var ret = new List<Kbtter4IronPythonPlugin>();

            engine = Python.CreateEngine();

            var context = HostingHelpers.GetLanguageContext(engine) as PythonContext;
            var path = context.GetSearchPaths();
            path.Add(Environment.CurrentDirectory + "\\");
            engine.SetSearchPaths(path);

            engine.Runtime.LoadAssembly(typeof(Status).Assembly);

            foreach (var i in files)
            {
                try
                {
                    var scope = engine.CreateScope();
                    scope.SetVariable("Kbtter4", new Kbtter4PluginProvider(instance));
                    var src = engine.CreateScriptSourceFromFile(i);
                    var code = src.Compile();
                    code.Execute(scope);
                    var p = new Kbtter4IronPythonPlugin(scope,instance);
                    ret.Add(p);
                }
                catch (Exception e)
                {
                    instance.LogError(String.Format("プラグイン読み込み中にエラーが発生しました : {0}\n{1}", i, e.Message));

                }
            }

            return ret;
        }

        private void initRuby()
        {
            ScriptRuntimeSetup runtimeSetup = ScriptRuntimeSetup.ReadConfiguration();
            var languageSetup = IronRuby.RubyHostingExtensions.AddRubySetup(runtimeSetup);

            runtimeSetup.DebugMode = false;
            runtimeSetup.PrivateBinding = false;
            runtimeSetup.HostType = typeof(RhoHost);

            languageSetup.Options["NoAdaptiveCompilation"] = false;
            languageSetup.Options["CompilationThreshold"] = 0;
            languageSetup.Options["Verbosity"] = 2;

            m_runtime = IronRuby.Ruby.CreateRuntime(runtimeSetup);
            m_engine = IronRuby.Ruby.GetEngine(m_runtime);
            m_context = (RubyContext)Microsoft.Scripting.Hosting.Providers.HostingHelpers.GetLanguageContext(m_engine);

            m_context.ObjectClass.SetConstant("RHO_WP7", 1);
            m_context.Loader.LoadAssembly("RhoRubyLib", "rho.rubyext.rubyextLibraryInitializer", true, true);

            System.Collections.ObjectModel.Collection<string> paths = new System.Collections.ObjectModel.Collection<string>();
            paths.Add("lib");
            paths.Add("apps/app");
            m_engine.SetSearchPaths(paths);
        }

        public PythonEngine(string scriptsPath)
        {
            Log.Notice("PythonEngine", sLConsole.GetString("Initializing Python engine."));
            _scriptPath = scriptsPath;
            _engine = Python.CreateEngine();

            string dir = Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName;
            var list = new List<string>();
            list.Add(Path.Combine(dir, "Schumix.Irc.dll"));
            list.Add(Path.Combine(dir, "Schumix.Framework.dll"));

            foreach(var l in list)
                _engine.Runtime.LoadAssembly(Assembly.LoadFile(l));

            list.Clear();

            var paths = _engine.GetSearchPaths();
            paths.Add(_scriptPath);
            paths.Add(Path.Combine(_scriptPath, "Libs"));
            _engine.SetSearchPaths(paths);

            LoadScripts();

            _watcher = new FileSystemWatcher(_scriptPath)
            {
                NotifyFilter = NotifyFilters.FileName | NotifyFilters.Attributes | NotifyFilters.LastAccess |
                NotifyFilters.LastWrite | NotifyFilters.Security | NotifyFilters.Size,
                EnableRaisingEvents = true
            };

            _watcher.Created += (s, e) => LoadScripts(true);
            _watcher.Changed += (s, e) => LoadScripts(true);
            _watcher.Deleted += (s, e) => LoadScripts(true);
            _watcher.Renamed += (s, e) => LoadScripts(true);
        }

        public BasicScriptHost()
        {
            _engine = Python.CreateEngine();

            var searchPaths = _engine.GetSearchPaths();
            searchPaths.Add(IOHelper.ConvertToFullPath("./scripts/"));
            _engine.SetSearchPaths(searchPaths);
        }

		public Interpreter()
		{
			pyEngine = Python.CreateEngine();
			pyRuntime = pyEngine.Runtime;
			pyScope = pyEngine.CreateScope();
			var paths = pyEngine.GetSearchPaths();
			paths.Add(Path.Combine(Logic.Client.ExecutingDirectory, "Client", "LIB"));
			pyEngine.SetSearchPaths(paths);
		}

        public PyMarshaler()
        {
            _engine = Python.CreateEngine();
            _runtime = _engine.Runtime;

            ICollection<string> searchPaths = _engine.GetSearchPaths();
            searchPaths.Add("PyScripts");
            _engine.SetSearchPaths(searchPaths);
        }

 public PythonEngine(Game game)
 {
     _engine = Python.CreateEngine();
     var searchPaths = _engine.GetSearchPaths().ToList();
     var pythonPath = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "Scripting", "PythonIncludes");
     searchPaths.Add(pythonPath);
     _engine.SetSearchPaths(searchPaths);
     _engine.Runtime.Globals.SetVariable("WumpusGame", game);
     _game = game;
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="manager">The callback manager</param>
 /// <param name="contacts">The contact manager</param>
 public ScriptingManager(CallbackManager manager, ContactManager contacts)
 {
     _contactManager = contacts;
     _callbackManager = manager;
     _engine = Python.CreateEngine();
     var searchPaths = new List<string>(_engine.GetSearchPaths());
     searchPaths.Add(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PythonLib"));
     _engine.SetSearchPaths(searchPaths);
     _engine.Runtime.Globals.SetVariable("callbackManager", _callbackManager);
     _engine.Runtime.Globals.SetVariable("contactManagerObject", _contactManager);
 }

 public void Initialise(Scene scene, IConfigSource config)
 {
     m_log.Info("[PythonModuleLoader] Initializing...");
     m_scene = scene;
     m_config = config;
     m_pyengine = Python.CreateEngine();
     m_pyscope = m_pyengine.CreateScope();
     ICollection<string> paths = m_pyengine.GetSearchPaths();
     paths.Add(AppDomain.CurrentDomain.BaseDirectory);
     paths.Add(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ScriptEngines"));
     m_pyengine.SetSearchPaths(paths);
     m_log.Info("Added " + AppDomain.CurrentDomain.BaseDirectory + " to python module search path");
 }

 public static void InitScriptEngine(bool debug)
 {
     if (engine == null || loadedModules == null || errors == null)
     {
         engine = Python.CreateEngine();
         engine.SetTrace(null);
         var paths = engine.GetSearchPaths();
         paths.Add(HostingEnvironment.MapPath(@"~/Python"));
         paths.Add(HostingEnvironment.MapPath(@"~/Protoplasm-Python"));
         engine.SetSearchPaths(paths);
         loadedModules = new Dictionary<string,int>();
         errors = new List<string>();
     }
 }

        private RubyEngine()
        {
            string directory = Directory.GetCurrentDirectory();
            Console.WriteLine(directory);
            engine = IronRuby.Ruby.CreateEngine();
            engine.SetSearchPaths(new List<string>()
                                      {
                                          String.Format(@"{0}\IronRuby", physicalPath),
                                          String.Format(@"{0}\ruby\site_ruby\1.8", physicalPath),
                                          String.Format(@"{0}\ruby\1.8", physicalPath),
                                          //@".\lib\\IronRuby\gems\1.8\gems\less-1.1.13\lib\vendor\treetop\lib",
                                          String.Format(@"{0}\IronRuby\gems\1.8\gems\less-1.1.13\lib\", physicalPath)
                                      });

            scope = engine.CreateScope();
            engine.Execute(@"require 'less'", scope);
        }

        public static void Main(string[] args)
        {
            Assembly.LoadFile("IronRuby.dll");
            Assembly.LoadFile("IronRuby.Libraries.dll");

            engine = IronRuby.Ruby.CreateEngine();
            var paths = engine.GetSearchPaths().ToList();
            paths.Add(Path.Combine("ruby", "Lib", "ironruby"));
            paths.Add(Path.Combine("ruby", "Lib", "ruby", "1.9.1"));
            engine.SetSearchPaths(paths);

            engine.Runtime.LoadAssembly(Assembly.LoadFile(Assembly.GetExecutingAssembly().Location));
            engine.Runtime.LoadAssembly(Assembly.LoadFile("LibuvSharp.dll"));

            if (System.IO.Directory.Exists("ruby")) {
                foreach (string file in System.IO.Directory.GetFiles("ruby", "*.rb")) {
                    Load(file);
                }
            }
        }

        private IRE()
        {
            LogsTailLength = 1000;

            _defaultEngine = Ruby.CreateEngine((setup) => {
                setup.ExceptionDetail = true;
            });

            var paths = (new[] { Environment.CurrentDirectory, Environment.CurrentDirectory + @"\scripts"});
            paths.ToList().AddRange(_defaultEngine.GetSearchPaths());
            _defaultEngine.SetSearchPaths(paths);
            _defaultEngine.Runtime.LoadAssembly(typeof(IRE).Assembly);

            _outStream = new MemoryStream();

            _errStream = new MemoryStream();

            _defaultEngine.Runtime.IO.SetOutput(_outStream, Encoding.UTF8);
            _defaultEngine.Runtime.IO.SetErrorOutput(_errStream, Encoding.UTF8);
        }

        private void EngineRun() {
            lock(_pyLock) {
                _pyEngine = Python.CreateEngine();
                _pyEngine.Runtime.IO.SetOutput(_engineOutput, new StreamWriter(_engineOutput, System.Text.Encoding.UTF8));
                ICollection<string> paths = _pyEngine.GetSearchPaths();
                string path = Path.GetDirectoryName(_filePath);
                _logger.Log(path);
                paths.Add(path);
                _pyEngine.SetSearchPaths(paths);

                _pyScope = _pyEngine.CreateScope();
            }

            _logger.Log("Engine started. Initializing TerminalOS.");
            try {
                _pyEngine.ExecuteFile(_filePath, _pyScope);
            }
            catch (Exception e) {
                _logger.Log(e.Message + e.StackTrace);
            }

            _logger.Log("TerminalOS has stopped.");
        }