ApplicationContext.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="ApplicationContext.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Provides consistent context information between the client</summary>
//-----------------------------------------------------------------------
using System;
using System.Security.Principal;
using Csla.Core;
using Csla.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System.Security.Claims;
 
namespace Csla
{
  public static class ApplicationContext
  {
    #region Context Manager
 
    private static IContextManager _contextManager;
 
    internal static void SettingsChanged()
    {
      _dataPortalReturnObjectOnExceptionSet = false;
      _propertyChangedModeSet = false;
      _transactionIsolationLevelSet = false;
      _defaultTransactionTimeoutInSecondsSet = false;
      _authenticationTypeName = null;
      _dataPortalActivator = null;
      _dataPortalUrl = null;
      _dataPortalProxyFactory = null;
      _dataPortalProxy = null;
      _VersionRoutingTag = null;
    }
 
    private static IContextManager _webContextManager;
    private static readonly Type _webManagerType;
 
    static ApplicationContext()
    {
      Type _contextManagerType = null;
      if (_contextManagerType == null)
        _contextManagerType = Type.GetType("Csla.Windows.ApplicationContextManager, Csla.Windows");
 
      if (_contextManagerType == null)
        _contextManagerType = Type.GetType("Csla.Xaml.ApplicationContextManager, Csla.Xaml");
 
      if (_contextManagerType != null)
        _contextManager = (IContextManager)Activator.CreateInstance(_contextManagerType);
 
      if (_contextManager == null)
        _contextManager = new ApplicationContextManager();
 
      if (_webManagerType == null)
      {
        _webManagerType = Type.GetType("Csla.Web.ApplicationContextManager, Csla.Web");
        if (_webManagerType != null)
          WebContextManager = (IContextManager)Activator.CreateInstance(_webManagerType);
      }
    }
 
    public static IContextManager WebContextManager
    {
      get { return _webContextManager; }
      set { _webContextManager = value; }
    }
 
    public static IContextManager ContextManager
    {
      get
      {
        if (WebContextManager != null && WebContextManager.IsValid)
          return WebContextManager;
        return _contextManager;
      }
      set { _contextManager = value; }
    }
 
    #endregion
 
    #region User
 
    public static ClaimsPrincipal Principal
    {
      get { return (ClaimsPrincipal)ContextManager.GetUser(); }
      set { ContextManager.SetUser(value); }
    }
 
    public static IPrincipal User
    {
      get { return ContextManager.GetUser(); }
      set { ContextManager.SetUser(value); }
    }
 
    #endregion
 
    #region LocalContext
 
    public static ContextDictionary LocalContext
    {
      get
      {
        ContextDictionary ctx = ContextManager.GetLocalContext();
        if (ctx == null)
        {
          ctx = new ContextDictionary();
          ContextManager.SetLocalContext(ctx);
        }
        return ctx;
      }
    }
 
    #endregion
 
    #region Client/Global Context
 
    private static readonly object _syncContext = new object();
 
    public static ContextDictionary ClientContext
    {
      get
      {
        lock (_syncContext)
        {
          ContextDictionary ctx = ContextManager.GetClientContext();
          if (ctx == null)
          {
            ctx = new ContextDictionary();
            ContextManager.SetClientContext(ctx);
          }
          return ctx;
        }
      }
    }
 
    [Obsolete("Use ClientContext", false)]
    public static ContextDictionary GlobalContext
    {
      get
      {
        ContextDictionary ctx = ContextManager.GetGlobalContext();
        if (ctx == null)
        {
          ctx = new ContextDictionary();
          ContextManager.SetGlobalContext(ctx);
        }
        return ctx;
      }
    }
 
    internal static void SetContext(
      ContextDictionary clientContext,
      ContextDictionary globalContext)
    {
      lock (_syncContext)
        ContextManager.SetClientContext(clientContext);
      ContextManager.SetGlobalContext(globalContext);
    }
 
    public static void Clear()
    {
      SetContext(null, null);
      ContextManager.SetLocalContext(null);
    }
 
    #endregion
 
