public override object SetHostExecutionContext(HostExecutionContext hostExecutionContext)
{
var castHostExecutionContext = hostExecutionContext as DnxHostExecutionContext;
if (castHostExecutionContext != null)
{
object baseRevertParameter = null;
if (castHostExecutionContext.BaseContext != null)
{
baseRevertParameter = base.SetHostExecutionContext(castHostExecutionContext.BaseContext);
}
// Capture the current status of the thread context and then update the values
// The captured snapshot will be used to revert the status later
var originalThreadContext = castHostExecutionContext.ThreadContext.CaptureAndReplace(Thread.CurrentThread);
return (RevertAction)(() =>
{
originalThreadContext.CaptureAndReplace(Thread.CurrentThread);
if (baseRevertParameter != null)
{
base.Revert(baseRevertParameter);
}
});
}
else
{
return base.SetHostExecutionContext(hostExecutionContext);
}
}
internal static ExecutionContextSwitcher SetExecutionContext(ExecutionContext executionContext)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
BCLDebug.Assert(executionContext != null, "ExecutionContext cannot be null here.");
// Set up the switcher object to return;
ExecutionContextSwitcher ecsw = new ExecutionContextSwitcher();
ecsw.thread = Thread.CurrentThread;
ecsw.prevEC = Thread.CurrentThread.GetExecutionContextNoCreate(); // prev
ecsw.currEC = executionContext; //current
// Update the EC on thread
Thread.CurrentThread.SetExecutionContext(executionContext);
RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (executionContext != null)
{
//set the security context
SecurityContext sc = executionContext.SecurityContext;
if (sc != null)
{
// non-null SC: needs to be set
SecurityContext prevSeC = (ecsw.prevEC != null) ? ecsw.prevEC.SecurityContext : null;
ecsw.scsw = SecurityContext.SetSecurityContext(sc, prevSeC, ref stackMark);
}
else if (!SecurityContext.CurrentlyInDefaultFTSecurityContext(ecsw.prevEC))
{
// null incoming SC, but we're currently not in FT: use static FTSC to set
SecurityContext prevSeC = (ecsw.prevEC != null) ? ecsw.prevEC.SecurityContext : null;
ecsw.scsw = SecurityContext.SetSecurityContext(SecurityContext.FullTrustSecurityContext, prevSeC, ref stackMark);
}
// set the sync context
SynchronizationContext syncContext = executionContext.SynchronizationContext;
if (syncContext != null)
{
SynchronizationContext prevSyC = (ecsw.prevEC != null) ? ecsw.prevEC.SynchronizationContext : null;
ecsw.sysw = SynchronizationContext.SetSynchronizationContext(syncContext, prevSyC);
}
// set the Host Context
HostExecutionContext hostContext = executionContext.HostExecutionContext;
if (hostContext != null)
{
ecsw.hecsw = HostExecutionContextManager.SetHostExecutionContextInternal(hostContext);
}
}
}
catch
{
ecsw.UndoNoThrow();
throw;
}
return(ecsw);
}
public virtual void Revert(object previousState)
{
HostExecutionContextSwitcher switcher = previousState as HostExecutionContextSwitcher;
if (switcher == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotOverrideSetWithoutRevert"));
}
ExecutionContext executionContext = Thread.CurrentThread.ExecutionContext;
if (executionContext != switcher.executionContext)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseSwitcherOtherThread"));
}
switcher.executionContext = null;
if (executionContext.HostExecutionContext != switcher.currentHostContext)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseSwitcherOtherThread"));
}
HostExecutionContext previousHostContext = switcher.previousHostContext;
if ((CheckIfHosted() && (previousHostContext != null)) && (previousHostContext.State is IUnknownSafeHandle))
{
IUnknownSafeHandle state = (IUnknownSafeHandle)previousHostContext.State;
SetHostSecurityContext(state, false, null);
}
executionContext.HostExecutionContext = previousHostContext;
}
public virtual void Revert(object previousState)
{
HostExecutionContextSwitcher executionContextSwitcher = previousState as HostExecutionContextSwitcher;
if (executionContextSwitcher == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotOverrideSetWithoutRevert"));
}
ExecutionContext executionContext1 = Thread.CurrentThread.GetMutableExecutionContext();
ExecutionContext executionContext2 = executionContextSwitcher.executionContext;
if (executionContext1 != executionContext2)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseSwitcherOtherThread"));
}
executionContextSwitcher.executionContext = (ExecutionContext)null;
if (executionContext1.HostExecutionContext != executionContextSwitcher.currentHostContext)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseSwitcherOtherThread"));
}
HostExecutionContext executionContext3 = executionContextSwitcher.previousHostContext;
if (HostExecutionContextManager.CheckIfHosted() && executionContext3 != null && executionContext3.State is IUnknownSafeHandle)
{
HostExecutionContextManager.SetHostSecurityContext((SafeHandle)executionContext3.State, false, (SafeHandle)null);
}
HostExecutionContext executionContext4 = executionContext3;
executionContext1.HostExecutionContext = executionContext4;
}
public virtual void Revert(object previousState)
{
HostExecutionContextSwitcher hostExecutionContextSwitcher = previousState as HostExecutionContextSwitcher;
if (hostExecutionContextSwitcher == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotOverrideSetWithoutRevert"));
}
ExecutionContext mutableExecutionContext = Thread.CurrentThread.GetMutableExecutionContext();
if (mutableExecutionContext != hostExecutionContextSwitcher.executionContext)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseSwitcherOtherThread"));
}
hostExecutionContextSwitcher.executionContext = null;
HostExecutionContext hostExecutionContext = mutableExecutionContext.HostExecutionContext;
if (hostExecutionContext != hostExecutionContextSwitcher.currentHostContext)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseSwitcherOtherThread"));
}
HostExecutionContext previousHostContext = hostExecutionContextSwitcher.previousHostContext;
if (HostExecutionContextManager.CheckIfHosted() && previousHostContext != null && previousHostContext.State is IUnknownSafeHandle)
{
IUnknownSafeHandle context = (IUnknownSafeHandle)previousHostContext.State;
HostExecutionContextManager.SetHostSecurityContext(context, false, null);
}
mutableExecutionContext.HostExecutionContext = previousHostContext;
}
internal static HostExecutionContext CaptureHostExecutionContext()
{
HostExecutionContext result = null;
HostExecutionContextManager currentHostExecutionContextManager = HostExecutionContextManager.GetCurrentHostExecutionContextManager();
if (currentHostExecutionContextManager != null)
{
result = currentHostExecutionContextManager.Capture();
}
return(result);
}
internal static object SetHostExecutionContextInternal(HostExecutionContext hostContext)
{
HostExecutionContextManager currentHostExecutionContextManager = GetCurrentHostExecutionContextManager();
object obj2 = null;
if (currentHostExecutionContextManager != null)
{
obj2 = currentHostExecutionContextManager.SetHostExecutionContext(hostContext);
}
return(obj2);
}
internal static HostExecutionContext CaptureHostExecutionContext()
{
HostExecutionContext context = null;
HostExecutionContextManager currentHostExecutionContextManager = GetCurrentHostExecutionContextManager();
if (currentHostExecutionContextManager != null)
{
context = currentHostExecutionContextManager.Capture();
}
return(context);
}
public virtual HostExecutionContext Capture()
{
HostExecutionContext context = null;
if (CheckIfHosted())
{
IUnknownSafeHandle state = new IUnknownSafeHandle();
context = new HostExecutionContext(state);
CaptureHostSecurityContext(state);
}
return context;
}
internal static object SetHostExecutionContextInternal(HostExecutionContext hostContext)
{
HostExecutionContextManager executionContextManager = HostExecutionContextManager.GetCurrentHostExecutionContextManager();
object obj = (object)null;
if (executionContextManager != null)
{
obj = executionContextManager.SetHostExecutionContext(hostContext);
}
return(obj);
}
internal static HostExecutionContext CaptureHostExecutionContext()
{
HostExecutionContext executionContext = (HostExecutionContext)null;
HostExecutionContextManager executionContextManager = HostExecutionContextManager.GetCurrentHostExecutionContextManager();
if (executionContextManager != null)
{
executionContext = executionContextManager.Capture();
}
return(executionContext);
}
internal static object SetHostExecutionContextInternal(HostExecutionContext hostContext)
{
HostExecutionContextManager currentHostExecutionContextManager = HostExecutionContextManager.GetCurrentHostExecutionContextManager();
object result = null;
if (currentHostExecutionContextManager != null)
{
result = currentHostExecutionContextManager.SetHostExecutionContext(hostContext);
}
return(result);
}
internal static Object SetHostExecutionContextInternal(HostExecutionContext hostContext)
{
HostExecutionContextManager hostMgr = HostExecutionContextManager.GetCurrentHostExecutionContextManager();
Object switcher = null;
if (hostMgr != null)
{
switcher = hostMgr.SetHostExecutionContext(hostContext);
}
return(switcher);
}
public virtual HostExecutionContext Capture()
{
HostExecutionContext executionContext = (HostExecutionContext)null;
if (HostExecutionContextManager.CheckIfHosted())
{
IUnknownSafeHandle iunknownSafeHandle = new IUnknownSafeHandle();
executionContext = new HostExecutionContext((object)iunknownSafeHandle);
HostExecutionContextManager.CaptureHostSecurityContext((SafeHandle)iunknownSafeHandle);
}
return(executionContext);
}
public virtual HostExecutionContext Capture()
{
HostExecutionContext result = null;
if (HostExecutionContextManager.CheckIfHosted())
{
IUnknownSafeHandle unknownSafeHandle = new IUnknownSafeHandle();
result = new HostExecutionContext(unknownSafeHandle);
HostExecutionContextManager.CaptureHostSecurityContext(unknownSafeHandle);
}
return(result);
}
internal static HostExecutionContext CaptureHostExecutionContext()
{
HostExecutionContext hostContext = null;
// capture the host execution context
HostExecutionContextManager hostMgr = HostExecutionContextManager.GetCurrentHostExecutionContextManager();
if (hostMgr != null)
{
hostContext = hostMgr.Capture();
}
return(hostContext);
}
public virtual HostExecutionContext Capture()
{
HostExecutionContext context = null;
if (CheckIfHosted())
{
IUnknownSafeHandle state = new IUnknownSafeHandle();
context = new HostExecutionContext(state);
CaptureHostSecurityContext(state);
}
return(context);
}
internal static ExecutionContext Capture(ref StackCrawlMark stackMark, ExecutionContext.CaptureOptions options)
{
ExecutionContext.Reader executionContextReader = Thread.CurrentThread.GetExecutionContextReader();
if (executionContextReader.IsFlowSuppressed)
{
return((ExecutionContext)null);
}
SecurityContext securityContext = SecurityContext.Capture(executionContextReader, ref stackMark);
HostExecutionContext executionContext1 = HostExecutionContextManager.CaptureHostExecutionContext();
SynchronizationContext synchronizationContext = (SynchronizationContext)null;
LogicalCallContext logicalCallContext = (LogicalCallContext)null;
if (!executionContextReader.IsNull)
{
if ((options & ExecutionContext.CaptureOptions.IgnoreSyncCtx) == ExecutionContext.CaptureOptions.None)
{
synchronizationContext = executionContextReader.SynchronizationContext == null ? (SynchronizationContext)null : executionContextReader.SynchronizationContext.CreateCopy();
}
if (executionContextReader.LogicalCallContext.HasInfo)
{
logicalCallContext = executionContextReader.LogicalCallContext.Clone();
}
}
Dictionary <IAsyncLocal, object> dictionary = (Dictionary <IAsyncLocal, object>)null;
List <IAsyncLocal> asyncLocalList = (List <IAsyncLocal>)null;
if (!executionContextReader.IsNull)
{
dictionary = executionContextReader.DangerousGetRawExecutionContext()._localValues;
asyncLocalList = executionContextReader.DangerousGetRawExecutionContext()._localChangeNotifications;
}
if ((options & ExecutionContext.CaptureOptions.OptimizeDefaultCase) != ExecutionContext.CaptureOptions.None && securityContext == null && (executionContext1 == null && synchronizationContext == null) && ((logicalCallContext == null || !logicalCallContext.HasInfo) && (dictionary == null && asyncLocalList == null)))
{
return(ExecutionContext.s_dummyDefaultEC);
}
ExecutionContext executionContext2 = new ExecutionContext();
executionContext2.SecurityContext = securityContext;
if (executionContext2.SecurityContext != null)
{
executionContext2.SecurityContext.ExecutionContext = executionContext2;
}
executionContext2._hostExecutionContext = executionContext1;
executionContext2._syncContext = synchronizationContext;
executionContext2.LogicalCallContext = logicalCallContext;
executionContext2._localValues = dictionary;
executionContext2._localChangeNotifications = asyncLocalList;
executionContext2.isNewCapture = true;
return(executionContext2);
}
internal static ExecutionContext Capture(ref StackCrawlMark stackMark, ExecutionContext.CaptureOptions options)
{
ExecutionContext.Reader executionContextReader = Thread.CurrentThread.GetExecutionContextReader();
if (executionContextReader.IsFlowSuppressed)
{
return(null);
}
SecurityContext securityContext = SecurityContext.Capture(executionContextReader, ref stackMark);
HostExecutionContext hostExecutionContext = HostExecutionContextManager.CaptureHostExecutionContext();
SynchronizationContext synchronizationContext = null;
LogicalCallContext logicalCallContext = null;
if (!executionContextReader.IsNull)
{
if ((options & ExecutionContext.CaptureOptions.IgnoreSyncCtx) == ExecutionContext.CaptureOptions.None)
{
synchronizationContext = ((executionContextReader.SynchronizationContext == null) ? null : executionContextReader.SynchronizationContext.CreateCopy());
}
if (executionContextReader.LogicalCallContext.HasInfo)
{
logicalCallContext = executionContextReader.LogicalCallContext.Clone();
}
}
IAsyncLocalValueMap asyncLocalValueMap = null;
IAsyncLocal[] array = null;
if (!executionContextReader.IsNull)
{
asyncLocalValueMap = executionContextReader.DangerousGetRawExecutionContext()._localValues;
array = executionContextReader.DangerousGetRawExecutionContext()._localChangeNotifications;
}
if ((options & ExecutionContext.CaptureOptions.OptimizeDefaultCase) != ExecutionContext.CaptureOptions.None && securityContext == null && hostExecutionContext == null && synchronizationContext == null && (logicalCallContext == null || !logicalCallContext.HasInfo) && asyncLocalValueMap == null && array == null)
{
return(ExecutionContext.s_dummyDefaultEC);
}
ExecutionContext executionContext = new ExecutionContext();
executionContext.SecurityContext = securityContext;
if (executionContext.SecurityContext != null)
{
executionContext.SecurityContext.ExecutionContext = executionContext;
}
executionContext._hostExecutionContext = hostExecutionContext;
executionContext._syncContext = synchronizationContext;
executionContext.LogicalCallContext = logicalCallContext;
executionContext._localValues = asyncLocalValueMap;
executionContext._localChangeNotifications = array;
executionContext.isNewCapture = true;
return(executionContext);
}
[System.Security.SecuritySafeCritical] // auto-generated
public virtual HostExecutionContext Capture()
{
HostExecutionContext context = null;
// check if we are hosted
if (CheckIfHosted())
{
IUnknownSafeHandle unkSafeHandle = new IUnknownSafeHandle();
context = new HostExecutionContext(unkSafeHandle);
// call into the Hosting API to capture the host context
// stores the output IUnknown in the safehandle,
CaptureHostSecurityContext(unkSafeHandle);
}
// otherwise
return(context);
}
internal static ExecutionContextSwitcher SetExecutionContext(ExecutionContext executionContext, bool preserveSyncCtx)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
ExecutionContextSwitcher executionContextSwitcher = new ExecutionContextSwitcher();
Thread currentThread = Thread.CurrentThread;
ExecutionContext.Reader executionContextReader = currentThread.GetExecutionContextReader();
executionContextSwitcher.thread = currentThread;
executionContextSwitcher.outerEC = executionContextReader;
executionContextSwitcher.outerECBelongsToScope = currentThread.ExecutionContextBelongsToCurrentScope;
if (preserveSyncCtx)
{
executionContext.SynchronizationContext = executionContextReader.SynchronizationContext;
}
executionContext.SynchronizationContextNoFlow = executionContextReader.SynchronizationContextNoFlow;
currentThread.SetExecutionContext(executionContext, true);
RuntimeHelpers.PrepareConstrainedRegions();
try
{
ExecutionContext.OnAsyncLocalContextChanged(executionContextReader.DangerousGetRawExecutionContext(), executionContext);
SecurityContext securityContext1 = executionContext.SecurityContext;
if (securityContext1 != null)
{
SecurityContext.Reader securityContext2 = executionContextReader.SecurityContext;
executionContextSwitcher.scsw = SecurityContext.SetSecurityContext(securityContext1, securityContext2, false, ref stackMark);
}
else if (!SecurityContext.CurrentlyInDefaultFTSecurityContext(executionContextSwitcher.outerEC))
{
SecurityContext.Reader securityContext2 = executionContextReader.SecurityContext;
executionContextSwitcher.scsw = SecurityContext.SetSecurityContext(SecurityContext.FullTrustSecurityContext, securityContext2, false, ref stackMark);
}
HostExecutionContext executionContext1 = executionContext.HostExecutionContext;
if (executionContext1 != null)
{
executionContextSwitcher.hecsw = HostExecutionContextManager.SetHostExecutionContextInternal(executionContext1);
}
}
catch
{
executionContextSwitcher.UndoNoThrow();
throw;
}
return(executionContextSwitcher);
}
public virtual void Revert(Object previousState)
{
HostExecutionContextSwitcher hostContextSwitcher = previousState as HostExecutionContextSwitcher;
if (hostContextSwitcher == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotOverrideSetWithoutRevert"));
}
// check Undo is happening on the correct thread
ExecutionContext executionContext = Thread.CurrentThread.GetMutableExecutionContext();
if (executionContext != hostContextSwitcher.executionContext)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseSwitcherOtherThread"));
}
hostContextSwitcher.executionContext = null; // Make sure switcher cannot be re-used.
HostExecutionContext revertFromHostContext = executionContext.HostExecutionContext;
// if the current host context is not the same as the one in the switcher, then revert is being called out of order
if (revertFromHostContext != hostContextSwitcher.currentHostContext)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseSwitcherOtherThread"));
}
// get the previous host context
HostExecutionContext revertToHostContext = hostContextSwitcher.previousHostContext;
// now check if we are hosted and revert the context in the host
if (CheckIfHosted())
{
// try restore the previous context as the current context
if (revertToHostContext != null && revertToHostContext.State is IUnknownSafeHandle)
{
IUnknownSafeHandle unkprevSafeHandle = (IUnknownSafeHandle)revertToHostContext.State;
// call into the Hosting API to set the host context
SetHostSecurityContext(unkprevSafeHandle, false, null);
}
}
//restore the previous host context in the executioncontext
executionContext.HostExecutionContext = revertToHostContext;
}
public virtual object SetHostExecutionContext(HostExecutionContext hostExecutionContext)
{
if (hostExecutionContext == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext"));
}
HostExecutionContextSwitcher executionContextSwitcher = new HostExecutionContextSwitcher();
ExecutionContext executionContext = Thread.CurrentThread.GetMutableExecutionContext();
executionContextSwitcher.executionContext = executionContext;
executionContextSwitcher.currentHostContext = hostExecutionContext;
executionContextSwitcher.previousHostContext = (HostExecutionContext)null;
if (HostExecutionContextManager.CheckIfHosted() && hostExecutionContext.State is IUnknownSafeHandle)
{
IUnknownSafeHandle iunknownSafeHandle = new IUnknownSafeHandle();
executionContextSwitcher.previousHostContext = new HostExecutionContext((object)iunknownSafeHandle);
HostExecutionContextManager.SetHostSecurityContext((SafeHandle)hostExecutionContext.State, true, (SafeHandle)iunknownSafeHandle);
}
executionContext.HostExecutionContext = hostExecutionContext;
return((object)executionContextSwitcher);
}
public override object SetHostExecutionContext(HostExecutionContext hostExecutionContext) {
AspNetHostExecutionContext castHostExecutionContext = hostExecutionContext as AspNetHostExecutionContext;
if (castHostExecutionContext != null) {
// Call base.SetHostExecutionContext before calling our own logic.
object baseRevertParameter = null;
if (castHostExecutionContext.BaseContext != null) {
baseRevertParameter = base.SetHostExecutionContext(castHostExecutionContext.BaseContext);
}
ThreadContext currentContext = ThreadContext.Current;
if (currentContext != null && currentContext.HttpContext.ThreadContextId == castHostExecutionContext.HttpContextThreadContextId) {
// If we reached this point, then 'castHostExecutionContext' was captured for the HttpContext
// that is associated with the ThreadContext that is assigned to the current thread. We can
// safely restore it.
Action threadContextCleanupAction = currentContext.EnterExecutionContext();
// Perform cleanup in the opposite order from initialization.
return (RevertAction)(() => {
threadContextCleanupAction();
if (baseRevertParameter != null) {
base.Revert(baseRevertParameter);
}
});
}
else {
// If we reached this point, then 'castHostExecutionContext' was captured by us
// but is not applicable to the current thread. This can happen if the developer
// called ThreadPool.QueueUserWorkItem, for example. We don't restore HttpContext
// on such threads since they're not under the control of ASP.NET. In this case,
// we have already called base.SetHostExecutionContext, so we just need to return
// the result of that function directly to our caller.
return baseRevertParameter;
}
}
else {
// If we reached this point, then 'hostExecutionContext' was generated by our
// base class instead of by us, so just delegate to the base implementation.
return base.SetHostExecutionContext(hostExecutionContext);
}
}
public virtual object SetHostExecutionContext(HostExecutionContext hostExecutionContext)
{
if (hostExecutionContext == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext"));
}
HostExecutionContextSwitcher switcher = new HostExecutionContextSwitcher();
ExecutionContext executionContext = Thread.CurrentThread.ExecutionContext;
switcher.executionContext = executionContext;
switcher.currentHostContext = hostExecutionContext;
switcher.previousHostContext = null;
if (CheckIfHosted() && (hostExecutionContext.State is IUnknownSafeHandle))
{
IUnknownSafeHandle state = new IUnknownSafeHandle();
switcher.previousHostContext = new HostExecutionContext(state);
IUnknownSafeHandle context = (IUnknownSafeHandle)hostExecutionContext.State;
SetHostSecurityContext(context, true, state);
}
executionContext.HostExecutionContext = hostExecutionContext;
return(switcher);
}
[System.Security.SecurityCritical] // auto-generated_required
public virtual Object SetHostExecutionContext(HostExecutionContext hostExecutionContext)
{
if (hostExecutionContext == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext"));
}
Contract.EndContractBlock();
HostExecutionContextSwitcher switcher = new HostExecutionContextSwitcher();
ExecutionContext currentExecutionContext = Thread.CurrentThread.GetMutableExecutionContext();
switcher.executionContext = currentExecutionContext;
switcher.currentHostContext = hostExecutionContext;
switcher.previousHostContext = null;
if (CheckIfHosted())
{
if (hostExecutionContext.State is IUnknownSafeHandle)
{
// setup the previous unknown handle
IUnknownSafeHandle unkPrevSafeHandle = new IUnknownSafeHandle();
switcher.previousHostContext = new HostExecutionContext(unkPrevSafeHandle);
// get the current handle
IUnknownSafeHandle unkSafeHandle = (IUnknownSafeHandle)hostExecutionContext.State;
// call into the Hosting API to set the host context
// second arg indicates whether we want to retrieve the previous context
SetHostSecurityContext(unkSafeHandle, true, unkPrevSafeHandle);
}
}
// store the current HostExecutionContext in the ExecutionContext.
currentExecutionContext.HostExecutionContext = hostExecutionContext;
return(switcher);
}
public virtual new Object SetHostExecutionContext(HostExecutionContext hostExecutionContext)
{
return(default(Object));
}
[System.Security.SecuritySafeCritical] // auto-generated
public virtual HostExecutionContext Capture()
{
HostExecutionContext context = null;
// check if we are hosted
if (CheckIfHosted())
{
IUnknownSafeHandle unkSafeHandle = new IUnknownSafeHandle();
context = new HostExecutionContext(unkSafeHandle);
// call into the Hosting API to capture the host context
// stores the output IUnknown in the safehandle,
CaptureHostSecurityContext(unkSafeHandle);
}
// otherwise
return context;
}
public virtual new Object SetHostExecutionContext(HostExecutionContext hostExecutionContext)
{
return default(Object);
}
public virtual object SetHostExecutionContext (HostExecutionContext hostExecutionContext)
{
throw new NotImplementedException ();
}
internal static object SetHostExecutionContextInternal(HostExecutionContext hostContext)
{
HostExecutionContextManager currentHostExecutionContextManager = GetCurrentHostExecutionContextManager();
object obj2 = null;
if (currentHostExecutionContextManager != null)
{
obj2 = currentHostExecutionContextManager.SetHostExecutionContext(hostContext);
}
return obj2;
}
internal DnxHostExecutionContext(HostExecutionContext baseContext, ThreadContext threadContext)
{
BaseContext = baseContext;
ThreadContext = threadContext;
}
public virtual object SetHostExecutionContext(HostExecutionContext hostExecutionContext)
{
if (hostExecutionContext == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext"));
}
HostExecutionContextSwitcher switcher = new HostExecutionContextSwitcher();
ExecutionContext executionContext = Thread.CurrentThread.ExecutionContext;
switcher.executionContext = executionContext;
switcher.currentHostContext = hostExecutionContext;
switcher.previousHostContext = null;
if (CheckIfHosted() && (hostExecutionContext.State is IUnknownSafeHandle))
{
IUnknownSafeHandle state = new IUnknownSafeHandle();
switcher.previousHostContext = new HostExecutionContext(state);
IUnknownSafeHandle context = (IUnknownSafeHandle) hostExecutionContext.State;
SetHostSecurityContext(context, true, state);
}
executionContext.HostExecutionContext = hostExecutionContext;
return switcher;
}
internal AspNetHostExecutionContext(HostExecutionContext baseContext, object httpContextThreadContextId) {
BaseContext = baseContext;
HttpContextThreadContextId = httpContextThreadContextId;
}
[System.Security.SecurityCritical] // auto-generated
internal static Object SetHostExecutionContextInternal(HostExecutionContext hostContext)
{
HostExecutionContextManager hostMgr = HostExecutionContextManager.GetCurrentHostExecutionContextManager();
Object switcher = null;
if (hostMgr != null)
{
switcher = hostMgr.SetHostExecutionContext(hostContext);
//
}
return switcher;
}
private static HostExecutionContext CreateCopyHelper(HostExecutionContext hostExecutionContext)
{
return (hostExecutionContext != null) ? hostExecutionContext.CreateCopy() : null;
}
private static HostExecutionContext CreateCopyHelper(HostExecutionContext hostExecutionContext) {
// creating a copy of a null context should just itself return null
return (hostExecutionContext != null) ? hostExecutionContext.CreateCopy() : null;
}
[HandleProcessCorruptedStateExceptions] //
#endif // FEATURE_CORRUPTING_EXCEPTIONS
internal static ExecutionContextSwitcher SetExecutionContext(ExecutionContext executionContext, bool preserveSyncCtx)
{
#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
Contract.Assert(executionContext != null);
Contract.Assert(executionContext != s_dummyDefaultEC);
// Set up the switcher object to return;
ExecutionContextSwitcher ecsw = new ExecutionContextSwitcher();
Thread currentThread = Thread.CurrentThread;
ExecutionContext.Reader outerEC = currentThread.GetExecutionContextReader();
ecsw.thread = currentThread;
ecsw.outerEC = outerEC;
ecsw.outerECBelongsToScope = currentThread.ExecutionContextBelongsToCurrentScope;
if (preserveSyncCtx)
{
executionContext.SynchronizationContext = outerEC.SynchronizationContext;
}
executionContext.SynchronizationContextNoFlow = outerEC.SynchronizationContextNoFlow;
currentThread.SetExecutionContext(executionContext, belongsToCurrentScope: true);
RuntimeHelpers.PrepareConstrainedRegions();
try
{
#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
//set the security context
SecurityContext sc = executionContext.SecurityContext;
if (sc != null)
{
// non-null SC: needs to be set
SecurityContext.Reader prevSeC = outerEC.SecurityContext;
ecsw.scsw = SecurityContext.SetSecurityContext(sc, prevSeC, false, ref stackMark);
}
else if (!SecurityContext.CurrentlyInDefaultFTSecurityContext(ecsw.outerEC))
{
// null incoming SC, but we're currently not in FT: use static FTSC to set
SecurityContext.Reader prevSeC = outerEC.SecurityContext;
ecsw.scsw = SecurityContext.SetSecurityContext(SecurityContext.FullTrustSecurityContext, prevSeC, false, ref stackMark);
}
#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
#if FEATURE_CAS_POLICY
// set the Host Context
HostExecutionContext hostContext = executionContext.HostExecutionContext;
if (hostContext != null)
{
ecsw.hecsw = HostExecutionContextManager.SetHostExecutionContextInternal(hostContext);
}
#endif // FEATURE_CAS_POLICY
}
catch
{
ecsw.UndoNoThrow();
throw;
}
return(ecsw);
}
[System.Security.SecurityCritical] // auto-generated_required
public virtual Object SetHostExecutionContext(HostExecutionContext hostExecutionContext)
{
if (hostExecutionContext == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext"));
}
Contract.EndContractBlock();
HostExecutionContextSwitcher switcher = new HostExecutionContextSwitcher();
ExecutionContext currentExecutionContext = Thread.CurrentThread.GetMutableExecutionContext();
switcher.executionContext = currentExecutionContext;
switcher.currentHostContext = hostExecutionContext;
switcher.previousHostContext = null;
if (CheckIfHosted())
{
if (hostExecutionContext.State is IUnknownSafeHandle)
{
// setup the previous unknown handle
IUnknownSafeHandle unkPrevSafeHandle = new IUnknownSafeHandle();
switcher.previousHostContext = new HostExecutionContext(unkPrevSafeHandle);
// get the current handle
IUnknownSafeHandle unkSafeHandle = (IUnknownSafeHandle)hostExecutionContext.State;
// call into the Hosting API to set the host context
// second arg indicates whether we want to retrieve the previous context
SetHostSecurityContext(unkSafeHandle,true,unkPrevSafeHandle);
}
}
// store the current HostExecutionContext in the ExecutionContext.
currentExecutionContext.HostExecutionContext = hostExecutionContext;
return switcher;
}
public virtual object SetHostExecutionContext(HostExecutionContext hostExecutionContext)
{
throw new NotImplementedException();
}
[System.Security.SecurityCritical] // auto-generated
static internal ExecutionContext Capture(ref StackCrawlMark stackMark, CaptureOptions options)
{
ExecutionContext.Reader ecCurrent = Thread.CurrentThread.GetExecutionContextReader();
// check to see if Flow is suppressed
if (ecCurrent.IsFlowSuppressed)
{
return(null);
}
//
// Attempt to capture context. There may be nothing to capture...
//
#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
// capture the security context
SecurityContext secCtxNew = SecurityContext.Capture(ecCurrent, ref stackMark);
#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
#if FEATURE_CAS_POLICY
// capture the host execution context
HostExecutionContext hostCtxNew = HostExecutionContextManager.CaptureHostExecutionContext();
#endif // FEATURE_CAS_POLICY
#if FEATURE_SYNCHRONIZATIONCONTEXT
SynchronizationContext syncCtxNew = null;
#endif
LogicalCallContext logCtxNew = null;
if (!ecCurrent.IsNull)
{
#if FEATURE_SYNCHRONIZATIONCONTEXT
// capture the [....] context
if (0 == (options & CaptureOptions.IgnoreSyncCtx))
{
syncCtxNew = (ecCurrent.SynchronizationContext == null) ? null : ecCurrent.SynchronizationContext.CreateCopy();
}
#endif // #if FEATURE_SYNCHRONIZATIONCONTEXT
// copy over the Logical Call Context
if (ecCurrent.LogicalCallContext.HasInfo)
{
logCtxNew = ecCurrent.LogicalCallContext.Clone();
}
}
//
// If we didn't get anything but defaults, and we're allowed to return the
// dummy default EC, don't bother allocating a new context.
//
if (0 != (options & CaptureOptions.OptimizeDefaultCase) &&
#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
secCtxNew == null &&
#endif
#if FEATURE_CAS_POLICY
hostCtxNew == null &&
#endif // FEATURE_CAS_POLICY
#if FEATURE_SYNCHRONIZATIONCONTEXT
syncCtxNew == null &&
#endif // #if FEATURE_SYNCHRONIZATIONCONTEXT
(logCtxNew == null || !logCtxNew.HasInfo))
{
return(s_dummyDefaultEC);
}
//
// Allocate the new context, and fill it in.
//
ExecutionContext ecNew = new ExecutionContext();
#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
ecNew.SecurityContext = secCtxNew;
if (ecNew.SecurityContext != null)
{
ecNew.SecurityContext.ExecutionContext = ecNew;
}
#endif
#if FEATURE_CAS_POLICY
ecNew._hostExecutionContext = hostCtxNew;
#endif // FEATURE_CAS_POLICY
#if FEATURE_SYNCHRONIZATIONCONTEXT
ecNew._syncContext = syncCtxNew;
#endif // #if FEATURE_SYNCHRONIZATIONCONTEXT
ecNew.LogicalCallContext = logCtxNew;
ecNew.isNewCapture = true;
return(ecNew);
}
