// https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2015/20151102/csv // Z:\jsc.svn\examples\javascript\chrome\hybrid\ChromeHybridCaptureAE\Application.cs static Application() { #region document if (Native.document != null) { // patch the awaiter.. Console.SetOut(new xConsole()); // also. all workers we will be creating will need to start to expect switch commands... // how can we tap in them? //__worker_onfirstmessage: {{ // ManagedThreadId = 10, href = https://192.168.1.196:13946/view-source#worker, // MethodTargetTypeIndex = type$PgZysaxv_bTu4GEkwmJdJrQ, // MethodTargetType = ___ctor_b__1_5_d, // MethodToken = jwsABpdwBjGQu09dvBXjxw, // MethodType = FuncOfObjectToObject, // stateTypeHandleIndex = null, // stateType = null, // state = [object Object], // IsIProgress = false }} // // can we start a task, yet also have special access for the posted messages? // what about threads that did not hop to background? // dont they want to hop to background? HopToThreadPoolAwaitable.VirtualOnCompleted = continuation => { Action<ShadowIAsyncStateMachine> MoveNext0 = null; // async dont like ref? var shadowstate = ShadowIAsyncStateMachine.FromContinuation(continuation, ref MoveNext0); var MoveNext = MoveNext0; Console.WriteLine("enter HopToThreadPoolAwaitable.VirtualOnCompleted " + new { shadowstate.state }); // post a message to the document var xx = new __Task.InternalTaskExtensionsScope { InternalTaskExtensionsScope_function = continuation }; var x = new __Task<object>(); // reusing thread init for generic task start, although, resuming needs special implementation.. x.InternalInitializeInlineWorker( new Action(xx.f), //action, default(object), default(CancellationToken), default(TaskCreationOptions), TaskScheduler.Default, yield: (worker, e) => { // like operator for JSON? //Console.WriteLine("enter HopToThreadPoolAwaitable InternalInitializeInlineWorker yield"); var data = new { HopToUIAwaitable = new { // state to hop back shadowstate = default(ShadowIAsyncStateMachine) } }; data = (dynamic)e.data; //if (data.HopToUIAwaitable ) if (data.HopToUIAwaitable == null) return; // time to hop back on continuation? Console.ForegroundColor = ConsoleColor.Blue; Console.WriteLine("enter HopToThreadPoolAwaitable yield HopToUIAwaitable, resume state? " + new { data.HopToUIAwaitable.shadowstate.state }); Console.ForegroundColor = ConsoleColor.Black; //enter HopToThreadPoolAwaitable yield HopToUIAwaitable //worker Task Run function has returned {{ value_Task = null, value_TaskOfT = null }} //__Task.InternalStart inner complete {{ yield = {{ value = null }} }} // the worker should be in a suspended state, as we may want to jump back? // MoveNext(data.HopToUIAwaitable.shadowstate); } ); x.Start(); }; return; } #endregion #region worker if (Native.worker != null) { Console.WriteLine("about to enable HopToUIAwaitable..."); Native.worker.onfirstmessage += e => { Console.WriteLine("enter onfirstmessage"); HopToUIAwaitable.VirtualOnCompleted = continuation => { // first jump out? InternalInlineWorker.InternalOverrideTaskOfT = new TaskCompletionSource<object>().Task; // post a message to the document // um. how can we signal that we are not done? Action<ShadowIAsyncStateMachine> MoveNext = null; // async dont like ref? var shadowstate = ShadowIAsyncStateMachine.FromContinuation(continuation, ref MoveNext); Console.WriteLine("enter HopToUIAwaitable.VirtualOnCompleted, postMessage " + new { shadowstate.state }); // postMessageAsync ? if ui wants to return, instead of restaring this thread? e.postMessage( new { HopToUIAwaitable = new { // state to hop back shadowstate } } ); }; }; return; } #endregion }
static Application() { #region document if (Native.document != null) { // patch the awaiter.. //Console.SetOut(new xConsole()); // also. all workers we will be creating will need to start to expect switch commands... // how can we tap in them? //__worker_onfirstmessage: {{ // ManagedThreadId = 10, href = https://192.168.1.196:13946/view-source#worker, // MethodTargetTypeIndex = type$PgZysaxv_bTu4GEkwmJdJrQ, // MethodTargetType = ___ctor_b__1_5_d, // MethodToken = jwsABpdwBjGQu09dvBXjxw, // MethodType = FuncOfObjectToObject, // stateTypeHandleIndex = null, // stateType = null, // state = [object Object], // IsIProgress = false }} // // can we start a task, yet also have special access for the posted messages? // what about threads that did not hop to background? // dont they want to hop to background? HopToWorker.VirtualOnCompleted = continuation => { Action<ShadowIAsyncStateMachine> MoveNext0 = null; // async dont like ref? var shadowstate = ShadowIAsyncStateMachine.FromContinuation(continuation, ref MoveNext0); var MoveNext = MoveNext0; Console.WriteLine("enter HopToWorker " + new { shadowstate.state }); // post a message to the document var xx = new __Task.InternalTaskExtensionsScope { InternalTaskExtensionsScope_function = continuation }; var x = new __Task<object>(); // reusing thread init for generic task start, although, resuming needs special implementation.. x.InternalInitializeInlineWorker( new Action(xx.f), //action, default(object), default(CancellationToken), default(TaskCreationOptions), TaskScheduler.Default, yield: (worker, e) => { // like operator for JSON? //Console.WriteLine("enter HopToThreadPoolAwaitable InternalInitializeInlineWorker yield"); var data = new { vSetTitle = default(string), HopToUIAwaitable = new { // state to hop back shadowstate = default(ShadowIAsyncStateMachine) } }; data = (dynamic)e.data; //if (data.HopToUIAwaitable ) if (data.vSetTitle != null) { Console.Title = data.vSetTitle; } if (data.HopToUIAwaitable == null) return; // time to hop back on continuation? var that = (TestSwitchToServiceContextAsync.ShadowIAsyncStateMachine)data.HopToUIAwaitable.shadowstate; //Console.ForegroundColor = ConsoleColor.Blue; Console.WriteLine("work about to hop into ui " + new { that.state }); //Console.ForegroundColor = ConsoleColor.Black; //enter HopToThreadPoolAwaitable yield HopToUIAwaitable //worker Task Run function has returned {{ value_Task = null, value_TaskOfT = null }} //__Task.InternalStart inner complete {{ yield = {{ value = null }} }} // the worker should be in a suspended state, as we may want to jump back? // //MoveNext(data.HopToUIAwaitable.shadowstate); #region xAsyncStateMachineType var xAsyncStateMachineType = typeof(Application).Assembly.GetTypes().FirstOrDefault( item => { // safety check 1 //Console.WriteLine(new { sw.ElapsedMilliseconds, item.FullName }); var xisIAsyncStateMachine = typeof(IAsyncStateMachine).IsAssignableFrom(item); if (xisIAsyncStateMachine) { //Console.WriteLine(new { item.FullName, isIAsyncStateMachine }); return item.FullName == that.TypeName; } return false; } ); #endregion var NewStateMachine = FormatterServices.GetUninitializedObject(xAsyncStateMachineType); var isIAsyncStateMachine = NewStateMachine is IAsyncStateMachine; var NewStateMachineI = (IAsyncStateMachine)NewStateMachine; #region 1__state xAsyncStateMachineType.GetFields( System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance ).WithEach( AsyncStateMachineSourceField => { Console.WriteLine(new { AsyncStateMachineSourceField }); if (AsyncStateMachineSourceField.Name.EndsWith("1__state")) { AsyncStateMachineSourceField.SetValue( NewStateMachineI, that.state ); } var xStringField = that.StringFields.AsEnumerable().FirstOrDefault( f => DecoratedString(f.FieldName) == DecoratedString(AsyncStateMachineSourceField.Name) ); if (xStringField != null) { // once we are to go back to client. we need to reverse it? AsyncStateMachineSourceField.SetValue( NewStateMachineI, xStringField.value ); // next xml? // before lets send our strings back with the new state! // what about exceptions? } } ); #endregion //new IHTMLPre { // "inside iframe invoke state" // }.AttachToDocument(); NewStateMachineI.MoveNext(); } ); x.Start(); }; return; } #endregion #region worker if (Native.worker != null) { Console.WriteLine("about to enable HopToUI..."); Native.worker.onfirstmessage += e => { Console.WriteLine("enter onfirstmessage"); ScriptCoreLib.JavaScript.BCLImplementation.System.__Console.vSetTitle = value => { e.postMessage( new { vSetTitle = value } ); }; HopToUI.VirtualOnCompleted = continuation => { // https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2015/201511/20151102/hoptoui // first jump out? InternalInlineWorker.InternalOverrideTaskOfT = new TaskCompletionSource<object>().Task; // post a message to the document // um. how can we signal that we are not done? //Action<ShadowIAsyncStateMachine> MoveNext = null; // async dont like ref? //var shadowstate = ShadowIAsyncStateMachine.FromContinuation(continuation, ref MoveNext); var r = TestSwitchToServiceContextAsync.ShadowIAsyncStateMachine.ResumeableFromContinuation(continuation); Console.WriteLine("enter HopToUI, postMessage " + new { r.shadowstate.state }); // postMessageAsync ? if ui wants to return, instead of restaring this thread? e.postMessage( new { HopToUIAwaitable = new { // state to hop back r.shadowstate } } ); }; }; return; } #endregion }