C# IJavascriptObject类代码示例

 private JsGenericObject(HTMLViewContext context, IJavascriptObject value)
 {
     JSValue = value;
     _MappedJSValue = value;
     CValue = null;
     _HTMLViewContext = context;
 }

 public VueJavascriptViewModelUpdater(IWebView webView, IJavascriptObject listener, Lazy<IJavascriptObject> vueHelper, IWebSessionLogger logger)
 {
     _WebView = webView;
     _Listener = listener;
     _VueHelper = vueHelper;
     _Logger = logger;
 }

 private JSGenericObject(IWebView context, IJavascriptObject value)
 {
     JSValue = value;
     _MappedJSValue = value;
     CValue = null;
     _CefV8Context = context;
 }

        internal void RegisterCollectionMapping(IJavascriptObject jsFather, string att, int index, IJavascriptObject child)
        {
            var father = GetGlobalCached(jsFather);
            var jsos = (att == null) ? father : ((JsGenericObject)father).Attributes[att];

            Update(((JSArray)jsos).Items[index] as IJSObservableBridge, child);
        }

        private void SetResult(IJavascriptObject[] e, IJSCBridgeCache bridge, Task<object> resulttask)
        {
            _IWebView.RunAsync (() =>
                 {
                     if (e.Length < 2)
                         return;

                     IJavascriptObject promise = e[1];
                     if (!resulttask.IsFaulted)
                     {
                         bridge.RegisterInSession(resulttask.Result, (bridgevalue) =>
                         {
                             promise.InvokeAsync("fullfill", _IWebView, bridgevalue.GetJSSessionValue());
                         });
                     }
                     else
                     {
                         string error = (resulttask.IsCanceled) ? "Cancelled" :
                             ((resulttask.Exception == null) ? "Faulted" : resulttask.Exception.Flatten().InnerException.Message);

                         promise.InvokeAsync("reject", _IWebView, _IWebView.Factory.CreateString(error));
                     }

                 });
        }

        private void MappNested(object from, IJavascriptObject resobject, JsGenericObject gres)
        {
            if (from == null)
                return;

           var propertyInfos = from.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => p.CanRead);

            foreach (var propertyInfo in propertyInfos)
            {
                var propertyName = propertyInfo.Name;
                object childvalue;
                try
                {
                    childvalue = propertyInfo.GetValue(from, null); 
                }
                catch(Exception e)
                {
                    _Logger.Info(()=> $"Unable to convert property {propertyName} from {@from} exception {e}");
                    continue;
                }

                var childres = UnsafelMap(childvalue);          
                _Context.WebView.Run(() => resobject.SetValue(propertyName, childres.JSValue));
                gres.UpdateCSharpProperty(propertyName, childres);
            }
        }

 public void SpliceCollection(IJavascriptObject array, int index, int number, IJavascriptObject added) 
 {
     _WebView.RunAsync(() => 
     {
         AddUnsafe(array, index, number, added);
     });
 }

 public void ClearAllCollection(IJavascriptObject array)
 {
     _WebView.RunAsync(() =>
     {
         var length = array.GetArrayLength();
         array.Invoke("silentSplice", _WebView, _WebView.Factory.CreateInt(0), _WebView.Factory.CreateInt(length));
     });
 }

        protected override bool LocalComputeJavascriptValue(IJavascriptObjectFactory factory)
        {
            if (JSValue != null)
                return false;

            JSValue = factory.CreateObject(true);
            return true;
        }

 public void MoveCollectionItem(IJavascriptObject array, IJavascriptObject item, int oldIndex, int newIndex)
 {
     _WebView.RunAsync(() => 
     {
         array.Invoke("silentSplice", _WebView, _WebView.Factory.CreateInt(oldIndex), _WebView.Factory.CreateInt(1));
         AddUnsafe(array, newIndex, 0, item);
     });
 }

 public VueVmManager(IWebView webView, IJavascriptObject listener, IWebSessionLogger logger) 
 {
     _WebView = webView;
     _Logger = logger;
     _VueHelperLazy = new Lazy<IJavascriptObject>(GetVueHelper);
     _VueJavascriptSessionInjector =  new VueJavascriptSessionInjector(webView, listener, _VueHelperLazy, _Logger);
     _VueJavascriptViewModelUpdater = new VueJavascriptViewModelUpdater(webView, listener, _VueHelperLazy, _Logger);    
 }

        private void JavascriptColectionChanged(IJavascriptObject[] arguments)
        {
            var values = arguments[1].GetArrayElements();
            var types = arguments[2].GetArrayElements();
            var indexes = arguments[3].GetArrayElements();
            var collectionChange = new JavascriptCollectionChanges(arguments[0], values.Zip(types, indexes, (v, t, i) => new IndividualJavascriptCollectionChange(t.GetStringValue() == "added" ? CollectionChangeType.Add : CollectionChangeType.Remove, i.GetIntValue(), v)));

            _Observer.OnJavaScriptCollectionChanges(collectionChange);
        }

        internal void RegisterMapping(IJavascriptObject father, string att, IJavascriptObject child)
        {
            var global = GetGlobalCached(father);
            if (global is JSCommand)
                return;

            var jso = (JsGenericObject)global;
            Update(jso.Attributes[att] as IJSObservableBridge, child);
        }

 private async void CanExecuteCommand(IJavascriptObject[] e)
 {
     var parameter = _JavascriptToCSharpConverter.GetFirstArgumentOrNull(e);
     var res = await UIDispatcher.EvaluateAsync(() => _Command.CanExecute(parameter));
     await WebView.RunAsync(() =>
     {
         UpdateProperty("CanExecuteValue", (f) => f.CreateBool(res));
     });
 }

        protected override bool LocalComputeJavascriptValue(IJavascriptObjectFactory factory)
        {
            if (JSValue != null)
                return false;

            JSValue = factory.CreateObject(true);
            JSValue.SetValue("CanExecuteValue", factory.CreateBool(_InitialCanExecute));
            JSValue.SetValue("CanExecuteCount", factory.CreateInt(_Count));
            return true;
        }