C# ScriptEngine类代码示例

 static ScriptEngine CreateScriptEngineWithCoffeeScriptLoaded()
 {
     var engine = new ScriptEngine();
     engine.Execute(Properties.Resources.coffeescript);
     engine.Execute("function compile(c) { return CoffeeScript.compile(c); }");
     return engine;
 }

 private static object __GETTER__ToStringTag(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is SetIterator))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'get [Symbol.toStringTag]' is not generic.");
     return ((SetIterator)thisObj).ToStringTag;
 }

 private static object __GETTER__ByteLength(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is ArrayBufferInstance))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'get byteLength' is not generic.");
     return ((ArrayBufferInstance)thisObj).ByteLength;
 }

 public override string ToString(ScriptEngine engine)
 {
     string msg = engine.Pad() + "Return" + Environment.NewLine;
     engine.IndentationLevel += ScriptEngine.PaddingIncrement;
     msg += engine.Pad() + "LHS:" + Environment.NewLine;
     {
         engine.IndentationLevel += ScriptEngine.PaddingIncrement;
         for (int i = 0; i < _lhs.Count; i++)
         {
             msg += _lhs[i].ToString(engine);
         }
         engine.IndentationLevel -= ScriptEngine.PaddingIncrement;
     }
     msg += engine.Pad() + "RHS:" + Environment.NewLine;
     {
         engine.IndentationLevel += ScriptEngine.PaddingIncrement;
         for (int i = 0; i < _rhs.Count; i++)
         {
             msg += _rhs[i].ToString(engine);
         }
         engine.IndentationLevel -= ScriptEngine.PaddingIncrement;
     }
     engine.IndentationLevel -= ScriptEngine.PaddingIncrement;
     return msg;
 }

 public ResponseInstance(ScriptEngine engine, HttpListenerResponse response)
     : base(engine)
 {
     this.Response = response;
     this.PopulateFields();
     this.PopulateFunctions();
 }

 /// <summary>
 /// Creates a new FunctionContext instance.
 /// </summary>
 /// <param name="engine"> The script engine. </param>
 /// <param name="scope"> The function scope. </param>
 /// <param name="functionName"> The name of the function. </param>
 /// <param name="argumentNames"> The names of the arguments. </param>
 /// <param name="body"> The source code for the body of the function. </param>
 /// <param name="options"> Options that influence the compiler. </param>
 public FunctionMethodGenerator(ScriptEngine engine, DeclarativeScope scope, string functionName, IList<string> argumentNames, string body, CompilerOptions options)
     : base(engine, scope, new StringScriptSource(body), options)
 {
     this.Name = functionName;
     this.ArgumentNames = argumentNames;
     this.BodyText = body;
 }

 private static List<PropertyNameAndValue> GetDeclarativeProperties(ScriptEngine engine)
 {
     return new List<PropertyNameAndValue>(4)
     {
         new PropertyNameAndValue(engine.Symbol.Species, new PropertyDescriptor(new ClrStubFunction(engine.FunctionInstancePrototype, "get [Symbol.species]", 0, __GETTER__Species), null, PropertyAttributes.Configurable)),
     };
 }

 private static object __GETTER__Species(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is MapConstructor))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'get [Symbol.species]' is not generic.");
     return ((MapConstructor)thisObj).Species;
 }

        public override Token Build(Token lastToken, ScriptEngine engine, Script script, ref SourceCode sourceCode)
        {
            while ((++sourceCode).SpecialChar)
            {
            }
            if (sourceCode.Peek() != '{')
            {
                sourceCode.Throw(String.Format("Error parsing a 'do' statement, expected a '{' but got '{0}' instead.",
                                               sourceCode.Peek()));
            }
            List<List<List<Token>>> code = engine.BuildLongTokens(ref sourceCode, ref script, new[] {'}'});

            if (!sourceCode.SeekToNext("while"))
            {
                sourceCode.Throw("Error parsing a 'do' statement, was expecting a 'while' after the { } block.");
            }

            if (!sourceCode.SeekToNext('('))
            {
                sourceCode.Throw("Error parsing a 'do' statement, was expecting a '(' after 'while'.");
            }

            List<List<Token>> exitCondition = engine.BuildTokensAdvanced(ref sourceCode, ref script, new[] {')'});

            return new DoWhileToken(code, exitCondition);
        }

 /// <summary>
 /// Creates a new JavaScriptException instance.
 /// </summary>
 /// <param name="name"> The name of the error, e.g "RangeError". </param>
 /// <param name="message"> A description of the error. </param>
 /// <param name="lineNumber"> The line number in the source file the error occurred on. </param>
 /// <param name="sourcePath"> The path or URL of the source file.  Can be <c>null</c>. </param>
 public JavaScriptException(ScriptEngine engine, string name, string message, int lineNumber, string sourcePath)
     : base(string.Format("{0}: {1}", name, message))
 {
     this.ErrorObject = CreateError(engine, name, message);
     this.LineNumber = lineNumber;
     this.SourcePath = sourcePath;
 }

        public RequireJsCompiler(TextWriter consoleOut, string currentDirectory)
        {
            _jsEngine = new ScriptEngine();
            _jsEngine.CompatibilityMode = CompatibilityMode.ECMAScript3;

            _jsEngine.Evaluate(LoadResource("require.js"));
            _jsEngine.Evaluate(LoadResource("json2.js"));
            _jsEngine.Evaluate(LoadResource(@"adapt\rhino.js"));

            _jsEngine.Evaluate("require(" + new JavaScriptSerializer().Serialize(new {
                baseUrl = ResourceBaseUrl
            }) + ");");

            _fs = new NativeFS(_jsEngine, currentDirectory);
            _jsEngine.SetGlobalValue("YUNoFS", _fs);

            _path = new NativePath(_jsEngine, currentDirectory);
            _jsEngine.SetGlobalValue("YUNoPath", _path);

            _ioAdapter = new IOAdapter(_jsEngine, consoleOut);

            _jsEngine.SetGlobalFunction("load", (Action<string>)_ioAdapter.load);

            _jsEngine.SetGlobalValue("ioe", _ioAdapter);
            _jsEngine.SetGlobalValue("IsRunningYUNoAMD", true);

            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "env.js", @"build\jslib\env.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "yunoamd/args.js", @"build\jslib\yunoamd\args.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "build.js", @"build\build.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "print.js", @"build\jslib\yunoamd\print.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "fs.js", @"build\jslib\yunoamd\fs.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "path.js", @"build\jslib\yunoamd\path.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "file.js", @"build\jslib\node\file.js");
        }

 internal Meta(ScriptEngine engine, ModelInstance instance)
     : base(engine, engine.Object.InstancePrototype)
 {
     this.PopulateFunctions();
     this.instance = instance;
     this.typeWrapper = new TypeWrapper(engine, instance.Type);
 }

 private static object __STUB__ToLocaleString(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is NumberInstance))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'toLocaleString' is not generic.");
     return ((NumberInstance)thisObj).ToLocaleString();
 }

 private static object __STUB__ValueOf(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is SymbolInstance))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'valueOf' is not generic.");
     return ((SymbolInstance)thisObj).ValueOf();
 }

 private static object __STUB__Call(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is MapConstructor))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'Call' is not generic.");
     return ((MapConstructor)thisObj).Call();
 }