DataPortal.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="DataPortal.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>This is the client-side DataPortal.</summary>
//-----------------------------------------------------------------------
using System;
using System.ComponentModel;
using Csla.Reflection;
using Csla.Properties;
using Csla.Server;
using Csla.Serialization.Mobile;
using System.Threading.Tasks;
 
namespace Csla
{
  public static class DataPortal
  {
    public static event Action<System.Object> DataPortalInitInvoke;
 
    public static event Action<DataPortalEventArgs> DataPortalInvoke;
 
    public static event Action<DataPortalEventArgs> DataPortalInvokeComplete;
 
    internal static void OnDataPortalInitInvoke(object e)
    {
      DataPortalInitInvoke?.Invoke(e);
    }
 
    internal static void OnDataPortalInvoke(DataPortalEventArgs e)
    {
      DataPortalInvoke?.Invoke(e);
    }
 
    internal static void OnDataPortalInvokeComplete(DataPortalEventArgs e)
    {
      DataPortalInvokeComplete?.Invoke(e);
    }
 
    public static T Create<T>(params object[] criteria)
    {
      var dp = new DataPortal<T>();
      return dp.Create(criteria);
    }
 
    public static T Create<T>()
    {
      return Create<T>(EmptyCriteria.Instance);
    }
 
    public static object Create(Type objectType, object criteria)
    {
      return DataPortal<object>.Create(objectType, criteria);
    }
 
    [Obsolete]
    public static void BeginCreate<T>(EventHandler<DataPortalResult<T>> callback)
      where T : IMobileObject
    {
      BeginCreate<T>(EmptyCriteria.Instance, callback, null);
    }
 
    [Obsolete]
    public static void BeginCreate<T>(EventHandler<DataPortalResult<T>> callback, object userState)
      where T : IMobileObject
    {
      BeginCreate<T>(EmptyCriteria.Instance, callback, userState);
    }
 
    [Obsolete]
    public static void BeginCreate<T>(object criteria, EventHandler<DataPortalResult<T>> callback)
      where T : IMobileObject
    {
      BeginCreate<T>(criteria, callback, null);
    }
 
    [Obsolete]
    public static void BeginCreate<T>(object criteria, EventHandler<DataPortalResult<T>> callback, object userState)
      where T : IMobileObject
    {
      DataPortal<T> dp = new DataPortal<T>();
      dp.CreateCompleted += callback;
      dp.BeginCreate(criteria, userState);
    }
 
    public static async Task<T> CreateAsync<T>()
    {
      DataPortal<T> dp = new DataPortal<T>();
      return await dp.CreateAsync();
    }
 
    public static async Task<T> CreateAsync<T>(params object[] criteria)
    {
      DataPortal<T> dp = new DataPortal<T>();
      return await dp.CreateAsync(criteria);
    }
 
    public static T Fetch<T>(params object[] criteria)
    {
      var dp = new DataPortal<T>();
      return dp.Fetch(criteria);
    }
 
    public static T Fetch<T>()
    {
      return Fetch<T>(EmptyCriteria.Instance);
    }
 
    internal static object Fetch(Type objectType, object criteria)
    {
      return DataPortal<object>.Fetch(objectType, criteria);
    }
 
    [Obsolete]
    public static void BeginFetch<T>(EventHandler<DataPortalResult<T>> callback)
      where T : IMobileObject
    {
      BeginFetch<T>(EmptyCriteria.Instance, callback, null);
    }
 
    [Obsolete]
    public static void BeginFetch<T>(EventHandler<DataPortalResult<T>> callback, object userState)
      where T : IMobileObject
    {
      BeginFetch<T>(EmptyCriteria.Instance, callback, userState);
    }
 
    [Obsolete]
    public static void BeginFetch<T>(object criteria, EventHandler<DataPortalResult<T>> callback)
      where T : IMobileObject
    {
      BeginFetch<T>(criteria, callback, null);
    }
 
    [Obsolete]
    public static void BeginFetch<T>(object criteria, EventHandler<DataPortalResult<T>> callback, object userState)
      where T : IMobileObject
    {
      var dp = new DataPortal<T>();
      dp.FetchCompleted += callback;
      dp.BeginFetch(criteria, userState);
    }
 
    public static async Task<T> FetchAsync<T>()
      where T : IMobileObject
    {
      var dp = new DataPortal<T>();
      return await dp.FetchAsync();
    }
 
    public static async Task<T> FetchAsync<T>(params object[] criteria)
      where T : IMobileObject
    {
      var dp = new DataPortal<T>();
      return await dp.FetchAsync(criteria);
    }
 
    public static T Update<T>(T obj)
    {
      var dp = new DataPortal<T>();
      return dp.Update(obj);
    }
 
    [Obsolete]
    public static void BeginUpdate<T>(T obj, EventHandler<DataPortalResult<T>> callback)
      where T : IMobileObject
    {
      BeginUpdate<T>(obj, callback, null);
    }
 
    [Obsolete]
    public static void BeginUpdate<T>(T obj, EventHandler<DataPortalResult<T>> callback, object userState)
      where T : IMobileObject
    {
      DataPortal<T> dp = new DataPortal<T>();
      dp.UpdateCompleted += callback;
      dp.BeginUpdate(obj, userState);
    }
 
