implab/ImplabNet Files · Implab.Fx/StaApartment.cs

working on promises

cin - - Load All Authors

File last commit:

r242:cbe10ac0731e v3


                r243:b1e0ffdf3451

Download file

             StaApartment.cs
        
                    204 lines
            
             | 6.7 KiB
            
                | text/x-csharp
            
             |
                CSharpLexer
            
             / Implab.Fx / StaApartment.cs
          
                    History
                
                 |
                  Source
                 | Raw
                 |Copy content
                 |Copy permalink

        cin
    
Code review for RunnableComponent...

              r210
            
      using Implab.Components;

      using Implab.Diagnostics;

      using Implab.Parallels;

      using System;

      using System.Collections.Generic;

      using System.Linq;

      using System.Text;

      using System.Threading;

      using System.Threading.Tasks;

      using System.Windows.Forms;

      namespace Implab.Fx {

          public class StaApartment : RunnableComponent {

              readonly Thread m_worker;

              SynchronizationContext m_syncContext;

        cin
    
Code review, added a non generic version of SyncContextPromise

              r211
            
              SyncContextPromise m_enterPromise;

        cin
    
Code review for RunnableComponent...

              r210
            
              readonly Promise m_threadStarted;

              readonly Promise m_threadTerminated;

              public StaApartment() : base(true) {

                  m_threadStarted = new Promise();

                  m_threadTerminated = new Promise();

                  m_worker = new Thread(WorkerEntry);

                  m_worker.SetApartmentState(ApartmentState.STA);

                  m_worker.IsBackground = true;

                  m_worker.Name = "STA managed aparment";

              }

              public SynchronizationContext SyncContext {

                  get {

                      if (m_syncContext == null)

                          throw new InvalidOperationException();

                      return m_syncContext;

                  }

              }

        cin
    
Code review, added a non generic version of SyncContextPromise

              r211
            
              /// <summary>

              /// Returns the promise which will dispatch all handlers inside the apartment using it's <see cref="SynchronizationContext"/>

              /// </summary>

              /// <remarks>

              /// Current implementation is optimized and will lost aync operation stack

              /// </remarks>

              /// <returns>The promise</returns>

              public IPromise Enter() {

                  if (m_enterPromise == null)

                      throw new InvalidOperationException();

                  return m_enterPromise;

              }

        cin
    
Code review for RunnableComponent...

              r210
            
              public IPromise Invoke(Action<ICancellationToken> action) {

                  Safe.ArgumentNotNull(action, "action");

                  if (m_syncContext == null)

                      throw new InvalidOperationException();

                  var p = new Promise();

                  var lop = TraceContext.Instance.CurrentOperation;

                  m_syncContext.Post(x => {

                      TraceContext.Instance.EnterLogicalOperation(lop, false);

                      try {

                          if (p.CancelOperationIfRequested())

                              return;

                          action(p);

                          p.Resolve();

                      } catch (Exception e) {

                          p.Reject(e);

                      } finally {

                          TraceContext.Instance.Leave();

                      }

                  }, null);

                  return p;

              }

              public IPromise<T> Invoke<T>(Func<ICancellationToken, T> action) {

                  Safe.ArgumentNotNull(action, "action");

                  if (m_syncContext == null)

                      throw new InvalidOperationException();

                  var p = new Promise<T>();

                  var lop = TraceContext.Instance.CurrentOperation;

                  m_syncContext.Post(x => {

                      TraceContext.Instance.EnterLogicalOperation(lop, false);

                      try {

                          if (p.CancelOperationIfRequested())

                              return;

                          p.Resolve(action(p));

                      } catch (Exception e) {

                          p.Reject(e);

                      } finally {

                          TraceContext.Instance.Leave();

                      }

                  }, null);

                  return p;

              }

              public IPromise Invoke(Action action) {

                  Safe.ArgumentNotNull(action, "action");

                  if (m_syncContext == null)

                      throw new InvalidOperationException();

                  var p = new Promise();

                  var lop = TraceContext.Instance.CurrentOperation;

                  m_syncContext.Post(x => {

                      TraceContext.Instance.EnterLogicalOperation(lop, false);

                      try {

                          if (p.CancelOperationIfRequested())

                              return;

                          action();

                          p.Resolve();

                      } catch (Exception e) {

                          p.Reject(e);

                      } finally {

                          TraceContext.Instance.Leave();

                      }

                  }, null);

                  return p;

              }

              public IPromise<T> Invoke<T>(Func<T> action) {

                  Safe.ArgumentNotNull(action, "action");

                  if (m_syncContext == null)

                      throw new InvalidOperationException();

                  var p = new Promise<T>();

                  var lop = TraceContext.Instance.CurrentOperation;

                  m_syncContext.Post(x => {

                      TraceContext.Instance.EnterLogicalOperation(lop, false);

                      try {

                          if (p.CancelOperationIfRequested())

                              return;

                          p.Resolve(action());

                      } catch (Exception e) {

                          p.Reject(e);

                      } finally {

                          TraceContext.Instance.Leave();

                      }

                  }, null);

                  return p;

              }

              /// <summary>

              /// Starts the apartment thread

              /// </summary>

              /// <returns>Promise which will be fullfiled when the syncronization

              /// context will be ready to accept tasks.</returns>

              protected override IPromise OnStart() {

                  m_worker.Start();

                  return m_threadStarted;

              }

              /// <summary>

              /// Posts quit message to the message loop of the apartment

              /// </summary>

              /// <returns>Promise</returns>

              protected override IPromise OnStop() {

                  m_syncContext.Post(x => Application.ExitThread(), null);

                  return m_threadTerminated;

              }

              void WorkerEntry() {

                  m_syncContext = new WindowsFormsSynchronizationContext();

                  SynchronizationContext.SetSynchronizationContext(m_syncContext);

        cin
    
Code review, added a non generic version of SyncContextPromise

              r211
            
                  m_enterPromise = new SyncContextPromise(m_syncContext);

        cin
    
Code review for RunnableComponent...

              r210
            
                  m_threadStarted.Resolve();

        cin
    
Code review, added a non generic version of SyncContextPromise

              r211
            
                  m_enterPromise.Resolve();

        cin
    
Code review for RunnableComponent...

              r210
            
                  Application.OleRequired();

                  Application.Run();

                  try {

                      OnShutdown();

                      m_threadTerminated.Resolve();

                  } catch(Exception err) {

                      m_threadTerminated.Reject(err);

                  }

              }

              /// <summary>

              /// Called from the STA apartment after the message loop is terminated, override this

              /// method to handle apartment cleanup.

              /// </summary>

              protected virtual void OnShutdown() {

              }

              protected override void Dispose(bool disposing) {

                  if (disposing) {

        cin
    
Working on promises

              r242
            
                      if (!m_threadTerminated.IsFulfilled)

        cin
    
Code review for RunnableComponent...

              r210
            
                          m_syncContext.Post(x => Application.ExitThread(), null);

                  }

                  base.Dispose(disposing);

              }

          }

      }

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

