C# ScriptScope.SetVariable方法代码示例

        public Engine()
        {
            var options = new Dictionary<string, object>();
            options["DivisionOptions"] = PythonDivisionOptions.New;
            _history = new NullStream();
            _output = new EventRaisingStreamWriter(_history);
            _output.StringWritten += _output_StringWritten;
            _engine = Python.CreateEngine(options);
            _engine.Runtime.IO.SetOutput(_history, _output);
            _engine.Runtime.IO.SetErrorOutput(_history, _output);
            _scope = _engine.CreateScope();
            foreach (var t in _pluggable)
            {
                _scope.SetVariable(t.Name, DynamicHelpers.GetPythonTypeFromType(t));
            }
            _scope.SetVariable("CalculatorFunctions", DynamicHelpers.GetPythonTypeFromType(typeof(CalculatorFunctions)));
            _functioncache = new Dictionary<string, string>();
            //hidden functions
            _functioncache.Add("Var", "CalculatorFunctions.Var");
            _functioncache.Add("FncList", "CalculatorFunctions.FncList");
            _functioncache.Add("RegFunction", "CalculatorFunctions.RegFunction");

            foreach (var f in _functions)
            {
                if (_functioncache.ContainsKey(f.Name)) continue;
                _functioncache.Add(f.Name, f.FullName);
            }
            LoadBitops();
        }

        /// <summary>
        /// Load the core module that offers access to the simulation environment.
        /// </summary>
        public void LoadCoreModule()
        {
            scope = engine.CreateScope();

            // Allow scriptable access to...
            scope.SetVariable("status", Program.form.toolStripStatus);  // Statusbar.
            scope.SetVariable("log", Program.form.txtLog); // Simulation log.
            try
            {
                e_script = engine.CreateScriptSourceFromFile("syeon.py");
                e_script.Execute(scope);
            }
            catch(Exception e)
            {
                DialogResult ans = MessageBox.Show(
                e.Message, SSE, MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Error);
                if(ans == DialogResult.Abort)
                {
                    Program.form.Close();
                }
                else if(ans == DialogResult.Retry)
                {
                    LoadCoreModule(); // Recursion rules!
                }
            }
        }

        public override void Load(string code = "")
        {
            Engine = IronPython.Hosting.Python.CreateEngine();
            Scope = Engine.CreateScope();
            Scope.SetVariable("Commands", chatCommands);
            Scope.SetVariable("DataStore", DataStore.GetInstance());
            Scope.SetVariable("Find", Find.GetInstance());
            Scope.SetVariable("GlobalData", GlobalData);
            Scope.SetVariable("Plugin", this);
            Scope.SetVariable("Server", Pluton.Server.GetInstance());
            Scope.SetVariable("ServerConsoleCommands", consoleCommands);
            Scope.SetVariable("Util", Util.GetInstance());
            Scope.SetVariable("Web", Web.GetInstance());
            Scope.SetVariable("World", World.GetInstance());
            try {
                Engine.Execute(code, Scope);
                Class = Engine.Operations.Invoke(Scope.GetVariable(Name));
                Globals = Engine.Operations.GetMemberNames(Class);

                object author = GetGlobalObject("__author__");
                object about = GetGlobalObject("__about__");
                object version = GetGlobalObject("__version__");
                Author = author == null ? "" : author.ToString();
                About = about == null ? "" : about.ToString();
                Version = version == null ? "" : version.ToString();

                State = PluginState.Loaded;
            } catch (Exception ex) {
                Logger.LogException(ex);
                State = PluginState.FailedToLoad;
            }

            PluginLoader.GetInstance().OnPluginLoaded(this);
        }

 public void Initialize()
 {
     _pyEngine = Python.CreateEngine();
     _pyScope = _pyEngine.CreateScope();
     _pyScope.SetVariable("handler", _scriptHandler); // ([name], [value]) 
     _pyScope.SetVariable("game", MainWindow.Game);
     _pyScope.SetVariable("config", MainWindow.Config);
 }

 private void ThisAddIn_Startup(object sender, System.EventArgs e)
 {
     _python = Python.CreateEngine();
     _python_scope = _python.CreateScope();
     _python_scope.SetVariable("Application", Application);
     _python_scope.SetVariable("Function", Application.WorksheetFunction);
     _python_scope.SetVariable("Cells", Application.Cells);
 }

 public void Init(string player)
 {
     m_scope = m_engine.CreateScope();
     m_scope.SetVariable("player", player);
     m_scope.SetVariable("ClearBox", BoxState.Clear);
     m_scope.SetVariable("XBox", BoxState.X);
     m_scope.SetVariable("OBox", BoxState.O);
     source = m_engine.CreateScriptSourceFromString(System.IO.File.ReadAllText("AI.py"), SourceCodeKind.AutoDetect);
 }

 public Core()
 {
     _engine = Python.CreateEngine();
     _scope = _engine.CreateScope();
     _scope.SetVariable("printChat", new Action<string>(Chat.Print));
     _scope.SetVariable("PlayerInstance", Player.Instance);
     _scope.SetVariable("drawCircle", new Action<string, float, AIHeroClient>(pyDrawCircle));
     Game.OnTick += Game_OnTick;
     Drawing.OnDraw += Drawing_OnDraw;
 }

        public MDbgScriptForm(SptWrapper ext)
        {
            _host = Ruby.CreateEngine();

            _scope = _host.CreateScope();
            _scope.SetVariable("ext", ext);
            _scope.SetVariable("dbg", new Environment(this));

            _ext = ext;
            InitializeComponent();
        }

 public Engine(string filePath,Inventor.PlanarSketch oSketch,Inventor.Application oApp, double slotHeight, double slotWidth)
 {
     _engine = Python.CreateEngine(new Dictionary<string, object>() { {"Frames", true}, {"FullFrames", true}});
     _runtime = _engine.Runtime;
     Assembly invAssembly = Assembly.LoadFile(@"C:\Windows\Microsoft.NET\assembly\GAC_MSIL\Autodesk.Inventor.Interop\v4.0_17.0.0.0__d84147f8b4276564\Autodesk.Inventor.interop.dll");
     _runtime.LoadAssembly(invAssembly);
     _scope = _engine.CreateScope();
     //Make variable names visible within the python file.  These string names will be used an arguments in the python file.
     _scope.SetVariable("oPlanarSketch",oSketch);
     _scope.SetVariable("oApp",oApp);
     _scope.SetVariable("slotHeight",slotHeight);
     _scope.SetVariable("slotWidth",slotWidth);
     ScriptSource _script = _engine.CreateScriptSourceFromFile(filePath);
     _code = _script.Compile();
 }

        public ReplWindow()
        {
            InitializeComponent();

            _engine = Ruby.CreateEngine();
            _scope = Ruby.CreateRuntime().CreateScope();

            _scope.SetVariable("pi", Math.PI);
            _scope.SetVariable("e", Math.E);
            _scope.SetVariable("_", new Extension());

            var source = _engine.CreateScriptSourceFromString("require 'RubyInt.exe'\nrequire 'Mathos.dll'\nrequire '" + Settings.DataDirectory + "Std.rb'", SourceCodeKind.Statements);

            source.Execute(_scope);
        }

 private static void EvaluateContext(ScriptScope scope, ICompiledCodeContext context)
 {
     scope.SetVariable("contexts", context);
     scope.SetVariable("hosts", context.Hosts);
     scope.SetVariable("groups", context.Groups);
     scope.SetVariable("sites", context.Sites);
     scope.SetVariable("equipments", context.Equipments);
     scope.SetVariable("signals", context.Signals);
     scope.SetVariable("affairs", context.Affairs);
     scope.SetVariable("commands", context.Commands);
     scope.SetVariable("users", context.Users);
 }

        private static void Main()
        {
            try
            {
                PyEngine = Python.CreateEngine();
                NtrClient = new NtrClient();
                ScriptHelper = new ScriptHelper();

                GlobalScope = PyEngine.CreateScope();
                GlobalScope.SetVariable("nc", ScriptHelper);

                LoadConfig();

                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                GCmdWindow = new CmdWindow();
                Dc = new DebugConsole();
                Application.Run(GCmdWindow);
            }
            catch (Exception e)
            {
                BugReporter br = new BugReporter(e, "Program exception");
                MessageBox.Show(
                    @"WARNING - NTRDebugger has encountered an error" + Environment.NewLine +
                    @"This error is about to crash the program, please send the generated" + Environment.NewLine +
                    @"Error log to imthe666st!" + Environment.NewLine + Environment.NewLine +
                    @"Sorry for the inconvinience -imthe666st"
                    );
            }
        }

 public Plugin(string filename)
 {
     this.filename = filename;
     scope = engine.CreateScope();
     scope.SetVariable("hookme", Program.data.pluginMngr.pluginsApi);
     engine.SetSearchPaths(Program.data.configuration.lstPluginsSearchPath);
 }

        private void RenderView(ScriptScope scope, ViewContext context, TextWriter writer)
        {
            scope.SetVariable("view_data", context.ViewData);
            scope.SetVariable("model", context.ViewData.Model);
            scope.SetVariable("context", context);
            scope.SetVariable("response", context.HttpContext.Response);
            scope.SetVariable("url", new RubyUrlHelper(context.RequestContext));
            scope.SetVariable("html", new RubyHtmlHelper(context, new Container(context.ViewData)));
            scope.SetVariable("ajax", new RubyAjaxHelper(context, new Container(context.ViewData)));

            var script = new StringBuilder();
            Template.ToScript("render_page", script);

            if (_master != null)
                _master.Template.ToScript("render_layout", script);
            else
                script.AppendLine("def render_layout; yield; end");

            script.AppendLine("def view_data.method_missing(methodname); get_Item(methodname.to_s); end");
            script.AppendLine("render_layout { |content| render_page }");

            try
            {
                _rubyEngine.ExecuteScript(script.ToString(), scope);
            }
            catch (Exception e)
            {
                writer.Write(e.ToString());
            }
        }

 public Py(Bot bot)
 {
     this.bot = bot;
     engine = Python.CreateEngine();
     scope = engine.CreateScope();
     scope.SetVariable("tools", new PythonTools());
     var outputStream = new ProducerConsumerStream();
     var outputStreamWriter = new StreamWriter(outputStream);
     outputStreamReader = new StreamReader(outputStream);
     engine.Runtime.IO.SetOutput(outputStream, outputStreamWriter);
 }