    #region Settings
 
    public static bool IsOffline { get; set; }
 
    public static bool UseReflectionFallback { get; set; } = false;
 
    private static Csla.Server.IDataPortalActivator _dataPortalActivator = null;
    private static readonly object _dataPortalActivatorSync = new object();
 
    public static Csla.Server.IDataPortalActivator DataPortalActivator
    {
      get
      {
        if (_dataPortalActivator == null)
        {
          lock (_dataPortalActivatorSync)
          {
            if (_dataPortalActivator == null)
            {
              var typeName = ConfigurationManager.AppSettings["CslaDataPortalActivator"];
              if (!string.IsNullOrWhiteSpace(typeName))
              {
                var type = Type.GetType(typeName);
                _dataPortalActivator = (Csla.Server.IDataPortalActivator)Reflection.MethodCaller.CreateInstance(type);
              }
              else
              {
                _dataPortalActivator = new Csla.Server.DefaultDataPortalActivator();
              }
            }
          }
        }
        return _dataPortalActivator;
      }
      set
      {
        _dataPortalActivator = value;
      }
    }
 
    private static string _dataPortalUrl = null;
 
    public static string DataPortalUrlString
    {
      get
      {
        if (_dataPortalUrl == null)
        {
          _dataPortalUrl = ConfigurationManager.AppSettings["CslaDataPortalUrl"];
        }
        return _dataPortalUrl;
      }
      set
      {
        _dataPortalUrl = value;
      }
    }
 
    private static string _VersionRoutingTag = null;
 
    public static string VersionRoutingTag
    {
      get
      {
        if (string.IsNullOrWhiteSpace(_VersionRoutingTag))
          _VersionRoutingTag = ConfigurationManager.AppSettings["CslaVersionRoutingTag"];
        return _VersionRoutingTag;
      }
      internal set
      {
        if (!string.IsNullOrWhiteSpace(value))
          if (value.Contains("-") || value.Contains("/"))
            throw new ArgumentException("valueRoutingToken");
        _VersionRoutingTag = value;
      }
    }
 
    public static Uri DataPortalUrl
    {
      get { return new Uri(DataPortalUrlString); }
    }
 
    private static string _dataPortalProxyFactory;
    public static string DataPortalProxyFactory
    {
      get
      {
        if (string.IsNullOrEmpty(_dataPortalProxyFactory))
        {
          _dataPortalProxyFactory = ConfigurationManager.AppSettings["CslaDataPortalProxyFactory"];
          if (string.IsNullOrEmpty(_dataPortalProxyFactory))
            _dataPortalProxyFactory = "Default";
        }
        return _dataPortalProxyFactory;
      }
      set
      {
        _dataPortalProxyFactory = value;
        DataPortal.ResetProxyFactory();
      }
    }
 
    private static string _authenticationTypeName;
 
    public static string AuthenticationType
    {
      get
      {
        if (string.IsNullOrWhiteSpace(_authenticationTypeName))
          _authenticationTypeName = ConfigurationManager.AppSettings["CslaAuthentication"];
        if (string.IsNullOrWhiteSpace(_authenticationTypeName))
          _authenticationTypeName = "Csla";
        return _authenticationTypeName;
      }
      set { _authenticationTypeName = value; }
    }
 
    private static string _dataPortalProxy;
 
    public static string DataPortalProxy
    {
      get
      {
        if (string.IsNullOrEmpty(_dataPortalProxy))
          _dataPortalProxy = ConfigurationManager.AppSettings["CslaDataPortalProxy"];
        if (string.IsNullOrEmpty(_dataPortalProxy))
          _dataPortalProxy = "Local";
        return _dataPortalProxy;
      }
      set
      {
        _dataPortalProxy = value;
        DataPortal.ResetProxyType();
      }
    }
 
    public static bool AutoCloneOnUpdate
    {
      get
      {
        bool result = true;
        string setting = ConfigurationManager.AppSettings["CslaAutoCloneOnUpdate"];
        if (!string.IsNullOrEmpty(setting))
          result = bool.Parse(setting);
        return result;
      }
    }
 