    public static async Task<T> UpdateAsync<T>(T obj)
      where T : IMobileObject
    {
      DataPortal<T> dp = new DataPortal<T>();
      return await dp.UpdateAsync(obj);
    }
 
    public static void Delete<T>(params object[] criteria)
    {
      var dp = new DataPortal<T>();
      dp.Delete(criteria);
    }
 
    internal static void Delete(Type objectType, object criteria)
    {
      DataPortal<object>.Delete(objectType, criteria);
    }
 
    [Obsolete]
    public static void BeginDelete<T>(object criteria, EventHandler<DataPortalResult<T>> callback)
      where T : IMobileObject
    {
      BeginDelete<T>(criteria, callback, null);
    }
 
    [Obsolete]
    public static void BeginDelete<T>(object criteria, EventHandler<DataPortalResult<T>> callback, object userState)
      where T : IMobileObject
    {
      var dp = new DataPortal<T>();
      dp.DeleteCompleted += callback;
      dp.BeginDelete(criteria, userState);
    }
 
    public static async Task DeleteAsync<T>(params object[] criteria)
      where T : IMobileObject
    {
      var dp = new DataPortal<T>();
      await dp.DeleteAsync(criteria);
    }
 
    public static T Execute<T>(T obj)
    {
      return Update(obj);
    }
 
    [Obsolete]
    public static void BeginExecute<T>(T obj, EventHandler<DataPortalResult<T>> callback) 
      where T : IMobileObject
    {
      BeginExecute<T>(obj, callback, null);
    }
 
    [Obsolete]
    public static void BeginExecute<T>(T obj, EventHandler<DataPortalResult<T>> callback, object userState) 
      where T : IMobileObject
    {
      var dp = new DataPortal<T>();
      dp.ExecuteCompleted += callback;
      dp.BeginExecute(obj, userState);
    }
 
    public static async Task<T> ExecuteAsync<T>(T command) 
      where T : IMobileObject
    {
      var dp = new DataPortal<T>();
      return await dp.ExecuteAsync(command);
    }
 
    public static T CreateChild<T>()
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      return (T)(portal.Create(typeof(T)));
    }
 
    public static T CreateChild<T>(params object[] parameters)
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      return (T)(portal.Create(typeof(T), parameters));
    }
 
    public static async Task<T> CreateChildAsync<T>()
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      return await portal.CreateAsync<T>();
    }
 
    public static async Task<T> CreateChildAsync<T>(params object[] parameters)
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      return await portal.CreateAsync<T>(parameters);
    }
 
    public static T FetchChild<T>()
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      return (T)(portal.Fetch(typeof(T)));
    }
 
    public static T FetchChild<T>(params object[] parameters)
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      return (T)(portal.Fetch(typeof(T), parameters));
    }
 
    public static async Task<T> FetchChildAsync<T>()
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      return await portal.FetchAsync<T>();
    }
 
    public static async Task<T> FetchChildAsync<T>(params object[] parameters)
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      return await portal.FetchAsync<T>(parameters);
    }
 
    public static void UpdateChild(object child)
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      portal.Update(child);
    }
 
    public static void UpdateChild(object child, params object[] parameters)
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      portal.Update(child, parameters);
    }
 
    public static async Task UpdateChildAsync(object child)
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      await portal.UpdateAsync(child).ConfigureAwait(false);
    }
 
    public static async Task UpdateChildAsync(object child, params object[] parameters)
    {
      Server.ChildDataPortal portal = new Server.ChildDataPortal();
      await portal.UpdateAsync(child, parameters).ConfigureAwait(false);
    }
 
    private static DataPortalClient.IDataPortalProxyFactory _dataProxyFactory;
 
    internal static void LoadDataPortalProxyFactory()
    {
      if (_dataProxyFactory == null)
      {
        if (String.IsNullOrEmpty(ApplicationContext.DataPortalProxyFactory) || ApplicationContext.DataPortalProxyFactory == "Default")
        {
          _dataProxyFactory = new DataPortalClient.DataPortalProxyFactory();
        }
        else
        {
          var proxyFactoryType = 
            Type.GetType(ApplicationContext.DataPortalProxyFactory) ?? 
            throw new InvalidOperationException(
              string.Format(Resources.UnableToLoadDataPortalProxyFactory, ApplicationContext.DataPortalProxyFactory));
 
          _dataProxyFactory = (DataPortalClient.IDataPortalProxyFactory)MethodCaller.CreateInstance(proxyFactoryType);
        }
      }
    }
 
    public static DataPortalClient.IDataPortalProxyFactory ProxyFactory
    {
      get
      {
        if (_dataProxyFactory == null)
          LoadDataPortalProxyFactory();
        return _dataProxyFactory;
      }
      set
      {
        _dataProxyFactory = value;
      }
    }
 
    public static string ProxyTypeName
    {
      get { return ApplicationContext.DataPortalProxy; }
      set { ApplicationContext.DataPortalProxy = value; }
    }
 
    public static void ResetProxyFactory()
    {
      _dataProxyFactory = null;
    }
 
    public static void ResetProxyType()
    {
      if (_dataProxyFactory != null)
      {
        _dataProxyFactory.ResetProxyType();
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Obsolete("Proxies no longer cached")]
    public static void ReleaseProxy()
    { }
  }
}