public override void Cleanup() { engine_.Dispose(); engine_ = null; runtime_.Dispose(); runtime_ = null; }
public JavaScriptConverter(JavaScriptEngine engine) { engine_ = new WeakReference<JavaScriptEngine>(engine); api_ = engine.Api; projectionTypes_ = new Dictionary<Type, JavaScriptProjection>(); eventMarshallers_ = new Dictionary<Type, Expression>(); }
internal JavaScriptExecutionContext(JavaScriptEngine engine, JavaScriptEngine previousEngine) { Debug.Assert(engine != null); previousEngine_ = previousEngine; engine_ = engine; }
internal JavaScriptExecutionContext(JavaScriptEngine engine, Action release) { Debug.Assert(engine != null); Debug.Assert(release != null); engine_ = engine; release_ = release; }
internal JavaScriptExecutionContext(JavaScriptEngine engine, Action release) { Debug.Assert(engine != null); Debug.Assert(release != null); engine_ = engine; release_ = release; }
private void Dispose(bool disposing) { if (release_ != null) release_(); if (disposing) { engine_ = null; release_ = null; } }
public override void Cleanup() { dataView_ = null; typedArray_ = null; buffer_ = null; engine_.Dispose(); engine_ = null; runtime_.Dispose(); runtime_ = null; }
public JavaScriptExecutionContext AcquireContext() { var c = currentEngine; if (c != this) { ClaimContextPrivate(); currentEngine = this; } return(new JavaScriptExecutionContext(this, c)); }
private IJavaScriptValue EchoForProjectedNamespace(JavaScriptEngine source, bool construct, IJavaScriptValue thisValue, IEnumerable<IJavaScriptValue> args) { string arg = args.First().ToString(); arg = arg.Replace("{", "{{").Replace("}", "}}"); Debug.WriteLine(string.Format(arg, (object[])args.Skip(1).ToArray())); if (arg == "toast promise done") { successSignal.SetResult(0); } return source.UndefinedValue; }
private IJavaScriptValue Echo(JavaScriptEngine source, bool construct, IJavaScriptValue thisValue, IEnumerable<IJavaScriptValue> args) { string arg = args.First().ToString(); arg = arg.Replace("{", "{{").Replace("}", "}}"); Log.Message(string.Format(arg, (object[])args.Skip(1).ToArray())); if (arg == "toast promise done") { Assert.Succeeded(); } return source.UndefinedValue; }
private void Dispose(bool disposing) { if (release_ != null) { release_(); } if (disposing) { engine_ = null; release_ = null; } }
internal JavaScriptValue(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine) { Debug.Assert(handle != null); Debug.Assert(engine != null); Debug.Assert(Enum.IsDefined(typeof(JavaScriptValueType), type)); handle.SetEngine(engine); api_ = engine.Api; uint count; Errors.ThrowIfIs(api_.JsAddRef(handle.DangerousGetHandle(), out count)); handle_ = handle; type_ = type; engine_ = new WeakReference<JavaScriptEngine>(engine); }
public override void Setup() { runtime_ = new JavaScriptRuntime(new JavaScriptRuntimeSettings()); engine_ = runtime_.CreateEngine(); var baseline = new ScriptSource("test://init.js", @"(function(global) { global.buffer = new ArrayBuffer(1024); global.typedArray = new Uint8ClampedArray(buffer); global.dataView = new DataView(buffer, 1); })(this);"); engine_.Execute(baseline); buffer_ = (JavaScriptArrayBuffer)engine_.GetGlobalVariable("buffer"); typedArray_ = (JavaScriptTypedArray)engine_.GetGlobalVariable("typedArray"); dataView_ = (JavaScriptDataView)engine_.GetGlobalVariable("dataView"); }
internal void ReleaseContextPrivate(JavaScriptEngine previous) { if (currentEngine != this) { throw new Exception("Incorrect JavaScriptExecutionContext disposal."); } if (previous != currentEngine) { Errors.ThrowIfIs(api_.JsReleaseCurrentContext()); currentEngine = previous; if (previous != null) { previous.ClaimContextPrivate(); } } }
private void ProjectMethods(string owningTypeName, JavaScriptObject target, JavaScriptEngine engine, IEnumerable <MethodInfo> methods) { var methodsByName = methods.GroupBy(m => m.Name); foreach (var group in methodsByName) { var method = engine.CreateFunction((eng, ctor, thisObj, args) => { var @this = thisObj as JavaScriptObject; if (@this == null) { eng.SetException(eng.CreateTypeError("Could not call method '" + group.Key + "' because there was an invalid 'this' context.")); return(eng.UndefinedValue); } var argsArray = args.ToArray(); var candidate = GetBestFitMethod(group, thisObj, argsArray); if (candidate == null) { eng.SetException(eng.CreateReferenceError("Could not find suitable method or not enough arguments to invoke '" + group.Key + "'.")); return(eng.UndefinedValue); } List <object> argsToPass = new List <object>(); for (int i = 0; i < candidate.GetParameters().Length; i++) { argsToPass.Add(ToObject(argsArray[i])); } try { return(FromObject(candidate.Invoke(@this.ExternalObject, argsToPass.ToArray()))); } catch (Exception ex) { eng.SetException(FromObject(ex)); return(eng.UndefinedValue); } }, owningTypeName + "." + group.Key); //var propDescriptor = engine.CreateObject(); //propDescriptor.SetPropertyByName("configurable", engine.TrueValue); //propDescriptor.SetPropertyByName("enumerable", engine.TrueValue); //propDescriptor.SetPropertyByName("value", method); //target.DefineProperty(group.Key, propDescriptor); target.SetPropertyByName(group.Key, method); } }
// used by InitializeProjectionForType private JavaScriptObject CreateObjectFor(JavaScriptEngine engine, JavaScriptProjection baseTypeProjection) { if (baseTypeProjection != null) { // todo: revisit to see if there is a better way to do this // Can probably get // ((engine.GlobalObject.GetPropertyByName("Object") as JavaScriptObject).GetPropertyByName("create") as JavaScriptFunction).Invoke(baseTypeProjection.Prototype) // but this is so much clearer dynamic global = engine.GlobalObject; JavaScriptObject result = global.Object.create(baseTypeProjection.Prototype); return(result); } else { return(engine.CreateObject()); } }
private IJavaScriptValue MessageDialog(JavaScriptEngine source, bool construct, IJavaScriptValue thisValue, IEnumerable<IJavaScriptValue> args) { if (!construct) { var undefined = source.UndefinedValue; source.SetException(source.CreateTypeError("Must call as a constructor.")); return undefined; } var dlg = new MessageDialog(args.First().ToString()); return source.Converter.FromWindowsRuntimeObject(dlg); }
public async Task Setup() { await DispatchContainer.GlobalDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { runtime_ = new JavaScriptRuntime(); engine_ = runtime_.CreateEngine(); }); }
private void ProjectEvents(string owningTypeName, JavaScriptObject target, JavaScriptEngine engine, IEnumerable<EventInfo> events, JavaScriptProjection baseTypeProjection, bool instance) { var eventsArray = events.ToArray(); var eventsLookup = eventsArray.ToDictionary(ei => ei.Name.ToLower()); // General approach here // if there is a base thing, invoke that // for each event, register a delegate that marshals it back to JavaScript var add = engine.CreateFunction((eng, ctor, thisObj, args) => { bool callBase = instance && (baseTypeProjection?.HasInstanceEvents ?? false); var @this = thisObj as JavaScriptObject; if (@this == null) return eng.UndefinedValue; if (callBase) { var baseObj = baseTypeProjection.Prototype; var baseFn = baseObj.GetPropertyByName("addEventListener") as JavaScriptFunction; if (baseFn != null) { baseFn.Call(@this, args); } } var argsArray = args.ToArray(); if (argsArray.Length < 2) return eng.UndefinedValue; string eventName = argsArray[0].ToString(); JavaScriptFunction callbackFunction = argsArray[1] as JavaScriptFunction; if (callbackFunction == null) return eng.UndefinedValue; EventInfo curEvent; if (!eventsLookup.TryGetValue(eventName, out curEvent)) return eng.UndefinedValue; MethodInfo targetMethod = curEvent.EventHandlerType.GetMethod("Invoke"); var paramsExpr = targetMethod.GetParameters().Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToArray(); int cookie = EventMarshaler.RegisterDelegate(callbackFunction, SynchronizationContext.Current); var marshaler = Expression.Lambda(curEvent.EventHandlerType, Expression.Block( Expression.Call( typeof(EventMarshaler).GetMethod(nameof(EventMarshaler.InvokeJavaScriptCallback)), Expression.Constant(cookie), Expression.NewArrayInit(typeof(string), targetMethod.GetParameters().Select(p => Expression.Constant(p.Name))), Expression.NewArrayInit(typeof(object), paramsExpr)) ), paramsExpr); curEvent.AddMethod.Invoke(@this.ExternalObject, new object[] { marshaler.Compile() }); return eng.UndefinedValue; }, owningTypeName + ".addEventListener"); target.SetPropertyByName("addEventListener", add); }
private IJavaScriptValue Success(JavaScriptEngine source, bool construct, IJavaScriptValue thisValue, IEnumerable<IJavaScriptValue> args) { successSignal.SetResult(0); return source.UndefinedValue; }
internal JavaScriptValue(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine) { Debug.Assert(handle != null); Debug.Assert(engine != null); Debug.Assert(type >= 0 && type <= JavaScriptValueType.DataView); handle.SetEngine(engine); api_ = engine.Api; uint count; Errors.ThrowIfIs(api_.JsAddRef(handle.DangerousGetHandle(), out count)); handle_ = handle; type_ = type; engine_ = engine.engineWeakReference; }
public JavaScriptConverter(JavaScriptEngine engine) { engine_ = new WeakReference <JavaScriptEngine>(engine); api_ = engine.Api; }
public void Setup() { var settings = new JavaScriptRuntimeSettings(); runtime_ = new JavaScriptRuntime(settings); engine_ = runtime_.CreateEngine(); }
internal JavaScriptSymbol(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine): base(handle, type, engine) { }
internal JavaScriptValue(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine) { Debug.Assert(handle != null); Debug.Assert(engine != null); Debug.Assert(Enum.IsDefined(typeof(JavaScriptValueType), type)); handle.SetEngine(engine); api_ = engine.Api; uint count; Errors.ThrowIfIs(api_.JsAddRef(handle.DangerousGetHandle(), out count)); handle_ = handle; type_ = type; engine_ = new WeakReference <JavaScriptEngine>(engine); }
internal JavaScriptFunction(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine): base(handle, type, engine) { }
internal JavaScriptTypedArray(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine) : base(handle, type, engine) { arrayType_ = new Lazy <JavaScriptTypedArrayType>(GetArrayType); }
public override void Setup() { var settings = new JavaScriptRuntimeSettings() { EnableIdleProcessing = true, }; runtime_ = new JavaScriptRuntime(settings); engine_ = runtime_.CreateEngine(); }
private IJavaScriptValue Echo(JavaScriptEngine source, bool construct, IJavaScriptValue thisValue, IEnumerable<IJavaScriptValue> args) { Log.Message(string.Format(args.First().ToString(), (object[])args.Skip(1).ToArray())); return source.UndefinedValue; }
internal JavaScriptArrayBuffer(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine) : base(handle, type, engine) { len_ = new Lazy <uint>(GetLength); }
private IJavaScriptValue EchoForNoNamespace(JavaScriptEngine source, bool construct, IJavaScriptValue thisValue, IEnumerable<IJavaScriptValue> args) { string arg = args.First().ToString(); Assert.AreEqual("callback completed", arg); successSignal.SetResult(0); return source.UndefinedValue; }
internal JavaScriptFunction(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine) : base(handle, type, engine) { }
public void Dispose() { engine_.ReleaseContextPrivate(previousEngine_); engine_ = null; }
internal JavaScriptDataView(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine) : base(handle, type, engine) { }
private void ProjectMethods(string owningTypeName, JavaScriptObject target, JavaScriptEngine engine, IEnumerable<MethodInfo> methods) { var methodsByName = methods.GroupBy(m => m.Name); foreach (var group in methodsByName) { var method = engine.CreateFunction((eng, ctor, thisObj, args) => { var @this = thisObj as JavaScriptObject; if (@this == null) { eng.SetException(eng.CreateTypeError("Could not call method '" + group.Key + "' because there was an invalid 'this' context.")); return eng.UndefinedValue; } var argsArray = args.ToArray(); var candidate = GetBestFitMethod(group, thisObj, argsArray); if (candidate == null) { eng.SetException(eng.CreateReferenceError("Could not find suitable method or not enough arguments to invoke '" + group.Key + "'.")); return eng.UndefinedValue; } List<object> argsToPass = new List<object>(); for (int i = 0; i < candidate.GetParameters().Length; i++) { argsToPass.Add(ToObject(argsArray[i])); } try { return FromObject(candidate.Invoke(@this.ExternalObject, argsToPass.ToArray())); } catch (Exception ex) { eng.SetException(FromObject(ex)); return eng.UndefinedValue; } }, owningTypeName + "." + group.Key); //var propDescriptor = engine.CreateObject(); //propDescriptor.SetPropertyByName("configurable", engine.TrueValue); //propDescriptor.SetPropertyByName("enumerable", engine.TrueValue); //propDescriptor.SetPropertyByName("value", method); //target.DefineProperty(group.Key, propDescriptor); target.SetPropertyByName(group.Key, method); } }
public override void Setup() { var settings = new JavaScriptRuntimeSettings() { AllowScriptInterrupt = true, }; runtime_ = new JavaScriptRuntime(settings); engine_ = runtime_.CreateEngine(); }
internal JavaScriptDataView(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine) : base(handle, type, engine) { }
internal JavaScriptTypedArray(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine): base(handle, type, engine) { arrayType_ = new Lazy<JavaScriptTypedArrayType>(GetArrayType); }
private void ProjectEvents(string owningTypeName, JavaScriptObject target, JavaScriptEngine engine, IEnumerable <EventInfo> events, JavaScriptProjection baseTypeProjection, bool instance) { var eventsArray = events.ToArray(); var eventsLookup = eventsArray.ToDictionary(ei => ei.Name.ToLower()); // General approach here // if there is a base thing, invoke that // for each event, register a delegate that marshals it back to JavaScript var add = engine.CreateFunction((eng, ctor, thisObj, args) => { bool callBase = instance && (baseTypeProjection?.HasInstanceEvents ?? false); var @this = thisObj as JavaScriptObject; if (@this == null) { return(eng.UndefinedValue); } if (callBase) { var baseObj = baseTypeProjection.Prototype; var baseFn = baseObj.GetPropertyByName("addEventListener") as JavaScriptFunction; if (baseFn != null) { baseFn.Call(@this, args); } } var argsArray = args.ToArray(); if (argsArray.Length < 2) { return(eng.UndefinedValue); } string eventName = argsArray[0].ToString(); JavaScriptFunction callbackFunction = argsArray[1] as JavaScriptFunction; if (callbackFunction == null) { return(eng.UndefinedValue); } EventInfo curEvent; if (!eventsLookup.TryGetValue(eventName, out curEvent)) { return(eng.UndefinedValue); } MethodInfo targetMethod = curEvent.EventHandlerType.GetMethod("Invoke"); var paramsExpr = targetMethod.GetParameters().Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToArray(); int cookie = EventMarshaler.RegisterDelegate(callbackFunction, SynchronizationContext.Current); var marshaler = Expression.Lambda(curEvent.EventHandlerType, Expression.Block( Expression.Call( typeof(EventMarshaler).GetMethod(nameof(EventMarshaler.InvokeJavaScriptCallback)), Expression.Constant(cookie), Expression.NewArrayInit(typeof(string), targetMethod.GetParameters().Select(p => Expression.Constant(p.Name))), Expression.NewArrayInit(typeof(object), paramsExpr)) ), paramsExpr); curEvent.AddMethod.Invoke(@this.ExternalObject, new object[] { marshaler.Compile() }); return(eng.UndefinedValue); }, owningTypeName + ".addEventListener"); target.SetPropertyByName("addEventListener", add); }
// used by InitializeProjectionForType private JavaScriptObject CreateObjectFor(JavaScriptEngine engine, JavaScriptProjection baseTypeProjection) { if (baseTypeProjection != null) { // todo: revisit to see if there is a better way to do this // Can probably get // ((engine.GlobalObject.GetPropertyByName("Object") as JavaScriptObject).GetPropertyByName("create") as JavaScriptFunction).Invoke(baseTypeProjection.Prototype) // but this is so much clearer dynamic global = engine.GlobalObject; JavaScriptObject result = global.Object.create(baseTypeProjection.Prototype); return result; } else { return engine.CreateObject(); } }
internal JavaScriptSymbol(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine) : base(handle, type, engine) { }
private void ProjectProperties(string owningTypeName, JavaScriptObject target, JavaScriptEngine engine, IEnumerable<PropertyInfo> properties) { foreach (var prop in properties) { if (prop.GetIndexParameters().Length > 0) throw new NotSupportedException("Index properties not supported for projecting CLR to JavaScript objects."); JavaScriptFunction jsGet = null, jsSet = null; if (prop.GetMethod != null) { jsGet = engine.CreateFunction((eng, ctor, thisObj, args) => { var @this = thisObj as JavaScriptObject; if (@this == null) { eng.SetException(eng.CreateTypeError("Could not retrieve property '" + prop.Name + "' because there was an invalid 'this' context.")); return eng.UndefinedValue; } try { return FromObject(prop.GetValue(@this.ExternalObject)); } catch (Exception ex) { eng.SetException(FromObject(ex)); return eng.UndefinedValue; } }, owningTypeName + "." + prop.Name + ".get"); } if (prop.SetMethod != null) { jsSet = engine.CreateFunction((eng, ctor, thisObj, args) => { var @this = thisObj as JavaScriptObject; if (@this == null) { eng.SetException(eng.CreateTypeError("Could not retrieve property '" + prop.Name + "' because there was an invalid 'this' context.")); return eng.UndefinedValue; } try { var val = ToObject(args.First()); if (prop.PropertyType == typeof(int)) { val = (int)(double)val; } prop.SetValue(@this.ExternalObject, val); return eng.UndefinedValue; } catch (Exception ex) { eng.SetException(FromObject(ex)); return eng.UndefinedValue; } }, owningTypeName + "." + prop.Name + ".set"); } var descriptor = engine.CreateObject(); if (jsGet != null) descriptor.SetPropertyByName("get", jsGet); if (jsSet != null) descriptor.SetPropertyByName("set", jsSet); descriptor.SetPropertyByName("enumerable", engine.TrueValue); target.DefineProperty(prop.Name, descriptor); } }
public async Task Cleanup() { await DispatchContainer.GlobalDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { engine_.Dispose(); engine_ = null; runtime_.Dispose(); runtime_ = null; }); }
public override void Setup() { runtime_ = new JavaScriptRuntime(); engine_ = runtime_.CreateEngine(); }
public static void CheckForScriptExceptionOrThrow(JsErrorCode errorCode, JavaScriptEngine engine) { if (errorCode == JsErrorCode.JsErrorScriptException) { engine.OnRuntimeExceptionRaised(); return; } if (errorCode != JsErrorCode.JsNoError) ThrowFor(errorCode); }
static JavaScriptValue Echo(JavaScriptEngine engine, bool construct, JavaScriptValue thisValue, IEnumerable<JavaScriptValue> arguments) { Console.WriteLine(arguments.First().ToString(), (object[])arguments.Skip(1).ToArray()); return engine.UndefinedValue; }
private void ProjectMethods(string owningTypeName, JavaScriptObject target, JavaScriptEngine engine, IEnumerable <MethodInfo> methods) { var methodsByName = methods.GroupBy(m => m.Name); foreach (var group in methodsByName) { var groupKey = group.Key; var groupCandidates = group.ToList(); var method = engine.CreateFunction((eng, ctor, thisObj, args) => { var @this = thisObj as JavaScriptObject; if (@this == null) { if (thisObj.Type == JavaScriptValueType.Undefined) { var global = engine.GlobalObject.Prototype; thisObj = @this = global; } else { eng.SetException(eng.CreateTypeError("Could not call method '" + groupKey + "' because there was an invalid 'this' context.")); return(eng.UndefinedValue); } } var argsArray = args.ToArray(); var candidate = GetBestFitMethod(groupCandidates, thisObj, argsArray); if (candidate == null) { eng.SetException(eng.CreateReferenceError("Could not find suitable method or not enough arguments to invoke '" + groupKey + "'.")); return(eng.UndefinedValue); } if (!parameterCache.TryGetValue(candidate, out var parameters)) { parameters = candidate.GetParameters(); parameterCache[candidate] = parameters; } var parameterCount = parameters.Length; var argsToPass = engine.BorrowArrayOfObjects(parameterCount); for (int i = 0; i < parameterCount && i < argsArray.Length; i++) { var val = ToObject(argsArray[i]); var parameterType = parameters[i].ParameterType; if (val != null && parameterType == typeof(string) && !(val is string)) { val = argsArray[i].ToString(); } if (val is Double d && parameterType != typeof(Double)) { val = Convert.ChangeType(val, parameterType); } argsToPass[i] = val; } var t = @this; object obj = null; while (obj == null && t.IsTruthy && t.Prototype != null) { obj = t.ExternalObject; if (obj == null) { t = t.Prototype; } } try { var result = FromObject(candidate.Invoke(obj, argsToPass)); engine.ReleaseArrayOfObjects(argsToPass); return(result); } catch (Exception ex) { eng.SetException(FromObject(ex), ex); return(eng.UndefinedValue); } }, owningTypeName + "." + groupKey); //var propDescriptor = engine.CreateObject(); //propDescriptor.SetPropertyByName("configurable", engine.TrueValue); //propDescriptor.SetPropertyByName("enumerable", engine.TrueValue); //propDescriptor.SetPropertyByName("value", method); //target.DefineProperty(group.Key, propDescriptor); target.SetPropertyByName(groupKey, method); } }
internal JavaScriptArrayBuffer(JavaScriptValueSafeHandle handle, JavaScriptValueType type, JavaScriptEngine engine): base(handle, type, engine) { len_ = new Lazy<uint>(GetLength); }
private void ProjectProperties(string owningTypeName, JavaScriptObject target, JavaScriptEngine engine, IEnumerable <PropertyInfo> properties) { foreach (var prop in properties) { if (prop.GetIndexParameters().Length > 0) { throw new NotSupportedException("Index properties not supported for projecting CLR to JavaScript objects."); } JavaScriptFunction jsGet = null, jsSet = null; if (prop.GetMethod != null) { jsGet = engine.CreateFunction((eng, ctor, thisObj, args) => { var @this = thisObj as JavaScriptObject; if (@this == null) { eng.SetException(eng.CreateTypeError("Could not retrieve property '" + prop.Name + "' because there was an invalid 'this' context.")); return(eng.UndefinedValue); } object external = null; if (!prop.GetMethod.IsStatic) { external = @this.ExternalObject; if (external == null) { external = @this.Prototype.ExternalObject; } if (external == null) { throw new Exception("this object not found for method invocation. Perhaps it has been garbage collected."); } } try { return(FromObject(prop.GetValue(external))); } catch (Exception ex) { eng.SetException(FromObject(ex), ex); return(eng.UndefinedValue); } }, owningTypeName + "." + prop.Name + ".get"); } if (prop.SetMethod != null) { jsSet = engine.CreateFunction((eng, ctor, thisObj, args) => { var @this = thisObj as JavaScriptObject; if (@this == null) { eng.SetException(eng.CreateTypeError("Could not retrieve property '" + prop.Name + "' because there was an invalid 'this' context.")); return(eng.UndefinedValue); } try { var val = ToObject(args.First()); if (prop.PropertyType == typeof(int)) { val = (int)(double)val; } var obj = @this.ExternalObject; if (obj == null && @this.Prototype.ExternalObject == engine.GlobalObject.Prototype.ExternalObject) { obj = @this.Prototype.ExternalObject; } prop.SetValue(obj, val); return(eng.UndefinedValue); } catch (Exception ex) { eng.SetException(FromObject(ex), ex); return(eng.UndefinedValue); } }, owningTypeName + "." + prop.Name + ".set"); } var descriptor = engine.CreateObject(); if (jsGet != null) { descriptor.SetPropertyByName("get", jsGet); } if (jsSet != null) { descriptor.SetPropertyByName("set", jsSet); } descriptor.SetPropertyByName("enumerable", engine.TrueValue); target.DefineProperty(prop.Name, descriptor); } }