CslaDataProvider.cs

Go to the documentation of this file.

#if !XAMARIN && !WINDOWS_UWP
//-----------------------------------------------------------------------
// <copyright file="CslaDataProvider.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Wraps and creates a CSLA .NET-style object </summary>
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Windows.Data;
using System.Reflection;
using Csla.Reflection;
using Csla.Properties;
 
namespace Csla.Xaml
{
  public class CslaDataProvider : DataSourceProvider
  {
 
    public CslaDataProvider()
    {
      _commandManager = new CslaDataProviderCommandManager(this);
      _factoryParameters = new ObservableCollection<object>();
      _factoryParameters.CollectionChanged += 
        new System.Collections.Specialized.NotifyCollectionChangedEventHandler(_factoryParameters_CollectionChanged);
    }
 
    public event EventHandler<Csla.Core.SavedEventArgs> Saved;
    protected virtual void OnSaved(object newObject, Exception error, object userState)
    {
      if (Saved != null)
        Saved(this, new Csla.Core.SavedEventArgs(newObject, error, userState));
    }
 
    void _factoryParameters_CollectionChanged(
      object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
      BeginQuery();
    }
 
#region Properties
 
    private Type _objectType = null;
    private bool _manageLifetime;
    private string _factoryMethod = string.Empty;
    private ObservableCollection<object> _factoryParameters;
    private bool _isAsynchronous;
    private CslaDataProviderCommandManager _commandManager;
    private bool _isBusy;
 
    public CslaDataProviderCommandManager CommandManager
    {
      get
      {
        return _commandManager;
      }
    }
 
    public Type ObjectType
    {
      get 
      { 
        return _objectType; 
      }
      set 
      { 
        _objectType = value;
        OnPropertyChanged(new PropertyChangedEventArgs("ObjectType"));
      }
    }
 
    public bool ManageObjectLifetime
    {
      get
      {
        return _manageLifetime;
      }
      set
      {
        _manageLifetime = value;
        OnPropertyChanged(new PropertyChangedEventArgs("ManageObjectLifetime"));
      }
    }
 
    private object _dataChangedHandler;
 
    public object DataChangedHandler
    {
      get
      {
        return _dataChangedHandler;
      }
      set
      {
        _dataChangedHandler = value;
        var dialog = value as IErrorDialog;
        if (dialog != null)
          dialog.Register(this);
        OnPropertyChanged(new PropertyChangedEventArgs("DataChangedHandler"));
      }
    }
 
    public string FactoryMethod
    {
      get
      {
        return _factoryMethod;
      }
      set
      {
        _factoryMethod = value;
        OnPropertyChanged(new PropertyChangedEventArgs("FactoryMethod"));
      }
    }
 
    public IList FactoryParameters
    {
      get
      {
        return _factoryParameters;
      }
    }
 
    public bool IsAsynchronous
    {
      get { return _isAsynchronous; }
      set { _isAsynchronous = value; }
    }
 
    public object ObjectInstance
    {
      get { return Data; }
      set 
      {
        OnQueryFinished(value, null, null, null);
        OnPropertyChanged(new PropertyChangedEventArgs("ObjectInstance"));
      }
    }
 
    public bool IsBusy
    {
      get { return _isBusy; }
      protected set
      {
        _isBusy = value;
        OnPropertyChanged(new PropertyChangedEventArgs("IsBusy"));
      }
    }
 
    public void Rebind()
    {
      object tmp = ObjectInstance;
      ObjectInstance = null;
      ObjectInstance = tmp;
    }
 
#endregion
 
#region Query
 
    private bool _firstRun = true;
    private bool _init = false;
    private bool _endInitCompete = false;
    private bool _endInitError = false;
 
    protected override void BeginInit()
    {
      _init = true;
      base.BeginInit();
    }
 
    protected override void EndInit()
    {
      _init = false;
      base.EndInit();
      _endInitCompete = true;
    }
 
    protected override void BeginQuery()
    {
      if (_init)
        return;
 
      if (_firstRun)
      {
        _firstRun = false;
        if (!IsInitialLoadEnabled)
          return;
      }
 
      if (_endInitError)
      {
        // this handles a case where the WPF form initilizer
        // invokes the data provider twice when an exception
        // occurs - we really don't want to try the query twice
        // or report the error twice
        _endInitError = false;
        OnQueryFinished(null);
        return;
      }
 
      if (this.IsRefreshDeferred)
        return;
 
      QueryRequest request = new QueryRequest();
      request.ObjectType = _objectType;
      request.FactoryMethod = _factoryMethod;
      request.FactoryParameters = _factoryParameters;
      request.ManageObjectLifetime = _manageLifetime;
 
      IsBusy = true;
 
      if (IsAsynchronous)
        System.Threading.ThreadPool.QueueUserWorkItem(DoQuery, request);
      else
        DoQuery(request);
    }
 