cin Code review for RunnableComponent...	r210	using Implab.Components;
		using Implab.Diagnostics;
		using Implab.Parallels;
		using System;
		using System.Collections.Generic;
		using System.Linq;
		using System.Text;
		using System.Threading;
		using System.Threading.Tasks;
		using System.Windows.Forms;

		namespace Implab.Fx {
		public class StaApartment : RunnableComponent {
		readonly Thread m_worker;
		SynchronizationContext m_syncContext;
cin Code review, added a non generic version of SyncContextPromise	r211	SyncContextPromise m_enterPromise;

cin Code review for RunnableComponent...	r210	readonly Promise m_threadStarted;
		readonly Promise m_threadTerminated;

		public StaApartment() : base(true) {
		m_threadStarted = new Promise();
		m_threadTerminated = new Promise();

		m_worker = new Thread(WorkerEntry);
		m_worker.SetApartmentState(ApartmentState.STA);
		m_worker.IsBackground = true;
		m_worker.Name = "STA managed aparment";
		}

		public SynchronizationContext SyncContext {
		get {
		if (m_syncContext == null)
		throw new InvalidOperationException();
		return m_syncContext;
		}
		}

cin Code review, added a non generic version of SyncContextPromise	r211	/// <summary>
		/// Returns the promise which will dispatch all handlers inside the apartment using it's <see cref="SynchronizationContext"/>
		/// </summary>
		/// <remarks>
		/// Current implementation is optimized and will lost aync operation stack
		/// </remarks>
		/// <returns>The promise</returns>
		public IPromise Enter() {
		if (m_enterPromise == null)
		throw new InvalidOperationException();
		return m_enterPromise;
		}

cin Code review for RunnableComponent...	r210	public IPromise Invoke(Action<ICancellationToken> action) {
		Safe.ArgumentNotNull(action, "action");

		if (m_syncContext == null)
		throw new InvalidOperationException();
		var p = new Promise();
		var lop = TraceContext.Instance.CurrentOperation;

		m_syncContext.Post(x => {
		TraceContext.Instance.EnterLogicalOperation(lop, false);
		try {
		if (p.CancelOperationIfRequested())
		return;

		action(p);
		p.Resolve();
		} catch (Exception e) {
		p.Reject(e);
		} finally {
		TraceContext.Instance.Leave();
		}
		}, null);

		return p;
		}

		public IPromise<T> Invoke<T>(Func<ICancellationToken, T> action) {
		Safe.ArgumentNotNull(action, "action");

		if (m_syncContext == null)
		throw new InvalidOperationException();
		var p = new Promise<T>();
		var lop = TraceContext.Instance.CurrentOperation;

		m_syncContext.Post(x => {
		TraceContext.Instance.EnterLogicalOperation(lop, false);
		try {
		if (p.CancelOperationIfRequested())
		return;
		p.Resolve(action(p));
		} catch (Exception e) {
		p.Reject(e);
		} finally {
		TraceContext.Instance.Leave();
		}
		}, null);

		return p;
		}

		public IPromise Invoke(Action action) {
		Safe.ArgumentNotNull(action, "action");

		if (m_syncContext == null)
		throw new InvalidOperationException();
		var p = new Promise();
		var lop = TraceContext.Instance.CurrentOperation;

		m_syncContext.Post(x => {
		TraceContext.Instance.EnterLogicalOperation(lop, false);
		try {
		if (p.CancelOperationIfRequested())
		return;
		action();
		p.Resolve();
		} catch (Exception e) {
		p.Reject(e);
		} finally {
		TraceContext.Instance.Leave();
		}
		}, null);

		return p;
		}

		public IPromise<T> Invoke<T>(Func<T> action) {
		Safe.ArgumentNotNull(action, "action");

		if (m_syncContext == null)
		throw new InvalidOperationException();
		var p = new Promise<T>();
		var lop = TraceContext.Instance.CurrentOperation;

		m_syncContext.Post(x => {
		TraceContext.Instance.EnterLogicalOperation(lop, false);
		try {
		if (p.CancelOperationIfRequested())
		return;
		p.Resolve(action());
		} catch (Exception e) {
		p.Reject(e);
		} finally {
		TraceContext.Instance.Leave();
		}
		}, null);

		return p;
		}


		/// <summary>
		/// Starts the apartment thread
		/// </summary>
		/// <returns>Promise which will be fullfiled when the syncronization
		/// context will be ready to accept tasks.</returns>
		protected override IPromise OnStart() {
		m_worker.Start();
		return m_threadStarted;
		}

		/// <summary>
		/// Posts quit message to the message loop of the apartment
		/// </summary>
		/// <returns>Promise</returns>
		protected override IPromise OnStop() {
		m_syncContext.Post(x => Application.ExitThread(), null);
		return m_threadTerminated;
		}

		void WorkerEntry() {
		m_syncContext = new WindowsFormsSynchronizationContext();
		SynchronizationContext.SetSynchronizationContext(m_syncContext);
cin Code review, added a non generic version of SyncContextPromise	r211	m_enterPromise = new SyncContextPromise(m_syncContext);
cin Code review for RunnableComponent...	r210	m_threadStarted.Resolve();
cin Code review, added a non generic version of SyncContextPromise	r211	m_enterPromise.Resolve();
cin Code review for RunnableComponent...	r210
		Application.OleRequired();
		Application.Run();

		try {
		OnShutdown();
		m_threadTerminated.Resolve();
		} catch(Exception err) {
		m_threadTerminated.Reject(err);
		}
		}

		/// <summary>
		/// Called from the STA apartment after the message loop is terminated, override this
		/// method to handle apartment cleanup.
		/// </summary>
		protected virtual void OnShutdown() {
		}

		protected override void Dispose(bool disposing) {
		if (disposing) {
cin Working on promises	r242	if (!m_threadTerminated.IsFulfilled)
cin Code review for RunnableComponent...	r210	m_syncContext.Post(x => Application.ExitThread(), null);
		}
		base.Dispose(disposing);
		}
		}
		}