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 System.Security.Claims;
using Microsoft.Extensions.DependencyInjection;
using System.ComponentModel;
 
namespace Csla
{
  public class ApplicationContext
  {
    public ApplicationContext(ApplicationContextAccessor applicationContextAccessor)
    {
      ApplicationContextAccessor = applicationContextAccessor;
      ApplicationContextAccessor.GetContextManager().ApplicationContext = this;
    }
 
    internal ApplicationContextAccessor ApplicationContextAccessor { get; set; }
 
    public IContextManager ContextManager => ApplicationContextAccessor.GetContextManager();
 
    public ClaimsPrincipal Principal
    {
      get { return (ClaimsPrincipal)ContextManager.GetUser(); }
      set { ContextManager.SetUser(value); }
    }
 
    public IPrincipal User
    {
      get { return ContextManager.GetUser(); }
      set { ContextManager.SetUser(value); }
    }
 
    public ContextDictionary LocalContext
    {
      get
      {
        ContextDictionary ctx = ContextManager.GetLocalContext();
        if (ctx == null)
        {
          ctx = new ContextDictionary();
          ContextManager.SetLocalContext(ctx);
        }
        return ctx;
      }
    }
 
    private readonly object _syncContext = new();
 
    public ContextDictionary ClientContext
    {
      get
      {
        lock (_syncContext)
        {
          ContextDictionary ctx = ContextManager.GetClientContext(ExecutionLocation);
          if (ctx == null)
          {
            ctx = new ContextDictionary();
            ContextManager.SetClientContext(ctx, ExecutionLocation);
          }
          return ctx;
        }
      }
    }
 
    internal void SetContext(ContextDictionary clientContext)
    {
      lock (_syncContext)
        ContextManager.SetClientContext(clientContext, ExecutionLocation);
    }
 
    public void Clear()
    {
      SetContext(null);
      ContextManager.SetLocalContext(null);
    }
 
    #region Settings
 
    public bool IsOffline { get; set; }
 
    public static bool UseReflectionFallback { get; set; } = false;
 
    public static string VersionRoutingTag { get; internal set; }
 
    public static string AuthenticationType { get; internal set; } = "Csla";
 
    public static bool AutoCloneOnUpdate { get; internal set; } = true;
 
    public static bool DataPortalReturnObjectOnException { get; internal set; }
 
    public enum ExecutionLocations
    {
      Client,
      Server
    }
 
    public static Type SerializationFormatter { get; internal set; } = typeof(Serialization.Mobile.MobileFormatter);
 
    public static PropertyChangedModes PropertyChangedMode { get; set; }
 
    public enum PropertyChangedModes
    {
      Windows,
      Xaml
    }
 
    private ExecutionLocations _executionLocation =
#if (ANDROID || IOS || NETFX_CORE) && !NETSTANDARD
      ExecutionLocations.MobileClient;
#else
      ExecutionLocations.Client;
#endif
 
    public ExecutionLocations ExecutionLocation
    {
      get { return _executionLocation; }
    }
 
    internal void SetExecutionLocation(ExecutionLocations location)
    {
      _executionLocation = location;
    }
 
    public const string DefaultRuleSet = "default";
 
    public string RuleSet
    {
      get
      {
        var ruleSet = (string)ClientContext.GetValueOrNull("__ruleSet");
        return string.IsNullOrEmpty(ruleSet) ? ApplicationContext.DefaultRuleSet : ruleSet;
      }
      set
      {
        ClientContext["__ruleSet"] = value;
      }
    }
 
    public static TransactionIsolationLevel DefaultTransactionIsolationLevel { get; internal set; } = TransactionIsolationLevel.Unspecified;
 
    public static int DefaultTransactionTimeoutInSeconds { get; internal set; } = 30;
 
    public static System.Transactions.TransactionScopeAsyncFlowOption DefaultTransactionAsyncFlowOption
      { get; internal set; } = System.Transactions.TransactionScopeAsyncFlowOption.Suppress;
 
    #endregion
 
    #region Logical Execution Location
    public enum LogicalExecutionLocations
    {
      Client,
      Server
    }
 
    public LogicalExecutionLocations LogicalExecutionLocation
    {
      get
      {
        object location = LocalContext.GetValueOrNull("__logicalExecutionLocation");
        if (location != null)
          return (LogicalExecutionLocations)location;
        else
          return LogicalExecutionLocations.Client;
      }
    }
 
    internal void SetLogicalExecutionLocation(LogicalExecutionLocations location)
    {
      LocalContext["__logicalExecutionLocation"] = location;
    }
    #endregion
 
    public bool IsAStatefulContextManager => ContextManager.IsStatefulContext;
 
    internal IServiceProvider CurrentServiceProvider => ApplicationContextAccessor.ServiceProvider;
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public T CreateInstanceDI<T>(params object[] parameters)
    {
      return (T)CreateInstanceDI(typeof(T), parameters);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public T GetRequiredService<T>()
    {
      if (CurrentServiceProvider == null) 
        throw new NullReferenceException(nameof(CurrentServiceProvider));
 
      var result = CurrentServiceProvider.GetRequiredService<T>();
      return result;
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public object GetRequiredService(Type serviceType)
    {
      if (CurrentServiceProvider == null)
        throw new NullReferenceException(nameof(CurrentServiceProvider));
 
      return CurrentServiceProvider.GetRequiredService(serviceType);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public object CreateInstanceDI(Type objectType, params object[] parameters)
    {
      object result;
      if (CurrentServiceProvider != null)
          result = ActivatorUtilities.CreateInstance(CurrentServiceProvider, objectType, parameters);
      else
        result = Activator.CreateInstance(objectType, parameters);
      if (result is IUseApplicationContext tmp)
      {
        tmp.ApplicationContext = this;
      }
      return result;
    }
 
    internal object CreateGenericInstanceDI(Type type, params Type[] paramTypes)
    {
      var genericType = type.GetGenericTypeDefinition();
      var gt = genericType.MakeGenericType(paramTypes);
      return CreateInstanceDI(gt);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public T CreateInstance<T>(params object[] parameters)
    {
      return (T)CreateInstance(typeof(T), parameters);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public object CreateInstance(Type objectType, params object[] parameters)
    {
      object result;
      result = Activator.CreateInstance(objectType, parameters);
      if (result is IUseApplicationContext tmp)
      {
        tmp.ApplicationContext = this;
      }
      return result;
    }
 
    internal object CreateGenericInstance(Type type, params Type[] paramTypes)
    {
      var genericType = type.GetGenericTypeDefinition();
      var gt = genericType.MakeGenericType(paramTypes);
      return CreateInstance(gt);
    }
 
  }
}