    private static bool _dataPortalReturnObjectOnException = false;
    private static bool _dataPortalReturnObjectOnExceptionSet = false;
 
    public static bool DataPortalReturnObjectOnException
    {
      get
      {
        if (!_dataPortalReturnObjectOnExceptionSet)
        {
          string setting = ConfigurationManager.AppSettings["CslaDataPortalReturnObjectOnException"];
          if (!string.IsNullOrEmpty(setting))
            DataPortalReturnObjectOnException = bool.Parse(setting);
          _dataPortalReturnObjectOnExceptionSet = true;
        }
        return _dataPortalReturnObjectOnException;
      }
      set
      {
        _dataPortalReturnObjectOnException = value;
        _dataPortalReturnObjectOnExceptionSet = true;
      }
    }
 
    public enum ExecutionLocations
    {
      Client,
      Server
    }
 
    public static SerializationFormatters SerializationFormatter
    {
      get
      {
        var result = SerializationFormatters.CustomFormatter;
 
        string tmp = ConfigurationManager.AppSettings["CslaSerializationFormatter"];
        if (string.IsNullOrWhiteSpace(tmp))
#if NETSTANDARD2_0 || NET5_0
          tmp = "MobileFormatter";
#else
          tmp = "BinaryFormatter";
#endif
        if (Enum.TryParse(tmp, true, out SerializationFormatters serializationFormatter))
          result = serializationFormatter;
 
        return result;
      }
    }
 
    public enum SerializationFormatters
    {
#if !NETSTANDARD2_0 && !NET5_0
      NetDataContractSerializer,
#endif
      BinaryFormatter,
      CustomFormatter,
      MobileFormatter
    }
 
    private static PropertyChangedModes _propertyChangedMode = PropertyChangedModes.Xaml;
    private static bool _propertyChangedModeSet;
    public static PropertyChangedModes PropertyChangedMode
    {
      get
      {
        if (!_propertyChangedModeSet)
        {
          string tmp = ConfigurationManager.AppSettings["CslaPropertyChangedMode"];
          if (string.IsNullOrEmpty(tmp))
            tmp = "Xaml";
          _propertyChangedMode = (PropertyChangedModes)
            Enum.Parse(typeof(PropertyChangedModes), tmp);
          _propertyChangedModeSet = true;
        }
        return _propertyChangedMode;
      }
      set
      {
        _propertyChangedMode = value;
        _propertyChangedModeSet = true;
      }
    }
 
    public enum PropertyChangedModes
    {
      Windows,
      Xaml
    }
 
    private static ExecutionLocations _executionLocation =
#if (ANDROID || IOS || NETFX_CORE) && !NETSTANDARD
      ExecutionLocations.MobileClient;
#else
      ExecutionLocations.Client;
#endif
 
    public static ExecutionLocations ExecutionLocation
    {
      get { return _executionLocation; }
    }
 
    internal static void SetExecutionLocation(ExecutionLocations location)
    {
      _executionLocation = location;
    }
 
    public const string DefaultRuleSet = "default";
 
    public static string RuleSet
    {
      get
      {
        var ruleSet = (string)ClientContext.GetValueOrNull("__ruleSet");
        return string.IsNullOrEmpty(ruleSet) ? ApplicationContext.DefaultRuleSet : ruleSet;
      }
      set
      {
        ApplicationContext.ClientContext["__ruleSet"] = value;
      }
    }
 
    private static TransactionIsolationLevel _transactionIsolationLevel = TransactionIsolationLevel.Unspecified;
    private static bool _transactionIsolationLevelSet = false;
 
    public static TransactionIsolationLevel DefaultTransactionIsolationLevel
    {
      get
      {
        if (!_transactionIsolationLevelSet)
        {
          string tmp = ConfigurationManager.AppSettings["CslaDefaultTransactionIsolationLevel"];
          if (!string.IsNullOrEmpty(tmp))
          {
            _transactionIsolationLevel = (TransactionIsolationLevel)Enum.Parse(typeof(TransactionIsolationLevel), tmp);
          }
          _transactionIsolationLevelSet = true;
        }
        return _transactionIsolationLevel;
      }
      set
      {
        _transactionIsolationLevel = value;
        _transactionIsolationLevelSet = true;
      }
    }
 
