CancellableViewModel.cs

Go to the documentation of this file.

#if !XAMARIN && !WINDOWS_UWP
//-----------------------------------------------------------------------
// <copyright file="CancellableViewModel.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Base class used to create CancellableViewModel objects,</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
 
using Csla.Reflection;
 
namespace Csla.Xaml
{
  [Obsolete("Use ViewModelBase.RefreshAsync", false)]
  public abstract class CancellableViewModel<T> : ViewModel<T>
  {
    private CslaOperation<T> _lastOperation;
    private Action<CslaOperation<T>> _nextOperationExecutor = null;
 
    protected CancellableViewModel()
    {
      IsConcurentRefreshesAllowed = true;
    }
 
    public bool IsConcurentRefreshesAllowed { get; set; }
 
    [Obsolete("Use RefreshAsync", false)]
    protected new void BeginRefresh(Action<EventHandler<DataPortalResult<T>>> factoryMethod)
    {
      ExecuteOperation(operation => operation.Execute(factoryMethod));
    }
 
    [Obsolete("Use RefreshAsync", false)]
    protected override void BeginRefresh(string factoryMethod, params object[] factoryParameters)
    {
      ExecuteOperation(operation => operation.Execute(factoryMethod, factoryParameters));
    }
 
    [Obsolete("Use RefreshAsync", false)]
    public virtual void CancelRefresh()
    {
      _nextOperationExecutor = null;
      if (_lastOperation != null)
      {
        _lastOperation.Cancel();
      }
      IsBusy = false;
      Model = default(T);
      Error = null;
    }
 
    private void ExecuteOperation(Action<CslaOperation<T>> operationExecutor)
    {
      try
      {
        if (_lastOperation != null)
          _lastOperation.Cancel();
 
        if (!IsConcurentRefreshesAllowed && _lastOperation != null)
        {
          _nextOperationExecutor = operationExecutor;
          return;
        }
 
        Error = null;
        IsBusy = true;
 
        _lastOperation = new CslaOperation<T>(QueryCompleted);
        operationExecutor(_lastOperation);
      }
      catch (Exception ex)
      {
        Error = ex;
        IsBusy = false;
      }
    }
 
    private void QueryCompleted(DataPortalResult<T> result, bool isCanceled)
    {
      _lastOperation = null;
 
      if (!IsConcurentRefreshesAllowed && _nextOperationExecutor != null)
      {
        var executor = _nextOperationExecutor;
        _nextOperationExecutor = null;
        ExecuteOperation(executor);
        return;
      }
 
      if (isCanceled) return;
 
      try
      {
        if (result.Error == null)
        {
          OnRefreshing(result.Object);
          Model = result.Object;
        }
        else
          Error = result.Error;
        OnRefreshed();
      }
      finally
      {
        IsBusy = false;
      }
    }
  }
 
  internal class CslaOperation<T>
  {
    private readonly Action<DataPortalResult<T>, bool> _onCompletedQuery;
    private bool _isCanceled;
 
    public CslaOperation(Action<DataPortalResult<T>, bool> onCompletedQuery)
    {
      if (onCompletedQuery == null) throw new ArgumentNullException("onCompletedQuery");
 
      _onCompletedQuery = onCompletedQuery;
    }
 
    public void Cancel()
    {
      _isCanceled = true;
    }
 
    public void Execute(Action<EventHandler<DataPortalResult<T>>> factoryMethod)
    {
      EventHandler<DataPortalResult<T>> handler = (sender, result) => _onCompletedQuery(result, _isCanceled);
      factoryMethod(handler);
    }
 
    public void Execute(string factoryMethod, params object[] factoryParameters)
    {
      var parameters = new List<object>(factoryParameters) { CreateHandler() };
      MethodCaller.CallFactoryMethod(typeof(T), factoryMethod, parameters.ToArray());
    }
 
    private Delegate CreateHandler()
    {
      var args = typeof(DataPortalResult<>).MakeGenericType(typeof(T));
      System.Reflection.MethodInfo method = MethodCaller.GetNonPublicMethod(GetType(), "QueryCompleted");
      Delegate handler = Delegate.CreateDelegate(typeof(EventHandler<>).MakeGenericType(args), this, method);
      return handler;
    }
 
    private void QueryCompleted(object sender, EventArgs e)
    {
      DataPortalResult<T> result = (DataPortalResult<T>)e;
      _onCompletedQuery(result, _isCanceled);
    }
  }
}
#endif