Temporizador en Biblioteca Portátil

Siguiendo la sugerencia # 3 de David Kean, aquí está mi adaptador de temporizador hacky: coloque esto en una biblioteca PCL que se dirija a. net 4.0 y haga referencia a ella desde 4.5:

    public class PCLTimer
    {
        private Timer _timer;

        private Action _action;

        public PCLTimer(Action action, TimeSpan dueTime, TimeSpan period)
        {
            _action = action;

            _timer = new Timer(PCLTimerCallback, null, dueTime, period);           
        }

        private void PCLTimerCallback(object state)
        {
            _action.Invoke();
        }

        public bool Change(TimeSpan dueTime, TimeSpan period)
        {
            return _timer.Change(dueTime, period);
        }
    }

Y luego para usarlo, puede hacer esto desde su biblioteca PCL 4.5:

    private void TimeEvent()
    {            
        //place your timer callback code here
    }

    public void SetupTimer()
    {            
        //set up timer to run every second
        PCLTimer _pageTimer = new PCLTimer(new Action(TimeEvent), TimeSpan.FromMilliseconds(-1), TimeSpan.FromSeconds(1));

        //timer starts one second from now
        _pageTimer.Change(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));

    }

Implementación de la sugerencia #1 de David Kean con punto:

public delegate void TimerCallback(object state);

public sealed class Timer : CancellationTokenSource, IDisposable
{
    public Timer(TimerCallback callback, object state, int dueTime, int period)
    {
        Task.Delay(dueTime, Token).ContinueWith(async (t, s) =>
        {
            var tuple = (Tuple<TimerCallback, object>) s;

            while (true)
            {
                if (IsCancellationRequested)
                    break;
                Task.Run(() => tuple.Item1(tuple.Item2));
                await Task.Delay(period);
            }

        }, Tuple.Create(callback, state), CancellationToken.None,
            TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion,
            TaskScheduler.Default);
    }

    public new void Dispose() { base.Cancel(); }
}

Mejoré la respuesta de Ivan Leonenko al incluir un nuevo parámetro, que pone en cola las llamadas a la devolución de llamada si el período es menor que el tiempo de ejecución de la devolución de llamada. Y reemplazó el TimerCallback heredado con una acción. Y finalmente, use nuestro token de cancelación en el último retraso, y use ConfigureAwait para aumentar la concurrencia, ya que la devolución de llamada se puede ejecutar en cualquier subproceso.

internal sealed class Timer : CancellationTokenSource
{
    internal Timer(Action<object> callback, object state, int millisecondsDueTime, int millisecondsPeriod, bool waitForCallbackBeforeNextPeriod = false)
    {
        //Contract.Assert(period == -1, "This stub implementation only supports dueTime.");

        Task.Delay(millisecondsDueTime, Token).ContinueWith(async (t, s) =>
        {
            var tuple = (Tuple<Action<object>, object>) s;

            while (!IsCancellationRequested)
            {
                if (waitForCallbackBeforeNextPeriod)
                    tuple.Item1(tuple.Item2);
                else
                    Task.Run(() => tuple.Item1(tuple.Item2));

                await Task.Delay(millisecondsPeriod, Token).ConfigureAwait(false);
            }

        }, Tuple.Create(callback, state), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Default);
    }

    protected override void Dispose(bool disposing)
    {
        if(disposing)
            Cancel();

        base.Dispose(disposing);
    }
}

Puede crear una interfaz de temporizador utilizando una biblioteca PCL y luego crear una implementación de esa interfaz en una segunda biblioteca W8S utilizando un temporizador W8S.

Entonces podría usar la inyección de dependencias para inyectar la biblioteca W8S en la clase PCL.

Terminé con Observable.Timer de Reactive Extensions (Rx). Rx ya estaba incluido en el proyecto, por lo que la referencia adicional no era un problema.

Aquí hay un temporizador que se activa cada segundo:

IDisposable timer = Observable.Timer(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
    .Subscribe(_ => /* your useful code here */);

// unsubscribe/stop when timer is no longer needed
timer.Dispose();

System.Reactive.Linq.Observable la clase es en PCL friendly Rx-Linq Paquete NuGet.