    private static int _defaultTransactionTimeoutInSeconds = 600;
    private static bool _defaultTransactionTimeoutInSecondsSet = false;
 
    public static int DefaultTransactionTimeoutInSeconds
    {
      get
      {
        if (!_defaultTransactionTimeoutInSecondsSet)
        {
          var tmp = ConfigurationManager.AppSettings["CslaDefaultTransactionTimeoutInSeconds"];
          _defaultTransactionTimeoutInSeconds = string.IsNullOrEmpty(tmp) ? 30 : int.Parse(tmp);
          _defaultTransactionTimeoutInSecondsSet = true;
        }
        return _defaultTransactionTimeoutInSeconds;
      }
      set
      {
        _defaultTransactionTimeoutInSeconds = value;
        _defaultTransactionTimeoutInSecondsSet = true;
      }
    }
 
    private static System.Transactions.TransactionScopeAsyncFlowOption _defaultTransactionAsyncFlowOption;
    private static bool _defaultTransactionAsyncFlowOptionSet;
 
    public static System.Transactions.TransactionScopeAsyncFlowOption DefaultTransactionAsyncFlowOption
    {
      get
      {
        if (!_defaultTransactionAsyncFlowOptionSet)
        {
          _defaultTransactionAsyncFlowOptionSet = true;
          var tmp = ConfigurationManager.AppSettings["CslaDefaultTransactionAsyncFlowOption"];
          if (!Enum.TryParse<System.Transactions.TransactionScopeAsyncFlowOption>(tmp, out _defaultTransactionAsyncFlowOption))
            _defaultTransactionAsyncFlowOption = System.Transactions.TransactionScopeAsyncFlowOption.Suppress;
        }
        return _defaultTransactionAsyncFlowOption;
      }
      set
      {
        _defaultTransactionAsyncFlowOption = value;
        _defaultTransactionAsyncFlowOptionSet = true;
      }
    }
 
    #endregion
 
    #region Logical Execution Location
    public enum LogicalExecutionLocations
    {
      Client,
      Server
    }
 
    public static LogicalExecutionLocations LogicalExecutionLocation
    {
      get
      {
        object location = LocalContext.GetValueOrNull("__logicalExecutionLocation");
        if (location != null)
          return (LogicalExecutionLocations)location;
        else
          return LogicalExecutionLocations.Client;
      }
    }
 
    internal static void SetLogicalExecutionLocation(LogicalExecutionLocations location)
    {
      LocalContext["__logicalExecutionLocation"] = location;
    }
    #endregion
 
    #region ServiceProvider
 
    private static IServiceCollection _serviceCollection;
 
    internal static void SetServiceCollection(IServiceCollection serviceCollection)
    {
      _serviceCollection = serviceCollection;
    }
 
    public static IServiceProvider DefaultServiceProvider
    {
      internal get
      {
        var result = ContextManager.GetDefaultServiceProvider();
        if (result == null && _serviceCollection != null)
        {
          result = _serviceCollection.BuildServiceProvider();
          _serviceCollection = null;
          DefaultServiceProvider = result;
        }
        return result;
      }
      set => ContextManager.SetDefaultServiceProvider(value);
    }
 
#pragma warning disable CS3003 // Type is not CLS-compliant
    public static IServiceProvider CurrentServiceProvider
#pragma warning restore CS3003 // Type is not CLS-compliant
    {
      internal get
      {
        var result = ContextManager?.GetServiceProvider();
        if (result == null)
        {
          var def = DefaultServiceProvider;
          if (def != null)
          {
            result = CurrentServiceProvider = def.CreateScope().ServiceProvider;
          }
        }
        return result;
      }
      set => ContextManager.SetServiceProvider(value);
    }
 
    #endregion
  }
}