    private void DoQuery(object state)
    {
      QueryRequest request = (QueryRequest)state;
      object result = null;
      Exception exceptionResult = null;
      object[] parameters = new List<object>(request.FactoryParameters).ToArray();
 
      try
      {
        // get factory method info
        BindingFlags flags = BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy;
        System.Reflection.MethodInfo factory = request.ObjectType.GetMethod(
          request.FactoryMethod, flags, null, 
          MethodCaller.GetParameterTypes(parameters), null);
 
        if (factory == null)
        {
          // strongly typed factory couldn't be found
          // so find one with the correct number of
          // parameters 
          int parameterCount = parameters.Length;
          System.Reflection.MethodInfo[] methods = request.ObjectType.GetMethods(flags);
          foreach (System.Reflection.MethodInfo method in methods)
            if (method.Name == request.FactoryMethod && method.GetParameters().Length == parameterCount)
            {
              factory = method;
              break;
            }
        }
 
        if (factory == null)
        {
          // no matching factory could be found
          // so throw exception
          throw new InvalidOperationException(
            string.Format(Resources.NoSuchFactoryMethod, request.FactoryMethod));
        }
 
        // invoke factory method
        try
        {
          result = factory.Invoke(null, parameters);
        }
        catch (Csla.DataPortalException ex)
        {
          exceptionResult = ex.BusinessException;
        }
        catch (System.Reflection.TargetInvocationException ex)
        {
          if (ex.InnerException != null)
          {
            exceptionResult = ex.InnerException;
            var dpe = exceptionResult as Csla.DataPortalException;
            if (dpe != null && dpe.BusinessException != null)
              exceptionResult = dpe.BusinessException;
          }
          else
            exceptionResult = ex;
        }
        catch (Exception ex)
        {
          exceptionResult = ex;
        }
      }
      catch (Exception ex)
      {
        exceptionResult = ex;
      }
 
      if (request.ManageObjectLifetime && result != null)
      {
        Csla.Core.ISupportUndo undo = result as Csla.Core.ISupportUndo;
        if (undo != null)
          undo.BeginEdit();
      }
 
      //if (!System.Windows.Application.Current.Dispatcher.CheckAccess())
      //  System.Windows.Application.Current.Dispatcher.Invoke(
      //    new Action(() => { IsBusy = false; }), 
      //    new object[] { });
 
      if (!_endInitCompete && exceptionResult != null)
        _endInitError = true;
 
      // return result to base class
      OnQueryFinished(result, exceptionResult, (o) => { IsBusy = false; return null; }, null);
    }
 
#region QueryRequest Class
 
    private class QueryRequest
    {
      private Type _objectType;
 
      public Type ObjectType
      {
        get { return _objectType; }
        set { _objectType = value; }
      }
 
      private string _factoryMethod;
 
      public string FactoryMethod
      {
        get { return _factoryMethod; }
        set { _factoryMethod = value; }
      }
 
      private ObservableCollection<object> _factoryParameters;
 
      public ObservableCollection<object> FactoryParameters
      {
        get { return _factoryParameters; }
        set { _factoryParameters = 
          new ObservableCollection<object>(new List<object>(value)); }
      }
      private bool _manageLifetime;
 
      public bool ManageObjectLifetime
      {
        get { return _manageLifetime; }
        set { _manageLifetime = value; }
      }
    
    }
 
#endregion
 
#endregion
 
#region Cancel/Update/New/Remove  
 
    public void Cancel()
    {
      Csla.Core.ISupportUndo undo = this.Data as Csla.Core.ISupportUndo;
      if (undo != null && _manageLifetime)
      {
        IsBusy = true;
        undo.CancelEdit();
        undo.BeginEdit();
        IsBusy = false;
      }
    }
 
    public void Save()
    {
      // only do something if the object implements
      // ISavable
      Csla.Core.ISavable savable = this.Data as Csla.Core.ISavable;
      if (savable != null)
      {
        object result = savable;
        Exception exceptionResult = null;
        try
        {
          IsBusy = true;
 
          // clone the object if possible
          ICloneable clonable = savable as ICloneable;
          if (clonable != null)
            savable = (Csla.Core.ISavable)clonable.Clone();
 
          // apply edits in memory
          Csla.Core.ISupportUndo undo = savable as Csla.Core.ISupportUndo;
          if (undo != null && _manageLifetime)
            undo.ApplyEdit();
 
 
          // save the clone
          result = savable.Save();
 
          if (!ReferenceEquals(savable, this.Data) && !Csla.ApplicationContext.AutoCloneOnUpdate)
          {
            // raise Saved event from original object
            Core.ISavable original = this.Data as Core.ISavable;
            if (original != null)
              original.SaveComplete(result);
          }
 
          // start editing the resulting object
          undo = result as Csla.Core.ISupportUndo;
          if (undo != null && _manageLifetime)
            undo.BeginEdit();
        }
        catch (Exception ex)
        {
          exceptionResult = ex;
        }
        // clear previous object
        OnQueryFinished(null, exceptionResult, null, null);
        // return result to base class
        OnQueryFinished(result, null, null, null);
        IsBusy = false;
        OnSaved(result, exceptionResult, null);
      }
    }
 
 
    public object AddNew()
    {
      // only do something if the object implements
      // IBindingList
      IBindingList list = this.Data as IBindingList;
      if (list != null && list.AllowNew)
        return list.AddNew();
      else
        return null;
 
    }
 
    public void RemoveItem(object sender, ExecuteEventArgs e)
    {
      var item = e.MethodParameter;
      // only do something if the object implements
      // IBindingList
      IBindingList list;
      Csla.Core.BusinessBase bb = item as Csla.Core.BusinessBase;
      if (bb != null)
        list = bb.Parent as IBindingList;
      else
        list = this.Data as IBindingList;
      if (list != null && list.AllowRemove)
        list.Remove(item);
    }
 
#endregion
 
  }
}
#endif