public unsafe void ToJS(Exception?value) { if (value == null) { slot.Type = MarshalerType.None; } else { Exception cpy = value; if (cpy is AggregateException ae && ae.InnerExceptions.Count == 1) { cpy = ae.InnerExceptions[0]; } var jse = cpy as JSException; if (jse != null && jse.jsException != null) { // this is JSException roundtrip if (jse.jsException.IsDisposed) { throw new ObjectDisposedException(nameof(value)); } slot.Type = MarshalerType.JSException; slot.JSHandle = jse.jsException.JSHandle; } else { ToJS(cpy.Message); slot.Type = MarshalerType.Exception; slot.GCHandle = JSHostImplementation.GetJSOwnedObjectGCHandle(cpy); } } }
/// <summary> /// Gets or sets the Array with the index specified by <paramref name="i" />. /// </summary> /// <param name="i">The index.</param> public object this[int i] { [MethodImpl(MethodImplOptions.NoInlining)] // https://github.com/dotnet/runtime/issues/71425 get { this.AssertNotDisposed(); Interop.Runtime.GetByIndexRef(JSHandle, i, out int exception, out object indexValue); if (exception != 0) { throw new JSException((string)indexValue); } JSHostImplementation.ReleaseInFlight(indexValue); return(indexValue); } [MethodImpl(MethodImplOptions.NoInlining)] // https://github.com/dotnet/runtime/issues/71425 set { this.AssertNotDisposed(); Interop.Runtime.SetByIndexRef(JSHandle, i, value, out int exception, out object res); if (exception != 0) { throw new JSException((string)res); } } }
public unsafe void ToManaged(out Exception?value) { if (slot.Type == MarshalerType.None) { value = null; return; } if (slot.Type == MarshalerType.Exception) { // this is managed exception round-trip #pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type. value = (Exception)((GCHandle)slot.GCHandle).Target; #pragma warning restore CS8600 // Converting null literal or possible null value to non-nullable type. return; } JSObject?jsException = null; if (slot.JSHandle != IntPtr.Zero) { // this is JSException round-trip jsException = JSHostImplementation.CreateCSOwnedProxy(slot.JSHandle); } string?message; ToManaged(out message); value = new JSException(message !, jsException); }
public unsafe void ToManaged(out JSObject?value) { if (slot.Type == MarshalerType.None) { value = null; return; } value = JSHostImplementation.CreateCSOwnedProxy(slot.JSHandle); }
public static object Invoke(this JSObject self, string method, params object?[] args) { ArgumentNullException.ThrowIfNull(self); ObjectDisposedException.ThrowIf(self.IsDisposed, self); Interop.Runtime.InvokeJSWithArgsRef(self.JSHandle, method, args, out int exception, out object res); if (exception != 0) { throw new JSException((string)res); } JSHostImplementation.ReleaseInFlight(res); return(res); }
[MethodImplAttribute(MethodImplOptions.NoInlining)] // https://github.com/dotnet/runtime/issues/71425 public static void MarshalPromise(Span <JSMarshalerArgument> arguments) { fixed(JSMarshalerArgument *ptr = arguments) { Interop.Runtime.MarshalPromise(ptr); ref JSMarshalerArgument exceptionArg = ref arguments[0]; if (exceptionArg.slot.Type != MarshalerType.None) { JSHostImplementation.ThrowException(ref exceptionArg); } }
public static object GetObjectProperty(this JSObject self, string name) { ArgumentNullException.ThrowIfNull(self); ObjectDisposedException.ThrowIf(self.IsDisposed, self); Interop.Runtime.GetObjectPropertyRef(self.JSHandle, name, out int exception, out object propertyValue); if (exception != 0) { throw new JSException((string)propertyValue); } JSHostImplementation.ReleaseInFlight(propertyValue); return(propertyValue); }
/// <summary> /// Implementation of the argument marshaling. /// It's used by JSImport code generator and should not be used by developers in source code. /// </summary> public unsafe void ToJS(ArraySegment <byte> value) { if (value.Array == null) { slot.Type = MarshalerType.None; return; } slot.Type = MarshalerType.ArraySegment; slot.GCHandle = JSHostImplementation.GetJSOwnedObjectGCHandleRef(value.Array, GCHandleType.Pinned); var refPtr = (IntPtr)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(value.Array)); slot.IntPtrValue = refPtr + value.Offset; slot.Length = value.Count; }
internal static unsafe void InvokeJSImpl(JSObject jsFunction, Span <JSMarshalerArgument> arguments) { IntPtr functionJSHandle = jsFunction.JSHandle; fixed(JSMarshalerArgument *ptr = arguments) { Interop.Runtime.InvokeJSFunction(functionJSHandle, ptr); ref JSMarshalerArgument exceptionArg = ref arguments[0]; if (exceptionArg.slot.Type != MarshalerType.None) { JSHostImplementation.ThrowException(ref exceptionArg); } }
public static object GetGlobalObject(string?str = null) { int exception; Interop.Runtime.GetGlobalObjectRef(str, out exception, out object jsObj); if (exception != 0) { throw new JSException($"Error obtaining a handle to global {str}"); } JSHostImplementation.ReleaseInFlight(jsObj); return(jsObj); }
/// <summary> /// Invoke a named method of the object, or throws a JSException on error. /// </summary> /// <param name="self">thisArg</param> /// <param name="method">The name of the method to invoke.</param> /// <param name="args">The argument list to pass to the invoke command.</param> /// <returns> /// <para> /// The return value can either be a primitive (string, int, double), a JSObject for JavaScript objects, a /// System.Threading.Tasks.Task(object) for JavaScript promises, an array of /// a byte, int or double (for Javascript objects typed as ArrayBuffer) or a /// System.Func to represent JavaScript functions. The specific version of /// the Func that will be returned depends on the parameters of the Javascript function /// and return value. /// </para> /// <para> /// The value of a returned promise (The Task(object) return) can in turn be any of the above /// valuews. /// </para> /// </returns> public static object Invoke(this JSObject self, string method, params object?[] args) { if (self == null) { throw new ArgumentNullException(nameof(self)); } if (self.IsDisposed) { throw new ObjectDisposedException($"Cannot access a disposed {self.GetType().Name}."); } Interop.Runtime.InvokeJSWithArgsRef(self.JSHandle, method, args, out int exception, out object res); if (exception != 0) { throw new JSException((string)res); } JSHostImplementation.ReleaseInFlight(res); return(res); }
/// <summary> /// Returns the named property from the object, or throws a JSException on error. /// </summary> /// <param name="self">thisArg</param> /// <param name="name">The name of the property to lookup</param> /// <remarks> /// This method can raise a JSException if fetching the property in Javascript raises an exception. /// </remarks> /// <returns> /// <para> /// The return value can either be a primitive (string, int, double), a /// JSObject for JavaScript objects, a /// System.Threading.Tasks.Task (object) for JavaScript promises, an array of /// a byte, int or double (for Javascript objects typed as ArrayBuffer) or a /// System.Func to represent JavaScript functions. The specific version of /// the Func that will be returned depends on the parameters of the Javascript function /// and return value. /// </para> /// <para> /// The value of a returned promise (The Task(object) return) can in turn be any of the above /// valuews. /// </para> /// </returns> public static object GetObjectProperty(this JSObject self, string name) { if (self == null) { throw new ArgumentNullException(nameof(self)); } if (self.IsDisposed) { throw new ObjectDisposedException($"Cannot access a disposed {self.GetType().Name}."); } Interop.Runtime.GetObjectPropertyRef(self.JSHandle, name, out int exception, out object propertyValue); if (exception != 0) { throw new JSException((string)propertyValue); } JSHostImplementation.ReleaseInFlight(propertyValue); return(propertyValue); }
public Uint8Array(ArrayBuffer buffer) : base(JavaScriptImports.CreateCSOwnedObject(nameof(Uint8Array), new object[] { buffer })) { JSHostImplementation.RegisterCSOwnedObject(this); }
public Uint8Array(int length) : base(JavaScriptImports.CreateCSOwnedObject(nameof(Uint8Array), new object[] { length })) { JSHostImplementation.RegisterCSOwnedObject(this); }
/// <summary> /// Initializes a new instance of the Array class. /// </summary> /// <param name="_params">Parameters.</param> public Array(params object[] _params) : base(JavaScriptImports.CreateCSOwnedObject(nameof(Array), _params)) { JSHostImplementation.RegisterCSOwnedObject(this); }
public static Task <JSObject> ImportAsync(string moduleName, string moduleUrl, CancellationToken cancellationToken = default) { return(JSHostImplementation.ImportAsync(moduleName, moduleUrl, cancellationToken)); }