WcfProxy.cs

Go to the documentation of this file.

#if !NETSTANDARD2_0 && !NET5_0
//-----------------------------------------------------------------------
// <copyright file="WcfProxy.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Implements a data portal proxy to relay data portal</summary>
//-----------------------------------------------------------------------
using System;
using System.ServiceModel;
using System.Threading.Tasks;
using Csla.Server;
using Csla.Server.Hosts.WcfChannel;
 
namespace Csla.DataPortalClient
{
  public class WcfProxy : IDataPortalProxy
  {
    private static System.ServiceModel.Channels.Binding _defaultBinding;
    private const int TimeoutInMinutes = 10;
    private static string _defaultEndPoint = "WcfDataPortal";
 
    public static System.ServiceModel.Channels.Binding DefaultBinding
    {
      get 
      {
        if (_defaultBinding == null)
        {
          _defaultBinding = new WSHttpBinding();
          WSHttpBinding binding = (WSHttpBinding)_defaultBinding;
          binding.MaxReceivedMessageSize = int.MaxValue;
          binding.ReaderQuotas = new System.Xml.XmlDictionaryReaderQuotas()
          {
            MaxBytesPerRead = int.MaxValue,
            MaxDepth = int.MaxValue,
            MaxArrayLength = int.MaxValue,
            MaxStringContentLength = int.MaxValue,
            MaxNameTableCharCount = int.MaxValue
          };
 
          binding.ReceiveTimeout = TimeSpan.FromMinutes(TimeoutInMinutes);
          binding.SendTimeout = TimeSpan.FromMinutes(TimeoutInMinutes);
          binding.OpenTimeout = TimeSpan.FromMinutes(TimeoutInMinutes);
        } 
        return _defaultBinding; 
      }
      set { _defaultBinding = value; }
    }
 
    public static string DefaultUrl
    {
      get { return ApplicationContext.DataPortalUrlString; }
      set { ApplicationContext.DataPortalUrlString = value; }
    }
 
    public static string DefaultEndPoint
    {
      get { return _defaultEndPoint; }
      set { _defaultEndPoint = value; }
    }
 
    public WcfProxy()
    {
      this.DataPortalUrl = WcfProxy.DefaultUrl;
      this.Binding = WcfProxy.DefaultBinding;
      this.EndPoint = WcfProxy.DefaultEndPoint;
    }
 
    public WcfProxy(string dataPortalUrl)
    {
      this.DataPortalUrl = dataPortalUrl;
      this.Binding = WcfProxy.DefaultBinding;
      this.EndPoint = WcfProxy.DefaultEndPoint;
    }
    
    public bool IsServerRemote
    {
      get { return true; }
    }
 
    public System.ServiceModel.Channels.Binding Binding { get; protected set; }
 
    public string DataPortalUrl { get; protected set; }
 
    public string EndPoint { get; protected set; }
 
    protected virtual ChannelFactory<IWcfPortal> GetChannelFactory()
    {
      if (!string.IsNullOrEmpty(ApplicationContext.DataPortalUrlString))
        return new ChannelFactory<IWcfPortal>(Binding, new EndpointAddress(ApplicationContext.DataPortalUrl));
      else
        return new ChannelFactory<IWcfPortal>(EndPoint);
    }
 
    protected virtual IWcfPortal GetProxy(ChannelFactory<IWcfPortal> cf)
    {
      return cf.CreateChannel();
    }
 
    public async Task<DataPortalResult> Create(Type objectType, object criteria, DataPortalContext context, bool isSync)
    {
      ChannelFactory<IWcfPortal> cf = GetChannelFactory();
      var proxy = GetProxy(cf);
      WcfResponse response = null;
      try
      {
        var request = new CreateRequest(objectType, criteria, context);
        if (isSync)
          response = proxy.Create(request);
        else
          response = await proxy.CreateAsync(request);
        if (cf != null)
          cf.Close();
      }
      catch
      {
        cf.Abort();
        throw;
      }
      object result = response.Result;
      if (result is Exception)
        throw (Exception)result;
      return (DataPortalResult)result;
    }
 
#pragma warning disable 1998
    public async Task<DataPortalResult> Fetch(Type objectType, object criteria, DataPortalContext context, bool isSync)
#pragma warning restore 1998
    {
      ChannelFactory<IWcfPortal> cf = GetChannelFactory();
      var proxy = GetProxy(cf);
      WcfResponse response = null;
      try
      {
        var request = new FetchRequest(objectType, criteria, context);
        if (isSync)
          response = proxy.Fetch(request);
        else
          response = await proxy.FetchAsync(request);
        if (cf != null)
          cf.Close();
      }
      catch
      {
        cf.Abort();
        throw;
      }
      object result = response.Result;
      if (result is Exception)
        throw (Exception)result;
      return (DataPortalResult)result;
    }
 
#pragma warning disable 1998
    public async Task<DataPortalResult> Update(object obj, DataPortalContext context, bool isSync)
#pragma warning restore 1998
    {
      ChannelFactory<IWcfPortal> cf = GetChannelFactory();
      var proxy = GetProxy(cf);
      WcfResponse response = null;
      try
      {
        var request = new UpdateRequest(obj, context);
        if (isSync)
          response = proxy.Update(request);
        else
          response = await proxy.UpdateAsync(request);
        if (cf != null)
          cf.Close();
      }
      catch
      {
        cf.Abort();
        throw;
      }
      object result = response.Result;
      if (result is Exception)
        throw (Exception)result;
      return (DataPortalResult)result;
    }
 
#pragma warning disable 1998
    public async Task<DataPortalResult> Delete(Type objectType, object criteria, DataPortalContext context, bool isSync)
#pragma warning restore 1998
    {
      ChannelFactory<IWcfPortal> cf = GetChannelFactory();
      var proxy = GetProxy(cf);
      WcfResponse response = null;
      try
      {
        var request = new DeleteRequest(objectType, criteria, context);
        if (isSync)
          response = proxy.Delete(request);
        else
          response = await proxy.DeleteAsync(request);
        if (cf != null)
          cf.Close();
      }
      catch
      {
        cf.Abort();
        throw;
      }
      object result = response.Result;
      if (result is Exception)
        throw (Exception)result;
      return (DataPortalResult)result;
    }
  }
}
#endif