public static void PostAction(
     this DispatcherObject obj,
     Action action,
     DispatcherPriority priority = DispatcherPriority.Input)
 {
     obj.Dispatcher.BeginInvoke(priority, action);
 }

 public static void InvokeIfRequired(this Dispatcher disp, Action dotIt, DispatcherPriority priority)
 {
     if (disp.Thread != Thread.CurrentThread)
         disp.Invoke(priority, dotIt);
     else
         dotIt();
 }

 public static void InvokeIfRequired(this Dispatcher dispatcher, Action action, DispatcherPriority priority)
 {
     if (!dispatcher.CheckAccess())
     dispatcher.Invoke(priority, (Delegate) action);
       else
     action();
 }

        public LightClawSynchronizationContext(Dispatcher dispatcher, DispatcherPriority priority)
        {
            Contract.Requires<ArgumentNullException>(dispatcher != null);

            this.dispatcher = dispatcher;
            this.priority = priority;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="DispatcherTimer"/> class.
 /// </summary>
 /// <param name="interval">The interval at which to tick.</param>
 /// <param name="priority">The priority to use.</param>
 /// <param name="dispatcher">The dispatcher to use.</param>
 /// <param name="callback">The event to call when the timer ticks.</param>
 public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback, Dispatcher dispatcher)
 {
     this.priority = priority;
     this.Dispatcher = dispatcher;
     this.Interval = interval;
     this.Tick += callback;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="DispatcherThrottle" /> class.
        /// </summary>
        /// <param name="priority">The priority of the dispatcher.</param>
        /// <param name="target">The target action to invoke when the throttle condition is hit.</param>
        public DispatcherThrottle(DispatcherPriority priority, [NotNull] Action target)
        {
            Contract.Requires(target != null);

            _target = target;
            _priority = priority;
        }

 internal DispatcherOperation(Dispatcher dispatcher, Delegate del, DispatcherPriority priority, object[] args)
 {
     myDispatcher = dispatcher;
     myDelegate = del;
     myPriority = priority;
     myArgs = args;
 }

        /// <summary>
        ///     Creates a timer that is bound to the specified dispatcher and
        ///     will be processed at the specified priority, after the
        ///     specified timeout.
        /// </summary>
        /// <param name="interval">
        ///     The interval to tick the timer after.
        /// </param>
        /// <param name="priority">
        ///     The priority to process the timer at.
        /// </param>
        /// <param name="callback">
        ///     The callback to call when the timer ticks.
        /// </param>
        /// <param name="dispatcher">
        ///     The dispatcher to use to process the timer.
        /// </param>
        public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback, Dispatcher dispatcher) // NOTE: should be Priority
        {
            // 






            if(callback == null)
            {
                throw new ArgumentNullException("callback");
            }
            if(dispatcher == null)
            {
                throw new ArgumentNullException("dispatcher");
            }

            if (interval.TotalMilliseconds < 0)
                throw new ArgumentOutOfRangeException("interval", SR.Get(SRID.TimeSpanPeriodOutOfRange_TooSmall));

            if (interval.TotalMilliseconds > Int32.MaxValue)
                throw new ArgumentOutOfRangeException("interval", SR.Get(SRID.TimeSpanPeriodOutOfRange_TooLarge));

            Initialize(dispatcher, priority, interval);
            
            Tick += callback;
            Start();
        }

		public void Execute(Delegate method, DispatcherPriority priority)
		{
			if (application == null)
			{
				ExecuteDirectlyOrDuringATest(method);
				return;
			}

			var dispatcher = application.Dispatcher;

			if ((application != null) && isAsync)
			{
				dispatcher.BeginInvoke(method);
				return;
			}

			var notRequireUiThread = dispatcher.CheckAccess();

			if (notRequireUiThread)
			{
				ExecuteDirectlyOrDuringATest(method);
				return;
			}

			if (isAsync)
			{
				dispatcher.BeginInvoke(method, priority);
				return;
			}

			dispatcher.Invoke(method, priority);
		}

 public DispatcherTimer(Dispatcher dispatcher, ITaskScheduler scheduler, TimeSpan interval, DispatcherPriority priority)
 {
     this.dispatcher = dispatcher;
     this.scheduler = scheduler;
     this.Interval = interval;
     this.Priority = priority;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DispatcherTimer"/> class.
 /// </summary>
 /// <param name="interval">The interval at which to tick.</param>
 /// <param name="priority">The priority to use.</param>
 /// <param name="dispatcher">The dispatcher to use.</param>
 /// <param name="callback">The event to call when the timer ticks.</param>
 public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback, Dispatcher dispatcher)
 {
     _priority = priority;
     Dispatcher = dispatcher;
     Interval = interval;
     Tick += callback;
 }

 /// <summary>
 /// for UI methods to switch current thread to UI thread
 /// </summary>
 public static void InvokeIfRequired(this DispatcherObject control, Action methodcall, DispatcherPriority priorityForCall)
 {
     if (control.Dispatcher.Thread != Thread.CurrentThread)
         control.Dispatcher.Invoke(priorityForCall, methodcall);
     else
         methodcall();
 }

 public virtual void Invoke(DispatcherPriority priority, Delegate method, object arg)
 {
     if (!this.uiThreadDispatcher.HasShutdownStarted)
     {
         this.uiThreadDispatcher.Invoke(priority, method, arg);
     }
 }

		internal DispatcherOperation (Dispatcher dis, DispatcherPriority prio, Delegate d, object arg)
			: this (dis, prio)
		{
			delegate_method = d;
			delegate_args = new object [1];
			delegate_args [0] = arg;
		}

 public virtual void BeginInvoke(DispatcherPriority priority, Delegate method, object arg, params object[] args)
 {
     if (!this.uiThreadDispatcher.HasShutdownStarted)
     {
         this.uiThreadDispatcher.BeginInvoke(priority, method, arg, args);
     }
 }

 public static void DispatchFrame(DispatcherPriority priority = DispatcherPriority.Background)
 {
     DispatcherFrame frame = new DispatcherFrame();
     Dispatcher.CurrentDispatcher.BeginInvoke(priority,
         new DispatcherOperationCallback((f)=>((DispatcherFrame)f).Continue = false), frame);
     Dispatcher.PushFrame(frame);
 }

 public static void Invoke(
     this IDispatcherService dispatcher,
     Action action,
     DispatcherPriority priority
     )
 {
     dispatcher.Invoke(action, priority);
 }

 public static DispatcherOperation BeginInvoke(
     this IDispatcherService dispatcher,
     Action action,
     DispatcherPriority priority
     )
 {
     return dispatcher.BeginInvoke(action, priority);
 }

 public DispatcherTimer(TimeSpan interval, DispatcherPriority priority,
     EventHandler callback, Dispatcher dispatcher)
 {
     this.priority = priority;
     this.target_dispatcher = dispatcher;
     this.interval = interval.Ticks;
     this.callback = callback;
 }

 public static void DoEvents(DispatcherPriority nPrio)
 {
     DispatcherFrame nestedFrame = new DispatcherFrame();
     DispatcherOperation exitOperation = Dispatcher.CurrentDispatcher.BeginInvoke(nPrio, exitFrameCallback, nestedFrame);
     Dispatcher.PushFrame(nestedFrame);
     if (exitOperation.Status != DispatcherOperationStatus.Completed)
         exitOperation.Abort();
 }