Beispiel #1
0
        /// <summary>
        /// Creates a new <c>Object</c> that stores some external data
        /// </summary>
        /// <remarks>
        /// Requires an active script context.
        /// </remarks>
        /// <param name="data">External data that the object will represent. May be null.</param>
        /// <param name="finalizer">The callback for when the object is finalized. May be null.</param>
        /// <returns>The new <c>Object</c></returns>
        public static JsValue CreateExternalObject(IntPtr data, JsFinalizeCallback finalizer)
        {
            JsValue reference;

            JsErrorHelpers.ThrowIfError(NativeMethods.JsCreateExternalObject(data, finalizer, out reference));

            return(reference);
        }
        static JavaScriptEngine()
        {
            NativeCallback = NativeCallbackThunk;
            NativeCallbackPtr = Marshal.GetFunctionPointerForDelegate(NativeCallback);

            FinalizerCallback = FinalizerCallbackThunk;
            FinalizerCallbackPtr = Marshal.GetFunctionPointerForDelegate(FinalizerCallback);
        }
Beispiel #3
0
        static JavaScriptEngine()
        {
            NativeCallback    = NativeCallbackThunk;
            NativeCallbackPtr = Marshal.GetFunctionPointerForDelegate(NativeCallback);

            FinalizerCallback    = FinalizerCallbackThunk;
            FinalizerCallbackPtr = Marshal.GetFunctionPointerForDelegate(FinalizerCallback);
        }
        /// <summary>
        /// Disposes a type mapper
        /// </summary>
        public void Dispose()
        {
            if (_disposedFlag.Set())
            {
                var lazyEmbeddedObjects = _lazyEmbeddedObjects;
                if (lazyEmbeddedObjects != null)
                {
                    if (lazyEmbeddedObjects.Count > 0)
                    {
                        foreach (EmbeddedObjectKey key in lazyEmbeddedObjects.Keys)
                        {
                            Lazy <EmbeddedObject> lazyEmbeddedObject;

                            if (lazyEmbeddedObjects.TryGetValue(key, out lazyEmbeddedObject))
                            {
                                lazyEmbeddedObject.Value?.Dispose();
                            }
                        }

                        lazyEmbeddedObjects.Clear();
                    }

                    _lazyEmbeddedObjects = null;
                }

                _embeddedObjectFinalizeCallback = null;

                var lazyEmbeddedTypes = _lazyEmbeddedTypes;
                if (lazyEmbeddedTypes != null)
                {
                    if (lazyEmbeddedTypes.Count > 0)
                    {
                        foreach (string key in lazyEmbeddedTypes.Keys)
                        {
                            Lazy <EmbeddedType> lazyEmbeddedType;

                            if (lazyEmbeddedTypes.TryGetValue(key, out lazyEmbeddedType))
                            {
                                lazyEmbeddedType.Value?.Dispose();
                            }
                        }

                        lazyEmbeddedTypes.Clear();
                    }

                    _lazyEmbeddedTypes = null;
                }

                _embeddedTypeFinalizeCallback = null;
            }
        }
        /// <summary>
        /// Creates a JavaScript value from an host object if the it does not already exist
        /// </summary>
        /// <param name="obj">Instance of host type</param>
        /// <returns>JavaScript value created from an host object</returns>
        public JsValue GetOrCreateScriptObject(object obj)
        {
            if (!_embeddedObjectStorageInitialized)
            {
                lock (_embeddedObjectStorageInitializationSynchronizer)
                {
                    if (!_embeddedObjectStorageInitialized)
                    {
                        _lazyEmbeddedObjects            = new ConcurrentDictionary <EmbeddedObjectKey, Lazy <EmbeddedObject> >();
                        _embeddedObjectFinalizeCallback = EmbeddedObjectFinalizeCallback;

                        _embeddedObjectStorageInitialized = true;
                    }
                }
            }

            var            embeddedObjectKey = new EmbeddedObjectKey(obj);
            EmbeddedObject embeddedObject    = _lazyEmbeddedObjects.GetOrAdd(
                embeddedObjectKey,
                key => new Lazy <EmbeddedObject>(() => CreateEmbeddedObjectOrFunction(obj))
                ).Value;

            return(embeddedObject.ScriptValue);
        }
        /// <summary>
        /// Creates a JavaScript value from an host type if the it does not already exist
        /// </summary>
        /// <param name="type">Host type</param>
        /// <returns>JavaScript value created from an host type</returns>
        public JsValue GetOrCreateScriptType(Type type)
        {
            if (!_embeddedTypeStorageInitialized)
            {
                lock (_embeddedTypeStorageInitializationSynchronizer)
                {
                    if (!_embeddedTypeStorageInitialized)
                    {
                        _lazyEmbeddedTypes            = new ConcurrentDictionary <string, Lazy <EmbeddedType> >();
                        _embeddedTypeFinalizeCallback = EmbeddedTypeFinalizeCallback;

                        _embeddedTypeStorageInitialized = true;
                    }
                }
            }

            string       embeddedTypeKey = type.AssemblyQualifiedName;
            EmbeddedType embeddedType    = _lazyEmbeddedTypes.GetOrAdd(
                embeddedTypeKey,
                key => new Lazy <EmbeddedType>(() => CreateEmbeddedType(type))
                ).Value;

            return(embeddedType.ScriptValue);
        }
Beispiel #7
0
 public static extern JsErrorCode JsCreateCustomExternalObject(IntPtr data, ulong inlineSlotSize, JsTraceCallback traceCallback, JsFinalizeCallback finalizeCallback, ref JsGetterSetterInterceptor getterSetterInterceptor, JsValueRef prototype, out JsValueRef @object);
Beispiel #8
0
 public static extern JsErrorCode JsCreateTracedExternalObject(IntPtr data, ulong inlineSlotSize, JsTraceCallback traceCallback, JsFinalizeCallback finalizeCallback, JsValueRef prototype, out JsValueRef @object);
Beispiel #9
0
 public static extern JsErrorCode JsCreateExternalObjectWithPrototype(IntPtr data, JsFinalizeCallback finalizeCallback, JsValueRef prototype, out JsValueRef @object);
Beispiel #10
0
 public static extern JsErrorCode JsCreateExternalArrayBuffer(IntPtr data, uint byteLength, JsFinalizeCallback finalizeCallback, IntPtr callbackState, out JsValueRef result);
Beispiel #11
0
 public static extern JsErrorCode JsCreateExternalObject(IntPtr data, JsFinalizeCallback finalizeCallback, out JsValueRef @object);
 internal static extern JsErrorCode JsCreateExternalObject(IntPtr data, JsFinalizeCallback finalizeCallback, out JsValue obj);